From c8e0654ffe46fe0a62deb44b719393b629a0b79d Mon Sep 17 00:00:00 2001 From: John David Pressman Date: Fri, 31 Jan 2020 03:34:36 -0800 Subject: [PATCH 1/5] Add crypto reference page to docs Change 'black2b' to 'blake2b' in CameLIGO/ReasonLIGO frontend --- gitlab-pages/docs/reference/crypto.md | 155 ++++++++++++++++++++++++++ src/passes/operators/operators.ml | 2 +- src/test/contracts/crypto.ligo | 3 + src/test/contracts/crypto.mligo | 2 + src/test/contracts/crypto.religo | 2 + src/test/integration_tests.ml | 48 +++++++- 6 files changed, 209 insertions(+), 3 deletions(-) create mode 100644 gitlab-pages/docs/reference/crypto.md create mode 100644 src/test/contracts/crypto.ligo create mode 100644 src/test/contracts/crypto.mligo create mode 100644 src/test/contracts/crypto.religo diff --git a/gitlab-pages/docs/reference/crypto.md b/gitlab-pages/docs/reference/crypto.md new file mode 100644 index 000000000..571c0265b --- /dev/null +++ b/gitlab-pages/docs/reference/crypto.md @@ -0,0 +1,155 @@ +--- +id: crypto-reference +title: Crypto +--- + +## Crypto.black2b(data: bytes): bytes + +Runs the [blake2b hash algorithm](https://en.wikipedia.org/wiki/BLAKE_(hash_function)#BLAKE2) +over the given `bytes` data and returns a `bytes` representing the hash. + + + + + +```pascaligo +function hasherman_blake (const s: bytes) : bytes is blake2b(s) +``` + + + +```cameligo +let hasherman_blake (s: bytes) : bytes = Crypto.blake2b s +``` + + + +```reasonligo +let hasherman_blake = (s: bytes) => Crypto.blake2b(s); +``` + + + +## Crypto.sha256(data: bytes) : bytes + +Runs the [sha256 hash algorithm](https://en.wikipedia.org/wiki/SHA-2) over the given +`bytes` data and returns a `bytes` representing the hash. + + + + +```pascaligo +function hasherman (const s : bytes) : bytes is + begin skip end with sha_256(s) +``` + + +```cameligo +let hasherman (s : bytes) : bytes = + Crypto.sha256 s +``` + + +```reasonligo +let hasherman = (s: bytes): bytes => Crypto.sha256(s); +``` + + + +## Crypto.sha512(data: bytes) : bytes + +Runs the [sha512 hash algorithm](https://en.wikipedia.org/wiki/SHA-2) over the given +`bytes` data and returns a `bytes` representing the hash. + + + + + +```pascaligo +function hasherman512 (const s: bytes) : bytes is sha_512(s) +``` + + + +```cameligo +let hasherman512 (s: bytes) : bytes = Crypto.sha512 s +``` + + + +```reasonligo +let hasherman512 = (s: bytes) => Crypto.sha512(s); +``` + + + +## Crypto.hash_key(k: key) : key_hash + +Hashes a key for easy comparison and storage. + + + + +```pascaligo +function check_hash_key (const kh1 : key_hash; const k2 : key) : bool * key_hash is block { + var ret : bool := False ; + var kh2 : key_hash := crypto_hash_key(k2) ; + if kh1 = kh2 then ret := True else skip; +} with (ret, kh2) +``` + + +```cameligo +let check_hash_key (kh1, k2: key_hash * key) : bool * key_hash = + let kh2 : key_hash = Crypto.hash_key k2 in + if kh1 = kh2 + then (true, kh2) + else (false, kh2) +``` + + +```reasonligo +let check_hash_key = ((kh1, k2): (key_hash, key)) : (bool, key_hash) => { + let kh2 : key_hash = Crypto.hash_key(k2); + if (kh1 == kh2) { + (true, kh2); + } + else { + (false, kh2); + } +}; +``` + + + +## Crypto.check(pk: key, signed: signature, data: bytes) : bool + +Check that a message has been signed by a particular key. + +> ⚠️ There is no way to *generate* a signed message in LIGO. This is because that would require storing a private key on chain, at which point it isn't very private anymore. + + + + +```pascaligo +function check_signature + (const pk: key; + const signed: signature; + const msg: bytes) : bool + is crypto_check(pk, signed, msg) +``` + + +```cameligo +let check_signature (pk, signed, msg: key * signature * bytes) : bool = + Crypto.check pk signed msg +``` + + +```reasonligo +let check_signature = ((pk, signed, msg): (key, signature, bytes)) : bool => { + Crypto.check(pk, signed, msg); +}; +``` + + diff --git a/src/passes/operators/operators.ml b/src/passes/operators/operators.ml index 6c8c92112..e6eb15c3e 100644 --- a/src/passes/operators/operators.ml +++ b/src/passes/operators/operators.ml @@ -162,7 +162,7 @@ module Simplify = struct | "failwith" -> ok C_FAILWITH | "Crypto.hash" -> ok C_HASH - | "Crypto.black2b" -> ok C_BLAKE2b + | "Crypto.blake2b" -> ok C_BLAKE2b | "Crypto.sha256" -> ok C_SHA256 | "Crypto.sha512" -> ok C_SHA512 | "Crypto.hash_key" -> ok C_HASH_KEY diff --git a/src/test/contracts/crypto.ligo b/src/test/contracts/crypto.ligo new file mode 100644 index 000000000..4e08f7b16 --- /dev/null +++ b/src/test/contracts/crypto.ligo @@ -0,0 +1,3 @@ +function hasherman512 (const s: bytes) : bytes is sha_512(s) + +function hasherman_blake (const s: bytes) : bytes is blake2b(s) diff --git a/src/test/contracts/crypto.mligo b/src/test/contracts/crypto.mligo new file mode 100644 index 000000000..9fa7e99e8 --- /dev/null +++ b/src/test/contracts/crypto.mligo @@ -0,0 +1,2 @@ +let hasherman512 (s: bytes) : bytes = Crypto.sha512 s +let hasherman_blake (s: bytes) : bytes = Crypto.blake2b s diff --git a/src/test/contracts/crypto.religo b/src/test/contracts/crypto.religo new file mode 100644 index 000000000..c5b17ce8e --- /dev/null +++ b/src/test/contracts/crypto.religo @@ -0,0 +1,2 @@ +let hasherman512 = (s: bytes) => Crypto.sha512(s); +let hasherman_blake = (s: bytes) => Crypto.blake2b(s); diff --git a/src/test/integration_tests.ml b/src/test/integration_tests.ml index 2449e085e..58b492fc2 100644 --- a/src/test/integration_tests.ml +++ b/src/test/integration_tests.ml @@ -428,6 +428,48 @@ let bytes_arithmetic () : unit result = let%bind () = Assert.assert_fail @@ Ast_simplified.Misc.assert_value_eq (b3 , b1) in ok () +let crypto () : unit result = + let%bind program = type_file "./contracts/crypto.ligo" in + let%bind foo = e_bytes_hex "0f00" in + let%bind foototo = e_bytes_hex "0f007070" in + let%bind b1 = Test_helpers.run_typed_program_with_simplified_input program "hasherman512" foo in + let%bind () = expect_eq program "hasherman512" foo b1 in + let%bind b2 = Test_helpers.run_typed_program_with_simplified_input program "hasherman512" foototo in + let%bind () = Assert.assert_fail @@ Ast_simplified.Misc.assert_value_eq (b2 , b1) in + let%bind b4 = Test_helpers.run_typed_program_with_simplified_input program "hasherman_blake" foo in + let%bind () = expect_eq program "hasherman_blake" foo b4 in + let%bind b5 = Test_helpers.run_typed_program_with_simplified_input program "hasherman_blake" foototo in + let%bind () = Assert.assert_fail @@ Ast_simplified.Misc.assert_value_eq (b5 , b4) in + ok () + +let crypto_mligo () : unit result = + let%bind program = mtype_file "./contracts/crypto.mligo" in + let%bind foo = e_bytes_hex "0f00" in + let%bind foototo = e_bytes_hex "0f007070" in + let%bind b1 = Test_helpers.run_typed_program_with_simplified_input program "hasherman512" foo in + let%bind () = expect_eq program "hasherman512" foo b1 in + let%bind b2 = Test_helpers.run_typed_program_with_simplified_input program "hasherman512" foototo in + let%bind () = Assert.assert_fail @@ Ast_simplified.Misc.assert_value_eq (b2 , b1) in + let%bind b4 = Test_helpers.run_typed_program_with_simplified_input program "hasherman_blake" foo in + let%bind () = expect_eq program "hasherman_blake" foo b4 in + let%bind b5 = Test_helpers.run_typed_program_with_simplified_input program "hasherman_blake" foototo in + let%bind () = Assert.assert_fail @@ Ast_simplified.Misc.assert_value_eq (b5 , b4) in + ok () + +let crypto_religo () : unit result = + let%bind program = retype_file "./contracts/crypto.religo" in + let%bind foo = e_bytes_hex "0f00" in + let%bind foototo = e_bytes_hex "0f007070" in + let%bind b1 = Test_helpers.run_typed_program_with_simplified_input program "hasherman512" foo in + let%bind () = expect_eq program "hasherman512" foo b1 in + let%bind b2 = Test_helpers.run_typed_program_with_simplified_input program "hasherman512" foototo in + let%bind () = Assert.assert_fail @@ Ast_simplified.Misc.assert_value_eq (b2 , b1) in + let%bind b4 = Test_helpers.run_typed_program_with_simplified_input program "hasherman_blake" foo in + let%bind () = expect_eq program "hasherman_blake" foo b4 in + let%bind b5 = Test_helpers.run_typed_program_with_simplified_input program "hasherman_blake" foototo in + let%bind () = Assert.assert_fail @@ Ast_simplified.Misc.assert_value_eq (b5 , b4) in + ok () + let bytes_arithmetic_mligo () : unit result = let%bind program = mtype_file "./contracts/bytes_arithmetic.mligo" in let%bind foo = e_bytes_hex "0f00" in @@ -2189,8 +2231,7 @@ let main = test_suite "Integration (End to End)" [ test "bool (religo)" bool_expression_religo ; test "arithmetic" arithmetic ; test "arithmetic (mligo)" arithmetic_mligo ; - test "arithmetic (religo)" arithmetic_religo ; - test "bitwise_arithmetic" bitwise_arithmetic ; + test "arithmetic (religo)" arithmetic_religo ; test "bitwise_arithmetic" bitwise_arithmetic ; test "bitwise_arithmetic (mligo)" bitwise_arithmetic_mligo; test "bitwise_arithmetic (religo)" bitwise_arithmetic_religo; test "string_arithmetic" string_arithmetic ; @@ -2199,6 +2240,9 @@ let main = test_suite "Integration (End to End)" [ test "bytes_arithmetic" bytes_arithmetic ; test "bytes_arithmetic (mligo)" bytes_arithmetic_mligo ; test "bytes_arithmetic (religo)" bytes_arithmetic_religo ; + test "crypto" crypto ; + test "crypto (mligo)" crypto_mligo ; + test "crypto (religo)" crypto_religo ; test "set_arithmetic" set_arithmetic ; test "set_arithmetic (mligo)" set_arithmetic_mligo ; test "set_arithmetic (religo)" set_arithmetic_religo ; From ef83e2c39a79f1f2a33ac1f2d9438201735e0aa9 Mon Sep 17 00:00:00 2001 From: John David Pressman Date: Fri, 31 Jan 2020 03:40:59 -0800 Subject: [PATCH 2/5] Add correction of 'black2b' to changelog --- CHANGELOG.md | 6 +++++- gitlab-pages/docs/reference/crypto.md | 2 +- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index dc0b56a81..1977c3295 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,10 +2,14 @@ ## [Unreleased] +## [Add crypto reference page to docs](https://gitlab.com/ligolang/ligo/-/merge_requests/370) +### Changed +- Corrected typo in CameLIGO/ReasonLIGO front end where Crypto.blake2b was 'Crypto.black2b' + ## [Failwith do not fail](https://gitlab.com/ligolang/ligo/merge_requests/337) - 2020-01-17 ### Added - running failing code in `ligo interpret`, `ligo dry-run`, `ligo run-function` will no longer be an error (return value : 0) - + ## [1899dfe8d7285580b3aa30fab933ed589f8f1bc5] - 2020-01-08 ### Added - Partial application and OCaml-like currying behavior to CameLIGO & ReasonLIGO diff --git a/gitlab-pages/docs/reference/crypto.md b/gitlab-pages/docs/reference/crypto.md index 571c0265b..7234d4880 100644 --- a/gitlab-pages/docs/reference/crypto.md +++ b/gitlab-pages/docs/reference/crypto.md @@ -3,7 +3,7 @@ id: crypto-reference title: Crypto --- -## Crypto.black2b(data: bytes): bytes +## Crypto.blake2b(data: bytes): bytes Runs the [blake2b hash algorithm](https://en.wikipedia.org/wiki/BLAKE_(hash_function)#BLAKE2) over the given `bytes` data and returns a `bytes` representing the hash. From c3cb69a0d0219ddaff17f5e3cf4f71489cdc9072 Mon Sep 17 00:00:00 2001 From: Sander Spies Date: Fri, 31 Jan 2020 16:05:59 +0100 Subject: [PATCH 3/5] Move error.messages handling to dune. --- src/passes/1-parser/cameligo/ParErr.ml | 442 -- src/passes/1-parser/cameligo/dune | 101 + .../cameligo/error.messages.checked-in | 3541 +++++++++++++ src/passes/1-parser/pascaligo/ParErr.ml | 546 -- src/passes/1-parser/pascaligo/dune | 102 + .../pascaligo/error.messages.checked-in | 4503 +++++++++++++++++ src/passes/1-parser/reasonligo/ParErr.ml | 526 -- src/passes/1-parser/reasonligo/dune | 101 + .../reasonligo/error.messages.checked-in | 4330 ++++++++++++++++ src/passes/1-parser/shared/ParserAPI.ml | 5 + 10 files changed, 12683 insertions(+), 1514 deletions(-) delete mode 100644 src/passes/1-parser/cameligo/ParErr.ml create mode 100644 src/passes/1-parser/cameligo/error.messages.checked-in delete mode 100644 src/passes/1-parser/pascaligo/ParErr.ml create mode 100644 src/passes/1-parser/pascaligo/error.messages.checked-in delete mode 100644 src/passes/1-parser/reasonligo/ParErr.ml create mode 100644 src/passes/1-parser/reasonligo/error.messages.checked-in diff --git a/src/passes/1-parser/cameligo/ParErr.ml b/src/passes/1-parser/cameligo/ParErr.ml deleted file mode 100644 index f1be602f1..000000000 --- a/src/passes/1-parser/cameligo/ParErr.ml +++ /dev/null @@ -1,442 +0,0 @@ - -(* This file was auto-generated based on "Parser.msg". *) - -(* Please note that the function [message] can raise [Not_found]. *) - -let message = - fun s -> - match s with - | 0 -> - "\n" - | 1 -> - "\n" - | 2 -> - "\n" - | 3 -> - "\n" - | 4 -> - "\n" - | 5 -> - "\n" - | 7 -> - "\n" - | 49 -> - "\n" - | 51 -> - "\n" - | 52 -> - "\n" - | 53 -> - "\n" - | 18 -> - "\n" - | 8 -> - "\n" - | 9 -> - "\n" - | 10 -> - "\n" - | 42 -> - "\n" - | 43 -> - "\n" - | 46 -> - "\n" - | 47 -> - "\n" - | 33 -> - "\n" - | 478 -> - "\n" - | 27 -> - "\n" - | 31 -> - "\n" - | 28 -> - "\n" - | 35 -> - "\n" - | 12 -> - "\n" - | 16 -> - "\n" - | 6 -> - "\n" - | 13 -> - "\n" - | 61 -> - "\n" - | 133 -> - "\n" - | 379 -> - "\n" - | 381 -> - "\n" - | 472 -> - "\n" - | 169 -> - "\n" - | 134 -> - "\n" - | 136 -> - "\n" - | 137 -> - "\n" - | 153 -> - "\n" - | 380 -> - "\n" - | 63 -> - "\n" - | 142 -> - "\n" - | 143 -> - "\n" - | 128 -> - "\n" - | 145 -> - "\n" - | 72 -> - "\n" - | 94 -> - "\n" - | 106 -> - "\n" - | 95 -> - "\n" - | 108 -> - "\n" - | 109 -> - "\n" - | 110 -> - "\n" - | 73 -> - "\n" - | 91 -> - "\n" - | 93 -> - "\n" - | 92 -> - "\n" - | 90 -> - "\n" - | 77 -> - "\n" - | 78 -> - "\n" - | 65 -> - "\n" - | 66 -> - "\n" - | 67 -> - "\n" - | 120 -> - "\n" - | 121 -> - "\n" - | 124 -> - "\n" - | 125 -> - "\n" - | 147 -> - "\n" - | 148 -> - "\n" - | 149 -> - "\n" - | 157 -> - "\n" - | 156 -> - "\n" - | 481 -> - "\n" - | 483 -> - "\n" - | 221 -> - "\n" - | 246 -> - "\n" - | 223 -> - "\n" - | 225 -> - "\n" - | 219 -> - "\n" - | 230 -> - "\n" - | 259 -> - "\n" - | 260 -> - "\n" - | 247 -> - "\n" - | 268 -> - "\n" - | 232 -> - "\n" - | 261 -> - "\n" - | 262 -> - "\n" - | 270 -> - "\n" - | 272 -> - "\n" - | 274 -> - "\n" - | 276 -> - "\n" - | 278 -> - "\n" - | 195 -> - "\n" - | 263 -> - "\n" - | 289 -> - "\n" - | 292 -> - "\n" - | 249 -> - "\n" - | 297 -> - "\n" - | 266 -> - "\n" - | 160 -> - "\n" - | 164 -> - "\n" - | 445 -> - "\n" - | 337 -> - "\n" - | 317 -> - "\n" - | 447 -> - "\n" - | 319 -> - "\n" - | 320 -> - "\n" - | 321 -> - "\n" - | 448 -> - "\n" - | 462 -> - "\n" - | 463 -> - "\n" - | 449 -> - "\n" - | 450 -> - "\n" - | 452 -> - "\n" - | 451 -> - "\n" - | 453 -> - "\n" - | 454 -> - "\n" - | 455 -> - "\n" - | 457 -> - "\n" - | 333 -> - "\n" - | 335 -> - "\n" - | 339 -> - "\n" - | 336 -> - "\n" - | 334 -> - "\n" - | 345 -> - "\n" - | 346 -> - "\n" - | 348 -> - "\n" - | 347 -> - "\n" - | 349 -> - "\n" - | 350 -> - "\n" - | 351 -> - "\n" - | 373 -> - "\n" - | 352 -> - "\n" - | 354 -> - "\n" - | 458 -> - "\n" - | 460 -> - "\n" - | 464 -> - "\n" - | 446 -> - "\n" - | 316 -> - "\n" - | 444 -> - "\n" - | 165 -> - "\n" - | 167 -> - "\n" - | 168 -> - "\n" - | 172 -> - "\n" - | 171 -> - "\n" - | 163 -> - "\n" - | 465 -> - "\n" - | 467 -> - "\n" - | 468 -> - "\n" - | 166 -> - "\n" - | 239 -> - "\n" - | 240 -> - "\n" - | 243 -> - "\n" - | 244 -> - "\n" - | 441 -> - "\n" - | 173 -> - "\n" - | 428 -> - "\n" - | 429 -> - "\n" - | 174 -> - "\n" - | 175 -> - "\n" - | 434 -> - "\n" - | 435 -> - "\n" - | 438 -> - "\n" - | 439 -> - "\n" - | 427 -> - "\n" - | 421 -> - "\n" - | 422 -> - "\n" - | 423 -> - "\n" - | 177 -> - "\n" - | 308 -> - "\n" - | 309 -> - "\n" - | 412 -> - "\n" - | 419 -> - "\n" - | 411 -> - "\n" - | 310 -> - "\n" - | 312 -> - "\n" - | 324 -> - "\n" - | 325 -> - "\n" - | 326 -> - "\n" - | 327 -> - "\n" - | 329 -> - "\n" - | 328 -> - "\n" - | 330 -> - "\n" - | 331 -> - "\n" - | 332 -> - "\n" - | 384 -> - "\n" - | 385 -> - "\n" - | 387 -> - "\n" - | 340 -> - "\n" - | 314 -> - "\n" - | 311 -> - "\n" - | 401 -> - "\n" - | 402 -> - "\n" - | 404 -> - "\n" - | 403 -> - "\n" - | 405 -> - "\n" - | 406 -> - "\n" - | 407 -> - "\n" - | 415 -> - "\n" - | 408 -> - "\n" - | 410 -> - "\n" - | 178 -> - "\n" - | 179 -> - "\n" - | 182 -> - "\n" - | 183 -> - "\n" - | 186 -> - "\n" - | 306 -> - "\n" - | 304 -> - "\n" - | 188 -> - "\n" - | 190 -> - "\n" - | 191 -> - "\n" - | 192 -> - "\n" - | 193 -> - "\n" - | 198 -> - "\n" - | 218 -> - "\n" - | 197 -> - "\n" - | 214 -> - "\n" - | _ -> - raise Not_found diff --git a/src/passes/1-parser/cameligo/dune b/src/passes/1-parser/cameligo/dune index a9139a2ec..8824fdcd4 100644 --- a/src/passes/1-parser/cameligo/dune +++ b/src/passes/1-parser/cameligo/dune @@ -69,3 +69,104 @@ (targets all.mligo) (deps (:script_cover ../../../../vendors/ligo-utils/simple-utils/cover.sh) Parser.mly LexToken.mli ParToken.mly Parser.msg Unlexer.exe) (action (run %{script_cover} --lex-tokens=LexToken.mli --par-tokens=ParToken.mly --ext=mligo --unlexer=./Unlexer.exe --messages=Parser.msg --dir=. --concatenate Parser.mly ))) + +;; Error messages + +;; Generate error messages from scratch +; (rule +; (targets error.messages) +; (deps Parser.mly ParToken.mly error.messages.checked-in) +; (action +; (with-stdout-to %{targets} +; (bash +; "menhir \ +; --unused-tokens \ +; --list-errors \ +; --table \ +; --strict \ +; --external-tokens LexToken.mli \ +; --base Parser.mly \ +; ParToken.mly \ +; Parser.mly +; " +; ) +; )) +; ) + +(rule + (targets error.messages) + (deps Parser.mly ParToken.mly error.messages.checked-in LexToken.mli) + (action + (with-stdout-to %{targets} + (run + menhir + --unused-tokens + --update-errors error.messages.checked-in + --table + --strict + --external-tokens LexToken.mli + --base Parser.mly + ParToken.mly + Parser.mly + ) + )) +) + +(rule + (target error.messages.new) + (action + (with-stdout-to %{target} + (run + menhir + --unused-tokens + --list-errors + --table + --strict + --external-tokens LexToken.mli + --base Parser.mly + ParToken.mly + Parser.mly + ) + ) + ) +) + +(alias + (name runtest) + (deps error.messages error.messages.new) + (action + (run + menhir + --unused-tokens + --table + --strict + --external-tokens LexToken.mli + --base Parser.mly + ParToken.mly + Parser.mly + --compare-errors error.messages.new + --compare-errors error.messages + ) + ) + ) + + + +(rule + (targets ParErr.ml) + (deps Parser.mly ParToken.mly error.messages.checked-in LexToken.mli) + (action + (with-stdout-to %{targets} + (run + menhir + --unused-tokens + --table + --strict + --external-tokens LexToken.mli + --base Parser.mly + ParToken.mly + Parser.mly + --compile-errors error.messages.checked-in + ) + )) +) diff --git a/src/passes/1-parser/cameligo/error.messages.checked-in b/src/passes/1-parser/cameligo/error.messages.checked-in new file mode 100644 index 000000000..d0cbf4a33 --- /dev/null +++ b/src/passes/1-parser/cameligo/error.messages.checked-in @@ -0,0 +1,3541 @@ +interactive_expr: Begin True RBRACKET +## +## Ends in an error in state: 214. +## +## sequence -> Begin option(sep_or_term_list(expr,SEMI)) . End [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## Begin option(sep_or_term_list(expr,SEMI)) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 246, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 300, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 301, spurious reduction of production expr -> base_cond__open(expr) +## In state 239, spurious reduction of production nsepseq(expr,SEMI) -> expr +## In state 217, spurious reduction of production sep_or_term_list(expr,SEMI) -> nsepseq(expr,SEMI) +## In state 213, spurious reduction of production option(sep_or_term_list(expr,SEMI)) -> sep_or_term_list(expr,SEMI) +## + + + +interactive_expr: Begin With +## +## Ends in an error in state: 197. +## +## sequence -> Begin . option(sep_or_term_list(expr,SEMI)) End [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## Begin +## + + + +interactive_expr: C_None WILD +## +## Ends in an error in state: 218. +## +## add_expr_level -> mult_expr_level . [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE PLUS Or NE MINUS Let LT LE In GT GE End Else EQ EOF CONS COMMA COLON CAT BOOL_OR BOOL_AND Attr ] +## bin_op(mult_expr_level,Mod,unary_expr_level) -> mult_expr_level . Mod unary_expr_level [ With VBAR Type Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS Let LT LE In GT GE End Else EQ EOF CONS COMMA COLON CAT BOOL_OR BOOL_AND Attr ] +## bin_op(mult_expr_level,SLASH,unary_expr_level) -> mult_expr_level . SLASH unary_expr_level [ With VBAR Type Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS Let LT LE In GT GE End Else EQ EOF CONS COMMA COLON CAT BOOL_OR BOOL_AND Attr ] +## bin_op(mult_expr_level,TIMES,unary_expr_level) -> mult_expr_level . TIMES unary_expr_level [ With VBAR Type Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS Let LT LE In GT GE End Else EQ EOF CONS COMMA COLON CAT BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## mult_expr_level +## + + + +interactive_expr: C_Some With +## +## Ends in an error in state: 198. +## +## constr_expr -> C_Some . core_expr [ With VBAR Type Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS Let LT LE In GT GE End Else EQ EOF CONS COMMA COLON CAT BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## C_Some +## + + + +interactive_expr: Constr DOT Ident DOT With +## +## Ends in an error in state: 193. +## +## projection -> Constr DOT Ident DOT . nsepseq(selection,DOT) [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## Constr DOT Ident DOT +## + + + +interactive_expr: Constr DOT Ident WILD +## +## Ends in an error in state: 192. +## +## module_field -> Constr DOT Ident . [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## projection -> Constr DOT Ident . DOT nsepseq(selection,DOT) [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## Constr DOT Ident +## + + + +interactive_expr: Constr DOT With +## +## Ends in an error in state: 191. +## +## module_field -> Constr DOT . Ident [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## projection -> Constr DOT . Ident DOT nsepseq(selection,DOT) [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## Constr DOT +## + + + +interactive_expr: Constr WILD +## +## Ends in an error in state: 190. +## +## constr_expr -> Constr . core_expr [ With VBAR Type Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS Let LT LE In GT GE End Else EQ EOF CONS COMMA COLON CAT BOOL_OR BOOL_AND Attr ] +## constr_expr -> Constr . [ With VBAR Type Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS Let LT LE In GT GE End Else EQ EOF CONS COMMA COLON CAT BOOL_OR BOOL_AND Attr ] +## module_field -> Constr . DOT Ident [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## projection -> Constr . DOT Ident DOT nsepseq(selection,DOT) [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## Constr +## + + + +interactive_expr: Fun WILD ARROW With +## +## Ends in an error in state: 188. +## +## fun_expr(expr) -> Fun nseq(irrefutable) ARROW . expr [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## Fun nseq(irrefutable) ARROW +## + + + +interactive_expr: Fun WILD RPAR +## +## Ends in an error in state: 304. +## +## nseq(irrefutable) -> irrefutable . seq(irrefutable) [ ARROW ] +## +## The known suffix of the stack is as follows: +## irrefutable +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 133, spurious reduction of production irrefutable -> sub_irrefutable +## + + + +interactive_expr: Fun WILD WILD RPAR +## +## Ends in an error in state: 306. +## +## seq(irrefutable) -> irrefutable . seq(irrefutable) [ ARROW ] +## +## The known suffix of the stack is as follows: +## irrefutable +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 133, spurious reduction of production irrefutable -> sub_irrefutable +## + + + +interactive_expr: Fun With +## +## Ends in an error in state: 186. +## +## fun_expr(expr) -> Fun . nseq(irrefutable) ARROW expr [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## Fun +## + + + +interactive_expr: Ident DOT Int DOT With +## +## Ends in an error in state: 183. +## +## nsepseq(selection,DOT) -> selection DOT . nsepseq(selection,DOT) [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## selection DOT +## + + + +interactive_expr: Ident DOT Int WILD +## +## Ends in an error in state: 182. +## +## nsepseq(selection,DOT) -> selection . [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## nsepseq(selection,DOT) -> selection . DOT nsepseq(selection,DOT) [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## selection +## + + + +interactive_expr: Ident DOT With +## +## Ends in an error in state: 179. +## +## projection -> Ident DOT . nsepseq(selection,DOT) [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## Ident DOT +## + + + +interactive_expr: Ident WILD +## +## Ends in an error in state: 178. +## +## core_expr -> Ident . [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## projection -> Ident . DOT nsepseq(selection,DOT) [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## Ident +## + + + +interactive_expr: If True Then Fun WILD ARROW With +## +## Ends in an error in state: 410. +## +## fun_expr(closed_if) -> Fun nseq(irrefutable) ARROW . closed_if [ Else ] +## fun_expr(expr) -> Fun nseq(irrefutable) ARROW . expr [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## Fun nseq(irrefutable) ARROW +## + + + +interactive_expr: If True Then Fun With +## +## Ends in an error in state: 408. +## +## fun_expr(closed_if) -> Fun . nseq(irrefutable) ARROW closed_if [ Else ] +## fun_expr(expr) -> Fun . nseq(irrefutable) ARROW expr [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## Fun +## + + + +interactive_expr: If True Then If True Then True Else With +## +## Ends in an error in state: 415. +## +## if_then_else(closed_if) -> If expr Then closed_if Else . closed_if [ Else ] +## if_then_else(expr) -> If expr Then closed_if Else . expr [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## If expr Then closed_if Else +## + + + +interactive_expr: If True Then If True Then With +## +## Ends in an error in state: 407. +## +## if_then(expr) -> If expr Then . expr [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## if_then_else(closed_if) -> If expr Then . closed_if Else closed_if [ Else ] +## if_then_else(expr) -> If expr Then . closed_if Else expr [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## If expr Then +## + + + +interactive_expr: If True Then If True With +## +## Ends in an error in state: 406. +## +## if_then(expr) -> If expr . Then expr [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## if_then_else(closed_if) -> If expr . Then closed_if Else closed_if [ Else ] +## if_then_else(expr) -> If expr . Then closed_if Else expr [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## If expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 246, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 300, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 301, spurious reduction of production expr -> base_cond__open(expr) +## + + + +interactive_expr: If True Then If With +## +## Ends in an error in state: 405. +## +## if_then(expr) -> If . expr Then expr [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## if_then_else(closed_if) -> If . expr Then closed_if Else closed_if [ Else ] +## if_then_else(expr) -> If . expr Then closed_if Else expr [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## If +## + + + +interactive_expr: If True Then Let WILD EQ Bytes Attr Type +## +## Ends in an error in state: 403. +## +## let_expr(closed_if) -> Let let_binding seq(Attr) . In closed_if [ Else ] +## let_expr(expr) -> Let let_binding seq(Attr) . In expr [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## Let let_binding seq(Attr) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 169, spurious reduction of production seq(Attr) -> +## In state 170, spurious reduction of production seq(Attr) -> Attr seq(Attr) +## + + + +interactive_expr: If True Then Let WILD EQ Bytes In With +## +## Ends in an error in state: 404. +## +## let_expr(closed_if) -> Let let_binding seq(Attr) In . closed_if [ Else ] +## let_expr(expr) -> Let let_binding seq(Attr) In . expr [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## Let let_binding seq(Attr) In +## + + + +interactive_expr: If True Then Let WILD EQ Bytes With +## +## Ends in an error in state: 402. +## +## let_expr(closed_if) -> Let let_binding . seq(Attr) In closed_if [ Else ] +## let_expr(expr) -> Let let_binding . seq(Attr) In expr [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## Let let_binding +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 246, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 300, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 301, spurious reduction of production expr -> base_cond__open(expr) +## In state 382, spurious reduction of production let_binding -> irrefutable option(type_annotation) EQ expr +## + + + +interactive_expr: If True Then Let With +## +## Ends in an error in state: 401. +## +## let_expr(closed_if) -> Let . let_binding seq(Attr) In closed_if [ Else ] +## let_expr(expr) -> Let . let_binding seq(Attr) In expr [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## Let +## + + + +interactive_expr: If True Then Match True Type +## +## Ends in an error in state: 311. +## +## match_expr(base_cond) -> Match expr . With option(VBAR) cases(base_cond) [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## match_expr(base_if_then_else) -> Match expr . With option(VBAR) cases(base_if_then_else) [ Else ] +## +## The known suffix of the stack is as follows: +## Match expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 246, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 300, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 301, spurious reduction of production expr -> base_cond__open(expr) +## + + + +interactive_expr: If True Then Match True With VBAR Begin +## +## Ends in an error in state: 314. +## +## match_expr(base_cond) -> Match expr With option(VBAR) . cases(base_cond) [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## match_expr(base_if_then_else) -> Match expr With option(VBAR) . cases(base_if_then_else) [ Else ] +## +## The known suffix of the stack is as follows: +## Match expr With option(VBAR) +## + + + +interactive_expr: If True Then Match True With WILD ARROW Bytes VBAR With +## +## Ends in an error in state: 340. +## +## cases(base_cond) -> cases(base_cond) VBAR . case_clause(base_cond) [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## cases(base_if_then_else) -> cases(base_cond) VBAR . case_clause(base_if_then_else) [ Else ] +## +## The known suffix of the stack is as follows: +## cases(base_cond) VBAR +## + + + +interactive_expr: If True Then Match True With WILD ARROW Fun WILD ARROW With +## +## Ends in an error in state: 387. +## +## fun_expr(base_cond) -> Fun nseq(irrefutable) ARROW . base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## fun_expr(base_if_then_else) -> Fun nseq(irrefutable) ARROW . base_if_then_else [ Else ] +## +## The known suffix of the stack is as follows: +## Fun nseq(irrefutable) ARROW +## + + + +interactive_expr: If True Then Match True With WILD ARROW Fun With +## +## Ends in an error in state: 385. +## +## fun_expr(base_cond) -> Fun . nseq(irrefutable) ARROW base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## fun_expr(base_if_then_else) -> Fun . nseq(irrefutable) ARROW base_if_then_else [ Else ] +## +## The known suffix of the stack is as follows: +## Fun +## + + + +interactive_expr: If True Then Match True With WILD ARROW If True Then True Else With +## +## Ends in an error in state: 384. +## +## if_then_else(base_cond) -> If expr Then closed_if Else . base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## if_then_else(base_if_then_else) -> If expr Then closed_if Else . base_if_then_else [ Else ] +## +## The known suffix of the stack is as follows: +## If expr Then closed_if Else +## + + + +interactive_expr: If True Then Match True With WILD ARROW If True Then With +## +## Ends in an error in state: 332. +## +## if_then(base_cond) -> If expr Then . base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## if_then_else(base_cond) -> If expr Then . closed_if Else base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## if_then_else(base_if_then_else) -> If expr Then . closed_if Else base_if_then_else [ Else ] +## +## The known suffix of the stack is as follows: +## If expr Then +## + + + +interactive_expr: If True Then Match True With WILD ARROW If True With +## +## Ends in an error in state: 331. +## +## if_then(base_cond) -> If expr . Then base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## if_then_else(base_cond) -> If expr . Then closed_if Else base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## if_then_else(base_if_then_else) -> If expr . Then closed_if Else base_if_then_else [ Else ] +## +## The known suffix of the stack is as follows: +## If expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 246, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 300, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 301, spurious reduction of production expr -> base_cond__open(expr) +## + + + +interactive_expr: If True Then Match True With WILD ARROW If With +## +## Ends in an error in state: 330. +## +## if_then(base_cond) -> If . expr Then base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## if_then_else(base_cond) -> If . expr Then closed_if Else base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## if_then_else(base_if_then_else) -> If . expr Then closed_if Else base_if_then_else [ Else ] +## +## The known suffix of the stack is as follows: +## If +## + + + +interactive_expr: If True Then Match True With WILD ARROW Let WILD EQ Bytes Attr Type +## +## Ends in an error in state: 328. +## +## let_expr(base_cond) -> Let let_binding seq(Attr) . In base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## let_expr(base_if_then_else) -> Let let_binding seq(Attr) . In base_if_then_else [ Else ] +## +## The known suffix of the stack is as follows: +## Let let_binding seq(Attr) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 169, spurious reduction of production seq(Attr) -> +## In state 170, spurious reduction of production seq(Attr) -> Attr seq(Attr) +## + + + +interactive_expr: If True Then Match True With WILD ARROW Let WILD EQ Bytes In With +## +## Ends in an error in state: 329. +## +## let_expr(base_cond) -> Let let_binding seq(Attr) In . base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## let_expr(base_if_then_else) -> Let let_binding seq(Attr) In . base_if_then_else [ Else ] +## +## The known suffix of the stack is as follows: +## Let let_binding seq(Attr) In +## + + + +interactive_expr: If True Then Match True With WILD ARROW Let WILD EQ Bytes With +## +## Ends in an error in state: 327. +## +## let_expr(base_cond) -> Let let_binding . seq(Attr) In base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## let_expr(base_if_then_else) -> Let let_binding . seq(Attr) In base_if_then_else [ Else ] +## +## The known suffix of the stack is as follows: +## Let let_binding +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 246, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 300, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 301, spurious reduction of production expr -> base_cond__open(expr) +## In state 382, spurious reduction of production let_binding -> irrefutable option(type_annotation) EQ expr +## + + + +interactive_expr: If True Then Match True With WILD ARROW Let With +## +## Ends in an error in state: 326. +## +## let_expr(base_cond) -> Let . let_binding seq(Attr) In base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## let_expr(base_if_then_else) -> Let . let_binding seq(Attr) In base_if_then_else [ Else ] +## +## The known suffix of the stack is as follows: +## Let +## + + + +interactive_expr: If True Then Match True With WILD ARROW With +## +## Ends in an error in state: 325. +## +## case_clause(base_cond) -> pattern ARROW . base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## case_clause(base_if_then_else) -> pattern ARROW . base_if_then_else [ Else ] +## +## The known suffix of the stack is as follows: +## pattern ARROW +## + + + +interactive_expr: If True Then Match True With WILD CONS Bytes SEMI +## +## Ends in an error in state: 324. +## +## case_clause(base_cond) -> pattern . ARROW base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## case_clause(base_if_then_else) -> pattern . ARROW base_if_then_else [ Else ] +## +## The known suffix of the stack is as follows: +## pattern +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 94, spurious reduction of production tail -> sub_pattern +## In state 318, spurious reduction of production pattern -> sub_pattern CONS tail +## + + + +interactive_expr: If True Then Match True With With +## +## Ends in an error in state: 312. +## +## match_expr(base_cond) -> Match expr With . option(VBAR) cases(base_cond) [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## match_expr(base_if_then_else) -> Match expr With . option(VBAR) cases(base_if_then_else) [ Else ] +## +## The known suffix of the stack is as follows: +## Match expr With +## + + + +interactive_expr: If True Then Match With +## +## Ends in an error in state: 310. +## +## match_expr(base_cond) -> Match . expr With option(VBAR) cases(base_cond) [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## match_expr(base_if_then_else) -> Match . expr With option(VBAR) cases(base_if_then_else) [ Else ] +## +## The known suffix of the stack is as follows: +## Match +## + + + +interactive_expr: If True Then True COMMA Bytes VBAR +## +## Ends in an error in state: 411. +## +## base_expr(closed_if) -> tuple_expr . [ Else ] +## base_expr(expr) -> tuple_expr . [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## tuple_expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 291, spurious reduction of production nsepseq(disj_expr_level,COMMA) -> disj_expr_level +## In state 290, spurious reduction of production tuple(disj_expr_level) -> disj_expr_level COMMA nsepseq(disj_expr_level,COMMA) +## In state 212, spurious reduction of production tuple_expr -> tuple(disj_expr_level) +## + + + +interactive_expr: If True Then True Else With +## +## Ends in an error in state: 419. +## +## if_then_else(expr) -> If expr Then closed_if Else . expr [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## If expr Then closed_if Else +## + + + +interactive_expr: If True Then True VBAR +## +## Ends in an error in state: 412. +## +## base_expr(closed_if) -> disj_expr_level . [ Else ] +## base_expr(expr) -> disj_expr_level . [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## bin_op(disj_expr_level,BOOL_OR,conj_expr_level) -> disj_expr_level . BOOL_OR conj_expr_level [ With Type Then SEMI RPAR RBRACKET RBRACE Or Let In End Else EOF COMMA COLON BOOL_OR Attr ] +## bin_op(disj_expr_level,Or,conj_expr_level) -> disj_expr_level . Or conj_expr_level [ With Type Then SEMI RPAR RBRACKET RBRACE Or Let In End Else EOF COMMA COLON BOOL_OR Attr ] +## tuple(disj_expr_level) -> disj_expr_level . COMMA nsepseq(disj_expr_level,COMMA) [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End Else EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## disj_expr_level +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## + + + +interactive_expr: If True Then With +## +## Ends in an error in state: 309. +## +## if_then(expr) -> If expr Then . expr [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## if_then_else(expr) -> If expr Then . closed_if Else expr [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## If expr Then +## + + + +interactive_expr: If True With +## +## Ends in an error in state: 308. +## +## if_then(expr) -> If expr . Then expr [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## if_then_else(expr) -> If expr . Then closed_if Else expr [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## If expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 246, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 300, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 301, spurious reduction of production expr -> base_cond__open(expr) +## + + + +interactive_expr: If With +## +## Ends in an error in state: 177. +## +## if_then(expr) -> If . expr Then expr [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## if_then_else(expr) -> If . expr Then closed_if Else expr [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## If +## + + + +interactive_expr: LBRACE Constr DOT Ident With +## +## Ends in an error in state: 423. +## +## projection -> Constr DOT Ident . DOT nsepseq(selection,DOT) [ With ] +## +## The known suffix of the stack is as follows: +## Constr DOT Ident +## + + + +interactive_expr: LBRACE Constr DOT With +## +## Ends in an error in state: 422. +## +## projection -> Constr DOT . Ident DOT nsepseq(selection,DOT) [ With ] +## +## The known suffix of the stack is as follows: +## Constr DOT +## + + + +interactive_expr: LBRACE Constr With +## +## Ends in an error in state: 421. +## +## projection -> Constr . DOT Ident DOT nsepseq(selection,DOT) [ With ] +## +## The known suffix of the stack is as follows: +## Constr +## + + + +interactive_expr: LBRACE Ident DOT Ident VBAR +## +## Ends in an error in state: 427. +## +## update_record -> LBRACE path . With sep_or_term_list(field_path_assignment,SEMI) RBRACE [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## LBRACE path +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 182, spurious reduction of production nsepseq(selection,DOT) -> selection +## In state 185, spurious reduction of production projection -> Ident DOT nsepseq(selection,DOT) +## In state 426, spurious reduction of production path -> projection +## + + + +interactive_expr: LBRACE Ident EQ Bytes SEMI Ident EQ Bytes SEMI With +## +## Ends in an error in state: 454. +## +## nsepseq(field_assignment,SEMI) -> field_assignment SEMI . nsepseq(field_assignment,SEMI) [ RBRACE ] +## seq(__anonymous_0(field_assignment,SEMI)) -> field_assignment SEMI . seq(__anonymous_0(field_assignment,SEMI)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_assignment SEMI +## + + + +interactive_expr: LBRACE Ident EQ Bytes SEMI Ident EQ Bytes With +## +## Ends in an error in state: 453. +## +## nsepseq(field_assignment,SEMI) -> field_assignment . [ RBRACE ] +## nsepseq(field_assignment,SEMI) -> field_assignment . SEMI nsepseq(field_assignment,SEMI) [ RBRACE ] +## seq(__anonymous_0(field_assignment,SEMI)) -> field_assignment . SEMI seq(__anonymous_0(field_assignment,SEMI)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_assignment +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 246, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 300, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 301, spurious reduction of production expr -> base_cond__open(expr) +## In state 420, spurious reduction of production field_assignment -> Ident EQ expr +## + + + +interactive_expr: LBRACE Ident EQ Bytes SEMI Ident With +## +## Ends in an error in state: 450. +## +## field_assignment -> Ident . EQ expr [ SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## Ident +## + + + +interactive_expr: LBRACE Ident EQ Bytes SEMI With +## +## Ends in an error in state: 449. +## +## nsepseq(field_assignment,SEMI) -> field_assignment SEMI . nsepseq(field_assignment,SEMI) [ RBRACE ] +## nseq(__anonymous_0(field_assignment,SEMI)) -> field_assignment SEMI . seq(__anonymous_0(field_assignment,SEMI)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_assignment SEMI +## + + + +interactive_expr: LBRACE Ident EQ Bytes With +## +## Ends in an error in state: 448. +## +## nsepseq(field_assignment,SEMI) -> field_assignment . [ RBRACE ] +## nsepseq(field_assignment,SEMI) -> field_assignment . SEMI nsepseq(field_assignment,SEMI) [ RBRACE ] +## nseq(__anonymous_0(field_assignment,SEMI)) -> field_assignment . SEMI seq(__anonymous_0(field_assignment,SEMI)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_assignment +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 246, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 300, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 301, spurious reduction of production expr -> base_cond__open(expr) +## In state 420, spurious reduction of production field_assignment -> Ident EQ expr +## + + + +interactive_expr: LBRACE Ident EQ With +## +## Ends in an error in state: 175. +## +## field_assignment -> Ident EQ . expr [ SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## Ident EQ +## + + + +interactive_expr: LBRACE Ident WILD +## +## Ends in an error in state: 174. +## +## field_assignment -> Ident . EQ expr [ SEMI RBRACE ] +## path -> Ident . [ With ] +## projection -> Ident . DOT nsepseq(selection,DOT) [ With ] +## +## The known suffix of the stack is as follows: +## Ident +## + + + +interactive_expr: LBRACE Ident With Ident DOT With +## +## Ends in an error in state: 430. +## +## nsepseq(field_name,DOT) -> Ident DOT . nsepseq(field_name,DOT) [ EQ ] +## +## The known suffix of the stack is as follows: +## Ident DOT +## + + + +interactive_expr: LBRACE Ident With Ident EQ Bytes SEMI Ident EQ Bytes SEMI With +## +## Ends in an error in state: 444. +## +## nsepseq(field_path_assignment,SEMI) -> field_path_assignment SEMI . nsepseq(field_path_assignment,SEMI) [ RBRACE ] +## seq(__anonymous_0(field_path_assignment,SEMI)) -> field_path_assignment SEMI . seq(__anonymous_0(field_path_assignment,SEMI)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_path_assignment SEMI +## + + + +interactive_expr: LBRACE Ident With Ident EQ Bytes SEMI Ident EQ Bytes With +## +## Ends in an error in state: 443. +## +## nsepseq(field_path_assignment,SEMI) -> field_path_assignment . [ RBRACE ] +## nsepseq(field_path_assignment,SEMI) -> field_path_assignment . SEMI nsepseq(field_path_assignment,SEMI) [ RBRACE ] +## seq(__anonymous_0(field_path_assignment,SEMI)) -> field_path_assignment . SEMI seq(__anonymous_0(field_path_assignment,SEMI)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_path_assignment +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 246, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 300, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 301, spurious reduction of production expr -> base_cond__open(expr) +## In state 438, spurious reduction of production field_path_assignment -> nsepseq(field_name,DOT) EQ expr +## + + + +interactive_expr: LBRACE Ident With Ident EQ Bytes SEMI With +## +## Ends in an error in state: 440. +## +## nsepseq(field_path_assignment,SEMI) -> field_path_assignment SEMI . nsepseq(field_path_assignment,SEMI) [ RBRACE ] +## nseq(__anonymous_0(field_path_assignment,SEMI)) -> field_path_assignment SEMI . seq(__anonymous_0(field_path_assignment,SEMI)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_path_assignment SEMI +## + + + +interactive_expr: LBRACE Ident With Ident EQ Bytes With +## +## Ends in an error in state: 439. +## +## nsepseq(field_path_assignment,SEMI) -> field_path_assignment . [ RBRACE ] +## nsepseq(field_path_assignment,SEMI) -> field_path_assignment . SEMI nsepseq(field_path_assignment,SEMI) [ RBRACE ] +## nseq(__anonymous_0(field_path_assignment,SEMI)) -> field_path_assignment . SEMI seq(__anonymous_0(field_path_assignment,SEMI)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_path_assignment +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 246, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 300, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 301, spurious reduction of production expr -> base_cond__open(expr) +## In state 438, spurious reduction of production field_path_assignment -> nsepseq(field_name,DOT) EQ expr +## + + + +interactive_expr: LBRACE Ident With Ident EQ With +## +## Ends in an error in state: 437. +## +## field_path_assignment -> nsepseq(field_name,DOT) EQ . expr [ SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## nsepseq(field_name,DOT) EQ +## + + + +interactive_expr: LBRACE Ident With Ident With +## +## Ends in an error in state: 429. +## +## nsepseq(field_name,DOT) -> Ident . [ EQ ] +## nsepseq(field_name,DOT) -> Ident . DOT nsepseq(field_name,DOT) [ EQ ] +## +## The known suffix of the stack is as follows: +## Ident +## + + + +interactive_expr: LBRACE Ident With With +## +## Ends in an error in state: 428. +## +## update_record -> LBRACE path With . sep_or_term_list(field_path_assignment,SEMI) RBRACE [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## LBRACE path With +## + + + +interactive_expr: LBRACE With +## +## Ends in an error in state: 173. +## +## record_expr -> LBRACE . sep_or_term_list(field_assignment,SEMI) RBRACE [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## update_record -> LBRACE . path With sep_or_term_list(field_path_assignment,SEMI) RBRACE [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## LBRACE +## + + + +interactive_expr: LBRACKET True End +## +## Ends in an error in state: 456. +## +## list__(expr) -> LBRACKET option(sep_or_term_list(expr,SEMI)) . RBRACKET [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## LBRACKET option(sep_or_term_list(expr,SEMI)) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 246, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 300, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 301, spurious reduction of production expr -> base_cond__open(expr) +## In state 239, spurious reduction of production nsepseq(expr,SEMI) -> expr +## In state 217, spurious reduction of production sep_or_term_list(expr,SEMI) -> nsepseq(expr,SEMI) +## In state 213, spurious reduction of production option(sep_or_term_list(expr,SEMI)) -> sep_or_term_list(expr,SEMI) +## + + + +interactive_expr: LBRACKET True SEMI True SEMI With +## +## Ends in an error in state: 244. +## +## nsepseq(expr,SEMI) -> expr SEMI . nsepseq(expr,SEMI) [ RBRACKET End ] +## seq(__anonymous_0(expr,SEMI)) -> expr SEMI . seq(__anonymous_0(expr,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## expr SEMI +## + + + +interactive_expr: LBRACKET True SEMI True With +## +## Ends in an error in state: 243. +## +## nsepseq(expr,SEMI) -> expr . [ RBRACKET End ] +## nsepseq(expr,SEMI) -> expr . SEMI nsepseq(expr,SEMI) [ RBRACKET End ] +## seq(__anonymous_0(expr,SEMI)) -> expr . SEMI seq(__anonymous_0(expr,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 246, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 300, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 301, spurious reduction of production expr -> base_cond__open(expr) +## + + + +interactive_expr: LBRACKET True SEMI With +## +## Ends in an error in state: 240. +## +## nsepseq(expr,SEMI) -> expr SEMI . nsepseq(expr,SEMI) [ RBRACKET End ] +## nseq(__anonymous_0(expr,SEMI)) -> expr SEMI . seq(__anonymous_0(expr,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## expr SEMI +## + + + +interactive_expr: LBRACKET True With +## +## Ends in an error in state: 239. +## +## nsepseq(expr,SEMI) -> expr . [ RBRACKET End ] +## nsepseq(expr,SEMI) -> expr . SEMI nsepseq(expr,SEMI) [ RBRACKET End ] +## nseq(__anonymous_0(expr,SEMI)) -> expr . SEMI seq(__anonymous_0(expr,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 246, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 300, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 301, spurious reduction of production expr -> base_cond__open(expr) +## + + + +interactive_expr: LBRACKET With +## +## Ends in an error in state: 166. +## +## list__(expr) -> LBRACKET . option(sep_or_term_list(expr,SEMI)) RBRACKET [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## LBRACKET +## + + + +interactive_expr: LPAR True COLON Ident VBAR +## +## Ends in an error in state: 483. +## +## par(__anonymous_1) -> LPAR expr COLON type_expr . RPAR [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## LPAR expr COLON type_expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 27, spurious reduction of production cartesian -> core_type +## In state 35, spurious reduction of production fun_type -> cartesian +## In state 26, spurious reduction of production type_expr -> fun_type +## + + + +interactive_expr: LPAR True COLON With +## +## Ends in an error in state: 482. +## +## par(__anonymous_1) -> LPAR expr COLON . type_expr RPAR [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## LPAR expr COLON +## + + + +interactive_expr: LPAR True With +## +## Ends in an error in state: 480. +## +## par(__anonymous_1) -> LPAR expr . COLON type_expr RPAR [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## par(expr) -> LPAR expr . RPAR [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## LPAR expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 246, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 300, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 301, spurious reduction of production expr -> base_cond__open(expr) +## + + + +interactive_expr: LPAR With +## +## Ends in an error in state: 163. +## +## par(__anonymous_1) -> LPAR . expr COLON type_expr RPAR [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## par(expr) -> LPAR . expr RPAR [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## unit -> LPAR . RPAR [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## LPAR +## + + + +interactive_expr: Let WILD EQ Bytes Attr Type +## +## Ends in an error in state: 171. +## +## let_expr(expr) -> Let let_binding seq(Attr) . In expr [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## Let let_binding seq(Attr) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 169, spurious reduction of production seq(Attr) -> +## In state 170, spurious reduction of production seq(Attr) -> Attr seq(Attr) +## + + + +interactive_expr: Let WILD EQ Bytes In With +## +## Ends in an error in state: 172. +## +## let_expr(expr) -> Let let_binding seq(Attr) In . expr [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## Let let_binding seq(Attr) In +## + + + +interactive_expr: Let WILD EQ Bytes With +## +## Ends in an error in state: 168. +## +## let_expr(expr) -> Let let_binding . seq(Attr) In expr [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## Let let_binding +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 246, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 300, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 301, spurious reduction of production expr -> base_cond__open(expr) +## In state 382, spurious reduction of production let_binding -> irrefutable option(type_annotation) EQ expr +## + + + +interactive_expr: Let With +## +## Ends in an error in state: 167. +## +## let_expr(expr) -> Let . let_binding seq(Attr) In expr [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## Let +## + + + +interactive_expr: MINUS With +## +## Ends in an error in state: 165. +## +## unary_expr_level -> MINUS . call_expr_level [ With VBAR Type Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS Let LT LE In GT GE End Else EQ EOF CONS COMMA COLON CAT BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## MINUS +## + + + +interactive_expr: Match True Type +## +## Ends in an error in state: 459. +## +## match_expr(base_cond) -> Match expr . With option(VBAR) cases(base_cond) [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## Match expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 246, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 300, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 301, spurious reduction of production expr -> base_cond__open(expr) +## + + + +interactive_expr: Match True With LPAR Bytes RPAR With +## +## Ends in an error in state: 316. +## +## pattern -> sub_pattern . CONS tail [ ARROW ] +## tuple(sub_pattern) -> sub_pattern . COMMA nsepseq(sub_pattern,COMMA) [ ARROW ] +## +## The known suffix of the stack is as follows: +## sub_pattern +## + + + +interactive_expr: Match True With VBAR Begin +## +## Ends in an error in state: 461. +## +## match_expr(base_cond) -> Match expr With option(VBAR) . cases(base_cond) [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## Match expr With option(VBAR) +## + + + +interactive_expr: Match True With WILD ARROW Bytes VBAR With +## +## Ends in an error in state: 479. +## +## cases(base_cond) -> cases(base_cond) VBAR . case_clause(base_cond) [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## cases(base_cond) VBAR +## + + + +interactive_expr: Match True With WILD ARROW Fun WILD ARROW With +## +## Ends in an error in state: 475. +## +## fun_expr(base_cond) -> Fun nseq(irrefutable) ARROW . base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## Fun nseq(irrefutable) ARROW +## + + + +interactive_expr: Match True With WILD ARROW Fun With +## +## Ends in an error in state: 473. +## +## fun_expr(base_cond) -> Fun . nseq(irrefutable) ARROW base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## Fun +## + + + +interactive_expr: Match True With WILD ARROW If True Then Fun WILD ARROW With +## +## Ends in an error in state: 354. +## +## fun_expr(base_cond) -> Fun nseq(irrefutable) ARROW . base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## fun_expr(closed_if) -> Fun nseq(irrefutable) ARROW . closed_if [ Else ] +## +## The known suffix of the stack is as follows: +## Fun nseq(irrefutable) ARROW +## + + + +interactive_expr: Match True With WILD ARROW If True Then Fun With +## +## Ends in an error in state: 352. +## +## fun_expr(base_cond) -> Fun . nseq(irrefutable) ARROW base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## fun_expr(closed_if) -> Fun . nseq(irrefutable) ARROW closed_if [ Else ] +## +## The known suffix of the stack is as follows: +## Fun +## + + + +interactive_expr: Match True With WILD ARROW If True Then If True Then True Else With +## +## Ends in an error in state: 373. +## +## if_then_else(base_cond) -> If expr Then closed_if Else . base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## if_then_else(closed_if) -> If expr Then closed_if Else . closed_if [ Else ] +## +## The known suffix of the stack is as follows: +## If expr Then closed_if Else +## + + + +interactive_expr: Match True With WILD ARROW If True Then If True Then With +## +## Ends in an error in state: 351. +## +## if_then(base_cond) -> If expr Then . base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## if_then_else(base_cond) -> If expr Then . closed_if Else base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## if_then_else(closed_if) -> If expr Then . closed_if Else closed_if [ Else ] +## +## The known suffix of the stack is as follows: +## If expr Then +## + + + +interactive_expr: Match True With WILD ARROW If True Then If True With +## +## Ends in an error in state: 350. +## +## if_then(base_cond) -> If expr . Then base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## if_then_else(base_cond) -> If expr . Then closed_if Else base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## if_then_else(closed_if) -> If expr . Then closed_if Else closed_if [ Else ] +## +## The known suffix of the stack is as follows: +## If expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 246, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 300, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 301, spurious reduction of production expr -> base_cond__open(expr) +## + + + +interactive_expr: Match True With WILD ARROW If True Then If With +## +## Ends in an error in state: 349. +## +## if_then(base_cond) -> If . expr Then base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## if_then_else(base_cond) -> If . expr Then closed_if Else base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## if_then_else(closed_if) -> If . expr Then closed_if Else closed_if [ Else ] +## +## The known suffix of the stack is as follows: +## If +## + + + +interactive_expr: Match True With WILD ARROW If True Then Let WILD EQ Bytes Attr Type +## +## Ends in an error in state: 347. +## +## let_expr(base_cond) -> Let let_binding seq(Attr) . In base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## let_expr(closed_if) -> Let let_binding seq(Attr) . In closed_if [ Else ] +## +## The known suffix of the stack is as follows: +## Let let_binding seq(Attr) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 169, spurious reduction of production seq(Attr) -> +## In state 170, spurious reduction of production seq(Attr) -> Attr seq(Attr) +## + + + +interactive_expr: Match True With WILD ARROW If True Then Let WILD EQ Bytes In With +## +## Ends in an error in state: 348. +## +## let_expr(base_cond) -> Let let_binding seq(Attr) In . base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## let_expr(closed_if) -> Let let_binding seq(Attr) In . closed_if [ Else ] +## +## The known suffix of the stack is as follows: +## Let let_binding seq(Attr) In +## + + + +interactive_expr: Match True With WILD ARROW If True Then Let WILD EQ Bytes With +## +## Ends in an error in state: 346. +## +## let_expr(base_cond) -> Let let_binding . seq(Attr) In base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## let_expr(closed_if) -> Let let_binding . seq(Attr) In closed_if [ Else ] +## +## The known suffix of the stack is as follows: +## Let let_binding +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 246, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 300, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 301, spurious reduction of production expr -> base_cond__open(expr) +## In state 382, spurious reduction of production let_binding -> irrefutable option(type_annotation) EQ expr +## + + + +interactive_expr: Match True With WILD ARROW If True Then Let With +## +## Ends in an error in state: 345. +## +## let_expr(base_cond) -> Let . let_binding seq(Attr) In base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## let_expr(closed_if) -> Let . let_binding seq(Attr) In closed_if [ Else ] +## +## The known suffix of the stack is as follows: +## Let +## + + + +interactive_expr: Match True With WILD ARROW If True Then Match True Type +## +## Ends in an error in state: 334. +## +## match_expr(base_if_then_else) -> Match expr . With option(VBAR) cases(base_if_then_else) [ Else ] +## +## The known suffix of the stack is as follows: +## Match expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 246, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 300, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 301, spurious reduction of production expr -> base_cond__open(expr) +## + + + +interactive_expr: Match True With WILD ARROW If True Then Match True With VBAR Begin +## +## Ends in an error in state: 336. +## +## match_expr(base_if_then_else) -> Match expr With option(VBAR) . cases(base_if_then_else) [ Else ] +## +## The known suffix of the stack is as follows: +## Match expr With option(VBAR) +## + + + +interactive_expr: Match True With WILD ARROW If True Then Match True With WILD ARROW Bytes With +## +## Ends in an error in state: 339. +## +## cases(base_cond) -> cases(base_cond) . VBAR case_clause(base_cond) [ VBAR ] +## cases(base_if_then_else) -> cases(base_cond) . VBAR case_clause(base_if_then_else) [ Else ] +## +## The known suffix of the stack is as follows: +## cases(base_cond) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 392, spurious reduction of production base_expr(base_cond) -> disj_expr_level +## In state 369, spurious reduction of production base_cond__open(base_cond) -> base_expr(base_cond) +## In state 370, spurious reduction of production base_cond -> base_cond__open(base_cond) +## In state 399, spurious reduction of production case_clause(base_cond) -> pattern ARROW base_cond +## In state 344, spurious reduction of production cases(base_cond) -> case_clause(base_cond) +## + + + +interactive_expr: Match True With WILD ARROW If True Then Match True With With +## +## Ends in an error in state: 335. +## +## match_expr(base_if_then_else) -> Match expr With . option(VBAR) cases(base_if_then_else) [ Else ] +## +## The known suffix of the stack is as follows: +## Match expr With +## + + + +interactive_expr: Match True With WILD ARROW If True Then Match With +## +## Ends in an error in state: 333. +## +## match_expr(base_if_then_else) -> Match . expr With option(VBAR) cases(base_if_then_else) [ Else ] +## +## The known suffix of the stack is as follows: +## Match +## + + + +interactive_expr: Match True With WILD ARROW If True Then True Else With +## +## Ends in an error in state: 472. +## +## if_then_else(base_cond) -> If expr Then closed_if Else . base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## If expr Then closed_if Else +## + + + +interactive_expr: Match True With WILD ARROW If True Then With +## +## Ends in an error in state: 470. +## +## if_then(base_cond) -> If expr Then . base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## if_then_else(base_cond) -> If expr Then . closed_if Else base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## If expr Then +## + + + +interactive_expr: Match True With WILD ARROW If True With +## +## Ends in an error in state: 469. +## +## if_then(base_cond) -> If expr . Then base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## if_then_else(base_cond) -> If expr . Then closed_if Else base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## If expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 246, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 300, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 301, spurious reduction of production expr -> base_cond__open(expr) +## + + + +interactive_expr: Match True With WILD ARROW If With +## +## Ends in an error in state: 468. +## +## if_then(base_cond) -> If . expr Then base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## if_then_else(base_cond) -> If . expr Then closed_if Else base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## If +## + + + +interactive_expr: Match True With WILD ARROW Let WILD EQ Bytes Attr Type +## +## Ends in an error in state: 466. +## +## let_expr(base_cond) -> Let let_binding seq(Attr) . In base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## Let let_binding seq(Attr) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 169, spurious reduction of production seq(Attr) -> +## In state 170, spurious reduction of production seq(Attr) -> Attr seq(Attr) +## + + + +interactive_expr: Match True With WILD ARROW Let WILD EQ Bytes In With +## +## Ends in an error in state: 467. +## +## let_expr(base_cond) -> Let let_binding seq(Attr) In . base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## Let let_binding seq(Attr) In +## + + + +interactive_expr: Match True With WILD ARROW Let WILD EQ Bytes With +## +## Ends in an error in state: 465. +## +## let_expr(base_cond) -> Let let_binding . seq(Attr) In base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## Let let_binding +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 246, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 300, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 301, spurious reduction of production expr -> base_cond__open(expr) +## In state 382, spurious reduction of production let_binding -> irrefutable option(type_annotation) EQ expr +## + + + +interactive_expr: Match True With WILD ARROW Let With +## +## Ends in an error in state: 464. +## +## let_expr(base_cond) -> Let . let_binding seq(Attr) In base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## Let +## + + + +interactive_expr: Match True With WILD ARROW True COMMA Bytes Else +## +## Ends in an error in state: 478. +## +## cases(base_cond) -> cases(base_cond) . VBAR case_clause(base_cond) [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## match_expr(base_cond) -> Match expr With option(VBAR) cases(base_cond) . [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## Match expr With option(VBAR) cases(base_cond) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 291, spurious reduction of production nsepseq(disj_expr_level,COMMA) -> disj_expr_level +## In state 290, spurious reduction of production tuple(disj_expr_level) -> disj_expr_level COMMA nsepseq(disj_expr_level,COMMA) +## In state 212, spurious reduction of production tuple_expr -> tuple(disj_expr_level) +## In state 476, spurious reduction of production base_expr(base_cond) -> tuple_expr +## In state 369, spurious reduction of production base_cond__open(base_cond) -> base_expr(base_cond) +## In state 370, spurious reduction of production base_cond -> base_cond__open(base_cond) +## In state 399, spurious reduction of production case_clause(base_cond) -> pattern ARROW base_cond +## In state 344, spurious reduction of production cases(base_cond) -> case_clause(base_cond) +## + + + +interactive_expr: Match True With WILD ARROW True Else +## +## Ends in an error in state: 477. +## +## base_expr(base_cond) -> disj_expr_level . [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## bin_op(disj_expr_level,BOOL_OR,conj_expr_level) -> disj_expr_level . BOOL_OR conj_expr_level [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Or Let In End EOF COMMA COLON BOOL_OR Attr ] +## bin_op(disj_expr_level,Or,conj_expr_level) -> disj_expr_level . Or conj_expr_level [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Or Let In End EOF COMMA COLON BOOL_OR Attr ] +## tuple(disj_expr_level) -> disj_expr_level . COMMA nsepseq(disj_expr_level,COMMA) [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## disj_expr_level +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## + + + +interactive_expr: Match True With WILD ARROW With +## +## Ends in an error in state: 463. +## +## case_clause(base_cond) -> pattern ARROW . base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## pattern ARROW +## + + + +interactive_expr: Match True With WILD COMMA WILD COMMA With +## +## Ends in an error in state: 321. +## +## nsepseq(sub_pattern,COMMA) -> sub_pattern COMMA . nsepseq(sub_pattern,COMMA) [ ARROW ] +## +## The known suffix of the stack is as follows: +## sub_pattern COMMA +## + + + +interactive_expr: Match True With WILD COMMA WILD With +## +## Ends in an error in state: 320. +## +## nsepseq(sub_pattern,COMMA) -> sub_pattern . [ ARROW ] +## nsepseq(sub_pattern,COMMA) -> sub_pattern . COMMA nsepseq(sub_pattern,COMMA) [ ARROW ] +## +## The known suffix of the stack is as follows: +## sub_pattern +## + + + +interactive_expr: Match True With WILD COMMA With +## +## Ends in an error in state: 319. +## +## tuple(sub_pattern) -> sub_pattern COMMA . nsepseq(sub_pattern,COMMA) [ ARROW ] +## +## The known suffix of the stack is as follows: +## sub_pattern COMMA +## + + + +interactive_expr: Match True With WILD CONS Bytes SEMI +## +## Ends in an error in state: 462. +## +## case_clause(base_cond) -> pattern . ARROW base_cond [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## pattern +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 94, spurious reduction of production tail -> sub_pattern +## In state 318, spurious reduction of production pattern -> sub_pattern CONS tail +## + + + +interactive_expr: Match True With WILD CONS With +## +## Ends in an error in state: 317. +## +## pattern -> sub_pattern CONS . tail [ ARROW ] +## +## The known suffix of the stack is as follows: +## sub_pattern CONS +## + + + +interactive_expr: Match True With WILD With +## +## Ends in an error in state: 337. +## +## pattern -> core_pattern . [ ARROW ] +## sub_pattern -> core_pattern . [ CONS COMMA ] +## +## The known suffix of the stack is as follows: +## core_pattern +## + + + +interactive_expr: Match True With With +## +## Ends in an error in state: 460. +## +## match_expr(base_cond) -> Match expr With . option(VBAR) cases(base_cond) [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## Match expr With +## + + + +interactive_expr: Match With +## +## Ends in an error in state: 164. +## +## match_expr(base_cond) -> Match . expr With option(VBAR) cases(base_cond) [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## Match +## + + + +interactive_expr: Not With +## +## Ends in an error in state: 160. +## +## unary_expr_level -> Not . call_expr_level [ With VBAR Type Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS Let LT LE In GT GE End Else EQ EOF CONS COMMA COLON CAT BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## Not +## + + + +interactive_expr: True BOOL_AND With +## +## Ends in an error in state: 266. +## +## bin_op(conj_expr_level,BOOL_AND,comp_expr_level) -> conj_expr_level BOOL_AND . comp_expr_level [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Or Let In End Else EOF COMMA COLON BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## conj_expr_level BOOL_AND +## + + + +interactive_expr: True BOOL_OR With +## +## Ends in an error in state: 297. +## +## bin_op(disj_expr_level,BOOL_OR,conj_expr_level) -> disj_expr_level BOOL_OR . conj_expr_level [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Or Let In End Else EOF COMMA COLON BOOL_OR Attr ] +## +## The known suffix of the stack is as follows: +## disj_expr_level BOOL_OR +## + + + +interactive_expr: True CAT With +## +## Ends in an error in state: 249. +## +## bin_op(cons_expr_level,CAT,cat_expr_level) -> cons_expr_level CAT . cat_expr_level [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Or NE Let LT LE In GT GE End Else EQ EOF COMMA COLON BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## cons_expr_level CAT +## + + + +interactive_expr: True COMMA True COMMA With +## +## Ends in an error in state: 292. +## +## nsepseq(disj_expr_level,COMMA) -> disj_expr_level COMMA . nsepseq(disj_expr_level,COMMA) [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End Else EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## disj_expr_level COMMA +## + + + +interactive_expr: True COMMA With +## +## Ends in an error in state: 289. +## +## tuple(disj_expr_level) -> disj_expr_level COMMA . nsepseq(disj_expr_level,COMMA) [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Let In End Else EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## disj_expr_level COMMA +## + + + +interactive_expr: True CONS With +## +## Ends in an error in state: 263. +## +## bin_op(add_expr_level,CONS,cons_expr_level) -> add_expr_level CONS . cons_expr_level [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Or NE Let LT LE In GT GE End Else EQ EOF COMMA COLON CAT BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## add_expr_level CONS +## + + + +interactive_expr: True Constr With +## +## Ends in an error in state: 195. +## +## module_field -> Constr . DOT Ident [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## projection -> Constr . DOT Ident DOT nsepseq(selection,DOT) [ With VBAR Type True Then TIMES String SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Nat NE Mutez Mod MINUS Let LT LPAR LE LBRACKET LBRACE Int In Ident GT GE False End Else EQ EOF Constr CONS COMMA COLON CAT Bytes Begin BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## Constr +## + + + +interactive_expr: True EQ With +## +## Ends in an error in state: 278. +## +## bin_op(comp_expr_level,EQ,cat_expr_level) -> comp_expr_level EQ . cat_expr_level [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Or NE Let LT LE In GT GE End Else EQ EOF COMMA COLON BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## comp_expr_level EQ +## + + + +interactive_expr: True GE With +## +## Ends in an error in state: 276. +## +## bin_op(comp_expr_level,GE,cat_expr_level) -> comp_expr_level GE . cat_expr_level [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Or NE Let LT LE In GT GE End Else EQ EOF COMMA COLON BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## comp_expr_level GE +## + + + +interactive_expr: True GT With +## +## Ends in an error in state: 274. +## +## bin_op(comp_expr_level,GT,cat_expr_level) -> comp_expr_level GT . cat_expr_level [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Or NE Let LT LE In GT GE End Else EQ EOF COMMA COLON BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## comp_expr_level GT +## + + + +interactive_expr: True LE With +## +## Ends in an error in state: 272. +## +## bin_op(comp_expr_level,LE,cat_expr_level) -> comp_expr_level LE . cat_expr_level [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Or NE Let LT LE In GT GE End Else EQ EOF COMMA COLON BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## comp_expr_level LE +## + + + +interactive_expr: True LT With +## +## Ends in an error in state: 270. +## +## bin_op(comp_expr_level,LT,cat_expr_level) -> comp_expr_level LT . cat_expr_level [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Or NE Let LT LE In GT GE End Else EQ EOF COMMA COLON BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## comp_expr_level LT +## + + + +interactive_expr: True MINUS C_None WILD +## +## Ends in an error in state: 262. +## +## bin_op(add_expr_level,MINUS,mult_expr_level) -> add_expr_level MINUS mult_expr_level . [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE PLUS Or NE MINUS Let LT LE In GT GE End Else EQ EOF CONS COMMA COLON CAT BOOL_OR BOOL_AND Attr ] +## bin_op(mult_expr_level,Mod,unary_expr_level) -> mult_expr_level . Mod unary_expr_level [ With VBAR Type Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS Let LT LE In GT GE End Else EQ EOF CONS COMMA COLON CAT BOOL_OR BOOL_AND Attr ] +## bin_op(mult_expr_level,SLASH,unary_expr_level) -> mult_expr_level . SLASH unary_expr_level [ With VBAR Type Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS Let LT LE In GT GE End Else EQ EOF CONS COMMA COLON CAT BOOL_OR BOOL_AND Attr ] +## bin_op(mult_expr_level,TIMES,unary_expr_level) -> mult_expr_level . TIMES unary_expr_level [ With VBAR Type Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS Let LT LE In GT GE End Else EQ EOF CONS COMMA COLON CAT BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## add_expr_level MINUS mult_expr_level +## + + + +interactive_expr: True MINUS With +## +## Ends in an error in state: 261. +## +## bin_op(add_expr_level,MINUS,mult_expr_level) -> add_expr_level MINUS . mult_expr_level [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE PLUS Or NE MINUS Let LT LE In GT GE End Else EQ EOF CONS COMMA COLON CAT BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## add_expr_level MINUS +## + +Biep boop bap + +interactive_expr: True Mod With +## +## Ends in an error in state: 232. +## +## bin_op(mult_expr_level,Mod,unary_expr_level) -> mult_expr_level Mod . unary_expr_level [ With VBAR Type Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS Let LT LE In GT GE End Else EQ EOF CONS COMMA COLON CAT BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## mult_expr_level Mod +## + + + +interactive_expr: True NE With +## +## Ends in an error in state: 268. +## +## bin_op(comp_expr_level,NE,cat_expr_level) -> comp_expr_level NE . cat_expr_level [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Or NE Let LT LE In GT GE End Else EQ EOF COMMA COLON BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## comp_expr_level NE +## + + + +interactive_expr: True Or With +## +## Ends in an error in state: 247. +## +## bin_op(disj_expr_level,Or,conj_expr_level) -> disj_expr_level Or . conj_expr_level [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE Or Let In End Else EOF COMMA COLON BOOL_OR Attr ] +## +## The known suffix of the stack is as follows: +## disj_expr_level Or +## + + + +interactive_expr: True PLUS C_None WILD +## +## Ends in an error in state: 260. +## +## bin_op(add_expr_level,PLUS,mult_expr_level) -> add_expr_level PLUS mult_expr_level . [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE PLUS Or NE MINUS Let LT LE In GT GE End Else EQ EOF CONS COMMA COLON CAT BOOL_OR BOOL_AND Attr ] +## bin_op(mult_expr_level,Mod,unary_expr_level) -> mult_expr_level . Mod unary_expr_level [ With VBAR Type Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS Let LT LE In GT GE End Else EQ EOF CONS COMMA COLON CAT BOOL_OR BOOL_AND Attr ] +## bin_op(mult_expr_level,SLASH,unary_expr_level) -> mult_expr_level . SLASH unary_expr_level [ With VBAR Type Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS Let LT LE In GT GE End Else EQ EOF CONS COMMA COLON CAT BOOL_OR BOOL_AND Attr ] +## bin_op(mult_expr_level,TIMES,unary_expr_level) -> mult_expr_level . TIMES unary_expr_level [ With VBAR Type Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS Let LT LE In GT GE End Else EQ EOF CONS COMMA COLON CAT BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## add_expr_level PLUS mult_expr_level +## + + + +interactive_expr: True PLUS With +## +## Ends in an error in state: 259. +## +## bin_op(add_expr_level,PLUS,mult_expr_level) -> add_expr_level PLUS . mult_expr_level [ With VBAR Type Then SEMI RPAR RBRACKET RBRACE PLUS Or NE MINUS Let LT LE In GT GE End Else EQ EOF CONS COMMA COLON CAT BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## add_expr_level PLUS +## + +Bliepaty + +interactive_expr: True SLASH With +## +## Ends in an error in state: 230. +## +## bin_op(mult_expr_level,SLASH,unary_expr_level) -> mult_expr_level SLASH . unary_expr_level [ With VBAR Type Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS Let LT LE In GT GE End Else EQ EOF CONS COMMA COLON CAT BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## mult_expr_level SLASH +## + + + +interactive_expr: True TIMES With +## +## Ends in an error in state: 219. +## +## bin_op(mult_expr_level,TIMES,unary_expr_level) -> mult_expr_level TIMES . unary_expr_level [ With VBAR Type Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS Let LT LE In GT GE End Else EQ EOF CONS COMMA COLON CAT BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## mult_expr_level TIMES +## + + + +interactive_expr: True True True WILD +## +## Ends in an error in state: 225. +## +## seq(core_expr) -> core_expr . seq(core_expr) [ With VBAR Type Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS Let LT LE In GT GE End Else EQ EOF CONS COMMA COLON CAT BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## core_expr +## + + + +interactive_expr: True True WILD +## +## Ends in an error in state: 223. +## +## nseq(core_expr) -> core_expr . seq(core_expr) [ With VBAR Type Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS Let LT LE In GT GE End Else EQ EOF CONS COMMA COLON CAT BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## core_expr +## + + + +interactive_expr: True VBAR +## +## Ends in an error in state: 246. +## +## base_expr(expr) -> disj_expr_level . [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## bin_op(disj_expr_level,BOOL_OR,conj_expr_level) -> disj_expr_level . BOOL_OR conj_expr_level [ With Type Then SEMI RPAR RBRACKET RBRACE Or Let In End EOF COMMA COLON BOOL_OR Attr ] +## bin_op(disj_expr_level,Or,conj_expr_level) -> disj_expr_level . Or conj_expr_level [ With Type Then SEMI RPAR RBRACKET RBRACE Or Let In End EOF COMMA COLON BOOL_OR Attr ] +## tuple(disj_expr_level) -> disj_expr_level . COMMA nsepseq(disj_expr_level,COMMA) [ With Type Then SEMI RPAR RBRACKET RBRACE Let In End EOF COLON Attr ] +## +## The known suffix of the stack is as follows: +## disj_expr_level +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## + + + +interactive_expr: True WILD +## +## Ends in an error in state: 221. +## +## call_expr -> core_expr . nseq(core_expr) [ With VBAR Type Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS Let LT LE In GT GE End Else EQ EOF CONS COMMA COLON CAT BOOL_OR BOOL_AND Attr ] +## call_expr_level -> core_expr . [ With VBAR Type Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS Let LT LE In GT GE End Else EQ EOF CONS COMMA COLON CAT BOOL_OR BOOL_AND Attr ] +## +## The known suffix of the stack is as follows: +## core_expr +## + + + +interactive_expr: True With +## +## Ends in an error in state: 498. +## +## interactive_expr -> expr . EOF [ # ] +## +## The known suffix of the stack is as follows: +## expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 246, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 300, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 301, spurious reduction of production expr -> base_cond__open(expr) +## + + + +interactive_expr: With +## +## Ends in an error in state: 496. +## +## interactive_expr' -> . interactive_expr [ # ] +## +## The known suffix of the stack is as follows: +## +## + + + +contract: Let Ident WILD COLON Ident VBAR +## +## Ends in an error in state: 156. +## +## let_binding -> Ident nseq(sub_irrefutable) option(type_annotation) . EQ expr [ Type Let In EOF Attr ] +## +## The known suffix of the stack is as follows: +## Ident nseq(sub_irrefutable) option(type_annotation) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 27, spurious reduction of production cartesian -> core_type +## In state 35, spurious reduction of production fun_type -> cartesian +## In state 26, spurious reduction of production type_expr -> fun_type +## In state 154, spurious reduction of production type_annotation -> COLON type_expr +## In state 155, spurious reduction of production option(type_annotation) -> type_annotation +## + + + +contract: Let Ident WILD EQ With +## +## Ends in an error in state: 157. +## +## let_binding -> Ident nseq(sub_irrefutable) option(type_annotation) EQ . expr [ Type Let In EOF Attr ] +## +## The known suffix of the stack is as follows: +## Ident nseq(sub_irrefutable) option(type_annotation) EQ +## + + + +contract: Let Ident WILD WILD With +## +## Ends in an error in state: 149. +## +## seq(sub_irrefutable) -> sub_irrefutable . seq(sub_irrefutable) [ EQ COLON ] +## +## The known suffix of the stack is as follows: +## sub_irrefutable +## + + + +contract: Let Ident WILD With +## +## Ends in an error in state: 148. +## +## nseq(sub_irrefutable) -> sub_irrefutable . seq(sub_irrefutable) [ EQ COLON ] +## +## The known suffix of the stack is as follows: +## sub_irrefutable +## + + + +contract: Let Ident With +## +## Ends in an error in state: 147. +## +## let_binding -> Ident . nseq(sub_irrefutable) option(type_annotation) EQ expr [ Type Let In EOF Attr ] +## sub_irrefutable -> Ident . [ EQ COMMA COLON ] +## +## The known suffix of the stack is as follows: +## Ident +## + + + +contract: Let LBRACE Ident EQ Bytes SEMI Ident EQ Bytes SEMI With +## +## Ends in an error in state: 125. +## +## nsepseq(field_pattern,SEMI) -> field_pattern SEMI . nsepseq(field_pattern,SEMI) [ RBRACE ] +## seq(__anonymous_0(field_pattern,SEMI)) -> field_pattern SEMI . seq(__anonymous_0(field_pattern,SEMI)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_pattern SEMI +## + + + +contract: Let LBRACE Ident EQ Bytes SEMI Ident EQ Bytes With +## +## Ends in an error in state: 124. +## +## nsepseq(field_pattern,SEMI) -> field_pattern . [ RBRACE ] +## nsepseq(field_pattern,SEMI) -> field_pattern . SEMI nsepseq(field_pattern,SEMI) [ RBRACE ] +## seq(__anonymous_0(field_pattern,SEMI)) -> field_pattern . SEMI seq(__anonymous_0(field_pattern,SEMI)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_pattern +## + + + +contract: Let LBRACE Ident EQ Bytes SEMI With +## +## Ends in an error in state: 121. +## +## nsepseq(field_pattern,SEMI) -> field_pattern SEMI . nsepseq(field_pattern,SEMI) [ RBRACE ] +## nseq(__anonymous_0(field_pattern,SEMI)) -> field_pattern SEMI . seq(__anonymous_0(field_pattern,SEMI)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_pattern SEMI +## + + + +contract: Let LBRACE Ident EQ Bytes With +## +## Ends in an error in state: 120. +## +## nsepseq(field_pattern,SEMI) -> field_pattern . [ RBRACE ] +## nsepseq(field_pattern,SEMI) -> field_pattern . SEMI nsepseq(field_pattern,SEMI) [ RBRACE ] +## nseq(__anonymous_0(field_pattern,SEMI)) -> field_pattern . SEMI seq(__anonymous_0(field_pattern,SEMI)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_pattern +## + + + +contract: Let LBRACE Ident EQ With +## +## Ends in an error in state: 67. +## +## field_pattern -> Ident EQ . sub_pattern [ SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## Ident EQ +## + + + +contract: Let LBRACE Ident With +## +## Ends in an error in state: 66. +## +## field_pattern -> Ident . EQ sub_pattern [ SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## Ident +## + + + +contract: Let LBRACE With +## +## Ends in an error in state: 65. +## +## record_pattern -> LBRACE . sep_or_term_list(field_pattern,SEMI) RBRACE [ WILD SEMI RPAR RBRACKET RBRACE LPAR LBRACE Ident EQ Constr CONS COMMA COLON ARROW ] +## +## The known suffix of the stack is as follows: +## LBRACE +## + + + +contract: Let LPAR Constr C_Some With +## +## Ends in an error in state: 78. +## +## constr_pattern -> C_Some . sub_pattern [ SEMI RPAR RBRACKET RBRACE CONS COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## C_Some +## + + + +contract: Let LPAR Constr Constr With +## +## Ends in an error in state: 77. +## +## constr_pattern -> Constr . [ SEMI RPAR RBRACKET RBRACE CONS COMMA ARROW ] +## constr_pattern -> Constr . sub_pattern [ SEMI RPAR RBRACKET RBRACE CONS COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## Constr +## + + + +contract: Let LPAR Constr LBRACKET WILD RPAR +## +## Ends in an error in state: 90. +## +## nsepseq(tail,SEMI) -> tail . [ RBRACKET ] +## nsepseq(tail,SEMI) -> tail . SEMI nsepseq(tail,SEMI) [ RBRACKET ] +## nseq(__anonymous_0(tail,SEMI)) -> tail . SEMI seq(__anonymous_0(tail,SEMI)) [ RBRACKET ] +## +## The known suffix of the stack is as follows: +## tail +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 94, spurious reduction of production tail -> sub_pattern +## + + + +contract: Let LPAR Constr LBRACKET WILD SEMI WILD RPAR +## +## Ends in an error in state: 92. +## +## nsepseq(tail,SEMI) -> tail . [ RBRACKET ] +## nsepseq(tail,SEMI) -> tail . SEMI nsepseq(tail,SEMI) [ RBRACKET ] +## seq(__anonymous_0(tail,SEMI)) -> tail . SEMI seq(__anonymous_0(tail,SEMI)) [ RBRACKET ] +## +## The known suffix of the stack is as follows: +## tail +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 94, spurious reduction of production tail -> sub_pattern +## + + + +contract: Let LPAR Constr LBRACKET WILD SEMI WILD SEMI With +## +## Ends in an error in state: 93. +## +## nsepseq(tail,SEMI) -> tail SEMI . nsepseq(tail,SEMI) [ RBRACKET ] +## seq(__anonymous_0(tail,SEMI)) -> tail SEMI . seq(__anonymous_0(tail,SEMI)) [ RBRACKET ] +## +## The known suffix of the stack is as follows: +## tail SEMI +## + + + +contract: Let LPAR Constr LBRACKET WILD SEMI With +## +## Ends in an error in state: 91. +## +## nsepseq(tail,SEMI) -> tail SEMI . nsepseq(tail,SEMI) [ RBRACKET ] +## nseq(__anonymous_0(tail,SEMI)) -> tail SEMI . seq(__anonymous_0(tail,SEMI)) [ RBRACKET ] +## +## The known suffix of the stack is as follows: +## tail SEMI +## + + + +contract: Let LPAR Constr LBRACKET With +## +## Ends in an error in state: 73. +## +## list__(tail) -> LBRACKET . option(sep_or_term_list(tail,SEMI)) RBRACKET [ SEMI RPAR RBRACKET RBRACE CONS COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## LBRACKET +## + + + +contract: Let LPAR Constr LPAR WILD COMMA WILD COMMA With +## +## Ends in an error in state: 110. +## +## nsepseq(tail,COMMA) -> tail COMMA . nsepseq(tail,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## tail COMMA +## + + + +contract: Let LPAR Constr LPAR WILD COMMA WILD SEMI +## +## Ends in an error in state: 109. +## +## nsepseq(tail,COMMA) -> tail . [ RPAR ] +## nsepseq(tail,COMMA) -> tail . COMMA nsepseq(tail,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## tail +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 94, spurious reduction of production tail -> sub_pattern +## + + + +contract: Let LPAR Constr LPAR WILD COMMA With +## +## Ends in an error in state: 108. +## +## tuple(tail) -> tail COMMA . nsepseq(tail,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## tail COMMA +## + + + +contract: Let LPAR Constr LPAR WILD CONS With +## +## Ends in an error in state: 95. +## +## tail -> sub_pattern CONS . tail [ SEMI RPAR RBRACKET COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## sub_pattern CONS +## + + + +contract: Let LPAR Constr LPAR WILD SEMI +## +## Ends in an error in state: 106. +## +## par(tail) -> LPAR tail . RPAR [ SEMI RPAR RBRACKET RBRACE CONS COMMA ARROW ] +## tuple(tail) -> tail . COMMA nsepseq(tail,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## LPAR tail +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 94, spurious reduction of production tail -> sub_pattern +## + + + +contract: Let LPAR Constr LPAR WILD With +## +## Ends in an error in state: 94. +## +## tail -> sub_pattern . [ SEMI RPAR RBRACKET COMMA ARROW ] +## tail -> sub_pattern . CONS tail [ SEMI RPAR RBRACKET COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## sub_pattern +## + + + +contract: Let LPAR Constr LPAR With +## +## Ends in an error in state: 72. +## +## par(ptuple) -> LPAR . ptuple RPAR [ SEMI RPAR RBRACKET RBRACE CONS COMMA ARROW ] +## par(tail) -> LPAR . tail RPAR [ SEMI RPAR RBRACKET RBRACE CONS COMMA ARROW ] +## unit -> LPAR . RPAR [ SEMI RPAR RBRACKET RBRACE CONS COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## LPAR +## + + + +contract: Let LPAR Constr WILD With +## +## Ends in an error in state: 145. +## +## par(closed_irrefutable) -> LPAR closed_irrefutable . RPAR [ WILD RPAR LPAR LBRACE Ident EQ Constr COMMA COLON ARROW ] +## +## The known suffix of the stack is as follows: +## LPAR closed_irrefutable +## + + + +contract: Let LPAR Constr With +## +## Ends in an error in state: 128. +## +## closed_irrefutable -> Constr . sub_pattern [ RPAR ] +## sub_irrefutable -> Constr . [ RPAR COMMA COLON ] +## +## The known suffix of the stack is as follows: +## Constr +## + + + +contract: Let LPAR WILD COLON With +## +## Ends in an error in state: 143. +## +## typed_pattern -> irrefutable COLON . type_expr [ RPAR ] +## +## The known suffix of the stack is as follows: +## irrefutable COLON +## + + + +contract: Let LPAR WILD WILD +## +## Ends in an error in state: 142. +## +## closed_irrefutable -> irrefutable . [ RPAR ] +## typed_pattern -> irrefutable . COLON type_expr [ RPAR ] +## +## The known suffix of the stack is as follows: +## irrefutable +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 133, spurious reduction of production irrefutable -> sub_irrefutable +## + + + +contract: Let LPAR With +## +## Ends in an error in state: 63. +## +## par(closed_irrefutable) -> LPAR . closed_irrefutable RPAR [ WILD RPAR LPAR LBRACE Ident EQ Constr COMMA COLON ARROW ] +## unit -> LPAR . RPAR [ WILD RPAR LPAR LBRACE Ident EQ Constr COMMA COLON ARROW ] +## +## The known suffix of the stack is as follows: +## LPAR +## + + + +contract: Let WILD COLON Ident VBAR +## +## Ends in an error in state: 380. +## +## let_binding -> irrefutable option(type_annotation) . EQ expr [ Type Let In EOF Attr ] +## +## The known suffix of the stack is as follows: +## irrefutable option(type_annotation) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 27, spurious reduction of production cartesian -> core_type +## In state 35, spurious reduction of production fun_type -> cartesian +## In state 26, spurious reduction of production type_expr -> fun_type +## In state 154, spurious reduction of production type_annotation -> COLON type_expr +## In state 155, spurious reduction of production option(type_annotation) -> type_annotation +## + + + +contract: Let WILD COLON With +## +## Ends in an error in state: 153. +## +## type_annotation -> COLON . type_expr [ EQ ] +## +## The known suffix of the stack is as follows: +## COLON +## + + + +contract: Let WILD COMMA WILD COMMA With +## +## Ends in an error in state: 137. +## +## nsepseq(sub_irrefutable,COMMA) -> sub_irrefutable COMMA . nsepseq(sub_irrefutable,COMMA) [ WILD RPAR LPAR LBRACE Ident EQ Constr COLON ARROW ] +## +## The known suffix of the stack is as follows: +## sub_irrefutable COMMA +## + + + +contract: Let WILD COMMA WILD With +## +## Ends in an error in state: 136. +## +## nsepseq(sub_irrefutable,COMMA) -> sub_irrefutable . [ WILD RPAR LPAR LBRACE Ident EQ Constr COLON ARROW ] +## nsepseq(sub_irrefutable,COMMA) -> sub_irrefutable . COMMA nsepseq(sub_irrefutable,COMMA) [ WILD RPAR LPAR LBRACE Ident EQ Constr COLON ARROW ] +## +## The known suffix of the stack is as follows: +## sub_irrefutable +## + + + +contract: Let WILD COMMA With +## +## Ends in an error in state: 134. +## +## tuple(sub_irrefutable) -> sub_irrefutable COMMA . nsepseq(sub_irrefutable,COMMA) [ WILD RPAR LPAR LBRACE Ident EQ Constr COLON ARROW ] +## +## The known suffix of the stack is as follows: +## sub_irrefutable COMMA +## + + + +contract: Let WILD EQ Bytes Attr With +## +## Ends in an error in state: 169. +## +## seq(Attr) -> Attr . seq(Attr) [ Type Let In EOF ] +## +## The known suffix of the stack is as follows: +## Attr +## + + + +contract: Let WILD EQ Bytes With +## +## Ends in an error in state: 487. +## +## let_declaration -> Let let_binding . seq(Attr) [ Type Let EOF ] +## +## The known suffix of the stack is as follows: +## Let let_binding +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 221, spurious reduction of production call_expr_level -> core_expr +## In state 228, spurious reduction of production unary_expr_level -> call_expr_level +## In state 210, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 218, spurious reduction of production add_expr_level -> mult_expr_level +## In state 258, spurious reduction of production cons_expr_level -> add_expr_level +## In state 248, spurious reduction of production cat_expr_level -> cons_expr_level +## In state 280, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 287, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 294, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 246, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 300, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 301, spurious reduction of production expr -> base_cond__open(expr) +## In state 382, spurious reduction of production let_binding -> irrefutable option(type_annotation) EQ expr +## + + + +contract: Let WILD EQ With +## +## Ends in an error in state: 381. +## +## let_binding -> irrefutable option(type_annotation) EQ . expr [ Type Let In EOF Attr ] +## +## The known suffix of the stack is as follows: +## irrefutable option(type_annotation) EQ +## + + + +contract: Let WILD WILD +## +## Ends in an error in state: 379. +## +## let_binding -> irrefutable . option(type_annotation) EQ expr [ Type Let In EOF Attr ] +## +## The known suffix of the stack is as follows: +## irrefutable +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 133, spurious reduction of production irrefutable -> sub_irrefutable +## + + + +contract: Let WILD With +## +## Ends in an error in state: 133. +## +## irrefutable -> sub_irrefutable . [ WILD RPAR LPAR LBRACE Ident EQ Constr COLON ARROW ] +## tuple(sub_irrefutable) -> sub_irrefutable . COMMA nsepseq(sub_irrefutable,COMMA) [ WILD RPAR LPAR LBRACE Ident EQ Constr COLON ARROW ] +## +## The known suffix of the stack is as follows: +## sub_irrefutable +## + + + +contract: Let With +## +## Ends in an error in state: 61. +## +## let_declaration -> Let . let_binding seq(Attr) [ Type Let EOF ] +## +## The known suffix of the stack is as follows: +## Let +## + + + +contract: Type Ident EQ Constr DOT With +## +## Ends in an error in state: 13. +## +## core_type -> Constr DOT . Ident [ VBAR Type TIMES SEMI RPAR RBRACE Let Ident EQ EOF COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## Constr DOT +## + + + +contract: Type Ident EQ Constr Of With +## +## Ends in an error in state: 6. +## +## variant -> Constr Of . fun_type [ VBAR Type SEMI RPAR RBRACE Let EQ EOF COMMA ] +## +## The known suffix of the stack is as follows: +## Constr Of +## + + + +contract: Type Ident EQ Constr VBAR With +## +## Ends in an error in state: 16. +## +## nsepseq(variant,VBAR) -> variant VBAR . nsepseq(variant,VBAR) [ Type SEMI RPAR RBRACE Let EQ EOF COMMA ] +## +## The known suffix of the stack is as follows: +## variant VBAR +## + + + +contract: Type Ident EQ Constr With +## +## Ends in an error in state: 12. +## +## core_type -> Constr . DOT Ident [ Type TIMES SEMI RPAR RBRACE Let Ident EQ EOF COMMA ARROW ] +## variant -> Constr . [ VBAR Type SEMI RPAR RBRACE Let EQ EOF COMMA ] +## variant -> Constr . Of fun_type [ VBAR Type SEMI RPAR RBRACE Let EQ EOF COMMA ] +## +## The known suffix of the stack is as follows: +## Constr +## + + + +contract: Type Ident EQ Ident ARROW With +## +## Ends in an error in state: 36. +## +## fun_type -> cartesian ARROW . fun_type [ VBAR Type SEMI RPAR RBRACE Let EQ EOF COMMA ] +## +## The known suffix of the stack is as follows: +## cartesian ARROW +## + + + +contract: Type Ident EQ Ident TIMES Constr With +## +## Ends in an error in state: 29. +## +## core_type -> Constr . DOT Ident [ VBAR Type TIMES SEMI RPAR RBRACE Let Ident EQ EOF COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## Constr +## + + + +contract: Type Ident EQ Ident TIMES Ident TIMES With +## +## Ends in an error in state: 32. +## +## nsepseq(core_type,TIMES) -> core_type TIMES . nsepseq(core_type,TIMES) [ VBAR Type SEMI RPAR RBRACE Let EQ EOF COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## core_type TIMES +## + + + +contract: Type Ident EQ Ident TIMES Ident With +## +## Ends in an error in state: 31. +## +## core_type -> core_type . Ident [ VBAR Type TIMES SEMI RPAR RBRACE Let Ident EQ EOF COMMA ARROW ] +## nsepseq(core_type,TIMES) -> core_type . [ VBAR Type SEMI RPAR RBRACE Let EQ EOF COMMA ARROW ] +## nsepseq(core_type,TIMES) -> core_type . TIMES nsepseq(core_type,TIMES) [ VBAR Type SEMI RPAR RBRACE Let EQ EOF COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## core_type +## + + + +contract: Type Ident EQ Ident TIMES With +## +## Ends in an error in state: 28. +## +## cartesian -> core_type TIMES . nsepseq(core_type,TIMES) [ VBAR Type SEMI RPAR RBRACE Let EQ EOF COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## core_type TIMES +## + + + +contract: Type Ident EQ Ident VBAR +## +## Ends in an error in state: 493. +## +## declarations -> declaration . [ EOF ] +## declarations -> declaration . declarations [ EOF ] +## +## The known suffix of the stack is as follows: +## declaration +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 27, spurious reduction of production cartesian -> core_type +## In state 35, spurious reduction of production fun_type -> cartesian +## In state 26, spurious reduction of production type_expr -> fun_type +## In state 60, spurious reduction of production type_decl -> Type Ident EQ type_expr +## In state 489, spurious reduction of production declaration -> type_decl +## + + + +contract: Type Ident EQ Ident With +## +## Ends in an error in state: 27. +## +## cartesian -> core_type . [ VBAR Type SEMI RPAR RBRACE Let EQ EOF COMMA ARROW ] +## cartesian -> core_type . TIMES nsepseq(core_type,TIMES) [ VBAR Type SEMI RPAR RBRACE Let EQ EOF COMMA ARROW ] +## core_type -> core_type . Ident [ VBAR Type TIMES SEMI RPAR RBRACE Let Ident EQ EOF COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## core_type +## + + + +contract: Type Ident EQ LBRACE Ident COLON Constr SEMI Ident COLON Constr SEMI With +## +## Ends in an error in state: 47. +## +## nsepseq(field_decl,SEMI) -> field_decl SEMI . nsepseq(field_decl,SEMI) [ RBRACE ] +## seq(__anonymous_0(field_decl,SEMI)) -> field_decl SEMI . seq(__anonymous_0(field_decl,SEMI)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_decl SEMI +## + + + +contract: Type Ident EQ LBRACE Ident COLON Constr SEMI Ident COLON Ident VBAR +## +## Ends in an error in state: 46. +## +## nsepseq(field_decl,SEMI) -> field_decl . [ RBRACE ] +## nsepseq(field_decl,SEMI) -> field_decl . SEMI nsepseq(field_decl,SEMI) [ RBRACE ] +## seq(__anonymous_0(field_decl,SEMI)) -> field_decl . SEMI seq(__anonymous_0(field_decl,SEMI)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_decl +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 27, spurious reduction of production cartesian -> core_type +## In state 35, spurious reduction of production fun_type -> cartesian +## In state 26, spurious reduction of production type_expr -> fun_type +## In state 20, spurious reduction of production field_decl -> Ident COLON type_expr +## + + + +contract: Type Ident EQ LBRACE Ident COLON Constr SEMI With +## +## Ends in an error in state: 43. +## +## nsepseq(field_decl,SEMI) -> field_decl SEMI . nsepseq(field_decl,SEMI) [ RBRACE ] +## nseq(__anonymous_0(field_decl,SEMI)) -> field_decl SEMI . seq(__anonymous_0(field_decl,SEMI)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_decl SEMI +## + + + +contract: Type Ident EQ LBRACE Ident COLON Ident VBAR +## +## Ends in an error in state: 42. +## +## nsepseq(field_decl,SEMI) -> field_decl . [ RBRACE ] +## nsepseq(field_decl,SEMI) -> field_decl . SEMI nsepseq(field_decl,SEMI) [ RBRACE ] +## nseq(__anonymous_0(field_decl,SEMI)) -> field_decl . SEMI seq(__anonymous_0(field_decl,SEMI)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_decl +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 27, spurious reduction of production cartesian -> core_type +## In state 35, spurious reduction of production fun_type -> cartesian +## In state 26, spurious reduction of production type_expr -> fun_type +## In state 20, spurious reduction of production field_decl -> Ident COLON type_expr +## + + + +contract: Type Ident EQ LBRACE Ident COLON With +## +## Ends in an error in state: 10. +## +## field_decl -> Ident COLON . type_expr [ SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## Ident COLON +## + + + +contract: Type Ident EQ LBRACE Ident With +## +## Ends in an error in state: 9. +## +## field_decl -> Ident . COLON type_expr [ SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## Ident +## + + + +contract: Type Ident EQ LBRACE With +## +## Ends in an error in state: 8. +## +## record_type -> LBRACE . sep_or_term_list(field_decl,SEMI) RBRACE [ Type SEMI RPAR RBRACE Let EQ EOF COMMA ] +## +## The known suffix of the stack is as follows: +## LBRACE +## + + + +contract: Type Ident EQ LPAR Ident COMMA Constr RPAR With +## +## Ends in an error in state: 18. +## +## core_type -> type_tuple . Ident [ VBAR Type TIMES SEMI RPAR RBRACE Let Ident EQ EOF COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## type_tuple +## + + + +contract: Type Ident EQ LPAR Ident COMMA Ident COMMA With +## +## Ends in an error in state: 53. +## +## nsepseq(type_expr,COMMA) -> type_expr COMMA . nsepseq(type_expr,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## type_expr COMMA +## + + + +contract: Type Ident EQ LPAR Ident COMMA Ident VBAR +## +## Ends in an error in state: 52. +## +## nsepseq(type_expr,COMMA) -> type_expr . [ RPAR ] +## nsepseq(type_expr,COMMA) -> type_expr . COMMA nsepseq(type_expr,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## type_expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 27, spurious reduction of production cartesian -> core_type +## In state 35, spurious reduction of production fun_type -> cartesian +## In state 26, spurious reduction of production type_expr -> fun_type +## + + + +contract: Type Ident EQ LPAR Ident COMMA With +## +## Ends in an error in state: 51. +## +## tuple(type_expr) -> type_expr COMMA . nsepseq(type_expr,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## type_expr COMMA +## + + + +contract: Type Ident EQ LPAR Ident VBAR +## +## Ends in an error in state: 49. +## +## par(type_expr) -> LPAR type_expr . RPAR [ VBAR Type TIMES SEMI RPAR RBRACE Let Ident EQ EOF COMMA ARROW ] +## tuple(type_expr) -> type_expr . COMMA nsepseq(type_expr,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## LPAR type_expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 27, spurious reduction of production cartesian -> core_type +## In state 35, spurious reduction of production fun_type -> cartesian +## In state 26, spurious reduction of production type_expr -> fun_type +## + + + +contract: Type Ident EQ LPAR With +## +## Ends in an error in state: 7. +## +## par(tuple(type_expr)) -> LPAR . tuple(type_expr) RPAR [ Ident ] +## par(type_expr) -> LPAR . type_expr RPAR [ VBAR Type TIMES SEMI RPAR RBRACE Let Ident EQ EOF COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## LPAR +## + + + +contract: Type Ident EQ VBAR Constr With +## +## Ends in an error in state: 5. +## +## variant -> Constr . [ VBAR Type SEMI RPAR RBRACE Let EQ EOF COMMA ] +## variant -> Constr . Of fun_type [ VBAR Type SEMI RPAR RBRACE Let EQ EOF COMMA ] +## +## The known suffix of the stack is as follows: +## Constr +## + + + +contract: Type Ident EQ VBAR With +## +## Ends in an error in state: 4. +## +## sum_type -> VBAR . nsepseq(variant,VBAR) [ Type SEMI RPAR RBRACE Let EQ EOF COMMA ] +## +## The known suffix of the stack is as follows: +## VBAR +## + + + +contract: Type Ident EQ With +## +## Ends in an error in state: 3. +## +## type_decl -> Type Ident EQ . type_expr [ Type Let EOF ] +## +## The known suffix of the stack is as follows: +## Type Ident EQ +## + + + +contract: Type Ident With +## +## Ends in an error in state: 2. +## +## type_decl -> Type Ident . EQ type_expr [ Type Let EOF ] +## +## The known suffix of the stack is as follows: +## Type Ident +## + + + +contract: Type With +## +## Ends in an error in state: 1. +## +## type_decl -> Type . Ident EQ type_expr [ Type Let EOF ] +## +## The known suffix of the stack is as follows: +## Type +## + + + +contract: With +## +## Ends in an error in state: 0. +## +## contract' -> . contract [ # ] +## +## The known suffix of the stack is as follows: +## +## + + + diff --git a/src/passes/1-parser/pascaligo/ParErr.ml b/src/passes/1-parser/pascaligo/ParErr.ml deleted file mode 100644 index a19b6aac2..000000000 --- a/src/passes/1-parser/pascaligo/ParErr.ml +++ /dev/null @@ -1,546 +0,0 @@ - -(* This file was auto-generated based on "Parser.msg". *) - -(* Please note that the function [message] can raise [Not_found]. *) - -let message = - fun s -> - match s with - | 0 -> - "\n" - | 1 -> - "\n" - | 2 -> - "\n" - | 3 -> - "\n" - | 25 -> - "\n" - | 5 -> - "\n" - | 7 -> - "\n" - | 8 -> - "\n" - | 48 -> - "\n" - | 9 -> - "\n" - | 10 -> - "\n" - | 52 -> - "\n" - | 53 -> - "\n" - | 56 -> - "\n" - | 57 -> - "\n" - | 59 -> - "\n" - | 11 -> - "\n" - | 12 -> - "\n" - | 20 -> - "\n" - | 21 -> - "\n" - | 13 -> - "\n" - | 6 -> - "\n" - | 61 -> - "\n" - | 34 -> - "\n" - | 15 -> - "\n" - | 64 -> - "\n" - | 543 -> - "\n" - | 29 -> - "\n" - | 32 -> - "\n" - | 541 -> - "\n" - | 35 -> - "\n" - | 26 -> - "\n" - | 39 -> - "\n" - | 27 -> - "\n" - | 18 -> - "\n" - | 67 -> - "\n" - | 68 -> - "\n" - | 84 -> - "\n" - | 85 -> - "\n" - | 86 -> - "\n" - | 87 -> - "\n" - | 514 -> - "\n" - | 373 -> - "\n" - | 374 -> - "\n" - | 507 -> - "\n" - | 377 -> - "\n" - | 375 -> - "\n" - | 376 -> - "\n" - | 378 -> - "\n" - | 379 -> - "\n" - | 380 -> - "\n" - | 381 -> - "\n" - | 382 -> - "\n" - | 484 -> - "\n" - | 485 -> - "\n" - | 486 -> - "\n" - | 487 -> - "\n" - | 504 -> - "\n" - | 511 -> - "\n" - | 510 -> - "\n" - | 386 -> - "\n" - | 387 -> - "\n" - | 388 -> - "\n" - | 389 -> - "\n" - | 393 -> - "\n" - | 395 -> - "\n" - | 397 -> - "\n" - | 398 -> - "\n" - | 402 -> - "\n" - | 399 -> - "\n" - | 400 -> - "\n" - | 404 -> - "\n" - | 408 -> - "\n" - | 405 -> - "\n" - | 406 -> - "\n" - | 390 -> - "\n" - | 396 -> - "\n" - | 413 -> - "\n" - | 414 -> - "\n" - | 415 -> - "\n" - | 500 -> - "\n" - | 501 -> - "\n" - | 502 -> - "\n" - | 416 -> - "\n" - | 496 -> - "\n" - | 417 -> - "\n" - | 461 -> - "\n" - | 456 -> - "\n" - | 462 -> - "\n" - | 418 -> - "\n" - | 419 -> - "\n" - | 425 -> - "\n" - | 429 -> - "\n" - | 430 -> - "\n" - | 420 -> - "\n" - | 433 -> - "\n" - | 434 -> - "\n" - | 435 -> - "\n" - | 422 -> - "\n" - | 424 -> - "\n" - | 444 -> - "\n" - | 445 -> - "\n" - | 446 -> - "\n" - | 449 -> - "\n" - | 450 -> - "\n" - | 478 -> - "\n" - | 479 -> - "\n" - | 482 -> - "\n" - | 481 -> - "\n" - | 447 -> - "\n" - | 476 -> - "\n" - | 448 -> - "\n" - | 437 -> - "\n" - | 438 -> - "\n" - | 439 -> - "\n" - | 440 -> - "\n" - | 441 -> - "\n" - | 536 -> - "\n" - | 515 -> - "\n" - | 516 -> - "\n" - | 517 -> - "\n" - | 518 -> - "\n" - | 519 -> - "\n" - | 520 -> - "\n" - | 529 -> - "\n" - | 532 -> - "\n" - | 524 -> - "\n" - | 525 -> - "\n" - | 547 -> - "\n" - | 181 -> - "\n" - | 549 -> - "\n" - | 159 -> - "\n" - | 172 -> - "\n" - | 188 -> - "\n" - | 189 -> - "\n" - | 180 -> - "\n" - | 195 -> - "\n" - | 174 -> - "\n" - | 190 -> - "\n" - | 191 -> - "\n" - | 197 -> - "\n" - | 199 -> - "\n" - | 201 -> - "\n" - | 203 -> - "\n" - | 205 -> - "\n" - | 182 -> - "\n" - | 192 -> - "\n" - | 179 -> - "\n" - | 185 -> - "\n" - | 209 -> - "\n" - | 91 -> - "\n" - | 342 -> - "\n" - | 343 -> - "\n" - | 346 -> - "\n" - | 347 -> - "\n" - | 371 -> - "\n" - | 366 -> - "\n" - | 368 -> - "\n" - | 92 -> - "\n" - | 93 -> - "\n" - | 362 -> - "\n" - | 94 -> - "\n" - | 95 -> - "\n" - | 144 -> - "\n" - | 145 -> - "\n" - | 148 -> - "\n" - | 149 -> - "\n" - | 364 -> - "\n" - | 96 -> - "\n" - | 158 -> - "\n" - | 100 -> - "\n" - | 217 -> - "\n" - | 218 -> - "\n" - | 220 -> - "\n" - | 221 -> - "\n" - | 224 -> - "\n" - | 225 -> - "\n" - | 358 -> - "\n" - | 353 -> - "\n" - | 355 -> - "\n" - | 101 -> - "\n" - | 102 -> - "\n" - | 350 -> - "\n" - | 336 -> - "\n" - | 338 -> - "\n" - | 103 -> - "\n" - | 332 -> - "\n" - | 330 -> - "\n" - | 333 -> - "\n" - | 334 -> - "\n" - | 328 -> - "\n" - | 156 -> - "\n" - | 105 -> - "\n" - | 320 -> - "\n" - | 321 -> - "\n" - | 322 -> - "\n" - | 323 -> - "\n" - | 324 -> - "\n" - | 137 -> - "\n" - | 138 -> - "\n" - | 139 -> - "\n" - | 140 -> - "\n" - | 151 -> - "\n" - | 106 -> - "\n" - | 107 -> - "\n" - | 309 -> - "\n" - | 310 -> - "\n" - | 154 -> - "\n" - | 177 -> - "\n" - | 312 -> - "\n" - | 315 -> - "\n" - | 316 -> - "\n" - | 133 -> - "\n" - | 108 -> - "\n" - | 69 -> - "\n" - | 70 -> - "\n" - | 71 -> - "\n" - | 72 -> - "\n" - | 79 -> - "\n" - | 80 -> - "\n" - | 75 -> - "\n" - | 76 -> - "\n" - | 77 -> - "\n" - | 109 -> - "\n" - | 110 -> - "\n" - | 111 -> - "\n" - | 112 -> - "\n" - | 114 -> - "\n" - | 117 -> - "\n" - | 230 -> - "\n" - | 231 -> - "\n" - | 269 -> - "\n" - | 293 -> - "\n" - | 270 -> - "\n" - | 272 -> - "\n" - | 273 -> - "\n" - | 294 -> - "\n" - | 300 -> - "\n" - | 299 -> - "\n" - | 303 -> - "\n" - | 302 -> - "\n" - | 240 -> - "\n" - | 283 -> - "\n" - | 284 -> - "\n" - | 287 -> - "\n" - | 288 -> - "\n" - | 291 -> - "\n" - | 277 -> - "\n" - | 279 -> - "\n" - | 241 -> - "\n" - | 266 -> - "\n" - | 267 -> - "\n" - | 275 -> - "\n" - | 263 -> - "\n" - | 232 -> - "\n" - | 297 -> - "\n" - | 233 -> - "\n" - | 245 -> - "\n" - | 246 -> - "\n" - | 262 -> - "\n" - | 247 -> - "\n" - | 248 -> - "\n" - | 256 -> - "\n" - | 118 -> - "\n" - | 122 -> - "\n" - | 228 -> - "\n" - | 123 -> - "\n" - | 130 -> - "\n" - | _ -> - raise Not_found diff --git a/src/passes/1-parser/pascaligo/dune b/src/passes/1-parser/pascaligo/dune index cbda30618..d0d43f02f 100644 --- a/src/passes/1-parser/pascaligo/dune +++ b/src/passes/1-parser/pascaligo/dune @@ -69,3 +69,105 @@ (targets all.ligo) (deps (:script_cover ../../../../vendors/ligo-utils/simple-utils/cover.sh) Parser.mly LexToken.mli ParToken.mly Parser.msg Unlexer.exe) (action (run %{script_cover} --lex-tokens=LexToken.mli --par-tokens=ParToken.mly --ext=ligo --unlexer=./Unlexer.exe --messages=Parser.msg --dir=. --concatenate Parser.mly))) + +;; Error messages + +;; Generate error messages from scratch +; (rule +; (targets error.messages) +; (deps Parser.mly ParToken.mly error.messages.checked-in) +; (action +; (with-stdout-to %{targets} +; (bash +; "menhir \ +; --unused-tokens \ +; --list-errors \ +; --table \ +; --strict \ +; --external-tokens LexToken.mli \ +; --base Parser.mly \ +; ParToken.mly \ +; Parser.mly +; " +; ) +; )) +; ) + +(rule + (targets error.messages) + (deps Parser.mly ParToken.mly error.messages.checked-in LexToken.mli) + (action + (with-stdout-to %{targets} + (run + menhir + --unused-tokens + --update-errors error.messages.checked-in + --table + --strict + --external-tokens LexToken.mli + --base Parser.mly + ParToken.mly + Parser.mly + ) + )) +) + +(rule + (target error.messages.new) + (action + (with-stdout-to %{target} + (run + menhir + --unused-tokens + --list-errors + --table + --strict + --external-tokens LexToken.mli + --base Parser.mly + ParToken.mly + Parser.mly + ) + ) + ) +) + +(alias + (name runtest) + (deps error.messages error.messages.new) + (action + (run + menhir + --unused-tokens + --table + --strict + --external-tokens LexToken.mli + --base Parser.mly + ParToken.mly + Parser.mly + --compare-errors error.messages.new + --compare-errors error.messages + ) + ) + ) + + + +(rule + (targets ParErr.ml) + (deps Parser.mly ParToken.mly error.messages.checked-in LexToken.mli) + (action + (with-stdout-to %{targets} + (run + menhir + --unused-tokens + --table + --strict + --external-tokens LexToken.mli + --base Parser.mly + ParToken.mly + Parser.mly + --compile-errors error.messages.checked-in + ) + )) +) + diff --git a/src/passes/1-parser/pascaligo/error.messages.checked-in b/src/passes/1-parser/pascaligo/error.messages.checked-in new file mode 100644 index 000000000..660825a6e --- /dev/null +++ b/src/passes/1-parser/pascaligo/error.messages.checked-in @@ -0,0 +1,4503 @@ +interactive_expr: BigMap LBRACKET Unit ARROW Bytes End +## +## Ends in an error in state: 130. +## +## injection(BigMap,binding) -> BigMap LBRACKET sep_or_term_list(binding,SEMI) . RBRACKET [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## BigMap LBRACKET sep_or_term_list(binding,SEMI) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 225, spurious reduction of production binding -> expr ARROW expr +## In state 226, spurious reduction of production nsepseq(binding,SEMI) -> binding +## In state 222, spurious reduction of production sep_or_term_list(binding,SEMI) -> nsepseq(binding,SEMI) +## + + + +interactive_expr: BigMap LBRACKET With +## +## Ends in an error in state: 123. +## +## injection(BigMap,binding) -> BigMap LBRACKET . sep_or_term_list(binding,SEMI) RBRACKET [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## injection(BigMap,binding) -> BigMap LBRACKET . RBRACKET [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## BigMap LBRACKET +## + + + +interactive_expr: BigMap Unit ARROW Bytes RBRACKET +## +## Ends in an error in state: 234. +## +## injection(BigMap,binding) -> BigMap sep_or_term_list(binding,SEMI) . End [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## BigMap sep_or_term_list(binding,SEMI) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 225, spurious reduction of production binding -> expr ARROW expr +## In state 226, spurious reduction of production nsepseq(binding,SEMI) -> binding +## In state 222, spurious reduction of production sep_or_term_list(binding,SEMI) -> nsepseq(binding,SEMI) +## + + + +interactive_expr: BigMap With +## +## Ends in an error in state: 122. +## +## injection(BigMap,binding) -> BigMap . sep_or_term_list(binding,SEMI) End [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## injection(BigMap,binding) -> BigMap . End [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## injection(BigMap,binding) -> BigMap . LBRACKET sep_or_term_list(binding,SEMI) RBRACKET [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## injection(BigMap,binding) -> BigMap . LBRACKET RBRACKET [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## BigMap +## + + + +interactive_expr: C_Some With +## +## Ends in an error in state: 118. +## +## core_expr -> C_Some . arguments [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## C_Some +## + + + +interactive_expr: Case Unit Of C_Some LPAR WILD With +## +## Ends in an error in state: 262. +## +## par(core_pattern) -> LPAR core_pattern . RPAR [ SEMI RPAR RBRACKET End CONS COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## LPAR core_pattern +## + + + +interactive_expr: Case Unit Of C_Some LPAR With +## +## Ends in an error in state: 254. +## +## par(core_pattern) -> LPAR . core_pattern RPAR [ SEMI RPAR RBRACKET End CONS COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## LPAR +## + + + +interactive_expr: Case Unit Of C_Some With +## +## Ends in an error in state: 253. +## +## constr_pattern -> C_Some . par(core_pattern) [ SEMI RPAR RBRACKET End CONS COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## C_Some +## + + + +interactive_expr: Case Unit Of Constr LPAR WILD With +## +## Ends in an error in state: 268. +## +## nsepseq(core_pattern,COMMA) -> core_pattern . [ RPAR ] +## nsepseq(core_pattern,COMMA) -> core_pattern . COMMA nsepseq(core_pattern,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## core_pattern +## + + + +interactive_expr: Case Unit Of Constr LPAR With +## +## Ends in an error in state: 252. +## +## par(nsepseq(core_pattern,COMMA)) -> LPAR . nsepseq(core_pattern,COMMA) RPAR [ SEMI RPAR RBRACKET End CONS COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## LPAR +## + + + +interactive_expr: Case Unit Of Constr With +## +## Ends in an error in state: 251. +## +## constr_pattern -> Constr . tuple_pattern [ SEMI RPAR RBRACKET End CONS COMMA ARROW ] +## constr_pattern -> Constr . [ SEMI RPAR RBRACKET End CONS COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## Constr +## + + + +interactive_expr: Case Unit Of LBRACKET VBAR Block +## +## Ends in an error in state: 239. +## +## case(expr) -> Case expr Of LBRACKET option(VBAR) . cases(expr) RBRACKET [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Of Function From End Else EOF Const COMMA Block Begin Attributes ARROW ] +## +## The known suffix of the stack is as follows: +## Case expr Of LBRACKET option(VBAR) +## + + + +interactive_expr: Case Unit Of LBRACKET WILD ARROW Bytes End +## +## Ends in an error in state: 303. +## +## case(expr) -> Case expr Of LBRACKET option(VBAR) cases(expr) . RBRACKET [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Of Function From End Else EOF Const COMMA Block Begin Attributes ARROW ] +## +## The known suffix of the stack is as follows: +## Case expr Of LBRACKET option(VBAR) cases(expr) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 301, spurious reduction of production case_clause(expr) -> pattern ARROW expr +## In state 305, spurious reduction of production nsepseq(case_clause(expr),VBAR) -> case_clause(expr) +## In state 302, spurious reduction of production cases(expr) -> nsepseq(case_clause(expr),VBAR) +## + + + +interactive_expr: Case Unit Of LBRACKET With +## +## Ends in an error in state: 238. +## +## case(expr) -> Case expr Of LBRACKET . option(VBAR) cases(expr) RBRACKET [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Of Function From End Else EOF Const COMMA Block Begin Attributes ARROW ] +## +## The known suffix of the stack is as follows: +## Case expr Of LBRACKET +## + + + +interactive_expr: Case Unit Of LPAR WILD COMMA With +## +## Ends in an error in state: 269. +## +## nsepseq(core_pattern,COMMA) -> core_pattern COMMA . nsepseq(core_pattern,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## core_pattern COMMA +## + + + +interactive_expr: Case Unit Of LPAR WILD CONS Bytes ARROW +## +## Ends in an error in state: 281. +## +## par(cons_pattern) -> LPAR cons_pattern . RPAR [ SEMI RPAR RBRACKET End CONS COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## LPAR cons_pattern +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 275, spurious reduction of production pattern -> core_pattern +## In state 274, spurious reduction of production cons_pattern -> core_pattern CONS pattern +## + + + +interactive_expr: Case Unit Of LPAR WILD CONS With +## +## Ends in an error in state: 273. +## +## cons_pattern -> core_pattern CONS . pattern [ RPAR ] +## +## The known suffix of the stack is as follows: +## core_pattern CONS +## + + + +interactive_expr: Case Unit Of LPAR WILD With +## +## Ends in an error in state: 272. +## +## cons_pattern -> core_pattern . CONS pattern [ RPAR ] +## nsepseq(core_pattern,COMMA) -> core_pattern . [ RPAR ] +## nsepseq(core_pattern,COMMA) -> core_pattern . COMMA nsepseq(core_pattern,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## core_pattern +## + + + +interactive_expr: Case Unit Of LPAR With +## +## Ends in an error in state: 247. +## +## par(cons_pattern) -> LPAR . cons_pattern RPAR [ SEMI RPAR RBRACKET End CONS COMMA ARROW ] +## par(nsepseq(core_pattern,COMMA)) -> LPAR . nsepseq(core_pattern,COMMA) RPAR [ SEMI RPAR RBRACKET End CONS COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## LPAR +## + + + +interactive_expr: Case Unit Of List LBRACKET WILD End +## +## Ends in an error in state: 285. +## +## injection(List,core_pattern) -> List LBRACKET sep_or_term_list(core_pattern,SEMI) . RBRACKET [ SEMI RPAR RBRACKET End CONS COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## List LBRACKET sep_or_term_list(core_pattern,SEMI) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 289, spurious reduction of production nsepseq(core_pattern,SEMI) -> core_pattern +## In state 288, spurious reduction of production sep_or_term_list(core_pattern,SEMI) -> nsepseq(core_pattern,SEMI) +## + + + +interactive_expr: Case Unit Of List LBRACKET With +## +## Ends in an error in state: 283. +## +## injection(List,core_pattern) -> List LBRACKET . sep_or_term_list(core_pattern,SEMI) RBRACKET [ SEMI RPAR RBRACKET End CONS COMMA ARROW ] +## injection(List,core_pattern) -> List LBRACKET . RBRACKET [ SEMI RPAR RBRACKET End CONS COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## List LBRACKET +## + + + +interactive_expr: Case Unit Of List WILD RBRACKET +## +## Ends in an error in state: 297. +## +## injection(List,core_pattern) -> List sep_or_term_list(core_pattern,SEMI) . End [ SEMI RPAR RBRACKET End CONS COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## List sep_or_term_list(core_pattern,SEMI) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 289, spurious reduction of production nsepseq(core_pattern,SEMI) -> core_pattern +## In state 288, spurious reduction of production sep_or_term_list(core_pattern,SEMI) -> nsepseq(core_pattern,SEMI) +## + + + +interactive_expr: Case Unit Of List WILD SEMI WILD SEMI With +## +## Ends in an error in state: 294. +## +## nsepseq(core_pattern,SEMI) -> core_pattern SEMI . nsepseq(core_pattern,SEMI) [ RBRACKET End ] +## seq(__anonymous_0(core_pattern,SEMI)) -> core_pattern SEMI . seq(__anonymous_0(core_pattern,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## core_pattern SEMI +## + + + +interactive_expr: Case Unit Of List WILD SEMI WILD With +## +## Ends in an error in state: 293. +## +## nsepseq(core_pattern,SEMI) -> core_pattern . [ RBRACKET End ] +## nsepseq(core_pattern,SEMI) -> core_pattern . SEMI nsepseq(core_pattern,SEMI) [ RBRACKET End ] +## seq(__anonymous_0(core_pattern,SEMI)) -> core_pattern . SEMI seq(__anonymous_0(core_pattern,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## core_pattern +## + + + +interactive_expr: Case Unit Of List WILD SEMI With +## +## Ends in an error in state: 290. +## +## nsepseq(core_pattern,SEMI) -> core_pattern SEMI . nsepseq(core_pattern,SEMI) [ RBRACKET End ] +## nseq(__anonymous_0(core_pattern,SEMI)) -> core_pattern SEMI . seq(__anonymous_0(core_pattern,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## core_pattern SEMI +## + + + +interactive_expr: Case Unit Of List WILD With +## +## Ends in an error in state: 289. +## +## nsepseq(core_pattern,SEMI) -> core_pattern . [ RBRACKET End ] +## nsepseq(core_pattern,SEMI) -> core_pattern . SEMI nsepseq(core_pattern,SEMI) [ RBRACKET End ] +## nseq(__anonymous_0(core_pattern,SEMI)) -> core_pattern . SEMI seq(__anonymous_0(core_pattern,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## core_pattern +## + + + +interactive_expr: Case Unit Of List With +## +## Ends in an error in state: 246. +## +## injection(List,core_pattern) -> List . sep_or_term_list(core_pattern,SEMI) End [ SEMI RPAR RBRACKET End CONS COMMA ARROW ] +## injection(List,core_pattern) -> List . End [ SEMI RPAR RBRACKET End CONS COMMA ARROW ] +## injection(List,core_pattern) -> List . LBRACKET sep_or_term_list(core_pattern,SEMI) RBRACKET [ SEMI RPAR RBRACKET End CONS COMMA ARROW ] +## injection(List,core_pattern) -> List . LBRACKET RBRACKET [ SEMI RPAR RBRACKET End CONS COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## List +## + + + +interactive_expr: Case Unit Of VBAR Block +## +## Ends in an error in state: 308. +## +## case(expr) -> Case expr Of option(VBAR) . cases(expr) End [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Of Function From End Else EOF Const COMMA Block Begin Attributes ARROW ] +## +## The known suffix of the stack is as follows: +## Case expr Of option(VBAR) +## + + + +interactive_expr: Case Unit Of WILD ARROW Bytes RBRACKET +## +## Ends in an error in state: 309. +## +## case(expr) -> Case expr Of option(VBAR) cases(expr) . End [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Of Function From End Else EOF Const COMMA Block Begin Attributes ARROW ] +## +## The known suffix of the stack is as follows: +## Case expr Of option(VBAR) cases(expr) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 301, spurious reduction of production case_clause(expr) -> pattern ARROW expr +## In state 305, spurious reduction of production nsepseq(case_clause(expr),VBAR) -> case_clause(expr) +## In state 302, spurious reduction of production cases(expr) -> nsepseq(case_clause(expr),VBAR) +## + + + +interactive_expr: Case Unit Of WILD ARROW Bytes Type +## +## Ends in an error in state: 305. +## +## nsepseq(case_clause(expr),VBAR) -> case_clause(expr) . [ RBRACKET End ] +## nsepseq(case_clause(expr),VBAR) -> case_clause(expr) . VBAR nsepseq(case_clause(expr),VBAR) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## case_clause(expr) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 301, spurious reduction of production case_clause(expr) -> pattern ARROW expr +## + + + +interactive_expr: Case Unit Of WILD ARROW Bytes VBAR With +## +## Ends in an error in state: 306. +## +## nsepseq(case_clause(expr),VBAR) -> case_clause(expr) VBAR . nsepseq(case_clause(expr),VBAR) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## case_clause(expr) VBAR +## + + + +interactive_expr: Case Unit Of WILD ARROW With +## +## Ends in an error in state: 300. +## +## case_clause(expr) -> pattern ARROW . expr [ VBAR RBRACKET End ] +## +## The known suffix of the stack is as follows: +## pattern ARROW +## + + + +interactive_expr: Case Unit Of WILD CONS WILD CONS With +## +## Ends in an error in state: 279. +## +## nsepseq(core_pattern,CONS) -> core_pattern CONS . nsepseq(core_pattern,CONS) [ RPAR ARROW ] +## +## The known suffix of the stack is as follows: +## core_pattern CONS +## + + + +interactive_expr: Case Unit Of WILD CONS WILD With +## +## Ends in an error in state: 278. +## +## nsepseq(core_pattern,CONS) -> core_pattern . [ RPAR ARROW ] +## nsepseq(core_pattern,CONS) -> core_pattern . CONS nsepseq(core_pattern,CONS) [ RPAR ARROW ] +## +## The known suffix of the stack is as follows: +## core_pattern +## + + + +interactive_expr: Case Unit Of WILD CONS With +## +## Ends in an error in state: 276. +## +## pattern -> core_pattern CONS . nsepseq(core_pattern,CONS) [ RPAR ARROW ] +## +## The known suffix of the stack is as follows: +## core_pattern CONS +## + + + +interactive_expr: Case Unit Of WILD RPAR +## +## Ends in an error in state: 299. +## +## case_clause(expr) -> pattern . ARROW expr [ VBAR RBRACKET End ] +## +## The known suffix of the stack is as follows: +## pattern +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 275, spurious reduction of production pattern -> core_pattern +## + + + +interactive_expr: Case Unit Of WILD With +## +## Ends in an error in state: 275. +## +## pattern -> core_pattern . [ RPAR ARROW ] +## pattern -> core_pattern . CONS nsepseq(core_pattern,CONS) [ RPAR ARROW ] +## +## The known suffix of the stack is as follows: +## core_pattern +## + + + +interactive_expr: Case Unit Of With +## +## Ends in an error in state: 237. +## +## case(expr) -> Case expr Of . option(VBAR) cases(expr) End [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Of Function From End Else EOF Const COMMA Block Begin Attributes ARROW ] +## case(expr) -> Case expr Of . LBRACKET option(VBAR) cases(expr) RBRACKET [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Of Function From End Else EOF Const COMMA Block Begin Attributes ARROW ] +## +## The known suffix of the stack is as follows: +## Case expr Of +## + + + +interactive_expr: Case Unit VBAR +## +## Ends in an error in state: 236. +## +## case(expr) -> Case expr . Of option(VBAR) cases(expr) End [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Of Function From End Else EOF Const COMMA Block Begin Attributes ARROW ] +## case(expr) -> Case expr . Of LBRACKET option(VBAR) cases(expr) RBRACKET [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Of Function From End Else EOF Const COMMA Block Begin Attributes ARROW ] +## +## The known suffix of the stack is as follows: +## Case expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## + + + +interactive_expr: Case With +## +## Ends in an error in state: 117. +## +## case(expr) -> Case . expr Of option(VBAR) cases(expr) End [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Of Function From End Else EOF Const COMMA Block Begin Attributes ARROW ] +## case(expr) -> Case . expr Of LBRACKET option(VBAR) cases(expr) RBRACKET [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Of Function From End Else EOF Const COMMA Block Begin Attributes ARROW ] +## +## The known suffix of the stack is as follows: +## Case +## + + + +interactive_expr: Constr With +## +## Ends in an error in state: 114. +## +## core_expr -> Constr . arguments [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## core_expr -> Constr . [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## Constr +## + + + +interactive_expr: Function LPAR Const Ident COLON Ident RPAR COLON Ident Is With +## +## Ends in an error in state: 112. +## +## fun_expr -> Function parameters COLON type_expr Is . expr [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Of Function From End Else EOF Const COMMA Block Begin Attributes ARROW ] +## +## The known suffix of the stack is as follows: +## Function parameters COLON type_expr Is +## + + + +interactive_expr: Function LPAR Const Ident COLON Ident RPAR COLON Ident VBAR +## +## Ends in an error in state: 111. +## +## fun_expr -> Function parameters COLON type_expr . Is expr [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Of Function From End Else EOF Const COMMA Block Begin Attributes ARROW ] +## +## The known suffix of the stack is as follows: +## Function parameters COLON type_expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 15, spurious reduction of production core_type -> Ident +## In state 29, spurious reduction of production cartesian -> core_type +## In state 35, spurious reduction of production fun_type -> cartesian +## In state 43, spurious reduction of production type_expr -> fun_type +## + + + +interactive_expr: Function LPAR Const Ident COLON Ident RPAR COLON With +## +## Ends in an error in state: 110. +## +## fun_expr -> Function parameters COLON . type_expr Is expr [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Of Function From End Else EOF Const COMMA Block Begin Attributes ARROW ] +## +## The known suffix of the stack is as follows: +## Function parameters COLON +## + + + +interactive_expr: Function LPAR Const Ident COLON Ident RPAR With +## +## Ends in an error in state: 109. +## +## fun_expr -> Function parameters . COLON type_expr Is expr [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Of Function From End Else EOF Const COMMA Block Begin Attributes ARROW ] +## +## The known suffix of the stack is as follows: +## Function parameters +## + + + +interactive_expr: Function LPAR Const Ident COLON With +## +## Ends in an error in state: 77. +## +## param_decl -> Const Ident COLON . param_type [ SEMI RPAR ] +## +## The known suffix of the stack is as follows: +## Const Ident COLON +## + + + +interactive_expr: Function LPAR Const Ident With +## +## Ends in an error in state: 76. +## +## param_decl -> Const Ident . COLON param_type [ SEMI RPAR ] +## +## The known suffix of the stack is as follows: +## Const Ident +## + + + +interactive_expr: Function LPAR Const With +## +## Ends in an error in state: 75. +## +## param_decl -> Const . Ident COLON param_type [ SEMI RPAR ] +## +## The known suffix of the stack is as follows: +## Const +## + + + +interactive_expr: Function LPAR Var Ident COLON Ident SEMI With +## +## Ends in an error in state: 80. +## +## nsepseq(param_decl,SEMI) -> param_decl SEMI . nsepseq(param_decl,SEMI) [ RPAR ] +## +## The known suffix of the stack is as follows: +## param_decl SEMI +## + + + +interactive_expr: Function LPAR Var Ident COLON Ident VBAR +## +## Ends in an error in state: 79. +## +## nsepseq(param_decl,SEMI) -> param_decl . [ RPAR ] +## nsepseq(param_decl,SEMI) -> param_decl . SEMI nsepseq(param_decl,SEMI) [ RPAR ] +## +## The known suffix of the stack is as follows: +## param_decl +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 15, spurious reduction of production core_type -> Ident +## In state 29, spurious reduction of production cartesian -> core_type +## In state 35, spurious reduction of production fun_type -> cartesian +## In state 74, spurious reduction of production param_type -> fun_type +## In state 73, spurious reduction of production param_decl -> Var Ident COLON param_type +## + + + +interactive_expr: Function LPAR Var Ident COLON With +## +## Ends in an error in state: 72. +## +## param_decl -> Var Ident COLON . param_type [ SEMI RPAR ] +## +## The known suffix of the stack is as follows: +## Var Ident COLON +## + + + +interactive_expr: Function LPAR Var Ident With +## +## Ends in an error in state: 71. +## +## param_decl -> Var Ident . COLON param_type [ SEMI RPAR ] +## +## The known suffix of the stack is as follows: +## Var Ident +## + + + +interactive_expr: Function LPAR Var With +## +## Ends in an error in state: 70. +## +## param_decl -> Var . Ident COLON param_type [ SEMI RPAR ] +## +## The known suffix of the stack is as follows: +## Var +## + + + +interactive_expr: Function LPAR With +## +## Ends in an error in state: 69. +## +## par(nsepseq(param_decl,SEMI)) -> LPAR . nsepseq(param_decl,SEMI) RPAR [ COLON ] +## +## The known suffix of the stack is as follows: +## LPAR +## + + + +interactive_expr: Function With +## +## Ends in an error in state: 108. +## +## fun_expr -> Function . parameters COLON type_expr Is expr [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Of Function From End Else EOF Const COMMA Block Begin Attributes ARROW ] +## +## The known suffix of the stack is as follows: +## Function +## + + + +interactive_expr: Ident DOT Ident ASS +## +## Ends in an error in state: 133. +## +## fun_call_or_par_or_projection -> projection . option(arguments) [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## path -> projection . [ With LBRACKET ] +## +## The known suffix of the stack is as follows: +## projection +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 321, spurious reduction of production nsepseq(selection,DOT) -> selection +## In state 324, spurious reduction of production projection -> Ident DOT nsepseq(selection,DOT) +## + + + +interactive_expr: Ident DOT Int DOT With +## +## Ends in an error in state: 322. +## +## nsepseq(selection,DOT) -> selection DOT . nsepseq(selection,DOT) [ With VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LPAR LE LBRACKET GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ASS ARROW ] +## +## The known suffix of the stack is as follows: +## selection DOT +## + + + +interactive_expr: Ident DOT Int While +## +## Ends in an error in state: 321. +## +## nsepseq(selection,DOT) -> selection . [ With VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LPAR LE LBRACKET GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ASS ARROW ] +## nsepseq(selection,DOT) -> selection . DOT nsepseq(selection,DOT) [ With VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LPAR LE LBRACKET GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ASS ARROW ] +## +## The known suffix of the stack is as follows: +## selection +## + + + +interactive_expr: Ident DOT With +## +## Ends in an error in state: 318. +## +## projection -> Ident DOT . nsepseq(selection,DOT) [ With VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LPAR LE LBRACKET GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ASS ARROW ] +## +## The known suffix of the stack is as follows: +## Ident DOT +## + + + +interactive_expr: Ident LBRACKET Unit VBAR +## +## Ends in an error in state: 218. +## +## brackets(expr) -> LBRACKET expr . RBRACKET [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ASS ARROW ] +## +## The known suffix of the stack is as follows: +## LBRACKET expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## + + + +interactive_expr: Ident LBRACKET With +## +## Ends in an error in state: 217. +## +## brackets(expr) -> LBRACKET . expr RBRACKET [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ASS ARROW ] +## +## The known suffix of the stack is as follows: +## LBRACKET +## + + + +interactive_expr: Ident LPAR Unit COMMA With +## +## Ends in an error in state: 316. +## +## nsepseq(expr,COMMA) -> expr COMMA . nsepseq(expr,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## expr COMMA +## + + + +interactive_expr: Ident LPAR Unit VBAR +## +## Ends in an error in state: 315. +## +## nsepseq(expr,COMMA) -> expr . [ RPAR ] +## nsepseq(expr,COMMA) -> expr . COMMA nsepseq(expr,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## + + + +interactive_expr: Ident LPAR With +## +## Ends in an error in state: 107. +## +## par(nsepseq(expr,COMMA)) -> LPAR . nsepseq(expr,COMMA) RPAR [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## LPAR +## + + + +interactive_expr: Ident While +## +## Ends in an error in state: 106. +## +## core_expr -> Ident . [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## fun_call -> Ident . arguments [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## path -> Ident . [ With LBRACKET ] +## projection -> Ident . DOT nsepseq(selection,DOT) [ With VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LPAR LE LBRACKET GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## Ident +## + + + +interactive_expr: Ident With Record Ident DOT With +## +## Ends in an error in state: 141. +## +## nsepseq(field_name,DOT) -> Ident DOT . nsepseq(field_name,DOT) [ EQ ] +## +## The known suffix of the stack is as follows: +## Ident DOT +## + + + +interactive_expr: Ident With Record Ident EQ Bytes RBRACKET +## +## Ends in an error in state: 214. +## +## ne_injection(Record,field_path_assignment) -> Record sep_or_term_list(field_path_assignment,SEMI) . End [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## Record sep_or_term_list(field_path_assignment,SEMI) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 171, spurious reduction of production field_path_assignment -> nsepseq(field_name,DOT) EQ expr +## In state 207, spurious reduction of production nsepseq(field_path_assignment,SEMI) -> field_path_assignment +## In state 146, spurious reduction of production sep_or_term_list(field_path_assignment,SEMI) -> nsepseq(field_path_assignment,SEMI) +## + + + +interactive_expr: Ident With Record Ident EQ Bytes SEMI Ident EQ Bytes SEMI With +## +## Ends in an error in state: 212. +## +## nsepseq(field_path_assignment,SEMI) -> field_path_assignment SEMI . nsepseq(field_path_assignment,SEMI) [ RBRACKET End ] +## seq(__anonymous_0(field_path_assignment,SEMI)) -> field_path_assignment SEMI . seq(__anonymous_0(field_path_assignment,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## field_path_assignment SEMI +## + + + +interactive_expr: Ident With Record Ident EQ Bytes SEMI Ident EQ Bytes VBAR +## +## Ends in an error in state: 211. +## +## nsepseq(field_path_assignment,SEMI) -> field_path_assignment . [ RBRACKET End ] +## nsepseq(field_path_assignment,SEMI) -> field_path_assignment . SEMI nsepseq(field_path_assignment,SEMI) [ RBRACKET End ] +## seq(__anonymous_0(field_path_assignment,SEMI)) -> field_path_assignment . SEMI seq(__anonymous_0(field_path_assignment,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## field_path_assignment +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 171, spurious reduction of production field_path_assignment -> nsepseq(field_name,DOT) EQ expr +## + + + +interactive_expr: Ident With Record Ident EQ Bytes SEMI With +## +## Ends in an error in state: 208. +## +## nsepseq(field_path_assignment,SEMI) -> field_path_assignment SEMI . nsepseq(field_path_assignment,SEMI) [ RBRACKET End ] +## nseq(__anonymous_0(field_path_assignment,SEMI)) -> field_path_assignment SEMI . seq(__anonymous_0(field_path_assignment,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## field_path_assignment SEMI +## + + + +interactive_expr: Ident With Record Ident EQ Bytes VBAR +## +## Ends in an error in state: 207. +## +## nsepseq(field_path_assignment,SEMI) -> field_path_assignment . [ RBRACKET End ] +## nsepseq(field_path_assignment,SEMI) -> field_path_assignment . SEMI nsepseq(field_path_assignment,SEMI) [ RBRACKET End ] +## nseq(__anonymous_0(field_path_assignment,SEMI)) -> field_path_assignment . SEMI seq(__anonymous_0(field_path_assignment,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## field_path_assignment +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 171, spurious reduction of production field_path_assignment -> nsepseq(field_name,DOT) EQ expr +## + + + +interactive_expr: Ident With Record Ident EQ With +## +## Ends in an error in state: 148. +## +## field_path_assignment -> nsepseq(field_name,DOT) EQ . expr [ SEMI RBRACKET End ] +## +## The known suffix of the stack is as follows: +## nsepseq(field_name,DOT) EQ +## + + + +interactive_expr: Ident With Record Ident With +## +## Ends in an error in state: 140. +## +## nsepseq(field_name,DOT) -> Ident . [ EQ ] +## nsepseq(field_name,DOT) -> Ident . DOT nsepseq(field_name,DOT) [ EQ ] +## +## The known suffix of the stack is as follows: +## Ident +## + + + +interactive_expr: Ident With Record LBRACKET Ident EQ Bytes End +## +## Ends in an error in state: 143. +## +## ne_injection(Record,field_path_assignment) -> Record LBRACKET sep_or_term_list(field_path_assignment,SEMI) . RBRACKET [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## Record LBRACKET sep_or_term_list(field_path_assignment,SEMI) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 171, spurious reduction of production field_path_assignment -> nsepseq(field_name,DOT) EQ expr +## In state 207, spurious reduction of production nsepseq(field_path_assignment,SEMI) -> field_path_assignment +## In state 146, spurious reduction of production sep_or_term_list(field_path_assignment,SEMI) -> nsepseq(field_path_assignment,SEMI) +## + + + +interactive_expr: Ident With Record LBRACKET With +## +## Ends in an error in state: 139. +## +## ne_injection(Record,field_path_assignment) -> Record LBRACKET . sep_or_term_list(field_path_assignment,SEMI) RBRACKET [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## Record LBRACKET +## + + + +interactive_expr: Ident With Record With +## +## Ends in an error in state: 138. +## +## ne_injection(Record,field_path_assignment) -> Record . sep_or_term_list(field_path_assignment,SEMI) End [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## ne_injection(Record,field_path_assignment) -> Record . LBRACKET sep_or_term_list(field_path_assignment,SEMI) RBRACKET [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## Record +## + + + +interactive_expr: Ident With With +## +## Ends in an error in state: 137. +## +## update_record -> path With . ne_injection(Record,field_path_assignment) [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## path With +## + + + +interactive_expr: If Unit Then Unit Else With +## +## Ends in an error in state: 330. +## +## cond_expr -> If expr Then expr option(SEMI) Else . expr [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Of Function From End Else EOF Const COMMA Block Begin Attributes ARROW ] +## +## The known suffix of the stack is as follows: +## If expr Then expr option(SEMI) Else +## + + + +interactive_expr: If Unit Then Unit SEMI EQ +## +## Ends in an error in state: 329. +## +## cond_expr -> If expr Then expr option(SEMI) . Else expr [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Of Function From End Else EOF Const COMMA Block Begin Attributes ARROW ] +## +## The known suffix of the stack is as follows: +## If expr Then expr option(SEMI) +## + + + +interactive_expr: If Unit Then Unit VBAR +## +## Ends in an error in state: 328. +## +## cond_expr -> If expr Then expr . option(SEMI) Else expr [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Of Function From End Else EOF Const COMMA Block Begin Attributes ARROW ] +## +## The known suffix of the stack is as follows: +## If expr Then expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## + + + +interactive_expr: If Unit Then With +## +## Ends in an error in state: 327. +## +## cond_expr -> If expr Then . expr option(SEMI) Else expr [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Of Function From End Else EOF Const COMMA Block Begin Attributes ARROW ] +## +## The known suffix of the stack is as follows: +## If expr Then +## + + + +interactive_expr: If Unit VBAR +## +## Ends in an error in state: 326. +## +## cond_expr -> If expr . Then expr option(SEMI) Else expr [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Of Function From End Else EOF Const COMMA Block Begin Attributes ARROW ] +## +## The known suffix of the stack is as follows: +## If expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## + + + +interactive_expr: If With +## +## Ends in an error in state: 105. +## +## cond_expr -> If . expr Then expr option(SEMI) Else expr [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Of Function From End Else EOF Const COMMA Block Begin Attributes ARROW ] +## +## The known suffix of the stack is as follows: +## If +## + + + +interactive_expr: LPAR Bytes RPAR With +## +## Ends in an error in state: 150. +## +## fun_call_or_par_or_projection -> par(expr) . option(arguments) [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## par(expr) +## + + + +interactive_expr: LPAR If Unit Then Bytes Else Bytes VBAR +## +## Ends in an error in state: 334. +## +## par(expr) -> LPAR expr . RPAR [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LPAR LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## tuple_comp -> expr . COMMA nsepseq(expr,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## LPAR expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 331, spurious reduction of production cond_expr -> If expr Then expr option(SEMI) Else expr +## In state 205, spurious reduction of production expr -> cond_expr +## + + + +interactive_expr: LPAR Unit COLON Ident VBAR +## +## Ends in an error in state: 340. +## +## annot_expr -> LPAR disj_expr COLON type_expr . RPAR [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## LPAR disj_expr COLON type_expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 15, spurious reduction of production core_type -> Ident +## In state 29, spurious reduction of production cartesian -> core_type +## In state 35, spurious reduction of production fun_type -> cartesian +## In state 43, spurious reduction of production type_expr -> fun_type +## + + + +interactive_expr: LPAR Unit COLON With +## +## Ends in an error in state: 339. +## +## annot_expr -> LPAR disj_expr COLON . type_expr RPAR [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## LPAR disj_expr COLON +## + + + +interactive_expr: LPAR Unit COMMA With +## +## Ends in an error in state: 336. +## +## tuple_comp -> expr COMMA . nsepseq(expr,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## expr COMMA +## + + + +interactive_expr: LPAR Unit VBAR +## +## Ends in an error in state: 338. +## +## annot_expr -> LPAR disj_expr . COLON type_expr RPAR [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## disj_expr -> disj_expr . Or conj_expr [ RPAR Or COMMA COLON ] +## expr -> disj_expr . [ RPAR COMMA ] +## +## The known suffix of the stack is as follows: +## LPAR disj_expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## + + + +interactive_expr: LPAR With +## +## Ends in an error in state: 103. +## +## annot_expr -> LPAR . disj_expr COLON type_expr RPAR [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## par(expr) -> LPAR . expr RPAR [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LPAR LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## par(tuple_comp) -> LPAR . tuple_comp RPAR [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## LPAR +## + + + +interactive_expr: List LBRACKET Unit End +## +## Ends in an error in state: 344. +## +## injection(List,expr) -> List LBRACKET sep_or_term_list(expr,SEMI) . RBRACKET [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## List LBRACKET sep_or_term_list(expr,SEMI) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 348, spurious reduction of production nsepseq(expr,SEMI) -> expr +## In state 347, spurious reduction of production sep_or_term_list(expr,SEMI) -> nsepseq(expr,SEMI) +## + + + +interactive_expr: List LBRACKET With +## +## Ends in an error in state: 342. +## +## injection(List,expr) -> List LBRACKET . sep_or_term_list(expr,SEMI) RBRACKET [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## injection(List,expr) -> List LBRACKET . RBRACKET [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## List LBRACKET +## + + + +interactive_expr: List Unit RBRACKET +## +## Ends in an error in state: 356. +## +## injection(List,expr) -> List sep_or_term_list(expr,SEMI) . End [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## List sep_or_term_list(expr,SEMI) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 348, spurious reduction of production nsepseq(expr,SEMI) -> expr +## In state 347, spurious reduction of production sep_or_term_list(expr,SEMI) -> nsepseq(expr,SEMI) +## + + + +interactive_expr: List With +## +## Ends in an error in state: 102. +## +## injection(List,expr) -> List . sep_or_term_list(expr,SEMI) End [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## injection(List,expr) -> List . End [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## injection(List,expr) -> List . LBRACKET sep_or_term_list(expr,SEMI) RBRACKET [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## injection(List,expr) -> List . LBRACKET RBRACKET [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## List +## + + + +interactive_expr: MINUS With +## +## Ends in an error in state: 101. +## +## unary_expr -> MINUS . core_expr [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## MINUS +## + + + +interactive_expr: Map LBRACKET Unit ARROW Bytes End +## +## Ends in an error in state: 361. +## +## injection(Map,binding) -> Map LBRACKET sep_or_term_list(binding,SEMI) . RBRACKET [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## Map LBRACKET sep_or_term_list(binding,SEMI) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 225, spurious reduction of production binding -> expr ARROW expr +## In state 226, spurious reduction of production nsepseq(binding,SEMI) -> binding +## In state 222, spurious reduction of production sep_or_term_list(binding,SEMI) -> nsepseq(binding,SEMI) +## + + + +interactive_expr: Map LBRACKET With +## +## Ends in an error in state: 359. +## +## injection(Map,binding) -> Map LBRACKET . sep_or_term_list(binding,SEMI) RBRACKET [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## injection(Map,binding) -> Map LBRACKET . RBRACKET [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## Map LBRACKET +## + + + +interactive_expr: Map Unit ARROW Bytes RBRACKET +## +## Ends in an error in state: 364. +## +## injection(Map,binding) -> Map sep_or_term_list(binding,SEMI) . End [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## Map sep_or_term_list(binding,SEMI) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 225, spurious reduction of production binding -> expr ARROW expr +## In state 226, spurious reduction of production nsepseq(binding,SEMI) -> binding +## In state 222, spurious reduction of production sep_or_term_list(binding,SEMI) -> nsepseq(binding,SEMI) +## + + + +interactive_expr: Map Unit ARROW Bytes SEMI Unit ARROW Bytes SEMI With +## +## Ends in an error in state: 231. +## +## nsepseq(binding,SEMI) -> binding SEMI . nsepseq(binding,SEMI) [ RBRACKET End ] +## seq(__anonymous_0(binding,SEMI)) -> binding SEMI . seq(__anonymous_0(binding,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## binding SEMI +## + + + +interactive_expr: Map Unit ARROW Bytes SEMI Unit ARROW Bytes VBAR +## +## Ends in an error in state: 230. +## +## nsepseq(binding,SEMI) -> binding . [ RBRACKET End ] +## nsepseq(binding,SEMI) -> binding . SEMI nsepseq(binding,SEMI) [ RBRACKET End ] +## seq(__anonymous_0(binding,SEMI)) -> binding . SEMI seq(__anonymous_0(binding,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## binding +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 225, spurious reduction of production binding -> expr ARROW expr +## + + + +interactive_expr: Map Unit ARROW Bytes SEMI With +## +## Ends in an error in state: 227. +## +## nsepseq(binding,SEMI) -> binding SEMI . nsepseq(binding,SEMI) [ RBRACKET End ] +## nseq(__anonymous_0(binding,SEMI)) -> binding SEMI . seq(__anonymous_0(binding,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## binding SEMI +## + + + +interactive_expr: Map Unit ARROW Bytes VBAR +## +## Ends in an error in state: 226. +## +## nsepseq(binding,SEMI) -> binding . [ RBRACKET End ] +## nsepseq(binding,SEMI) -> binding . SEMI nsepseq(binding,SEMI) [ RBRACKET End ] +## nseq(__anonymous_0(binding,SEMI)) -> binding . SEMI seq(__anonymous_0(binding,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## binding +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 225, spurious reduction of production binding -> expr ARROW expr +## + + + +interactive_expr: Map Unit ARROW With +## +## Ends in an error in state: 224. +## +## binding -> expr ARROW . expr [ SEMI RBRACKET End ] +## +## The known suffix of the stack is as follows: +## expr ARROW +## + + + +interactive_expr: Map Unit VBAR +## +## Ends in an error in state: 223. +## +## binding -> expr . ARROW expr [ SEMI RBRACKET End ] +## +## The known suffix of the stack is as follows: +## expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## + + + +interactive_expr: Map With +## +## Ends in an error in state: 100. +## +## injection(Map,binding) -> Map . sep_or_term_list(binding,SEMI) End [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## injection(Map,binding) -> Map . End [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## injection(Map,binding) -> Map . LBRACKET sep_or_term_list(binding,SEMI) RBRACKET [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## injection(Map,binding) -> Map . LBRACKET RBRACKET [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## Map +## + + + +interactive_expr: Not Bytes With +## +## Ends in an error in state: 152. +## +## add_expr -> mult_expr . [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE PLUS Or Of NE MINUS LT LE GT GE Function From End Else EQ EOF Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## mult_expr -> mult_expr . TIMES unary_expr [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## mult_expr -> mult_expr . SLASH unary_expr [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## mult_expr -> mult_expr . Mod unary_expr [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## mult_expr +## + + + +interactive_expr: Not With +## +## Ends in an error in state: 96. +## +## unary_expr -> Not . core_expr [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## Not +## + + + +interactive_expr: Record Ident EQ Bytes RBRACKET +## +## Ends in an error in state: 379. +## +## record_expr -> Record sep_or_term_list(field_assignment,SEMI) . End [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## Record sep_or_term_list(field_assignment,SEMI) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 367, spurious reduction of production field_assignment -> Ident EQ expr +## In state 372, spurious reduction of production nsepseq(field_assignment,SEMI) -> field_assignment +## In state 371, spurious reduction of production sep_or_term_list(field_assignment,SEMI) -> nsepseq(field_assignment,SEMI) +## + + + +interactive_expr: Record Ident EQ Bytes SEMI Ident EQ Bytes SEMI With +## +## Ends in an error in state: 377. +## +## nsepseq(field_assignment,SEMI) -> field_assignment SEMI . nsepseq(field_assignment,SEMI) [ RBRACKET End ] +## seq(__anonymous_0(field_assignment,SEMI)) -> field_assignment SEMI . seq(__anonymous_0(field_assignment,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## field_assignment SEMI +## + + + +interactive_expr: Record Ident EQ Bytes SEMI Ident EQ Bytes VBAR +## +## Ends in an error in state: 376. +## +## nsepseq(field_assignment,SEMI) -> field_assignment . [ RBRACKET End ] +## nsepseq(field_assignment,SEMI) -> field_assignment . SEMI nsepseq(field_assignment,SEMI) [ RBRACKET End ] +## seq(__anonymous_0(field_assignment,SEMI)) -> field_assignment . SEMI seq(__anonymous_0(field_assignment,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## field_assignment +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 367, spurious reduction of production field_assignment -> Ident EQ expr +## + + + +interactive_expr: Record Ident EQ Bytes SEMI With +## +## Ends in an error in state: 373. +## +## nsepseq(field_assignment,SEMI) -> field_assignment SEMI . nsepseq(field_assignment,SEMI) [ RBRACKET End ] +## nseq(__anonymous_0(field_assignment,SEMI)) -> field_assignment SEMI . seq(__anonymous_0(field_assignment,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## field_assignment SEMI +## + + + +interactive_expr: Record Ident EQ Bytes VBAR +## +## Ends in an error in state: 372. +## +## nsepseq(field_assignment,SEMI) -> field_assignment . [ RBRACKET End ] +## nsepseq(field_assignment,SEMI) -> field_assignment . SEMI nsepseq(field_assignment,SEMI) [ RBRACKET End ] +## nseq(__anonymous_0(field_assignment,SEMI)) -> field_assignment . SEMI seq(__anonymous_0(field_assignment,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## field_assignment +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 367, spurious reduction of production field_assignment -> Ident EQ expr +## + + + +interactive_expr: Record Ident EQ With +## +## Ends in an error in state: 95. +## +## field_assignment -> Ident EQ . expr [ SEMI RBRACKET End ] +## +## The known suffix of the stack is as follows: +## Ident EQ +## + + + +interactive_expr: Record Ident With +## +## Ends in an error in state: 94. +## +## field_assignment -> Ident . EQ expr [ SEMI RBRACKET End ] +## +## The known suffix of the stack is as follows: +## Ident +## + + + +interactive_expr: Record LBRACKET Ident EQ Bytes End +## +## Ends in an error in state: 368. +## +## record_expr -> Record LBRACKET sep_or_term_list(field_assignment,SEMI) . RBRACKET [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## Record LBRACKET sep_or_term_list(field_assignment,SEMI) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 367, spurious reduction of production field_assignment -> Ident EQ expr +## In state 372, spurious reduction of production nsepseq(field_assignment,SEMI) -> field_assignment +## In state 371, spurious reduction of production sep_or_term_list(field_assignment,SEMI) -> nsepseq(field_assignment,SEMI) +## + + + +interactive_expr: Record LBRACKET With +## +## Ends in an error in state: 93. +## +## record_expr -> Record LBRACKET . sep_or_term_list(field_assignment,SEMI) RBRACKET [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## Record LBRACKET +## + + + +interactive_expr: Record With +## +## Ends in an error in state: 92. +## +## record_expr -> Record . sep_or_term_list(field_assignment,SEMI) End [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## record_expr -> Record . LBRACKET sep_or_term_list(field_assignment,SEMI) RBRACKET [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## Record +## + + + +interactive_expr: Set LBRACKET Unit End +## +## Ends in an error in state: 383. +## +## injection(Set,expr) -> Set LBRACKET sep_or_term_list(expr,SEMI) . RBRACKET [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## Set LBRACKET sep_or_term_list(expr,SEMI) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 348, spurious reduction of production nsepseq(expr,SEMI) -> expr +## In state 347, spurious reduction of production sep_or_term_list(expr,SEMI) -> nsepseq(expr,SEMI) +## + + + +interactive_expr: Set LBRACKET With +## +## Ends in an error in state: 381. +## +## injection(Set,expr) -> Set LBRACKET . sep_or_term_list(expr,SEMI) RBRACKET [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## injection(Set,expr) -> Set LBRACKET . RBRACKET [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## Set LBRACKET +## + + + +interactive_expr: Set Unit RBRACKET +## +## Ends in an error in state: 386. +## +## injection(Set,expr) -> Set sep_or_term_list(expr,SEMI) . End [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## Set sep_or_term_list(expr,SEMI) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 348, spurious reduction of production nsepseq(expr,SEMI) -> expr +## In state 347, spurious reduction of production sep_or_term_list(expr,SEMI) -> nsepseq(expr,SEMI) +## + + + +interactive_expr: Set Unit SEMI Unit SEMI With +## +## Ends in an error in state: 353. +## +## nsepseq(expr,SEMI) -> expr SEMI . nsepseq(expr,SEMI) [ RBRACKET End ] +## seq(__anonymous_0(expr,SEMI)) -> expr SEMI . seq(__anonymous_0(expr,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## expr SEMI +## + + + +interactive_expr: Set Unit SEMI Unit VBAR +## +## Ends in an error in state: 352. +## +## nsepseq(expr,SEMI) -> expr . [ RBRACKET End ] +## nsepseq(expr,SEMI) -> expr . SEMI nsepseq(expr,SEMI) [ RBRACKET End ] +## seq(__anonymous_0(expr,SEMI)) -> expr . SEMI seq(__anonymous_0(expr,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## + + + +interactive_expr: Set Unit SEMI With +## +## Ends in an error in state: 349. +## +## nsepseq(expr,SEMI) -> expr SEMI . nsepseq(expr,SEMI) [ RBRACKET End ] +## nseq(__anonymous_0(expr,SEMI)) -> expr SEMI . seq(__anonymous_0(expr,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## expr SEMI +## + + + +interactive_expr: Set Unit VBAR +## +## Ends in an error in state: 348. +## +## nsepseq(expr,SEMI) -> expr . [ RBRACKET End ] +## nsepseq(expr,SEMI) -> expr . SEMI nsepseq(expr,SEMI) [ RBRACKET End ] +## nseq(__anonymous_0(expr,SEMI)) -> expr . SEMI seq(__anonymous_0(expr,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## + + + +interactive_expr: Set With +## +## Ends in an error in state: 91. +## +## injection(Set,expr) -> Set . sep_or_term_list(expr,SEMI) End [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## injection(Set,expr) -> Set . End [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## injection(Set,expr) -> Set . LBRACKET sep_or_term_list(expr,SEMI) RBRACKET [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## injection(Set,expr) -> Set . LBRACKET RBRACKET [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Contains Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## Set +## + + + +interactive_expr: Unit And With +## +## Ends in an error in state: 202. +## +## conj_expr -> conj_expr And . set_membership [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Or Of Function From End Else EOF Const COMMA COLON Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## conj_expr And +## + + + +interactive_expr: Unit CAT With +## +## Ends in an error in state: 178. +## +## cat_expr -> cons_expr CAT . cat_expr [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Or Of NE LT LE GT GE Function From End Else EQ EOF Const COMMA COLON Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## cons_expr CAT +## + + + +interactive_expr: Unit COLON +## +## Ends in an error in state: 172. +## +## disj_expr -> disj_expr . Or conj_expr [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Or Of Function From End Else EOF Const COMMA Block Begin Attributes ARROW ] +## expr -> disj_expr . [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Of Function From End Else EOF Const COMMA Block Begin Attributes ARROW ] +## +## The known suffix of the stack is as follows: +## disj_expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## + + + +interactive_expr: Unit CONS With +## +## Ends in an error in state: 185. +## +## cons_expr -> add_expr CONS . cons_expr [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Or Of NE LT LE GT GE Function From End Else EQ EOF Const COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## add_expr CONS +## + + + +interactive_expr: Unit Contains With +## +## Ends in an error in state: 175. +## +## set_membership -> core_expr Contains . set_membership [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Or Of Function From End Else EOF Const COMMA COLON Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## core_expr Contains +## + + + +interactive_expr: Unit EQ With +## +## Ends in an error in state: 198. +## +## comp_expr -> comp_expr EQ . cat_expr [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Or Of NE LT LE GT GE Function From End Else EQ EOF Const COMMA COLON Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## comp_expr EQ +## + + + +interactive_expr: Unit GE With +## +## Ends in an error in state: 196. +## +## comp_expr -> comp_expr GE . cat_expr [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Or Of NE LT LE GT GE Function From End Else EQ EOF Const COMMA COLON Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## comp_expr GE +## + + + +interactive_expr: Unit GT With +## +## Ends in an error in state: 194. +## +## comp_expr -> comp_expr GT . cat_expr [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Or Of NE LT LE GT GE Function From End Else EQ EOF Const COMMA COLON Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## comp_expr GT +## + + + +interactive_expr: Unit LE With +## +## Ends in an error in state: 192. +## +## comp_expr -> comp_expr LE . cat_expr [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Or Of NE LT LE GT GE Function From End Else EQ EOF Const COMMA COLON Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## comp_expr LE +## + + + +interactive_expr: Unit LT With +## +## Ends in an error in state: 190. +## +## comp_expr -> comp_expr LT . cat_expr [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Or Of NE LT LE GT GE Function From End Else EQ EOF Const COMMA COLON Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## comp_expr LT +## + + + +interactive_expr: Unit MINUS Unit With +## +## Ends in an error in state: 184. +## +## add_expr -> add_expr MINUS mult_expr . [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE PLUS Or Of NE MINUS LT LE GT GE Function From End Else EQ EOF Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## mult_expr -> mult_expr . TIMES unary_expr [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## mult_expr -> mult_expr . SLASH unary_expr [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## mult_expr -> mult_expr . Mod unary_expr [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## add_expr MINUS mult_expr +## + + + +interactive_expr: Unit MINUS With +## +## Ends in an error in state: 183. +## +## add_expr -> add_expr MINUS . mult_expr [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE PLUS Or Of NE MINUS LT LE GT GE Function From End Else EQ EOF Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## add_expr MINUS +## + + + +interactive_expr: Unit Mod With +## +## Ends in an error in state: 168. +## +## mult_expr -> mult_expr Mod . unary_expr [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## mult_expr Mod +## + + + +interactive_expr: Unit NE With +## +## Ends in an error in state: 188. +## +## comp_expr -> comp_expr NE . cat_expr [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Or Of NE LT LE GT GE Function From End Else EQ EOF Const COMMA COLON Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## comp_expr NE +## + + + +interactive_expr: Unit Or With +## +## Ends in an error in state: 173. +## +## disj_expr -> disj_expr Or . conj_expr [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Or Of Function From End Else EOF Const COMMA COLON Block Begin Attributes ARROW ] +## +## The known suffix of the stack is as follows: +## disj_expr Or +## + + + +interactive_expr: Unit PLUS Unit With +## +## Ends in an error in state: 182. +## +## add_expr -> add_expr PLUS mult_expr . [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE PLUS Or Of NE MINUS LT LE GT GE Function From End Else EQ EOF Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## mult_expr -> mult_expr . TIMES unary_expr [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## mult_expr -> mult_expr . SLASH unary_expr [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## mult_expr -> mult_expr . Mod unary_expr [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## add_expr PLUS mult_expr +## + + + +interactive_expr: Unit PLUS With +## +## Ends in an error in state: 181. +## +## add_expr -> add_expr PLUS . mult_expr [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE PLUS Or Of NE MINUS LT LE GT GE Function From End Else EQ EOF Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## add_expr PLUS +## + + + +interactive_expr: Unit SLASH With +## +## Ends in an error in state: 166. +## +## mult_expr -> mult_expr SLASH . unary_expr [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## mult_expr SLASH +## + + + +interactive_expr: Unit TIMES With +## +## Ends in an error in state: 153. +## +## mult_expr -> mult_expr TIMES . unary_expr [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## mult_expr TIMES +## + + + +interactive_expr: Unit VBAR +## +## Ends in an error in state: 570. +## +## interactive_expr -> expr . EOF [ # ] +## +## The known suffix of the stack is as follows: +## expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## + + + +interactive_expr: Unit With +## +## Ends in an error in state: 174. +## +## set_membership -> core_expr . Contains set_membership [ VBAR Type To Then SEMI RPAR RBRACKET RBRACE Or Of Function From End Else EOF Const COMMA COLON Block Begin Attributes And ARROW ] +## unary_expr -> core_expr . [ VBAR Type To Then TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or Of NE Mod MINUS LT LE GT GE Function From End Else EQ EOF Const CONS COMMA COLON CAT Block Begin Attributes And ARROW ] +## +## The known suffix of the stack is as follows: +## core_expr +## + + + +interactive_expr: With +## +## Ends in an error in state: 568. +## +## interactive_expr' -> . interactive_expr [ # ] +## +## The known suffix of the stack is as follows: +## +## + + + +contract: Attributes LBRACKET String End +## +## Ends in an error in state: 514. +## +## ne_injection(Attributes,String) -> Attributes LBRACKET sep_or_term_list(String,SEMI) . RBRACKET [ Type SEMI RBRACE Function End EOF Const Attributes ] +## +## The known suffix of the stack is as follows: +## Attributes LBRACKET sep_or_term_list(String,SEMI) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 506, spurious reduction of production nsepseq(String,SEMI) -> String +## In state 517, spurious reduction of production sep_or_term_list(String,SEMI) -> nsepseq(String,SEMI) +## + + + +contract: Attributes LBRACKET With +## +## Ends in an error in state: 513. +## +## ne_injection(Attributes,String) -> Attributes LBRACKET . sep_or_term_list(String,SEMI) RBRACKET [ Type SEMI RBRACE Function End EOF Const Attributes ] +## +## The known suffix of the stack is as follows: +## Attributes LBRACKET +## + + + +contract: Attributes String End Attributes String End SEMI With +## +## Ends in an error in state: 563. +## +## seq(declaration) -> declaration . seq(declaration) [ EOF ] +## +## The known suffix of the stack is as follows: +## declaration +## + + + +contract: Attributes String End SEMI With +## +## Ends in an error in state: 561. +## +## nseq(declaration) -> declaration . seq(declaration) [ EOF ] +## +## The known suffix of the stack is as follows: +## declaration +## + + + +contract: Attributes String End With +## +## Ends in an error in state: 556. +## +## attr_decl -> open_attr_decl . option(SEMI) [ Type Function EOF Const Attributes ] +## +## The known suffix of the stack is as follows: +## open_attr_decl +## + + + +contract: Attributes String RBRACKET +## +## Ends in an error in state: 518. +## +## ne_injection(Attributes,String) -> Attributes sep_or_term_list(String,SEMI) . End [ Type SEMI RBRACE Function End EOF Const Attributes ] +## +## The known suffix of the stack is as follows: +## Attributes sep_or_term_list(String,SEMI) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 506, spurious reduction of production nsepseq(String,SEMI) -> String +## In state 517, spurious reduction of production sep_or_term_list(String,SEMI) -> nsepseq(String,SEMI) +## + + + +contract: Attributes String SEMI String SEMI With +## +## Ends in an error in state: 509. +## +## nsepseq(String,SEMI) -> String SEMI . nsepseq(String,SEMI) [ RBRACKET End ] +## seq(__anonymous_0(String,SEMI)) -> String SEMI . seq(__anonymous_0(String,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## String SEMI +## + + + +contract: Attributes String SEMI String With +## +## Ends in an error in state: 508. +## +## nsepseq(String,SEMI) -> String . [ RBRACKET End ] +## nsepseq(String,SEMI) -> String . SEMI nsepseq(String,SEMI) [ RBRACKET End ] +## seq(__anonymous_0(String,SEMI)) -> String . SEMI seq(__anonymous_0(String,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## String +## + + + +contract: Attributes String SEMI With +## +## Ends in an error in state: 507. +## +## nsepseq(String,SEMI) -> String SEMI . nsepseq(String,SEMI) [ RBRACKET End ] +## nseq(__anonymous_0(String,SEMI)) -> String SEMI . seq(__anonymous_0(String,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## String SEMI +## + + + +contract: Attributes String With +## +## Ends in an error in state: 506. +## +## nsepseq(String,SEMI) -> String . [ RBRACKET End ] +## nsepseq(String,SEMI) -> String . SEMI nsepseq(String,SEMI) [ RBRACKET End ] +## nseq(__anonymous_0(String,SEMI)) -> String . SEMI seq(__anonymous_0(String,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## String +## + + + +contract: Attributes With +## +## Ends in an error in state: 505. +## +## ne_injection(Attributes,String) -> Attributes . sep_or_term_list(String,SEMI) End [ Type SEMI RBRACE Function End EOF Const Attributes ] +## ne_injection(Attributes,String) -> Attributes . LBRACKET sep_or_term_list(String,SEMI) RBRACKET [ Type SEMI RBRACE Function End EOF Const Attributes ] +## +## The known suffix of the stack is as follows: +## Attributes +## + + + +contract: Const Ident COLON Ident EQ Bytes VBAR +## +## Ends in an error in state: 554. +## +## const_decl -> open_const_decl . option(SEMI) [ Type Function EOF Const Attributes ] +## +## The known suffix of the stack is as follows: +## open_const_decl +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 463, spurious reduction of production unqualified_decl(EQ) -> Ident COLON type_expr EQ expr +## In state 464, spurious reduction of production open_const_decl -> Const unqualified_decl(EQ) +## + + + +contract: Const Ident COLON Ident EQ With +## +## Ends in an error in state: 462. +## +## unqualified_decl(EQ) -> Ident COLON type_expr EQ . expr [ Type SEMI RBRACE Function End EOF Const Attributes ] +## +## The known suffix of the stack is as follows: +## Ident COLON type_expr EQ +## + + + +contract: Const Ident COLON Ident VBAR +## +## Ends in an error in state: 461. +## +## unqualified_decl(EQ) -> Ident COLON type_expr . EQ expr [ Type SEMI RBRACE Function End EOF Const Attributes ] +## +## The known suffix of the stack is as follows: +## Ident COLON type_expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 15, spurious reduction of production core_type -> Ident +## In state 29, spurious reduction of production cartesian -> core_type +## In state 35, spurious reduction of production fun_type -> cartesian +## In state 43, spurious reduction of production type_expr -> fun_type +## + + + +contract: Const Ident COLON With +## +## Ends in an error in state: 460. +## +## unqualified_decl(EQ) -> Ident COLON . type_expr EQ expr [ Type SEMI RBRACE Function End EOF Const Attributes ] +## +## The known suffix of the stack is as follows: +## Ident COLON +## + + + +contract: Const Ident With +## +## Ends in an error in state: 459. +## +## unqualified_decl(EQ) -> Ident . COLON type_expr EQ expr [ Type SEMI RBRACE Function End EOF Const Attributes ] +## +## The known suffix of the stack is as follows: +## Ident +## + + + +contract: Const With +## +## Ends in an error in state: 458. +## +## open_const_decl -> Const . unqualified_decl(EQ) [ Type SEMI RBRACE Function End EOF Const Attributes ] +## +## The known suffix of the stack is as follows: +## Const +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Case Unit Of LBRACKET VBAR Block +## +## Ends in an error in state: 469. +## +## case(if_clause) -> Case expr Of LBRACKET option(VBAR) . cases(if_clause) RBRACKET [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Case expr Of LBRACKET option(VBAR) +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Case Unit Of LBRACKET WILD ARROW Skip End +## +## Ends in an error in state: 497. +## +## case(if_clause) -> Case expr Of LBRACKET option(VBAR) cases(if_clause) . RBRACKET [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Case expr Of LBRACKET option(VBAR) cases(if_clause) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 499, spurious reduction of production nsepseq(case_clause(if_clause),VBAR) -> case_clause(if_clause) +## In state 496, spurious reduction of production cases(if_clause) -> nsepseq(case_clause(if_clause),VBAR) +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Case Unit Of LBRACKET With +## +## Ends in an error in state: 468. +## +## case(if_clause) -> Case expr Of LBRACKET . option(VBAR) cases(if_clause) RBRACKET [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Case expr Of LBRACKET +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Case Unit Of VBAR Block +## +## Ends in an error in state: 502. +## +## case(if_clause) -> Case expr Of option(VBAR) . cases(if_clause) End [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Case expr Of option(VBAR) +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Case Unit Of WILD ARROW Skip RBRACKET +## +## Ends in an error in state: 503. +## +## case(if_clause) -> Case expr Of option(VBAR) cases(if_clause) . End [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Case expr Of option(VBAR) cases(if_clause) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 499, spurious reduction of production nsepseq(case_clause(if_clause),VBAR) -> case_clause(if_clause) +## In state 496, spurious reduction of production cases(if_clause) -> nsepseq(case_clause(if_clause),VBAR) +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Case Unit Of WILD ARROW Skip VBAR With +## +## Ends in an error in state: 500. +## +## nsepseq(case_clause(if_clause),VBAR) -> case_clause(if_clause) VBAR . nsepseq(case_clause(if_clause),VBAR) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## case_clause(if_clause) VBAR +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Case Unit Of WILD ARROW Skip With +## +## Ends in an error in state: 499. +## +## nsepseq(case_clause(if_clause),VBAR) -> case_clause(if_clause) . [ RBRACKET End ] +## nsepseq(case_clause(if_clause),VBAR) -> case_clause(if_clause) . VBAR nsepseq(case_clause(if_clause),VBAR) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## case_clause(if_clause) +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Case Unit Of WILD ARROW With +## +## Ends in an error in state: 471. +## +## case_clause(if_clause) -> pattern ARROW . if_clause [ VBAR RBRACKET End ] +## +## The known suffix of the stack is as follows: +## pattern ARROW +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Case Unit Of WILD RPAR +## +## Ends in an error in state: 470. +## +## case_clause(if_clause) -> pattern . ARROW if_clause [ VBAR RBRACKET End ] +## +## The known suffix of the stack is as follows: +## pattern +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 275, spurious reduction of production pattern -> core_pattern +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Case Unit Of With +## +## Ends in an error in state: 467. +## +## case(if_clause) -> Case expr Of . option(VBAR) cases(if_clause) End [ VBAR SEMI RBRACKET RBRACE End Else ] +## case(if_clause) -> Case expr Of . LBRACKET option(VBAR) cases(if_clause) RBRACKET [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Case expr Of +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Case Unit VBAR +## +## Ends in an error in state: 466. +## +## case(if_clause) -> Case expr . Of option(VBAR) cases(if_clause) End [ VBAR SEMI RBRACKET RBRACE End Else ] +## case(if_clause) -> Case expr . Of LBRACKET option(VBAR) cases(if_clause) RBRACKET [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Case expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Case With +## +## Ends in an error in state: 465. +## +## case(if_clause) -> Case . expr Of option(VBAR) cases(if_clause) End [ VBAR SEMI RBRACKET RBRACE End Else ] +## case(if_clause) -> Case . expr Of LBRACKET option(VBAR) cases(if_clause) RBRACKET [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Case +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin For Ident ARROW Ident With +## +## Ends in an error in state: 445. +## +## for_loop -> For Ident option(arrow_clause) . In collection expr block [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## For Ident option(arrow_clause) +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin For Ident ARROW With +## +## Ends in an error in state: 443. +## +## arrow_clause -> ARROW . Ident [ In ] +## +## The known suffix of the stack is as follows: +## ARROW +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin For Ident ASS Bytes To Unit VBAR +## +## Ends in an error in state: 456. +## +## for_loop -> For var_assign To expr . block [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## For var_assign To expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin For Ident ASS Bytes To With +## +## Ends in an error in state: 455. +## +## for_loop -> For var_assign To . expr block [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## For var_assign To +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin For Ident ASS Bytes VBAR +## +## Ends in an error in state: 454. +## +## for_loop -> For var_assign . To expr block [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## For var_assign +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 442, spurious reduction of production var_assign -> Ident ASS expr +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin For Ident ASS With +## +## Ends in an error in state: 441. +## +## var_assign -> Ident ASS . expr [ To ] +## +## The known suffix of the stack is as follows: +## Ident ASS +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin For Ident In Set Unit VBAR +## +## Ends in an error in state: 451. +## +## for_loop -> For Ident option(arrow_clause) In collection expr . block [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## For Ident option(arrow_clause) In collection expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin For Ident In Set With +## +## Ends in an error in state: 450. +## +## for_loop -> For Ident option(arrow_clause) In collection . expr block [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## For Ident option(arrow_clause) In collection +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin For Ident In With +## +## Ends in an error in state: 446. +## +## for_loop -> For Ident option(arrow_clause) In . collection expr block [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## For Ident option(arrow_clause) In +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin For Ident With +## +## Ends in an error in state: 440. +## +## for_loop -> For Ident . option(arrow_clause) In collection expr block [ VBAR SEMI RBRACKET RBRACE End Else ] +## var_assign -> Ident . ASS expr [ To ] +## +## The known suffix of the stack is as follows: +## For Ident +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin For With +## +## Ends in an error in state: 439. +## +## for_loop -> For . var_assign To expr block [ VBAR SEMI RBRACKET RBRACE End Else ] +## for_loop -> For . Ident option(arrow_clause) In collection expr block [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## For +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Ident ASS With +## +## Ends in an error in state: 483. +## +## assignment -> lhs ASS . rhs [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## lhs ASS +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Ident DOT Ident With +## +## Ends in an error in state: 477. +## +## lhs -> path . [ ASS ] +## map_lookup -> path . brackets(expr) [ ASS ] +## +## The known suffix of the stack is as follows: +## path +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 321, spurious reduction of production nsepseq(selection,DOT) -> selection +## In state 324, spurious reduction of production projection -> Ident DOT nsepseq(selection,DOT) +## In state 406, spurious reduction of production path -> projection +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Ident LBRACKET Bytes RBRACKET With +## +## Ends in an error in state: 482. +## +## assignment -> lhs . ASS rhs [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## lhs +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Ident With +## +## Ends in an error in state: 438. +## +## fun_call -> Ident . arguments [ VBAR SEMI RBRACKET RBRACE End Else ] +## path -> Ident . [ LBRACKET ASS ] +## projection -> Ident . DOT nsepseq(selection,DOT) [ LBRACKET ASS ] +## +## The known suffix of the stack is as follows: +## Ident +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin If Unit Then LBRACE Skip End +## +## Ends in an error in state: 534. +## +## clause_block -> LBRACE sep_or_term_list(statement,SEMI) . RBRACE [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## LBRACE sep_or_term_list(statement,SEMI) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 520, spurious reduction of production nsepseq(statement,SEMI) -> statement +## In state 537, spurious reduction of production sep_or_term_list(statement,SEMI) -> nsepseq(statement,SEMI) +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin If Unit Then LBRACE With +## +## Ends in an error in state: 437. +## +## clause_block -> LBRACE . sep_or_term_list(statement,SEMI) RBRACE [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## LBRACE +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin If Unit Then Skip Else With +## +## Ends in an error in state: 540. +## +## conditional -> If expr Then if_clause option(SEMI) Else . if_clause [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## If expr Then if_clause option(SEMI) Else +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin If Unit Then Skip SEMI EQ +## +## Ends in an error in state: 539. +## +## conditional -> If expr Then if_clause option(SEMI) . Else if_clause [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## If expr Then if_clause option(SEMI) +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin If Unit Then Skip With +## +## Ends in an error in state: 538. +## +## conditional -> If expr Then if_clause . option(SEMI) Else if_clause [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## If expr Then if_clause +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin If Unit Then With +## +## Ends in an error in state: 436. +## +## conditional -> If expr Then . if_clause option(SEMI) Else if_clause [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## If expr Then +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin If Unit VBAR +## +## Ends in an error in state: 435. +## +## conditional -> If expr . Then if_clause option(SEMI) Else if_clause [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## If expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin If With +## +## Ends in an error in state: 434. +## +## conditional -> If . expr Then if_clause option(SEMI) Else if_clause [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## If +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Patch Ident VBAR +## +## Ends in an error in state: 411. +## +## map_patch -> Patch path . With ne_injection(Map,binding) [ VBAR SEMI RBRACKET RBRACE End Else ] +## record_patch -> Patch path . With ne_injection(Record,field_assignment) [ VBAR SEMI RBRACKET RBRACE End Else ] +## set_patch -> Patch path . With ne_injection(Set,expr) [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Patch path +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 405, spurious reduction of production path -> Ident +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Patch Ident While +## +## Ends in an error in state: 405. +## +## path -> Ident . [ With VBAR SEMI RBRACKET RBRACE End Else ] +## projection -> Ident . DOT nsepseq(selection,DOT) [ With VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Ident +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Patch Ident With Map LBRACKET Unit ARROW Bytes End +## +## Ends in an error in state: 427. +## +## ne_injection(Map,binding) -> Map LBRACKET sep_or_term_list(binding,SEMI) . RBRACKET [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Map LBRACKET sep_or_term_list(binding,SEMI) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 225, spurious reduction of production binding -> expr ARROW expr +## In state 226, spurious reduction of production nsepseq(binding,SEMI) -> binding +## In state 222, spurious reduction of production sep_or_term_list(binding,SEMI) -> nsepseq(binding,SEMI) +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Patch Ident With Map LBRACKET With +## +## Ends in an error in state: 426. +## +## ne_injection(Map,binding) -> Map LBRACKET . sep_or_term_list(binding,SEMI) RBRACKET [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Map LBRACKET +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Patch Ident With Map Unit ARROW Bytes RBRACKET +## +## Ends in an error in state: 429. +## +## ne_injection(Map,binding) -> Map sep_or_term_list(binding,SEMI) . End [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Map sep_or_term_list(binding,SEMI) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 225, spurious reduction of production binding -> expr ARROW expr +## In state 226, spurious reduction of production nsepseq(binding,SEMI) -> binding +## In state 222, spurious reduction of production sep_or_term_list(binding,SEMI) -> nsepseq(binding,SEMI) +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Patch Ident With Map With +## +## Ends in an error in state: 425. +## +## ne_injection(Map,binding) -> Map . sep_or_term_list(binding,SEMI) End [ VBAR SEMI RBRACKET RBRACE End Else ] +## ne_injection(Map,binding) -> Map . LBRACKET sep_or_term_list(binding,SEMI) RBRACKET [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Map +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Patch Ident With Record Ident EQ Bytes RBRACKET +## +## Ends in an error in state: 423. +## +## ne_injection(Record,field_assignment) -> Record sep_or_term_list(field_assignment,SEMI) . End [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Record sep_or_term_list(field_assignment,SEMI) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 367, spurious reduction of production field_assignment -> Ident EQ expr +## In state 372, spurious reduction of production nsepseq(field_assignment,SEMI) -> field_assignment +## In state 371, spurious reduction of production sep_or_term_list(field_assignment,SEMI) -> nsepseq(field_assignment,SEMI) +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Patch Ident With Record LBRACKET Ident EQ Bytes End +## +## Ends in an error in state: 421. +## +## ne_injection(Record,field_assignment) -> Record LBRACKET sep_or_term_list(field_assignment,SEMI) . RBRACKET [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Record LBRACKET sep_or_term_list(field_assignment,SEMI) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 367, spurious reduction of production field_assignment -> Ident EQ expr +## In state 372, spurious reduction of production nsepseq(field_assignment,SEMI) -> field_assignment +## In state 371, spurious reduction of production sep_or_term_list(field_assignment,SEMI) -> nsepseq(field_assignment,SEMI) +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Patch Ident With Record LBRACKET With +## +## Ends in an error in state: 420. +## +## ne_injection(Record,field_assignment) -> Record LBRACKET . sep_or_term_list(field_assignment,SEMI) RBRACKET [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Record LBRACKET +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Patch Ident With Record With +## +## Ends in an error in state: 419. +## +## ne_injection(Record,field_assignment) -> Record . sep_or_term_list(field_assignment,SEMI) End [ VBAR SEMI RBRACKET RBRACE End Else ] +## ne_injection(Record,field_assignment) -> Record . LBRACKET sep_or_term_list(field_assignment,SEMI) RBRACKET [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Record +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Patch Ident With Set LBRACKET Unit End +## +## Ends in an error in state: 415. +## +## ne_injection(Set,expr) -> Set LBRACKET sep_or_term_list(expr,SEMI) . RBRACKET [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Set LBRACKET sep_or_term_list(expr,SEMI) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 348, spurious reduction of production nsepseq(expr,SEMI) -> expr +## In state 347, spurious reduction of production sep_or_term_list(expr,SEMI) -> nsepseq(expr,SEMI) +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Patch Ident With Set LBRACKET With +## +## Ends in an error in state: 414. +## +## ne_injection(Set,expr) -> Set LBRACKET . sep_or_term_list(expr,SEMI) RBRACKET [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Set LBRACKET +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Patch Ident With Set Unit RBRACKET +## +## Ends in an error in state: 417. +## +## ne_injection(Set,expr) -> Set sep_or_term_list(expr,SEMI) . End [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Set sep_or_term_list(expr,SEMI) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 348, spurious reduction of production nsepseq(expr,SEMI) -> expr +## In state 347, spurious reduction of production sep_or_term_list(expr,SEMI) -> nsepseq(expr,SEMI) +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Patch Ident With Set With +## +## Ends in an error in state: 413. +## +## ne_injection(Set,expr) -> Set . sep_or_term_list(expr,SEMI) End [ VBAR SEMI RBRACKET RBRACE End Else ] +## ne_injection(Set,expr) -> Set . LBRACKET sep_or_term_list(expr,SEMI) RBRACKET [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Set +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Patch Ident With With +## +## Ends in an error in state: 412. +## +## map_patch -> Patch path With . ne_injection(Map,binding) [ VBAR SEMI RBRACKET RBRACE End Else ] +## record_patch -> Patch path With . ne_injection(Record,field_assignment) [ VBAR SEMI RBRACKET RBRACE End Else ] +## set_patch -> Patch path With . ne_injection(Set,expr) [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Patch path With +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Patch With +## +## Ends in an error in state: 410. +## +## map_patch -> Patch . path With ne_injection(Map,binding) [ VBAR SEMI RBRACKET RBRACE End Else ] +## record_patch -> Patch . path With ne_injection(Record,field_assignment) [ VBAR SEMI RBRACKET RBRACE End Else ] +## set_patch -> Patch . path With ne_injection(Set,expr) [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Patch +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Remove Unit From Map With +## +## Ends in an error in state: 408. +## +## map_remove -> Remove expr From Map . path [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Remove expr From Map +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Remove Unit From Set With +## +## Ends in an error in state: 404. +## +## set_remove -> Remove expr From Set . path [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Remove expr From Set +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Remove Unit From With +## +## Ends in an error in state: 403. +## +## map_remove -> Remove expr From . Map path [ VBAR SEMI RBRACKET RBRACE End Else ] +## set_remove -> Remove expr From . Set path [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Remove expr From +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Remove Unit VBAR +## +## Ends in an error in state: 402. +## +## map_remove -> Remove expr . From Map path [ VBAR SEMI RBRACKET RBRACE End Else ] +## set_remove -> Remove expr . From Set path [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Remove expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Remove With +## +## Ends in an error in state: 401. +## +## map_remove -> Remove . expr From Map path [ VBAR SEMI RBRACKET RBRACE End Else ] +## set_remove -> Remove . expr From Set path [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Remove +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Skip End While +## +## Ends in an error in state: 548. +## +## open_fun_decl -> Function Ident parameters COLON type_expr Is block . With expr [ Type SEMI RBRACE Function End EOF Const Attributes ] +## +## The known suffix of the stack is as follows: +## Function Ident parameters COLON type_expr Is block +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Skip End With With +## +## Ends in an error in state: 549. +## +## open_fun_decl -> Function Ident parameters COLON type_expr Is block With . expr [ Type SEMI RBRACE Function End EOF Const Attributes ] +## +## The known suffix of the stack is as follows: +## Function Ident parameters COLON type_expr Is block With +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Skip RBRACE +## +## Ends in an error in state: 542. +## +## block -> Begin sep_or_term_list(statement,SEMI) . End [ With VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Begin sep_or_term_list(statement,SEMI) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 520, spurious reduction of production nsepseq(statement,SEMI) -> statement +## In state 537, spurious reduction of production sep_or_term_list(statement,SEMI) -> nsepseq(statement,SEMI) +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Skip SEMI Skip SEMI With +## +## Ends in an error in state: 523. +## +## nsepseq(statement,SEMI) -> statement SEMI . nsepseq(statement,SEMI) [ RBRACE End ] +## seq(__anonymous_0(statement,SEMI)) -> statement SEMI . seq(__anonymous_0(statement,SEMI)) [ RBRACE End ] +## +## The known suffix of the stack is as follows: +## statement SEMI +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Skip SEMI Skip With +## +## Ends in an error in state: 522. +## +## nsepseq(statement,SEMI) -> statement . [ RBRACE End ] +## nsepseq(statement,SEMI) -> statement . SEMI nsepseq(statement,SEMI) [ RBRACE End ] +## seq(__anonymous_0(statement,SEMI)) -> statement . SEMI seq(__anonymous_0(statement,SEMI)) [ RBRACE End ] +## +## The known suffix of the stack is as follows: +## statement +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Skip SEMI With +## +## Ends in an error in state: 521. +## +## nsepseq(statement,SEMI) -> statement SEMI . nsepseq(statement,SEMI) [ RBRACE End ] +## nseq(__anonymous_0(statement,SEMI)) -> statement SEMI . seq(__anonymous_0(statement,SEMI)) [ RBRACE End ] +## +## The known suffix of the stack is as follows: +## statement SEMI +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Skip With +## +## Ends in an error in state: 520. +## +## nsepseq(statement,SEMI) -> statement . [ RBRACE End ] +## nsepseq(statement,SEMI) -> statement . SEMI nsepseq(statement,SEMI) [ RBRACE End ] +## nseq(__anonymous_0(statement,SEMI)) -> statement . SEMI seq(__anonymous_0(statement,SEMI)) [ RBRACE End ] +## +## The known suffix of the stack is as follows: +## statement +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Var Ident COLON Ident ASS With +## +## Ends in an error in state: 397. +## +## unqualified_decl(ASS) -> Ident COLON type_expr ASS . expr [ SEMI RBRACE End ] +## +## The known suffix of the stack is as follows: +## Ident COLON type_expr ASS +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Var Ident COLON Ident VBAR +## +## Ends in an error in state: 396. +## +## unqualified_decl(ASS) -> Ident COLON type_expr . ASS expr [ SEMI RBRACE End ] +## +## The known suffix of the stack is as follows: +## Ident COLON type_expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 15, spurious reduction of production core_type -> Ident +## In state 29, spurious reduction of production cartesian -> core_type +## In state 35, spurious reduction of production fun_type -> cartesian +## In state 43, spurious reduction of production type_expr -> fun_type +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Var Ident COLON With +## +## Ends in an error in state: 395. +## +## unqualified_decl(ASS) -> Ident COLON . type_expr ASS expr [ SEMI RBRACE End ] +## +## The known suffix of the stack is as follows: +## Ident COLON +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Var Ident With +## +## Ends in an error in state: 394. +## +## unqualified_decl(ASS) -> Ident . COLON type_expr ASS expr [ SEMI RBRACE End ] +## +## The known suffix of the stack is as follows: +## Ident +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin Var With +## +## Ends in an error in state: 393. +## +## open_var_decl -> Var . unqualified_decl(ASS) [ SEMI RBRACE End ] +## +## The known suffix of the stack is as follows: +## Var +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin While Unit VBAR +## +## Ends in an error in state: 391. +## +## while_loop -> While expr . block [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## While expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin While With +## +## Ends in an error in state: 390. +## +## while_loop -> While . expr block [ VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## While +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Begin With +## +## Ends in an error in state: 392. +## +## block -> Begin . sep_or_term_list(statement,SEMI) End [ With VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Begin +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Block LBRACE Skip End +## +## Ends in an error in state: 545. +## +## block -> Block LBRACE sep_or_term_list(statement,SEMI) . RBRACE [ With VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Block LBRACE sep_or_term_list(statement,SEMI) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 520, spurious reduction of production nsepseq(statement,SEMI) -> statement +## In state 537, spurious reduction of production sep_or_term_list(statement,SEMI) -> nsepseq(statement,SEMI) +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Block LBRACE With +## +## Ends in an error in state: 389. +## +## block -> Block LBRACE . sep_or_term_list(statement,SEMI) RBRACE [ With VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Block LBRACE +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Block With +## +## Ends in an error in state: 388. +## +## block -> Block . LBRACE sep_or_term_list(statement,SEMI) RBRACE [ With VBAR SEMI RBRACKET RBRACE End Else ] +## +## The known suffix of the stack is as follows: +## Block +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is Bytes VBAR +## +## Ends in an error in state: 552. +## +## fun_decl -> open_fun_decl . option(SEMI) [ Type Function EOF Const Attributes ] +## +## The known suffix of the stack is as follows: +## open_fun_decl +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 174, spurious reduction of production unary_expr -> core_expr +## In state 126, spurious reduction of production mult_expr -> unary_expr +## In state 152, spurious reduction of production add_expr -> mult_expr +## In state 180, spurious reduction of production cons_expr -> add_expr +## In state 177, spurious reduction of production cat_expr -> cons_expr +## In state 200, spurious reduction of production comp_expr -> cat_expr +## In state 187, spurious reduction of production set_membership -> comp_expr +## In state 128, spurious reduction of production conj_expr -> set_membership +## In state 204, spurious reduction of production disj_expr -> conj_expr +## In state 172, spurious reduction of production expr -> disj_expr +## In state 547, spurious reduction of production open_fun_decl -> Function Ident parameters COLON type_expr Is expr +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident Is With +## +## Ends in an error in state: 87. +## +## open_fun_decl -> Function Ident parameters COLON type_expr Is . block With expr [ Type SEMI RBRACE Function End EOF Const Attributes ] +## open_fun_decl -> Function Ident parameters COLON type_expr Is . expr [ Type SEMI RBRACE Function End EOF Const Attributes ] +## +## The known suffix of the stack is as follows: +## Function Ident parameters COLON type_expr Is +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON Ident VBAR +## +## Ends in an error in state: 86. +## +## open_fun_decl -> Function Ident parameters COLON type_expr . Is block With expr [ Type SEMI RBRACE Function End EOF Const Attributes ] +## open_fun_decl -> Function Ident parameters COLON type_expr . Is expr [ Type SEMI RBRACE Function End EOF Const Attributes ] +## +## The known suffix of the stack is as follows: +## Function Ident parameters COLON type_expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 15, spurious reduction of production core_type -> Ident +## In state 29, spurious reduction of production cartesian -> core_type +## In state 35, spurious reduction of production fun_type -> cartesian +## In state 43, spurious reduction of production type_expr -> fun_type +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR COLON With +## +## Ends in an error in state: 85. +## +## open_fun_decl -> Function Ident parameters COLON . type_expr Is block With expr [ Type SEMI RBRACE Function End EOF Const Attributes ] +## open_fun_decl -> Function Ident parameters COLON . type_expr Is expr [ Type SEMI RBRACE Function End EOF Const Attributes ] +## +## The known suffix of the stack is as follows: +## Function Ident parameters COLON +## + + + +contract: Function Ident LPAR Const Ident COLON Ident RPAR With +## +## Ends in an error in state: 84. +## +## open_fun_decl -> Function Ident parameters . COLON type_expr Is block With expr [ Type SEMI RBRACE Function End EOF Const Attributes ] +## open_fun_decl -> Function Ident parameters . COLON type_expr Is expr [ Type SEMI RBRACE Function End EOF Const Attributes ] +## +## The known suffix of the stack is as follows: +## Function Ident parameters +## + + + +contract: Function Ident With +## +## Ends in an error in state: 68. +## +## open_fun_decl -> Function Ident . parameters COLON type_expr Is block With expr [ Type SEMI RBRACE Function End EOF Const Attributes ] +## open_fun_decl -> Function Ident . parameters COLON type_expr Is expr [ Type SEMI RBRACE Function End EOF Const Attributes ] +## +## The known suffix of the stack is as follows: +## Function Ident +## + + + +contract: Function With +## +## Ends in an error in state: 67. +## +## open_fun_decl -> Function . Ident parameters COLON type_expr Is block With expr [ Type SEMI RBRACE Function End EOF Const Attributes ] +## open_fun_decl -> Function . Ident parameters COLON type_expr Is expr [ Type SEMI RBRACE Function End EOF Const Attributes ] +## +## The known suffix of the stack is as follows: +## Function +## + + + +contract: Type Ident Is BigMap With +## +## Ends in an error in state: 18. +## +## core_type -> BigMap . type_tuple [ VBAR Type TIMES SEMI RPAR RBRACKET Is Function End EQ EOF Const COMMA Attributes ASS ARROW ] +## +## The known suffix of the stack is as follows: +## BigMap +## + + + +contract: Type Ident Is Constr Of With +## +## Ends in an error in state: 27. +## +## variant -> Constr Of . fun_type [ VBAR Type SEMI RPAR RBRACKET Is Function End EQ EOF Const COMMA Attributes ASS ] +## +## The known suffix of the stack is as follows: +## Constr Of +## + + + +contract: Type Ident Is Constr VBAR With +## +## Ends in an error in state: 39. +## +## nsepseq(variant,VBAR) -> variant VBAR . nsepseq(variant,VBAR) [ Type SEMI RPAR RBRACKET Is Function End EQ EOF Const COMMA Attributes ASS ] +## +## The known suffix of the stack is as follows: +## variant VBAR +## + + + +contract: Type Ident Is Constr With +## +## Ends in an error in state: 26. +## +## variant -> Constr . [ VBAR Type SEMI RPAR RBRACKET Is Function End EQ EOF Const COMMA Attributes ASS ] +## variant -> Constr . Of fun_type [ VBAR Type SEMI RPAR RBRACKET Is Function End EQ EOF Const COMMA Attributes ASS ] +## +## The known suffix of the stack is as follows: +## Constr +## + + + +contract: Type Ident Is Ident ARROW With +## +## Ends in an error in state: 36. +## +## fun_type -> cartesian ARROW . fun_type [ VBAR Type SEMI RPAR RBRACKET Is Function End EQ EOF Const COMMA Attributes ASS ] +## +## The known suffix of the stack is as follows: +## cartesian ARROW +## + + + +contract: Type Ident Is Ident TIMES Ident TIMES With +## +## Ends in an error in state: 33. +## +## nsepseq(core_type,TIMES) -> core_type TIMES . nsepseq(core_type,TIMES) [ VBAR Type SEMI RPAR RBRACKET Is Function End EQ EOF Const COMMA Attributes ASS ARROW ] +## +## The known suffix of the stack is as follows: +## core_type TIMES +## + + + +contract: Type Ident Is Ident TIMES LPAR Ident RPAR With +## +## Ends in an error in state: 32. +## +## nsepseq(core_type,TIMES) -> core_type . [ VBAR Type SEMI RPAR RBRACKET Is Function End EQ EOF Const COMMA Attributes ASS ARROW ] +## nsepseq(core_type,TIMES) -> core_type . TIMES nsepseq(core_type,TIMES) [ VBAR Type SEMI RPAR RBRACKET Is Function End EQ EOF Const COMMA Attributes ASS ARROW ] +## +## The known suffix of the stack is as follows: +## core_type +## + + + +contract: Type Ident Is Ident TIMES With +## +## Ends in an error in state: 30. +## +## cartesian -> core_type TIMES . nsepseq(core_type,TIMES) [ VBAR Type SEMI RPAR RBRACKET Is Function End EQ EOF Const COMMA Attributes ASS ARROW ] +## +## The known suffix of the stack is as follows: +## core_type TIMES +## + + + +contract: Type Ident Is Ident VBAR +## +## Ends in an error in state: 64. +## +## type_decl -> Type Ident Is type_expr . option(SEMI) [ Type Function EOF Const Attributes ] +## +## The known suffix of the stack is as follows: +## Type Ident Is type_expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 15, spurious reduction of production core_type -> Ident +## In state 29, spurious reduction of production cartesian -> core_type +## In state 35, spurious reduction of production fun_type -> cartesian +## In state 43, spurious reduction of production type_expr -> fun_type +## + + + +contract: Type Ident Is Ident With +## +## Ends in an error in state: 15. +## +## core_type -> Ident . [ VBAR Type TIMES SEMI RPAR RBRACKET Is Function End EQ EOF Const COMMA Attributes ASS ARROW ] +## core_type -> Ident . type_tuple [ VBAR Type TIMES SEMI RPAR RBRACKET Is Function End EQ EOF Const COMMA Attributes ASS ARROW ] +## +## The known suffix of the stack is as follows: +## Ident +## + + + +contract: Type Ident Is LPAR Constr RPAR With +## +## Ends in an error in state: 29. +## +## cartesian -> core_type . [ VBAR Type SEMI RPAR RBRACKET Is Function End EQ EOF Const COMMA Attributes ASS ARROW ] +## cartesian -> core_type . TIMES nsepseq(core_type,TIMES) [ VBAR Type SEMI RPAR RBRACKET Is Function End EQ EOF Const COMMA Attributes ASS ARROW ] +## +## The known suffix of the stack is as follows: +## core_type +## + + + +contract: Type Ident Is LPAR Ident VBAR +## +## Ends in an error in state: 61. +## +## par(type_expr) -> LPAR type_expr . RPAR [ VBAR Type TIMES SEMI RPAR RBRACKET Is Function End EQ EOF Const COMMA Attributes ASS ARROW ] +## +## The known suffix of the stack is as follows: +## LPAR type_expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 15, spurious reduction of production core_type -> Ident +## In state 29, spurious reduction of production cartesian -> core_type +## In state 35, spurious reduction of production fun_type -> cartesian +## In state 43, spurious reduction of production type_expr -> fun_type +## + + + +contract: Type Ident Is LPAR With +## +## Ends in an error in state: 6. +## +## par(type_expr) -> LPAR . type_expr RPAR [ VBAR Type TIMES SEMI RPAR RBRACKET Is Function End EQ EOF Const COMMA Attributes ASS ARROW ] +## +## The known suffix of the stack is as follows: +## LPAR +## + + + +contract: Type Ident Is List With +## +## Ends in an error in state: 13. +## +## core_type -> List . par(type_expr) [ VBAR Type TIMES SEMI RPAR RBRACKET Is Function End EQ EOF Const COMMA Attributes ASS ARROW ] +## +## The known suffix of the stack is as follows: +## List +## + + + +contract: Type Ident Is Map LPAR Ident COMMA With +## +## Ends in an error in state: 21. +## +## nsepseq(type_expr,COMMA) -> type_expr COMMA . nsepseq(type_expr,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## type_expr COMMA +## + + + +contract: Type Ident Is Map LPAR Ident VBAR +## +## Ends in an error in state: 20. +## +## nsepseq(type_expr,COMMA) -> type_expr . [ RPAR ] +## nsepseq(type_expr,COMMA) -> type_expr . COMMA nsepseq(type_expr,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## type_expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 15, spurious reduction of production core_type -> Ident +## In state 29, spurious reduction of production cartesian -> core_type +## In state 35, spurious reduction of production fun_type -> cartesian +## In state 43, spurious reduction of production type_expr -> fun_type +## + + + +contract: Type Ident Is Map LPAR With +## +## Ends in an error in state: 12. +## +## par(nsepseq(type_expr,COMMA)) -> LPAR . nsepseq(type_expr,COMMA) RPAR [ VBAR Type TIMES SEMI RPAR RBRACKET Is Function End EQ EOF Const COMMA Attributes ASS ARROW ] +## +## The known suffix of the stack is as follows: +## LPAR +## + + + +contract: Type Ident Is Map With +## +## Ends in an error in state: 11. +## +## core_type -> Map . type_tuple [ VBAR Type TIMES SEMI RPAR RBRACKET Is Function End EQ EOF Const COMMA Attributes ASS ARROW ] +## +## The known suffix of the stack is as follows: +## Map +## + + + +contract: Type Ident Is Record Ident COLON Ident RBRACKET +## +## Ends in an error in state: 59. +## +## record_type -> Record sep_or_term_list(field_decl,SEMI) . End [ Type SEMI RPAR RBRACKET Is Function End EQ EOF Const COMMA Attributes ASS ] +## +## The known suffix of the stack is as follows: +## Record sep_or_term_list(field_decl,SEMI) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 15, spurious reduction of production core_type -> Ident +## In state 29, spurious reduction of production cartesian -> core_type +## In state 35, spurious reduction of production fun_type -> cartesian +## In state 43, spurious reduction of production type_expr -> fun_type +## In state 47, spurious reduction of production field_decl -> Ident COLON type_expr +## In state 52, spurious reduction of production nsepseq(field_decl,SEMI) -> field_decl +## In state 51, spurious reduction of production sep_or_term_list(field_decl,SEMI) -> nsepseq(field_decl,SEMI) +## + + + +contract: Type Ident Is Record Ident COLON Ident SEMI Ident COLON Ident SEMI With +## +## Ends in an error in state: 57. +## +## nsepseq(field_decl,SEMI) -> field_decl SEMI . nsepseq(field_decl,SEMI) [ RBRACKET End ] +## seq(__anonymous_0(field_decl,SEMI)) -> field_decl SEMI . seq(__anonymous_0(field_decl,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## field_decl SEMI +## + + + +contract: Type Ident Is Record Ident COLON Ident SEMI Ident COLON Ident VBAR +## +## Ends in an error in state: 56. +## +## nsepseq(field_decl,SEMI) -> field_decl . [ RBRACKET End ] +## nsepseq(field_decl,SEMI) -> field_decl . SEMI nsepseq(field_decl,SEMI) [ RBRACKET End ] +## seq(__anonymous_0(field_decl,SEMI)) -> field_decl . SEMI seq(__anonymous_0(field_decl,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## field_decl +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 15, spurious reduction of production core_type -> Ident +## In state 29, spurious reduction of production cartesian -> core_type +## In state 35, spurious reduction of production fun_type -> cartesian +## In state 43, spurious reduction of production type_expr -> fun_type +## In state 47, spurious reduction of production field_decl -> Ident COLON type_expr +## + + + +contract: Type Ident Is Record Ident COLON Ident SEMI With +## +## Ends in an error in state: 53. +## +## nsepseq(field_decl,SEMI) -> field_decl SEMI . nsepseq(field_decl,SEMI) [ RBRACKET End ] +## nseq(__anonymous_0(field_decl,SEMI)) -> field_decl SEMI . seq(__anonymous_0(field_decl,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## field_decl SEMI +## + + + +contract: Type Ident Is Record Ident COLON Ident VBAR +## +## Ends in an error in state: 52. +## +## nsepseq(field_decl,SEMI) -> field_decl . [ RBRACKET End ] +## nsepseq(field_decl,SEMI) -> field_decl . SEMI nsepseq(field_decl,SEMI) [ RBRACKET End ] +## nseq(__anonymous_0(field_decl,SEMI)) -> field_decl . SEMI seq(__anonymous_0(field_decl,SEMI)) [ RBRACKET End ] +## +## The known suffix of the stack is as follows: +## field_decl +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 15, spurious reduction of production core_type -> Ident +## In state 29, spurious reduction of production cartesian -> core_type +## In state 35, spurious reduction of production fun_type -> cartesian +## In state 43, spurious reduction of production type_expr -> fun_type +## In state 47, spurious reduction of production field_decl -> Ident COLON type_expr +## + + + +contract: Type Ident Is Record Ident COLON With +## +## Ends in an error in state: 10. +## +## field_decl -> Ident COLON . type_expr [ SEMI RBRACKET End ] +## +## The known suffix of the stack is as follows: +## Ident COLON +## + + + +contract: Type Ident Is Record Ident With +## +## Ends in an error in state: 9. +## +## field_decl -> Ident . COLON type_expr [ SEMI RBRACKET End ] +## +## The known suffix of the stack is as follows: +## Ident +## + + + +contract: Type Ident Is Record LBRACKET Ident COLON Ident End +## +## Ends in an error in state: 48. +## +## record_type -> Record LBRACKET sep_or_term_list(field_decl,SEMI) . RBRACKET [ Type SEMI RPAR RBRACKET Is Function End EQ EOF Const COMMA Attributes ASS ] +## +## The known suffix of the stack is as follows: +## Record LBRACKET sep_or_term_list(field_decl,SEMI) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 15, spurious reduction of production core_type -> Ident +## In state 29, spurious reduction of production cartesian -> core_type +## In state 35, spurious reduction of production fun_type -> cartesian +## In state 43, spurious reduction of production type_expr -> fun_type +## In state 47, spurious reduction of production field_decl -> Ident COLON type_expr +## In state 52, spurious reduction of production nsepseq(field_decl,SEMI) -> field_decl +## In state 51, spurious reduction of production sep_or_term_list(field_decl,SEMI) -> nsepseq(field_decl,SEMI) +## + + + +contract: Type Ident Is Record LBRACKET With +## +## Ends in an error in state: 8. +## +## record_type -> Record LBRACKET . sep_or_term_list(field_decl,SEMI) RBRACKET [ Type SEMI RPAR RBRACKET Is Function End EQ EOF Const COMMA Attributes ASS ] +## +## The known suffix of the stack is as follows: +## Record LBRACKET +## + + + +contract: Type Ident Is Record With +## +## Ends in an error in state: 7. +## +## record_type -> Record . sep_or_term_list(field_decl,SEMI) End [ Type SEMI RPAR RBRACKET Is Function End EQ EOF Const COMMA Attributes ASS ] +## record_type -> Record . LBRACKET sep_or_term_list(field_decl,SEMI) RBRACKET [ Type SEMI RPAR RBRACKET Is Function End EQ EOF Const COMMA Attributes ASS ] +## +## The known suffix of the stack is as follows: +## Record +## + + + +contract: Type Ident Is Set With +## +## Ends in an error in state: 5. +## +## core_type -> Set . par(type_expr) [ VBAR Type TIMES SEMI RPAR RBRACKET Is Function End EQ EOF Const COMMA Attributes ASS ARROW ] +## +## The known suffix of the stack is as follows: +## Set +## + + + +contract: Type Ident Is VBAR Const +## +## Ends in an error in state: 25. +## +## sum_type -> option(VBAR) . nsepseq(variant,VBAR) [ Type SEMI RPAR RBRACKET Is Function End EQ EOF Const COMMA Attributes ASS ] +## +## The known suffix of the stack is as follows: +## option(VBAR) +## + + + +contract: Type Ident Is With +## +## Ends in an error in state: 3. +## +## type_decl -> Type Ident Is . type_expr option(SEMI) [ Type Function EOF Const Attributes ] +## +## The known suffix of the stack is as follows: +## Type Ident Is +## + + + +contract: Type Ident With +## +## Ends in an error in state: 2. +## +## type_decl -> Type Ident . Is type_expr option(SEMI) [ Type Function EOF Const Attributes ] +## +## The known suffix of the stack is as follows: +## Type Ident +## + + + +contract: Type With +## +## Ends in an error in state: 1. +## +## type_decl -> Type . Ident Is type_expr option(SEMI) [ Type Function EOF Const Attributes ] +## +## The known suffix of the stack is as follows: +## Type +## + + + +contract: With +## +## Ends in an error in state: 0. +## +## contract' -> . contract [ # ] +## +## The known suffix of the stack is as follows: +## +## + + + diff --git a/src/passes/1-parser/reasonligo/ParErr.ml b/src/passes/1-parser/reasonligo/ParErr.ml deleted file mode 100644 index 18b32b373..000000000 --- a/src/passes/1-parser/reasonligo/ParErr.ml +++ /dev/null @@ -1,526 +0,0 @@ - -(* This file was auto-generated based on "Parser.msg". *) - -(* Please note that the function [message] can raise [Not_found]. *) - -let message = - fun s -> - match s with - | 0 -> - "\n" - | 1 -> - "\n" - | 2 -> - "\n" - | 3 -> - "\n" - | 4 -> - "\n" - | 5 -> - "\n" - | 55 -> - "\n" - | 6 -> - "\n" - | 52 -> - "\n" - | 54 -> - "\n" - | 7 -> - "\n" - | 38 -> - "\n" - | 8 -> - "\n" - | 9 -> - "\n" - | 32 -> - "\n" - | 36 -> - "\n" - | 35 -> - "\n" - | 10 -> - "\n" - | 31 -> - "\n" - | 11 -> - "\n" - | 528 -> - "\n" - | 61 -> - "\n" - | 48 -> - "\n" - | 12 -> - "\n" - | 19 -> - "\n" - | 20 -> - "\n" - | 43 -> - "\n" - | 46 -> - "\n" - | 49 -> - "\n" - | 13 -> - "\n" - | 14 -> - "\n" - | 65 -> - "\n" - | 70 -> - "\n" - | 524 -> - "\n" - | 185 -> - "\n" - | 186 -> - "\n" - | 184 -> - "\n" - | 302 -> - "\n" - | 304 -> - "\n" - | 303 -> - "\n" - | 66 -> - "\n" - | 69 -> - "\n" - | 64 -> - "\n" - | 183 -> - "\n" - | 311 -> - "\n" - | 313 -> - "\n" - | 312 -> - "\n" - | 191 -> - "\n" - | 192 -> - "\n" - | 118 -> - "\n" - | 298 -> - "\n" - | 300 -> - "\n" - | 299 -> - "\n" - | 132 -> - "\n" - | 195 -> - "\n" - | 158 -> - "\n" - | 165 -> - "\n" - | 127 -> - "\n" - | 145 -> - "\n" - | 147 -> - "\n" - | 148 -> - "\n" - | 146 -> - "\n" - | 128 -> - "\n" - | 133 -> - "\n" - | 120 -> - "\n" - | 121 -> - "\n" - | 122 -> - "\n" - | 172 -> - "\n" - | 307 -> - "\n" - | 309 -> - "\n" - | 308 -> - "\n" - | 173 -> - "\n" - | 176 -> - "\n" - | 177 -> - "\n" - | 197 -> - "\n" - | 199 -> - "\n" - | 198 -> - "\n" - | 59 -> - "\n" - | 531 -> - "\n" - | 225 -> - "\n" - | 533 -> - "\n" - | 223 -> - "\n" - | 257 -> - "\n" - | 255 -> - "\n" - | 256 -> - "\n" - | 237 -> - "\n" - | 242 -> - "\n" - | 259 -> - "\n" - | 261 -> - "\n" - | 262 -> - "\n" - | 265 -> - "\n" - | 226 -> - "\n" - | 233 -> - "\n" - | 234 -> - "\n" - | 267 -> - "\n" - | 269 -> - "\n" - | 271 -> - "\n" - | 273 -> - "\n" - | 201 -> - "\n" - | 202 -> - "\n" - | 213 -> - "\n" - | 222 -> - "\n" - | 206 -> - "\n" - | 214 -> - "\n" - | 215 -> - "\n" - | 203 -> - "\n" - | 204 -> - "\n" - | 205 -> - "\n" - | 263 -> - "\n" - | 284 -> - "\n" - | 240 -> - "\n" - | 286 -> - "\n" - | 72 -> - "\n" - | 483 -> - "\n" - | 484 -> - "\n" - | 423 -> - "\n" - | 161 -> - "\n" - | 162 -> - "\n" - | 160 -> - "\n" - | 486 -> - "\n" - | 487 -> - "\n" - | 504 -> - "\n" - | 513 -> - "\n" - | 498 -> - "\n" - | 499 -> - "\n" - | 497 -> - "\n" - | 488 -> - "\n" - | 489 -> - "\n" - | 490 -> - "\n" - | 492 -> - "\n" - | 493 -> - "\n" - | 494 -> - "\n" - | 495 -> - "\n" - | 509 -> - "\n" - | 510 -> - "\n" - | 491 -> - "\n" - | 520 -> - "\n" - | 518 -> - "\n" - | 485 -> - "\n" - | 372 -> - "\n" - | 366 -> - "\n" - | 367 -> - "\n" - | 369 -> - "\n" - | 368 -> - "\n" - | 365 -> - "\n" - | 76 -> - "\n" - | 446 -> - "\n" - | 326 -> - "\n" - | 332 -> - "\n" - | 333 -> - "\n" - | 336 -> - "\n" - | 337 -> - "\n" - | 328 -> - "\n" - | 339 -> - "\n" - | 100 -> - "\n" - | 78 -> - "\n" - | 80 -> - "\n" - | 315 -> - "\n" - | 316 -> - "\n" - | 117 -> - "\n" - | 82 -> - "\n" - | 448 -> - "\n" - | 449 -> - "\n" - | 451 -> - "\n" - | 452 -> - "\n" - | 200 -> - "\n" - | 236 -> - "\n" - | 79 -> - "\n" - | 467 -> - "\n" - | 468 -> - "\n" - | 476 -> - "\n" - | 477 -> - "\n" - | 479 -> - "\n" - | 480 -> - "\n" - | 469 -> - "\n" - | 470 -> - "\n" - | 81 -> - "\n" - | 460 -> - "\n" - | 461 -> - "\n" - | 455 -> - "\n" - | 454 -> - "\n" - | 458 -> - "\n" - | 348 -> - "\n" - | 356 -> - "\n" - | 360 -> - "\n" - | 359 -> - "\n" - | 355 -> - "\n" - | 349 -> - "\n" - | 457 -> - "\n" - | 340 -> - "\n" - | 341 -> - "\n" - | 346 -> - "\n" - | 347 -> - "\n" - | 342 -> - "\n" - | 343 -> - "\n" - | 344 -> - "\n" - | 84 -> - "\n" - | 85 -> - "\n" - | 318 -> - "\n" - | 323 -> - "\n" - | 324 -> - "\n" - | 389 -> - "\n" - | 436 -> - "\n" - | 437 -> - "\n" - | 438 -> - "\n" - | 439 -> - "\n" - | 440 -> - "\n" - | 441 -> - "\n" - | 435 -> - "\n" - | 325 -> - "\n" - | 362 -> - "\n" - | 363 -> - "\n" - | 373 -> - "\n" - | 374 -> - "\n" - | 413 -> - "\n" - | 420 -> - "\n" - | 408 -> - "\n" - | 409 -> - "\n" - | 407 -> - "\n" - | 375 -> - "\n" - | 376 -> - "\n" - | 377 -> - "\n" - | 402 -> - "\n" - | 403 -> - "\n" - | 404 -> - "\n" - | 405 -> - "\n" - | 417 -> - "\n" - | 418 -> - "\n" - | 401 -> - "\n" - | 429 -> - "\n" - | 427 -> - "\n" - | 364 -> - "\n" - | 384 -> - "\n" - | 385 -> - "\n" - | 383 -> - "\n" - | 378 -> - "\n" - | 379 -> - "\n" - | 380 -> - "\n" - | 394 -> - "\n" - | 395 -> - "\n" - | 396 -> - "\n" - | 397 -> - "\n" - | 399 -> - "\n" - | 398 -> - "\n" - | 393 -> - "\n" - | 320 -> - "\n" - | 321 -> - "\n" - | 86 -> - "\n" - | 87 -> - "\n" - | 88 -> - "\n" - | 89 -> - "\n" - | 90 -> - "\n" - | 91 -> - "\n" - | 96 -> - "\n" - | 97 -> - "\n" - | 98 -> - "\n" - | 111 -> - "\n" - | 244 -> - "\n" - | _ -> - raise Not_found diff --git a/src/passes/1-parser/reasonligo/dune b/src/passes/1-parser/reasonligo/dune index 266196733..6eb7304b8 100644 --- a/src/passes/1-parser/reasonligo/dune +++ b/src/passes/1-parser/reasonligo/dune @@ -71,3 +71,104 @@ (targets all.religo) (deps (:script_cover ../../../../vendors/ligo-utils/simple-utils/cover.sh) Parser.mly LexToken.mli ParToken.mly Parser.msg Unlexer.exe) (action (run %{script_cover} --lex-tokens=LexToken.mli --par-tokens=ParToken.mly --ext=religo --unlexer=./Unlexer.exe --messages=Parser.msg --dir=. --concatenate Parser.mly ))) + +;; Error messages + +;; Generate error messages from scratch +; (rule +; (targets error.messages) +; (deps Parser.mly ParToken.mly error.messages.checked-in) +; (action +; (with-stdout-to %{targets} +; (bash +; "menhir \ +; --unused-tokens \ +; --list-errors \ +; --table \ +; --strict \ +; --external-tokens LexToken.mli \ +; --base Parser.mly \ +; ParToken.mly \ +; Parser.mly +; " +; ) +; )) +; ) + +(rule + (targets error.messages) + (deps Parser.mly ParToken.mly error.messages.checked-in LexToken.mli) + (action + (with-stdout-to %{targets} + (run + menhir + --unused-tokens + --update-errors error.messages.checked-in + --table + --strict + --external-tokens LexToken.mli + --base Parser.mly + ParToken.mly + Parser.mly + ) + )) +) + +(rule + (target error.messages.new) + (action + (with-stdout-to %{target} + (run + menhir + --unused-tokens + --list-errors + --table + --strict + --external-tokens LexToken.mli + --base Parser.mly + ParToken.mly + Parser.mly + ) + ) + ) +) + +(alias + (name runtest) + (deps error.messages error.messages.new) + (action + (run + menhir + --unused-tokens + --table + --strict + --external-tokens LexToken.mli + --base Parser.mly + ParToken.mly + Parser.mly + --compare-errors error.messages.new + --compare-errors error.messages + ) + ) + ) + + + +(rule + (targets ParErr.ml) + (deps Parser.mly ParToken.mly error.messages.checked-in LexToken.mli) + (action + (with-stdout-to %{targets} + (run + menhir + --unused-tokens + --table + --strict + --external-tokens LexToken.mli + --base Parser.mly + ParToken.mly + Parser.mly + --compile-errors error.messages.checked-in + ) + )) +) diff --git a/src/passes/1-parser/reasonligo/error.messages.checked-in b/src/passes/1-parser/reasonligo/error.messages.checked-in new file mode 100644 index 000000000..62600f5f8 --- /dev/null +++ b/src/passes/1-parser/reasonligo/error.messages.checked-in @@ -0,0 +1,4330 @@ +interactive_expr: C_None WILD +## +## Ends in an error in state: 252. +## +## call_expr_level -> call_expr_level_in . option(type_annotation_simple) [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## call_expr_level_in +## + + + +interactive_expr: C_Some WILD +## +## Ends in an error in state: 119. +## +## constr_expr -> C_Some . core_expr [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## C_Some +## + + + +interactive_expr: Constr DOT Ident WILD +## +## Ends in an error in state: 106. +## +## module_field -> Constr DOT Ident . [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE LBRACE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## projection -> Constr DOT Ident . selection [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE LBRACE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## Constr DOT Ident +## + + + +interactive_expr: Constr DOT WILD +## +## Ends in an error in state: 105. +## +## module_field -> Constr DOT . Ident [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE LBRACE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## projection -> Constr DOT . Ident selection [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE LBRACE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## Constr DOT +## + + + +interactive_expr: Constr WILD +## +## Ends in an error in state: 104. +## +## constr_expr -> Constr . core_expr [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## constr_expr -> Constr . [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## module_field -> Constr . DOT Ident [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## projection -> Constr . DOT Ident selection [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## Constr +## + + + +interactive_expr: Ident DOT Ident WILD +## +## Ends in an error in state: 99. +## +## selection -> DOT Ident . selection [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE LBRACE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## selection -> DOT Ident . [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE LBRACE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## DOT Ident +## + + + +interactive_expr: Ident DOT WILD +## +## Ends in an error in state: 98. +## +## selection -> DOT . Ident selection [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE LBRACE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## selection -> DOT . Ident [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE LBRACE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## DOT +## + + + +interactive_expr: Ident LBRACKET Int RBRACKET WILD +## +## Ends in an error in state: 97. +## +## selection -> LBRACKET Int RBRACKET . selection [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE LBRACE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## selection -> LBRACKET Int RBRACKET . [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE LBRACE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## LBRACKET Int RBRACKET +## + + + +interactive_expr: Ident LBRACKET Int WILD +## +## Ends in an error in state: 96. +## +## selection -> LBRACKET Int . RBRACKET selection [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE LBRACE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## selection -> LBRACKET Int . RBRACKET [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE LBRACE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## LBRACKET Int +## + + + +interactive_expr: Ident LBRACKET WILD +## +## Ends in an error in state: 95. +## +## selection -> LBRACKET . Int RBRACKET selection [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE LBRACE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## selection -> LBRACKET . Int RBRACKET [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE LBRACE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## LBRACKET +## + + + +interactive_expr: Ident WILD +## +## Ends in an error in state: 94. +## +## common_expr -> Ident . [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE LBRACE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## projection -> Ident . selection [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE LBRACE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## Ident +## + + + +interactive_expr: If LBRACE True VBAR +## +## Ends in an error in state: 329. +## +## parenthesized_expr -> LBRACE expr . RBRACE [ LBRACE ] +## +## The known suffix of the stack is as follows: +## LBRACE expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 244, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 301, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 302, spurious reduction of production expr -> base_cond__open(expr) +## + + + +interactive_expr: If LBRACE WILD +## +## Ends in an error in state: 328. +## +## parenthesized_expr -> LBRACE . expr RBRACE [ LBRACE ] +## +## The known suffix of the stack is as follows: +## LBRACE +## + + + +interactive_expr: If LPAR True RPAR LBRACE If LPAR Bytes RPAR LBRACE True RBRACE +## +## Ends in an error in state: 405. +## +## if_then_else(closed_if) -> If parenthesized_expr LBRACE closed_if . SEMI RBRACE Else LBRACE closed_if SEMI RBRACE [ SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE closed_if +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 401, spurious reduction of production base_expr(closed_if) -> disj_expr_level +## In state 404, spurious reduction of production base_if_then_else__open(closed_if) -> base_expr(closed_if) +## In state 403, spurious reduction of production closed_if -> base_if_then_else__open(closed_if) +## + + + +interactive_expr: If LPAR True RPAR LBRACE If LPAR Bytes RPAR LBRACE True SEMI RBRACE Else LBRACE True RBRACE +## +## Ends in an error in state: 410. +## +## if_then_else(closed_if) -> If parenthesized_expr LBRACE closed_if SEMI RBRACE Else LBRACE closed_if . SEMI RBRACE [ SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE closed_if SEMI RBRACE Else LBRACE closed_if +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 401, spurious reduction of production base_expr(closed_if) -> disj_expr_level +## In state 404, spurious reduction of production base_if_then_else__open(closed_if) -> base_expr(closed_if) +## In state 403, spurious reduction of production closed_if -> base_if_then_else__open(closed_if) +## + + + +interactive_expr: If LPAR True RPAR LBRACE If LPAR Bytes RPAR LBRACE True SEMI RBRACE Else LBRACE True SEMI WILD +## +## Ends in an error in state: 411. +## +## if_then_else(closed_if) -> If parenthesized_expr LBRACE closed_if SEMI RBRACE Else LBRACE closed_if SEMI . RBRACE [ SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE closed_if SEMI RBRACE Else LBRACE closed_if SEMI +## + + + +interactive_expr: If LPAR True RPAR LBRACE If LPAR Bytes RPAR LBRACE True SEMI RBRACE Else LBRACE WILD +## +## Ends in an error in state: 409. +## +## if_then_else(closed_if) -> If parenthesized_expr LBRACE closed_if SEMI RBRACE Else LBRACE . closed_if SEMI RBRACE [ SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE closed_if SEMI RBRACE Else LBRACE +## + + + +interactive_expr: If LPAR True RPAR LBRACE If LPAR Bytes RPAR LBRACE True SEMI RBRACE Else WILD +## +## Ends in an error in state: 408. +## +## if_then_else(closed_if) -> If parenthesized_expr LBRACE closed_if SEMI RBRACE Else . LBRACE closed_if SEMI RBRACE [ SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE closed_if SEMI RBRACE Else +## + + + +interactive_expr: If LPAR True RPAR LBRACE If LPAR Bytes RPAR LBRACE True SEMI RBRACE WILD +## +## Ends in an error in state: 407. +## +## if_then_else(closed_if) -> If parenthesized_expr LBRACE closed_if SEMI RBRACE . Else LBRACE closed_if SEMI RBRACE [ SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE closed_if SEMI RBRACE +## + + + +interactive_expr: If LPAR True RPAR LBRACE If LPAR Bytes RPAR LBRACE True SEMI WILD +## +## Ends in an error in state: 406. +## +## if_then_else(closed_if) -> If parenthesized_expr LBRACE closed_if SEMI . RBRACE Else LBRACE closed_if SEMI RBRACE [ SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE closed_if SEMI +## + + + +interactive_expr: If LPAR True RPAR LBRACE If LPAR Bytes RPAR LBRACE WILD +## +## Ends in an error in state: 392. +## +## if_then_else(closed_if) -> If parenthesized_expr LBRACE . closed_if SEMI RBRACE Else LBRACE closed_if SEMI RBRACE [ SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE +## + + + +interactive_expr: If LPAR True RPAR LBRACE If LPAR Bytes RPAR WILD +## +## Ends in an error in state: 391. +## +## if_then_else(closed_if) -> If parenthesized_expr . LBRACE closed_if SEMI RBRACE Else LBRACE closed_if SEMI RBRACE [ SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr +## + + + +interactive_expr: If LPAR True RPAR LBRACE If WILD +## +## Ends in an error in state: 390. +## +## if_then_else(closed_if) -> If . parenthesized_expr LBRACE closed_if SEMI RBRACE Else LBRACE closed_if SEMI RBRACE [ SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If +## + + + +interactive_expr: If LPAR True RPAR LBRACE Let VBAR +## +## Ends in an error in state: 395. +## +## let_expr(closed_if) -> seq(Attr) Let . let_binding SEMI closed_if [ SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## seq(Attr) Let +## + + + +interactive_expr: If LPAR True RPAR LBRACE Let WILD EQ Bytes SEMI WILD +## +## Ends in an error in state: 397. +## +## let_expr(closed_if) -> seq(Attr) Let let_binding SEMI . closed_if [ SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## seq(Attr) Let let_binding SEMI +## + + + +interactive_expr: If LPAR True RPAR LBRACE Let WILD EQ Bytes VBAR +## +## Ends in an error in state: 396. +## +## let_expr(closed_if) -> seq(Attr) Let let_binding . SEMI closed_if [ SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## seq(Attr) Let let_binding +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 244, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 301, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 302, spurious reduction of production expr -> base_cond__open(expr) +## In state 546, spurious reduction of production let_binding -> WILD option(type_annotation) EQ expr +## + + + +interactive_expr: If LPAR True RPAR LBRACE Switch True LBRACE VBAR VBAR +## +## Ends in an error in state: 376. +## +## case_clause(base_if_then_else) -> VBAR . pattern ARROW base_if_then_else option(SEMI) [ VBAR RBRACE ] +## +## The known suffix of the stack is as follows: +## VBAR +## + + + +interactive_expr: If LPAR True RPAR LBRACE Switch True LBRACE VBAR WILD ARROW Bytes SEMI WILD +## +## Ends in an error in state: 439. +## +## nseq(case_clause(base_if_then_else)) -> case_clause(base_if_then_else) . seq(case_clause(base_if_then_else)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## case_clause(base_if_then_else) +## + + + +interactive_expr: If LPAR True RPAR LBRACE Switch True LBRACE VBAR WILD ARROW Bytes VBAR Bytes ARROW Bytes SEMI WILD +## +## Ends in an error in state: 441. +## +## seq(case_clause(base_if_then_else)) -> case_clause(base_if_then_else) . seq(case_clause(base_if_then_else)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## case_clause(base_if_then_else) +## + + + +interactive_expr: If LPAR True RPAR LBRACE Switch True LBRACE VBAR WILD ARROW If LPAR Bytes RPAR LBRACE True RBRACE +## +## Ends in an error in state: 413. +## +## if_then_else(base_if_then_else) -> If parenthesized_expr LBRACE closed_if . SEMI RBRACE Else LBRACE base_if_then_else SEMI RBRACE [ VBAR SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE closed_if +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 401, spurious reduction of production base_expr(closed_if) -> disj_expr_level +## In state 404, spurious reduction of production base_if_then_else__open(closed_if) -> base_expr(closed_if) +## In state 403, spurious reduction of production closed_if -> base_if_then_else__open(closed_if) +## + + + +interactive_expr: If LPAR True RPAR LBRACE Switch True LBRACE VBAR WILD ARROW If LPAR Bytes RPAR LBRACE True SEMI RBRACE Else LBRACE True SEMI WILD +## +## Ends in an error in state: 430. +## +## if_then_else(base_if_then_else) -> If parenthesized_expr LBRACE closed_if SEMI RBRACE Else LBRACE base_if_then_else SEMI . RBRACE [ VBAR SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE closed_if SEMI RBRACE Else LBRACE base_if_then_else SEMI +## + + + +interactive_expr: If LPAR True RPAR LBRACE Switch True LBRACE VBAR WILD ARROW If LPAR Bytes RPAR LBRACE True SEMI RBRACE Else LBRACE True VBAR +## +## Ends in an error in state: 429. +## +## if_then_else(base_if_then_else) -> If parenthesized_expr LBRACE closed_if SEMI RBRACE Else LBRACE base_if_then_else . SEMI RBRACE [ VBAR SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE closed_if SEMI RBRACE Else LBRACE base_if_then_else +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 425, spurious reduction of production base_expr(base_if_then_else) -> disj_expr_level +## In state 428, spurious reduction of production base_if_then_else__open(base_if_then_else) -> base_expr(base_if_then_else) +## In state 426, spurious reduction of production base_if_then_else -> base_if_then_else__open(base_if_then_else) +## + + + +interactive_expr: If LPAR True RPAR LBRACE Switch True LBRACE VBAR WILD ARROW If LPAR Bytes RPAR LBRACE True SEMI RBRACE Else LBRACE WILD +## +## Ends in an error in state: 417. +## +## if_then_else(base_if_then_else) -> If parenthesized_expr LBRACE closed_if SEMI RBRACE Else LBRACE . base_if_then_else SEMI RBRACE [ VBAR SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE closed_if SEMI RBRACE Else LBRACE +## + + + +interactive_expr: If LPAR True RPAR LBRACE Switch True LBRACE VBAR WILD ARROW If LPAR Bytes RPAR LBRACE True SEMI RBRACE Else WILD +## +## Ends in an error in state: 416. +## +## if_then_else(base_if_then_else) -> If parenthesized_expr LBRACE closed_if SEMI RBRACE Else . LBRACE base_if_then_else SEMI RBRACE [ VBAR SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE closed_if SEMI RBRACE Else +## + + + +interactive_expr: If LPAR True RPAR LBRACE Switch True LBRACE VBAR WILD ARROW If LPAR Bytes RPAR LBRACE True SEMI RBRACE WILD +## +## Ends in an error in state: 415. +## +## if_then_else(base_if_then_else) -> If parenthesized_expr LBRACE closed_if SEMI RBRACE . Else LBRACE base_if_then_else SEMI RBRACE [ VBAR SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE closed_if SEMI RBRACE +## + + + +interactive_expr: If LPAR True RPAR LBRACE Switch True LBRACE VBAR WILD ARROW If LPAR Bytes RPAR LBRACE True SEMI WILD +## +## Ends in an error in state: 414. +## +## if_then_else(base_if_then_else) -> If parenthesized_expr LBRACE closed_if SEMI . RBRACE Else LBRACE base_if_then_else SEMI RBRACE [ VBAR SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE closed_if SEMI +## + + + +interactive_expr: If LPAR True RPAR LBRACE Switch True LBRACE VBAR WILD ARROW If LPAR Bytes RPAR LBRACE WILD +## +## Ends in an error in state: 389. +## +## if_then_else(base_if_then_else) -> If parenthesized_expr LBRACE . closed_if SEMI RBRACE Else LBRACE base_if_then_else SEMI RBRACE [ VBAR SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE +## + + + +interactive_expr: If LPAR True RPAR LBRACE Switch True LBRACE VBAR WILD ARROW If LPAR Bytes RPAR WILD +## +## Ends in an error in state: 388. +## +## if_then_else(base_if_then_else) -> If parenthesized_expr . LBRACE closed_if SEMI RBRACE Else LBRACE base_if_then_else SEMI RBRACE [ VBAR SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr +## + + + +interactive_expr: If LPAR True RPAR LBRACE Switch True LBRACE VBAR WILD ARROW If WILD +## +## Ends in an error in state: 387. +## +## if_then_else(base_if_then_else) -> If . parenthesized_expr LBRACE closed_if SEMI RBRACE Else LBRACE base_if_then_else SEMI RBRACE [ VBAR SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If +## + + + +interactive_expr: If LPAR True RPAR LBRACE Switch True LBRACE VBAR WILD ARROW Let VBAR +## +## Ends in an error in state: 419. +## +## let_expr(base_if_then_else) -> seq(Attr) Let . let_binding SEMI base_if_then_else [ VBAR SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## seq(Attr) Let +## + + + +interactive_expr: If LPAR True RPAR LBRACE Switch True LBRACE VBAR WILD ARROW Let WILD EQ Bytes SEMI WILD +## +## Ends in an error in state: 421. +## +## let_expr(base_if_then_else) -> seq(Attr) Let let_binding SEMI . base_if_then_else [ VBAR SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## seq(Attr) Let let_binding SEMI +## + + + +interactive_expr: If LPAR True RPAR LBRACE Switch True LBRACE VBAR WILD ARROW Let WILD EQ Bytes VBAR +## +## Ends in an error in state: 420. +## +## let_expr(base_if_then_else) -> seq(Attr) Let let_binding . SEMI base_if_then_else [ VBAR SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## seq(Attr) Let let_binding +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 244, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 301, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 302, spurious reduction of production expr -> base_cond__open(expr) +## In state 546, spurious reduction of production let_binding -> WILD option(type_annotation) EQ expr +## + + + +interactive_expr: If LPAR True RPAR LBRACE Switch True LBRACE VBAR WILD ARROW True ARROW Bytes RPAR +## +## Ends in an error in state: 432. +## +## case_clause(base_if_then_else) -> VBAR pattern ARROW base_if_then_else . option(SEMI) [ VBAR RBRACE ] +## +## The known suffix of the stack is as follows: +## VBAR pattern ARROW base_if_then_else +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 244, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 301, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 302, spurious reduction of production expr -> base_cond__open(expr) +## In state 295, spurious reduction of production es6_func -> ARROW expr +## In state 303, spurious reduction of production fun_expr -> disj_expr_level es6_func +## In state 424, spurious reduction of production base_expr(base_if_then_else) -> fun_expr +## In state 428, spurious reduction of production base_if_then_else__open(base_if_then_else) -> base_expr(base_if_then_else) +## In state 426, spurious reduction of production base_if_then_else -> base_if_then_else__open(base_if_then_else) +## + + + +interactive_expr: If LPAR True RPAR LBRACE Switch True LBRACE VBAR WILD ARROW True RPAR +## +## Ends in an error in state: 425. +## +## base_expr(base_if_then_else) -> disj_expr_level . [ VBAR SEMI RBRACE ] +## bin_op(disj_expr_level,BOOL_OR,conj_expr_level) -> disj_expr_level . BOOL_OR conj_expr_level [ VBAR SEMI RBRACE Or BOOL_OR ARROW ] +## bin_op(disj_expr_level,Or,conj_expr_level) -> disj_expr_level . Or conj_expr_level [ VBAR SEMI RBRACE Or BOOL_OR ARROW ] +## fun_expr -> disj_expr_level . es6_func [ VBAR SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## disj_expr_level +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## + + + +interactive_expr: If LPAR True RPAR LBRACE Switch True LBRACE VBAR WILD ARROW WILD +## +## Ends in an error in state: 386. +## +## case_clause(base_if_then_else) -> VBAR pattern ARROW . base_if_then_else option(SEMI) [ VBAR RBRACE ] +## +## The known suffix of the stack is as follows: +## VBAR pattern ARROW +## + + + +interactive_expr: If LPAR True RPAR LBRACE Switch True LBRACE VBAR WILD COMMA Bytes RPAR +## +## Ends in an error in state: 385. +## +## case_clause(base_if_then_else) -> VBAR pattern . ARROW base_if_then_else option(SEMI) [ VBAR RBRACE ] +## +## The known suffix of the stack is as follows: +## VBAR pattern +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 169, spurious reduction of production nsepseq(sub_pattern,COMMA) -> sub_pattern +## In state 172, spurious reduction of production tuple(sub_pattern) -> sub_pattern COMMA nsepseq(sub_pattern,COMMA) +## In state 383, spurious reduction of production pattern -> tuple(sub_pattern) +## + + + +interactive_expr: If LPAR True RPAR LBRACE Switch True LBRACE WILD +## +## Ends in an error in state: 375. +## +## switch_expr(base_if_then_else) -> Switch switch_expr_ LBRACE . cases(base_if_then_else) RBRACE [ SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## Switch switch_expr_ LBRACE +## + + + +interactive_expr: If LPAR True RPAR LBRACE Switch True WILD +## +## Ends in an error in state: 374. +## +## switch_expr(base_if_then_else) -> Switch switch_expr_ . LBRACE cases(base_if_then_else) RBRACE [ SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## Switch switch_expr_ +## + + + +interactive_expr: If LPAR True RPAR LBRACE Switch WILD +## +## Ends in an error in state: 333. +## +## switch_expr(base_if_then_else) -> Switch . switch_expr_ LBRACE cases(base_if_then_else) RBRACE [ SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## Switch +## + + + +interactive_expr: If LPAR True RPAR LBRACE True ARROW Bytes VBAR +## +## Ends in an error in state: 447. +## +## if_then(expr) -> If parenthesized_expr LBRACE closed_if . RBRACE [ VBAR SEMI RPAR RBRACKET RBRACE EOF COMMA ] +## if_then_else(expr) -> If parenthesized_expr LBRACE closed_if . SEMI RBRACE Else LBRACE expr SEMI RBRACE [ VBAR SEMI RPAR RBRACKET RBRACE EOF COMMA ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE closed_if +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 244, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 301, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 302, spurious reduction of production expr -> base_cond__open(expr) +## In state 295, spurious reduction of production es6_func -> ARROW expr +## In state 303, spurious reduction of production fun_expr -> disj_expr_level es6_func +## In state 400, spurious reduction of production base_expr(closed_if) -> fun_expr +## In state 404, spurious reduction of production base_if_then_else__open(closed_if) -> base_expr(closed_if) +## In state 403, spurious reduction of production closed_if -> base_if_then_else__open(closed_if) +## + + + +interactive_expr: If LPAR True RPAR LBRACE True SEMI RBRACE Else LBRACE True SEMI WILD +## +## Ends in an error in state: 453. +## +## if_then_else(expr) -> If parenthesized_expr LBRACE closed_if SEMI RBRACE Else LBRACE expr SEMI . RBRACE [ VBAR SEMI RPAR RBRACKET RBRACE EOF COMMA ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE closed_if SEMI RBRACE Else LBRACE expr SEMI +## + + + +interactive_expr: If LPAR True RPAR LBRACE True SEMI RBRACE Else LBRACE True VBAR +## +## Ends in an error in state: 452. +## +## if_then_else(expr) -> If parenthesized_expr LBRACE closed_if SEMI RBRACE Else LBRACE expr . SEMI RBRACE [ VBAR SEMI RPAR RBRACKET RBRACE EOF COMMA ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE closed_if SEMI RBRACE Else LBRACE expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 244, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 301, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 302, spurious reduction of production expr -> base_cond__open(expr) +## + + + +interactive_expr: If LPAR True RPAR LBRACE True SEMI RBRACE Else LBRACE WILD +## +## Ends in an error in state: 451. +## +## if_then_else(expr) -> If parenthesized_expr LBRACE closed_if SEMI RBRACE Else LBRACE . expr SEMI RBRACE [ VBAR SEMI RPAR RBRACKET RBRACE EOF COMMA ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE closed_if SEMI RBRACE Else LBRACE +## + + + +interactive_expr: If LPAR True RPAR LBRACE True SEMI RBRACE Else WILD +## +## Ends in an error in state: 450. +## +## if_then_else(expr) -> If parenthesized_expr LBRACE closed_if SEMI RBRACE Else . LBRACE expr SEMI RBRACE [ VBAR SEMI RPAR RBRACKET RBRACE EOF COMMA ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE closed_if SEMI RBRACE Else +## + + + +interactive_expr: If LPAR True RPAR LBRACE True SEMI RBRACE WILD +## +## Ends in an error in state: 449. +## +## if_then_else(expr) -> If parenthesized_expr LBRACE closed_if SEMI RBRACE . Else LBRACE expr SEMI RBRACE [ VBAR SEMI RPAR RBRACKET RBRACE EOF COMMA ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE closed_if SEMI RBRACE +## + + + +interactive_expr: If LPAR True RPAR LBRACE True SEMI WILD +## +## Ends in an error in state: 448. +## +## if_then_else(expr) -> If parenthesized_expr LBRACE closed_if SEMI . RBRACE Else LBRACE expr SEMI RBRACE [ VBAR SEMI RPAR RBRACKET RBRACE EOF COMMA ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE closed_if SEMI +## + + + +interactive_expr: If LPAR True RPAR LBRACE True VBAR +## +## Ends in an error in state: 401. +## +## base_expr(closed_if) -> disj_expr_level . [ SEMI RBRACE ] +## bin_op(disj_expr_level,BOOL_OR,conj_expr_level) -> disj_expr_level . BOOL_OR conj_expr_level [ SEMI RBRACE Or BOOL_OR ARROW ] +## bin_op(disj_expr_level,Or,conj_expr_level) -> disj_expr_level . Or conj_expr_level [ SEMI RBRACE Or BOOL_OR ARROW ] +## fun_expr -> disj_expr_level . es6_func [ SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## disj_expr_level +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## + + + +interactive_expr: If LPAR True RPAR LBRACE WILD +## +## Ends in an error in state: 332. +## +## if_then(expr) -> If parenthesized_expr LBRACE . closed_if RBRACE [ VBAR SEMI RPAR RBRACKET RBRACE EOF COMMA ] +## if_then_else(expr) -> If parenthesized_expr LBRACE . closed_if SEMI RBRACE Else LBRACE expr SEMI RBRACE [ VBAR SEMI RPAR RBRACKET RBRACE EOF COMMA ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE +## + + + +interactive_expr: If LPAR True RPAR WILD +## +## Ends in an error in state: 331. +## +## if_then(expr) -> If parenthesized_expr . LBRACE closed_if RBRACE [ VBAR SEMI RPAR RBRACKET RBRACE EOF COMMA ] +## if_then_else(expr) -> If parenthesized_expr . LBRACE closed_if SEMI RBRACE Else LBRACE expr SEMI RBRACE [ VBAR SEMI RPAR RBRACKET RBRACE EOF COMMA ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr +## + + + +interactive_expr: If LPAR True VBAR +## +## Ends in an error in state: 326. +## +## parenthesized_expr -> LPAR expr . RPAR [ LBRACE ] +## +## The known suffix of the stack is as follows: +## LPAR expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 244, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 301, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 302, spurious reduction of production expr -> base_cond__open(expr) +## + + + +interactive_expr: If LPAR WILD +## +## Ends in an error in state: 93. +## +## parenthesized_expr -> LPAR . expr RPAR [ LBRACE ] +## +## The known suffix of the stack is as follows: +## LPAR +## + + + +interactive_expr: If WILD +## +## Ends in an error in state: 92. +## +## if_then(expr) -> If . parenthesized_expr LBRACE closed_if RBRACE [ VBAR SEMI RPAR RBRACKET RBRACE EOF COMMA ] +## if_then_else(expr) -> If . parenthesized_expr LBRACE closed_if SEMI RBRACE Else LBRACE expr SEMI RBRACE [ VBAR SEMI RPAR RBRACKET RBRACE EOF COMMA ] +## +## The known suffix of the stack is as follows: +## If +## + + + +interactive_expr: LBRACE ELLIPSIS Constr DOT Ident WILD +## +## Ends in an error in state: 352. +## +## projection -> Constr DOT Ident . selection [ COMMA ] +## +## The known suffix of the stack is as follows: +## Constr DOT Ident +## + + + +interactive_expr: LBRACE ELLIPSIS Constr DOT WILD +## +## Ends in an error in state: 351. +## +## projection -> Constr DOT . Ident selection [ COMMA ] +## +## The known suffix of the stack is as follows: +## Constr DOT +## + + + +interactive_expr: LBRACE ELLIPSIS Constr WILD +## +## Ends in an error in state: 350. +## +## projection -> Constr . DOT Ident selection [ COMMA ] +## +## The known suffix of the stack is as follows: +## Constr +## + + + +interactive_expr: LBRACE ELLIPSIS Ident COMMA Ident COLON Bytes VBAR +## +## Ends in an error in state: 367. +## +## nsepseq(field_path_assignment,COMMA) -> field_path_assignment . [ RBRACE ] +## nsepseq(field_path_assignment,COMMA) -> field_path_assignment . COMMA nsepseq(field_path_assignment,COMMA) [ RBRACE ] +## nseq(__anonymous_0(field_path_assignment,COMMA)) -> field_path_assignment . COMMA seq(__anonymous_0(field_path_assignment,COMMA)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_path_assignment +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 244, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 301, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 302, spurious reduction of production expr -> base_cond__open(expr) +## In state 366, spurious reduction of production field_path_assignment -> nsepseq(field_name,DOT) COLON expr +## + + + +interactive_expr: LBRACE ELLIPSIS Ident COMMA Ident COLON WILD +## +## Ends in an error in state: 365. +## +## field_path_assignment -> nsepseq(field_name,DOT) COLON . expr [ RBRACE COMMA ] +## +## The known suffix of the stack is as follows: +## nsepseq(field_name,DOT) COLON +## + + + +interactive_expr: LBRACE ELLIPSIS Ident COMMA Ident COMMA Ident COLON Bytes VBAR +## +## Ends in an error in state: 371. +## +## nsepseq(field_path_assignment,COMMA) -> field_path_assignment . [ RBRACE ] +## nsepseq(field_path_assignment,COMMA) -> field_path_assignment . COMMA nsepseq(field_path_assignment,COMMA) [ RBRACE ] +## seq(__anonymous_0(field_path_assignment,COMMA)) -> field_path_assignment . COMMA seq(__anonymous_0(field_path_assignment,COMMA)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_path_assignment +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 244, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 301, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 302, spurious reduction of production expr -> base_cond__open(expr) +## In state 366, spurious reduction of production field_path_assignment -> nsepseq(field_name,DOT) COLON expr +## + + + +interactive_expr: LBRACE ELLIPSIS Ident COMMA Ident COMMA Ident COMMA WILD +## +## Ends in an error in state: 372. +## +## nsepseq(field_path_assignment,COMMA) -> field_path_assignment COMMA . nsepseq(field_path_assignment,COMMA) [ RBRACE ] +## seq(__anonymous_0(field_path_assignment,COMMA)) -> field_path_assignment COMMA . seq(__anonymous_0(field_path_assignment,COMMA)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_path_assignment COMMA +## + + + +interactive_expr: LBRACE ELLIPSIS Ident COMMA Ident COMMA WILD +## +## Ends in an error in state: 368. +## +## nsepseq(field_path_assignment,COMMA) -> field_path_assignment COMMA . nsepseq(field_path_assignment,COMMA) [ RBRACE ] +## nseq(__anonymous_0(field_path_assignment,COMMA)) -> field_path_assignment COMMA . seq(__anonymous_0(field_path_assignment,COMMA)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_path_assignment COMMA +## + + + +interactive_expr: LBRACE ELLIPSIS Ident COMMA Ident DOT Ident WILD +## +## Ends in an error in state: 358. +## +## nsepseq(field_name,DOT) -> Ident . [ COLON ] +## nsepseq(field_name,DOT) -> Ident . DOT nsepseq(field_name,DOT) [ COLON ] +## +## The known suffix of the stack is as follows: +## Ident +## + + + +interactive_expr: LBRACE ELLIPSIS Ident COMMA Ident DOT WILD +## +## Ends in an error in state: 357. +## +## nsepseq(field_name,DOT) -> Ident DOT . nsepseq(field_name,DOT) [ COLON ] +## +## The known suffix of the stack is as follows: +## Ident DOT +## + + + +interactive_expr: LBRACE ELLIPSIS Ident COMMA Ident WILD +## +## Ends in an error in state: 356. +## +## field_path_assignment -> Ident . [ RBRACE COMMA ] +## nsepseq(field_name,DOT) -> Ident . [ COLON ] +## nsepseq(field_name,DOT) -> Ident . DOT nsepseq(field_name,DOT) [ COLON ] +## +## The known suffix of the stack is as follows: +## Ident +## + + + +interactive_expr: LBRACE ELLIPSIS Ident COMMA WILD +## +## Ends in an error in state: 355. +## +## update_record -> LBRACE ELLIPSIS path COMMA . sep_or_term_list(field_path_assignment,COMMA) RBRACE [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE LBRACE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## LBRACE ELLIPSIS path COMMA +## + + + +interactive_expr: LBRACE ELLIPSIS Ident DOT Ident VBAR +## +## Ends in an error in state: 354. +## +## update_record -> LBRACE ELLIPSIS path . COMMA sep_or_term_list(field_path_assignment,COMMA) RBRACE [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE LBRACE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## LBRACE ELLIPSIS path +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 99, spurious reduction of production selection -> DOT Ident +## In state 102, spurious reduction of production projection -> Ident selection +## In state 353, spurious reduction of production path -> projection +## + + + +interactive_expr: LBRACE ELLIPSIS Ident WILD +## +## Ends in an error in state: 349. +## +## path -> Ident . [ COMMA ] +## projection -> Ident . selection [ COMMA ] +## +## The known suffix of the stack is as follows: +## Ident +## + + + +interactive_expr: LBRACE ELLIPSIS WILD +## +## Ends in an error in state: 348. +## +## update_record -> LBRACE ELLIPSIS . path COMMA sep_or_term_list(field_path_assignment,COMMA) RBRACE [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE LBRACE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## LBRACE ELLIPSIS +## + + + +interactive_expr: LBRACE Ident COLON Bytes VBAR +## +## Ends in an error in state: 471. +## +## sequence_or_record_in -> field_assignment . COMMA sep_or_term_list(field_assignment,COMMA) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_assignment +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 244, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 301, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 302, spurious reduction of production expr -> base_cond__open(expr) +## In state 468, spurious reduction of production field_assignment -> Ident COLON expr +## + + + +interactive_expr: LBRACE Ident COLON WILD +## +## Ends in an error in state: 467. +## +## field_assignment -> Ident COLON . expr [ RBRACE COMMA ] +## +## The known suffix of the stack is as follows: +## Ident COLON +## + + + +interactive_expr: LBRACE Ident COMMA Ident COLON Bytes VBAR +## +## Ends in an error in state: 477. +## +## nsepseq(field_assignment,COMMA) -> field_assignment . [ RBRACE ] +## nsepseq(field_assignment,COMMA) -> field_assignment . COMMA nsepseq(field_assignment,COMMA) [ RBRACE ] +## nseq(__anonymous_0(field_assignment,COMMA)) -> field_assignment . COMMA seq(__anonymous_0(field_assignment,COMMA)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_assignment +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 244, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 301, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 302, spurious reduction of production expr -> base_cond__open(expr) +## In state 468, spurious reduction of production field_assignment -> Ident COLON expr +## + + + +interactive_expr: LBRACE Ident COMMA Ident COMMA Ident COLON Bytes VBAR +## +## Ends in an error in state: 481. +## +## nsepseq(field_assignment,COMMA) -> field_assignment . [ RBRACE ] +## nsepseq(field_assignment,COMMA) -> field_assignment . COMMA nsepseq(field_assignment,COMMA) [ RBRACE ] +## seq(__anonymous_0(field_assignment,COMMA)) -> field_assignment . COMMA seq(__anonymous_0(field_assignment,COMMA)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_assignment +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 244, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 301, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 302, spurious reduction of production expr -> base_cond__open(expr) +## In state 468, spurious reduction of production field_assignment -> Ident COLON expr +## + + + +interactive_expr: LBRACE Ident COMMA Ident COMMA Ident COMMA WILD +## +## Ends in an error in state: 482. +## +## nsepseq(field_assignment,COMMA) -> field_assignment COMMA . nsepseq(field_assignment,COMMA) [ RBRACE ] +## seq(__anonymous_0(field_assignment,COMMA)) -> field_assignment COMMA . seq(__anonymous_0(field_assignment,COMMA)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_assignment COMMA +## + + + +interactive_expr: LBRACE Ident COMMA Ident COMMA WILD +## +## Ends in an error in state: 478. +## +## nsepseq(field_assignment,COMMA) -> field_assignment COMMA . nsepseq(field_assignment,COMMA) [ RBRACE ] +## nseq(__anonymous_0(field_assignment,COMMA)) -> field_assignment COMMA . seq(__anonymous_0(field_assignment,COMMA)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_assignment COMMA +## + + + +interactive_expr: LBRACE Ident COMMA Ident WILD +## +## Ends in an error in state: 473. +## +## field_assignment -> Ident . [ RBRACE COMMA ] +## field_assignment -> Ident . COLON expr [ RBRACE COMMA ] +## +## The known suffix of the stack is as follows: +## Ident +## + + + +interactive_expr: LBRACE Ident COMMA WILD +## +## Ends in an error in state: 472. +## +## sequence_or_record_in -> field_assignment COMMA . sep_or_term_list(field_assignment,COMMA) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_assignment COMMA +## + + + +interactive_expr: LBRACE Ident WILD +## +## Ends in an error in state: 466. +## +## common_expr -> Ident . [ TIMES SLASH SEMI RBRACE PLUS Or NE Mod MINUS LT LPAR LE GT GE EQEQ COLON CAT BOOL_OR BOOL_AND ARROW ] +## field_assignment -> Ident . [ COMMA ] +## field_assignment -> Ident . COLON expr [ COMMA ] +## projection -> Ident . selection [ TIMES SLASH SEMI RBRACE PLUS Or NE Mod MINUS LT LPAR LE GT GE EQEQ COLON CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## Ident +## + + + +interactive_expr: LBRACE True SEMI Bytes RBRACKET +## +## Ends in an error in state: 469. +## +## sequence_or_record -> LBRACE sequence_or_record_in . RBRACE [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## LBRACE sequence_or_record_in +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 244, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 301, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 302, spurious reduction of production expr -> base_cond__open(expr) +## In state 340, spurious reduction of production nsepseq(expr,SEMI) -> expr +## In state 339, spurious reduction of production sep_or_term_list(expr,SEMI) -> nsepseq(expr,SEMI) +## In state 486, spurious reduction of production sequence_or_record_in -> expr SEMI sep_or_term_list(expr,SEMI) +## + + + +interactive_expr: LBRACE True SEMI WILD +## +## Ends in an error in state: 485. +## +## option(SEMI) -> SEMI . [ RBRACE ] +## sequence_or_record_in -> expr SEMI . sep_or_term_list(expr,SEMI) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## expr SEMI +## + + + +interactive_expr: LBRACE True VBAR +## +## Ends in an error in state: 484. +## +## sequence_or_record_in -> expr . SEMI sep_or_term_list(expr,SEMI) [ RBRACE ] +## sequence_or_record_in -> expr . option(SEMI) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 244, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 301, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 302, spurious reduction of production expr -> base_cond__open(expr) +## + + + +interactive_expr: LBRACE WILD +## +## Ends in an error in state: 89. +## +## sequence_or_record -> LBRACE . sequence_or_record_in RBRACE [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## update_record -> LBRACE . ELLIPSIS path COMMA sep_or_term_list(field_path_assignment,COMMA) RBRACE [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## LBRACE +## + + + +interactive_expr: LBRACKET True COMMA ELLIPSIS True VBAR +## +## Ends in an error in state: 494. +## +## list_or_spread -> LBRACKET expr COMMA ELLIPSIS expr . RBRACKET [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## LBRACKET expr COMMA ELLIPSIS expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 244, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 301, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 302, spurious reduction of production expr -> base_cond__open(expr) +## + + + +interactive_expr: LBRACKET True COMMA ELLIPSIS WILD +## +## Ends in an error in state: 493. +## +## list_or_spread -> LBRACKET expr COMMA ELLIPSIS . expr RBRACKET [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## LBRACKET expr COMMA ELLIPSIS +## + + + +interactive_expr: LBRACKET True COMMA True COMMA True COMMA WILD +## +## Ends in an error in state: 504. +## +## nsepseq(expr,COMMA) -> expr COMMA . nsepseq(expr,COMMA) [ RBRACKET ] +## seq(__anonymous_0(expr,COMMA)) -> expr COMMA . seq(__anonymous_0(expr,COMMA)) [ RBRACKET ] +## +## The known suffix of the stack is as follows: +## expr COMMA +## + + + +interactive_expr: LBRACKET True COMMA True COMMA True VBAR +## +## Ends in an error in state: 503. +## +## nsepseq(expr,COMMA) -> expr . [ RBRACKET ] +## nsepseq(expr,COMMA) -> expr . COMMA nsepseq(expr,COMMA) [ RBRACKET ] +## seq(__anonymous_0(expr,COMMA)) -> expr . COMMA seq(__anonymous_0(expr,COMMA)) [ RBRACKET ] +## +## The known suffix of the stack is as follows: +## expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 244, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 301, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 302, spurious reduction of production expr -> base_cond__open(expr) +## + + + +interactive_expr: LBRACKET True COMMA True COMMA WILD +## +## Ends in an error in state: 501. +## +## nsepseq(expr,COMMA) -> expr COMMA . nsepseq(expr,COMMA) [ RBRACKET ] +## nseq(__anonymous_0(expr,COMMA)) -> expr COMMA . seq(__anonymous_0(expr,COMMA)) [ RBRACKET ] +## +## The known suffix of the stack is as follows: +## expr COMMA +## + + + +interactive_expr: LBRACKET True COMMA True VBAR +## +## Ends in an error in state: 500. +## +## nsepseq(expr,COMMA) -> expr . [ RBRACKET ] +## nsepseq(expr,COMMA) -> expr . COMMA nsepseq(expr,COMMA) [ RBRACKET ] +## nseq(__anonymous_0(expr,COMMA)) -> expr . COMMA seq(__anonymous_0(expr,COMMA)) [ RBRACKET ] +## +## The known suffix of the stack is as follows: +## expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 244, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 301, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 302, spurious reduction of production expr -> base_cond__open(expr) +## + + + +interactive_expr: LBRACKET True COMMA WILD +## +## Ends in an error in state: 492. +## +## list_or_spread -> LBRACKET expr COMMA . sep_or_term_list(expr,COMMA) RBRACKET [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## list_or_spread -> LBRACKET expr COMMA . ELLIPSIS expr RBRACKET [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## LBRACKET expr COMMA +## + + + +interactive_expr: LBRACKET True VBAR +## +## Ends in an error in state: 491. +## +## list_or_spread -> LBRACKET expr . COMMA sep_or_term_list(expr,COMMA) RBRACKET [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## list_or_spread -> LBRACKET expr . COMMA ELLIPSIS expr RBRACKET [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## option(expr) -> expr . [ RBRACKET ] +## +## The known suffix of the stack is as follows: +## LBRACKET expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 244, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 301, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 302, spurious reduction of production expr -> base_cond__open(expr) +## + + + +interactive_expr: LBRACKET WILD +## +## Ends in an error in state: 87. +## +## list_or_spread -> LBRACKET . expr COMMA sep_or_term_list(expr,COMMA) RBRACKET [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## list_or_spread -> LBRACKET . expr COMMA ELLIPSIS expr RBRACKET [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## list_or_spread -> LBRACKET . option(expr) RBRACKET [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## LBRACKET +## + + + +interactive_expr: LPAR True COMMA Bytes RPAR COLON Ident TIMES +## +## Ends in an error in state: 244. +## +## base_expr(expr) -> disj_expr_level . [ VBAR SEMI RPAR RBRACKET RBRACE EOF COMMA ] +## bin_op(disj_expr_level,BOOL_OR,conj_expr_level) -> disj_expr_level . BOOL_OR conj_expr_level [ VBAR SEMI RPAR RBRACKET RBRACE Or EOF COMMA BOOL_OR ARROW ] +## bin_op(disj_expr_level,Or,conj_expr_level) -> disj_expr_level . Or conj_expr_level [ VBAR SEMI RPAR RBRACKET RBRACE Or EOF COMMA BOOL_OR ARROW ] +## fun_expr -> disj_expr_level . es6_func [ VBAR SEMI RPAR RBRACKET RBRACE EOF COMMA ] +## +## The known suffix of the stack is as follows: +## disj_expr_level +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 211, spurious reduction of production option(type_expr_simple_args) -> +## In state 220, spurious reduction of production type_expr_simple -> Ident option(type_expr_simple_args) +## In state 227, spurious reduction of production type_annotation_simple -> COLON type_expr_simple +## In state 228, spurious reduction of production option(type_annotation_simple) -> type_annotation_simple +## In state 229, spurious reduction of production disj_expr_level -> par(tuple(disj_expr_level)) option(type_annotation_simple) +## + + + +interactive_expr: LPAR True COMMA Bytes RPAR WILD +## +## Ends in an error in state: 208. +## +## disj_expr_level -> par(tuple(disj_expr_level)) . option(type_annotation_simple) [ VBAR SEMI RPAR RBRACKET RBRACE Or EOF COMMA BOOL_OR ARROW ] +## +## The known suffix of the stack is as follows: +## par(tuple(disj_expr_level)) +## + + + +interactive_expr: LPAR True COMMA True COMMA WILD +## +## Ends in an error in state: 464. +## +## nsepseq(disj_expr_level,COMMA) -> disj_expr_level COMMA . nsepseq(disj_expr_level,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## disj_expr_level COMMA +## + + + +interactive_expr: LPAR True COMMA True VBAR +## +## Ends in an error in state: 463. +## +## bin_op(disj_expr_level,BOOL_OR,conj_expr_level) -> disj_expr_level . BOOL_OR conj_expr_level [ RPAR Or COMMA BOOL_OR ] +## bin_op(disj_expr_level,Or,conj_expr_level) -> disj_expr_level . Or conj_expr_level [ RPAR Or COMMA BOOL_OR ] +## nsepseq(disj_expr_level,COMMA) -> disj_expr_level . [ RPAR ] +## nsepseq(disj_expr_level,COMMA) -> disj_expr_level . COMMA nsepseq(disj_expr_level,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## disj_expr_level +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## + + + +interactive_expr: LPAR True COMMA WILD +## +## Ends in an error in state: 461. +## +## tuple(disj_expr_level) -> disj_expr_level COMMA . nsepseq(disj_expr_level,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## disj_expr_level COMMA +## + + + +interactive_expr: LPAR True VBAR +## +## Ends in an error in state: 460. +## +## base_expr(expr) -> disj_expr_level . [ RPAR ] +## bin_op(disj_expr_level,BOOL_OR,conj_expr_level) -> disj_expr_level . BOOL_OR conj_expr_level [ RPAR Or COMMA BOOL_OR ARROW ] +## bin_op(disj_expr_level,Or,conj_expr_level) -> disj_expr_level . Or conj_expr_level [ RPAR Or COMMA BOOL_OR ARROW ] +## fun_expr -> disj_expr_level . es6_func [ RPAR ] +## tuple(disj_expr_level) -> disj_expr_level . COMMA nsepseq(disj_expr_level,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## disj_expr_level +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## + + + +interactive_expr: LPAR WILD +## +## Ends in an error in state: 90. +## +## par(expr) -> LPAR . expr RPAR [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## par(tuple(disj_expr_level)) -> LPAR . tuple(disj_expr_level) RPAR [ VBAR SEMI RPAR RBRACKET RBRACE Or EOF COMMA COLON BOOL_OR ARROW ] +## unit -> LPAR . RPAR [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## LPAR +## + + + +interactive_expr: Let VBAR +## +## Ends in an error in state: 125. +## +## let_expr(expr) -> seq(Attr) Let . let_binding SEMI expr [ VBAR SEMI RPAR RBRACKET RBRACE EOF COMMA ] +## +## The known suffix of the stack is as follows: +## seq(Attr) Let +## + + + +interactive_expr: Let WILD EQ Bytes SEMI WILD +## +## Ends in an error in state: 324. +## +## let_expr(expr) -> seq(Attr) Let let_binding SEMI . expr [ VBAR SEMI RPAR RBRACKET RBRACE EOF COMMA ] +## +## The known suffix of the stack is as follows: +## seq(Attr) Let let_binding SEMI +## + + + +interactive_expr: Let WILD EQ Bytes VBAR +## +## Ends in an error in state: 323. +## +## let_expr(expr) -> seq(Attr) Let let_binding . SEMI expr [ VBAR SEMI RPAR RBRACKET RBRACE EOF COMMA ] +## +## The known suffix of the stack is as follows: +## seq(Attr) Let let_binding +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 244, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 301, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 302, spurious reduction of production expr -> base_cond__open(expr) +## In state 546, spurious reduction of production let_binding -> WILD option(type_annotation) EQ expr +## + + + +interactive_expr: MINUS WILD +## +## Ends in an error in state: 88. +## +## unary_expr_level -> MINUS . call_expr_level [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## MINUS +## + + + +interactive_expr: NOT WILD +## +## Ends in an error in state: 86. +## +## unary_expr_level -> NOT . call_expr_level [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## NOT +## + + + +interactive_expr: Switch Constr WILD +## +## Ends in an error in state: 108. +## +## module_field -> Constr . DOT Ident [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE LBRACE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## projection -> Constr . DOT Ident selection [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE LBRACE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## Constr +## + + + +interactive_expr: Switch LBRACE WILD +## +## Ends in an error in state: 347. +## +## update_record -> LBRACE . ELLIPSIS path COMMA sep_or_term_list(field_path_assignment,COMMA) RBRACE [ LBRACE ] +## +## The known suffix of the stack is as follows: +## LBRACE +## + + + +interactive_expr: Switch LBRACKET True RBRACE +## +## Ends in an error in state: 336. +## +## list__(expr) -> LBRACKET option(sep_or_term_list(expr,SEMI)) . RBRACKET [ LBRACE ] +## +## The known suffix of the stack is as follows: +## LBRACKET option(sep_or_term_list(expr,SEMI)) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 244, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 301, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 302, spurious reduction of production expr -> base_cond__open(expr) +## In state 340, spurious reduction of production nsepseq(expr,SEMI) -> expr +## In state 339, spurious reduction of production sep_or_term_list(expr,SEMI) -> nsepseq(expr,SEMI) +## In state 335, spurious reduction of production option(sep_or_term_list(expr,SEMI)) -> sep_or_term_list(expr,SEMI) +## + + + +interactive_expr: Switch LBRACKET True SEMI True SEMI WILD +## +## Ends in an error in state: 345. +## +## nsepseq(expr,SEMI) -> expr SEMI . nsepseq(expr,SEMI) [ RBRACKET RBRACE ] +## seq(__anonymous_0(expr,SEMI)) -> expr SEMI . seq(__anonymous_0(expr,SEMI)) [ RBRACKET RBRACE ] +## +## The known suffix of the stack is as follows: +## expr SEMI +## + + + +interactive_expr: Switch LBRACKET True SEMI True VBAR +## +## Ends in an error in state: 344. +## +## nsepseq(expr,SEMI) -> expr . [ RBRACKET RBRACE ] +## nsepseq(expr,SEMI) -> expr . SEMI nsepseq(expr,SEMI) [ RBRACKET RBRACE ] +## seq(__anonymous_0(expr,SEMI)) -> expr . SEMI seq(__anonymous_0(expr,SEMI)) [ RBRACKET RBRACE ] +## +## The known suffix of the stack is as follows: +## expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 244, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 301, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 302, spurious reduction of production expr -> base_cond__open(expr) +## + + + +interactive_expr: Switch LBRACKET True SEMI WILD +## +## Ends in an error in state: 341. +## +## nsepseq(expr,SEMI) -> expr SEMI . nsepseq(expr,SEMI) [ RBRACKET RBRACE ] +## nseq(__anonymous_0(expr,SEMI)) -> expr SEMI . seq(__anonymous_0(expr,SEMI)) [ RBRACKET RBRACE ] +## +## The known suffix of the stack is as follows: +## expr SEMI +## + + + +interactive_expr: Switch LBRACKET True VBAR +## +## Ends in an error in state: 340. +## +## nsepseq(expr,SEMI) -> expr . [ RBRACKET RBRACE ] +## nsepseq(expr,SEMI) -> expr . SEMI nsepseq(expr,SEMI) [ RBRACKET RBRACE ] +## nseq(__anonymous_0(expr,SEMI)) -> expr . SEMI seq(__anonymous_0(expr,SEMI)) [ RBRACKET RBRACE ] +## +## The known suffix of the stack is as follows: +## expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 244, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 301, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 302, spurious reduction of production expr -> base_cond__open(expr) +## + + + +interactive_expr: Switch LBRACKET WILD +## +## Ends in an error in state: 334. +## +## list__(expr) -> LBRACKET . option(sep_or_term_list(expr,SEMI)) RBRACKET [ LBRACE ] +## +## The known suffix of the stack is as follows: +## LBRACKET +## + + + +interactive_expr: Switch LPAR True VBAR +## +## Ends in an error in state: 458. +## +## par(expr) -> LPAR expr . RPAR [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE LBRACE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## LPAR expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 244, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 301, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 302, spurious reduction of production expr -> base_cond__open(expr) +## + + + +interactive_expr: Switch LPAR WILD +## +## Ends in an error in state: 84. +## +## par(expr) -> LPAR . expr RPAR [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE LBRACE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## unit -> LPAR . RPAR [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LPAR LE LBRACE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## LPAR +## + + + +interactive_expr: Switch True LBRACE VBAR LBRACKET VBAR +## +## Ends in an error in state: 377. +## +## list__(sub_pattern) -> LBRACKET . option(sep_or_term_list(sub_pattern,SEMI)) RBRACKET [ COMMA ARROW ] +## pattern -> LBRACKET . sub_pattern COMMA ELLIPSIS sub_pattern RBRACKET [ ARROW ] +## +## The known suffix of the stack is as follows: +## LBRACKET +## + + + +interactive_expr: Switch True LBRACE VBAR LBRACKET WILD COMMA ELLIPSIS VBAR +## +## Ends in an error in state: 380. +## +## pattern -> LBRACKET sub_pattern COMMA ELLIPSIS . sub_pattern RBRACKET [ ARROW ] +## +## The known suffix of the stack is as follows: +## LBRACKET sub_pattern COMMA ELLIPSIS +## + + + +interactive_expr: Switch True LBRACE VBAR LBRACKET WILD COMMA ELLIPSIS WILD WILD +## +## Ends in an error in state: 381. +## +## pattern -> LBRACKET sub_pattern COMMA ELLIPSIS sub_pattern . RBRACKET [ ARROW ] +## +## The known suffix of the stack is as follows: +## LBRACKET sub_pattern COMMA ELLIPSIS sub_pattern +## + + + +interactive_expr: Switch True LBRACE VBAR LBRACKET WILD COMMA WILD +## +## Ends in an error in state: 379. +## +## pattern -> LBRACKET sub_pattern COMMA . ELLIPSIS sub_pattern RBRACKET [ ARROW ] +## +## The known suffix of the stack is as follows: +## LBRACKET sub_pattern COMMA +## + + + +interactive_expr: Switch True LBRACE VBAR LBRACKET WILD WILD +## +## Ends in an error in state: 378. +## +## nsepseq(sub_pattern,SEMI) -> sub_pattern . [ RBRACKET ] +## nsepseq(sub_pattern,SEMI) -> sub_pattern . SEMI nsepseq(sub_pattern,SEMI) [ RBRACKET ] +## nseq(__anonymous_0(sub_pattern,SEMI)) -> sub_pattern . SEMI seq(__anonymous_0(sub_pattern,SEMI)) [ RBRACKET ] +## pattern -> LBRACKET sub_pattern . COMMA ELLIPSIS sub_pattern RBRACKET [ ARROW ] +## +## The known suffix of the stack is as follows: +## LBRACKET sub_pattern +## + + + +interactive_expr: Switch True LBRACE VBAR LPAR Bytes RPAR WILD +## +## Ends in an error in state: 384. +## +## tuple(sub_pattern) -> sub_pattern . COMMA nsepseq(sub_pattern,COMMA) [ ARROW ] +## +## The known suffix of the stack is as follows: +## sub_pattern +## + + + +interactive_expr: Switch True LBRACE VBAR VBAR +## +## Ends in an error in state: 509. +## +## case_clause(base_cond) -> VBAR . pattern ARROW base_cond option(SEMI) [ VBAR RBRACE ] +## +## The known suffix of the stack is as follows: +## VBAR +## + + + +interactive_expr: Switch True LBRACE VBAR WILD ARROW Bytes SEMI WILD +## +## Ends in an error in state: 542. +## +## nseq(case_clause(base_cond)) -> case_clause(base_cond) . seq(case_clause(base_cond)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## case_clause(base_cond) +## + + + +interactive_expr: Switch True LBRACE VBAR WILD ARROW Bytes VBAR Bytes ARROW Bytes SEMI WILD +## +## Ends in an error in state: 544. +## +## seq(case_clause(base_cond)) -> case_clause(base_cond) . seq(case_clause(base_cond)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## case_clause(base_cond) +## + + + +interactive_expr: Switch True LBRACE VBAR WILD ARROW If LPAR Bytes RPAR LBRACE True ARROW Bytes VBAR +## +## Ends in an error in state: 515. +## +## if_then(base_cond) -> If parenthesized_expr LBRACE closed_if . RBRACE [ VBAR SEMI RBRACE ] +## if_then_else(base_cond) -> If parenthesized_expr LBRACE closed_if . SEMI RBRACE Else LBRACE base_cond SEMI RBRACE [ VBAR SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE closed_if +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 244, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 301, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 302, spurious reduction of production expr -> base_cond__open(expr) +## In state 295, spurious reduction of production es6_func -> ARROW expr +## In state 303, spurious reduction of production fun_expr -> disj_expr_level es6_func +## In state 400, spurious reduction of production base_expr(closed_if) -> fun_expr +## In state 404, spurious reduction of production base_if_then_else__open(closed_if) -> base_expr(closed_if) +## In state 403, spurious reduction of production closed_if -> base_if_then_else__open(closed_if) +## + + + +interactive_expr: Switch True LBRACE VBAR WILD ARROW If LPAR Bytes RPAR LBRACE True SEMI RBRACE Else LBRACE True SEMI WILD +## +## Ends in an error in state: 534. +## +## if_then_else(base_cond) -> If parenthesized_expr LBRACE closed_if SEMI RBRACE Else LBRACE base_cond SEMI . RBRACE [ VBAR SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE closed_if SEMI RBRACE Else LBRACE base_cond SEMI +## + + + +interactive_expr: Switch True LBRACE VBAR WILD ARROW If LPAR Bytes RPAR LBRACE True SEMI RBRACE Else LBRACE True VBAR +## +## Ends in an error in state: 533. +## +## if_then_else(base_cond) -> If parenthesized_expr LBRACE closed_if SEMI RBRACE Else LBRACE base_cond . SEMI RBRACE [ VBAR SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE closed_if SEMI RBRACE Else LBRACE base_cond +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 528, spurious reduction of production base_expr(base_cond) -> disj_expr_level +## In state 530, spurious reduction of production base_cond__open(base_cond) -> base_expr(base_cond) +## In state 531, spurious reduction of production base_cond -> base_cond__open(base_cond) +## + + + +interactive_expr: Switch True LBRACE VBAR WILD ARROW If LPAR Bytes RPAR LBRACE True SEMI RBRACE Else LBRACE WILD +## +## Ends in an error in state: 519. +## +## if_then_else(base_cond) -> If parenthesized_expr LBRACE closed_if SEMI RBRACE Else LBRACE . base_cond SEMI RBRACE [ VBAR SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE closed_if SEMI RBRACE Else LBRACE +## + + + +interactive_expr: Switch True LBRACE VBAR WILD ARROW If LPAR Bytes RPAR LBRACE True SEMI RBRACE Else WILD +## +## Ends in an error in state: 518. +## +## if_then_else(base_cond) -> If parenthesized_expr LBRACE closed_if SEMI RBRACE Else . LBRACE base_cond SEMI RBRACE [ VBAR SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE closed_if SEMI RBRACE Else +## + + + +interactive_expr: Switch True LBRACE VBAR WILD ARROW If LPAR Bytes RPAR LBRACE True SEMI RBRACE WILD +## +## Ends in an error in state: 517. +## +## if_then_else(base_cond) -> If parenthesized_expr LBRACE closed_if SEMI RBRACE . Else LBRACE base_cond SEMI RBRACE [ VBAR SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE closed_if SEMI RBRACE +## + + + +interactive_expr: Switch True LBRACE VBAR WILD ARROW If LPAR Bytes RPAR LBRACE True SEMI WILD +## +## Ends in an error in state: 516. +## +## if_then_else(base_cond) -> If parenthesized_expr LBRACE closed_if SEMI . RBRACE Else LBRACE base_cond SEMI RBRACE [ VBAR SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE closed_if SEMI +## + + + +interactive_expr: Switch True LBRACE VBAR WILD ARROW If LPAR Bytes RPAR LBRACE WILD +## +## Ends in an error in state: 514. +## +## if_then(base_cond) -> If parenthesized_expr LBRACE . closed_if RBRACE [ VBAR SEMI RBRACE ] +## if_then_else(base_cond) -> If parenthesized_expr LBRACE . closed_if SEMI RBRACE Else LBRACE base_cond SEMI RBRACE [ VBAR SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr LBRACE +## + + + +interactive_expr: Switch True LBRACE VBAR WILD ARROW If LPAR Bytes RPAR WILD +## +## Ends in an error in state: 513. +## +## if_then(base_cond) -> If parenthesized_expr . LBRACE closed_if RBRACE [ VBAR SEMI RBRACE ] +## if_then_else(base_cond) -> If parenthesized_expr . LBRACE closed_if SEMI RBRACE Else LBRACE base_cond SEMI RBRACE [ VBAR SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If parenthesized_expr +## + + + +interactive_expr: Switch True LBRACE VBAR WILD ARROW If WILD +## +## Ends in an error in state: 512. +## +## if_then(base_cond) -> If . parenthesized_expr LBRACE closed_if RBRACE [ VBAR SEMI RBRACE ] +## if_then_else(base_cond) -> If . parenthesized_expr LBRACE closed_if SEMI RBRACE Else LBRACE base_cond SEMI RBRACE [ VBAR SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## If +## + + + +interactive_expr: Switch True LBRACE VBAR WILD ARROW Let VBAR +## +## Ends in an error in state: 521. +## +## let_expr(base_cond) -> seq(Attr) Let . let_binding SEMI base_cond [ VBAR SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## seq(Attr) Let +## + + + +interactive_expr: Switch True LBRACE VBAR WILD ARROW Let WILD EQ Bytes SEMI WILD +## +## Ends in an error in state: 523. +## +## let_expr(base_cond) -> seq(Attr) Let let_binding SEMI . base_cond [ VBAR SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## seq(Attr) Let let_binding SEMI +## + + + +interactive_expr: Switch True LBRACE VBAR WILD ARROW Let WILD EQ Bytes VBAR +## +## Ends in an error in state: 522. +## +## let_expr(base_cond) -> seq(Attr) Let let_binding . SEMI base_cond [ VBAR SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## seq(Attr) Let let_binding +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 244, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 301, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 302, spurious reduction of production expr -> base_cond__open(expr) +## In state 546, spurious reduction of production let_binding -> WILD option(type_annotation) EQ expr +## + + + +interactive_expr: Switch True LBRACE VBAR WILD ARROW True ARROW Bytes RPAR +## +## Ends in an error in state: 537. +## +## case_clause(base_cond) -> VBAR pattern ARROW base_cond . option(SEMI) [ VBAR RBRACE ] +## +## The known suffix of the stack is as follows: +## VBAR pattern ARROW base_cond +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 244, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 301, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 302, spurious reduction of production expr -> base_cond__open(expr) +## In state 295, spurious reduction of production es6_func -> ARROW expr +## In state 303, spurious reduction of production fun_expr -> disj_expr_level es6_func +## In state 527, spurious reduction of production base_expr(base_cond) -> fun_expr +## In state 530, spurious reduction of production base_cond__open(base_cond) -> base_expr(base_cond) +## In state 531, spurious reduction of production base_cond -> base_cond__open(base_cond) +## + + + +interactive_expr: Switch True LBRACE VBAR WILD ARROW True RPAR +## +## Ends in an error in state: 528. +## +## base_expr(base_cond) -> disj_expr_level . [ VBAR SEMI RBRACE ] +## bin_op(disj_expr_level,BOOL_OR,conj_expr_level) -> disj_expr_level . BOOL_OR conj_expr_level [ VBAR SEMI RBRACE Or BOOL_OR ARROW ] +## bin_op(disj_expr_level,Or,conj_expr_level) -> disj_expr_level . Or conj_expr_level [ VBAR SEMI RBRACE Or BOOL_OR ARROW ] +## fun_expr -> disj_expr_level . es6_func [ VBAR SEMI RBRACE ] +## +## The known suffix of the stack is as follows: +## disj_expr_level +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## + + + +interactive_expr: Switch True LBRACE VBAR WILD ARROW WILD +## +## Ends in an error in state: 511. +## +## case_clause(base_cond) -> VBAR pattern ARROW . base_cond option(SEMI) [ VBAR RBRACE ] +## +## The known suffix of the stack is as follows: +## VBAR pattern ARROW +## + + + +interactive_expr: Switch True LBRACE VBAR WILD COMMA Bytes RPAR +## +## Ends in an error in state: 510. +## +## case_clause(base_cond) -> VBAR pattern . ARROW base_cond option(SEMI) [ VBAR RBRACE ] +## +## The known suffix of the stack is as follows: +## VBAR pattern +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 169, spurious reduction of production nsepseq(sub_pattern,COMMA) -> sub_pattern +## In state 172, spurious reduction of production tuple(sub_pattern) -> sub_pattern COMMA nsepseq(sub_pattern,COMMA) +## In state 383, spurious reduction of production pattern -> tuple(sub_pattern) +## + + + +interactive_expr: Switch True LBRACE VBAR WILD COMMA VBAR +## +## Ends in an error in state: 168. +## +## tuple(sub_pattern) -> sub_pattern COMMA . nsepseq(sub_pattern,COMMA) [ RPAR ARROW ] +## +## The known suffix of the stack is as follows: +## sub_pattern COMMA +## + + + +interactive_expr: Switch True LBRACE VBAR WILD COMMA WILD COMMA VBAR +## +## Ends in an error in state: 170. +## +## nsepseq(sub_pattern,COMMA) -> sub_pattern COMMA . nsepseq(sub_pattern,COMMA) [ RPAR ARROW ] +## +## The known suffix of the stack is as follows: +## sub_pattern COMMA +## + + + +interactive_expr: Switch True LBRACE VBAR WILD COMMA WILD WILD +## +## Ends in an error in state: 169. +## +## nsepseq(sub_pattern,COMMA) -> sub_pattern . [ RPAR ARROW ] +## nsepseq(sub_pattern,COMMA) -> sub_pattern . COMMA nsepseq(sub_pattern,COMMA) [ RPAR ARROW ] +## +## The known suffix of the stack is as follows: +## sub_pattern +## + + + +interactive_expr: Switch True LBRACE VBAR WILD WILD +## +## Ends in an error in state: 435. +## +## pattern -> core_pattern . [ ARROW ] +## sub_pattern -> core_pattern . [ COMMA ] +## +## The known suffix of the stack is as follows: +## core_pattern +## + + + +interactive_expr: Switch True LBRACE WILD +## +## Ends in an error in state: 508. +## +## switch_expr(base_cond) -> Switch switch_expr_ LBRACE . cases(base_cond) RBRACE [ VBAR SEMI RPAR RBRACKET RBRACE EOF COMMA ] +## +## The known suffix of the stack is as follows: +## Switch switch_expr_ LBRACE +## + + + +interactive_expr: Switch True WILD +## +## Ends in an error in state: 507. +## +## switch_expr(base_cond) -> Switch switch_expr_ . LBRACE cases(base_cond) RBRACE [ VBAR SEMI RPAR RBRACKET RBRACE EOF COMMA ] +## +## The known suffix of the stack is as follows: +## Switch switch_expr_ +## + + + +interactive_expr: Switch WILD +## +## Ends in an error in state: 80. +## +## switch_expr(base_cond) -> Switch . switch_expr_ LBRACE cases(base_cond) RBRACE [ VBAR SEMI RPAR RBRACKET RBRACE EOF COMMA ] +## +## The known suffix of the stack is as follows: +## Switch +## + + + +interactive_expr: True ARROW WILD +## +## Ends in an error in state: 294. +## +## es6_func -> ARROW . expr [ VBAR SEMI RPAR RBRACKET RBRACE EOF COMMA ] +## +## The known suffix of the stack is as follows: +## ARROW +## + + + +interactive_expr: True BOOL_AND WILD +## +## Ends in an error in state: 248. +## +## bin_op(conj_expr_level,BOOL_AND,comp_expr_level) -> conj_expr_level BOOL_AND . comp_expr_level [ VBAR SEMI RPAR RBRACKET RBRACE Or EOF COMMA BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## conj_expr_level BOOL_AND +## + + + +interactive_expr: True BOOL_OR WILD +## +## Ends in an error in state: 292. +## +## bin_op(disj_expr_level,BOOL_OR,conj_expr_level) -> disj_expr_level BOOL_OR . conj_expr_level [ VBAR SEMI RPAR RBRACKET RBRACE Or EOF COMMA BOOL_OR ARROW ] +## +## The known suffix of the stack is as follows: +## disj_expr_level BOOL_OR +## + + + +interactive_expr: True CAT WILD +## +## Ends in an error in state: 271. +## +## bin_op(add_expr_level,CAT,cat_expr_level) -> add_expr_level CAT . cat_expr_level [ VBAR SEMI RPAR RBRACKET RBRACE Or NE LT LE GT GE EQEQ EOF COMMA BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## add_expr_level CAT +## + + + +interactive_expr: True COLON Ident LPAR Ident VBAR +## +## Ends in an error in state: 213. +## +## nsepseq(type_expr_simple,COMMA) -> type_expr_simple . [ RPAR ] +## nsepseq(type_expr_simple,COMMA) -> type_expr_simple . COMMA nsepseq(type_expr_simple,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## type_expr_simple +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 211, spurious reduction of production option(type_expr_simple_args) -> +## In state 220, spurious reduction of production type_expr_simple -> Ident option(type_expr_simple_args) +## + + + +interactive_expr: True COLON Ident LPAR WILD +## +## Ends in an error in state: 212. +## +## par(nsepseq(type_expr_simple,COMMA)) -> LPAR . nsepseq(type_expr_simple,COMMA) RPAR [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## LPAR +## + + + +interactive_expr: True COLON Ident WILD +## +## Ends in an error in state: 211. +## +## type_expr_simple -> Ident . option(type_expr_simple_args) [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## Ident +## + + + +interactive_expr: True COLON LPAR Ident ARROW Ident VBAR +## +## Ends in an error in state: 223. +## +## type_expr_simple -> LPAR type_expr_simple ARROW type_expr_simple . RPAR [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## LPAR type_expr_simple ARROW type_expr_simple +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 211, spurious reduction of production option(type_expr_simple_args) -> +## In state 220, spurious reduction of production type_expr_simple -> Ident option(type_expr_simple_args) +## + + + +interactive_expr: True COLON LPAR Ident ARROW WILD +## +## Ends in an error in state: 222. +## +## type_expr_simple -> LPAR type_expr_simple ARROW . type_expr_simple RPAR [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## LPAR type_expr_simple ARROW +## + + + +interactive_expr: True COLON LPAR Ident COMMA WILD +## +## Ends in an error in state: 214. +## +## nsepseq(type_expr_simple,COMMA) -> type_expr_simple COMMA . nsepseq(type_expr_simple,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## type_expr_simple COMMA +## + + + +interactive_expr: True COLON LPAR Ident RPAR WILD +## +## Ends in an error in state: 230. +## +## add_expr_level -> mult_expr_level . [ VBAR SEMI RPAR RBRACKET RBRACE PLUS Or NE MINUS LT LE GT GE EQEQ EOF COMMA CAT BOOL_OR BOOL_AND ARROW ] +## bin_op(mult_expr_level,Mod,unary_expr_level) -> mult_expr_level . Mod unary_expr_level [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA CAT BOOL_OR BOOL_AND ARROW ] +## bin_op(mult_expr_level,SLASH,unary_expr_level) -> mult_expr_level . SLASH unary_expr_level [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA CAT BOOL_OR BOOL_AND ARROW ] +## bin_op(mult_expr_level,TIMES,unary_expr_level) -> mult_expr_level . TIMES unary_expr_level [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## mult_expr_level +## + + + +interactive_expr: True COLON LPAR Ident VBAR +## +## Ends in an error in state: 221. +## +## nsepseq(type_expr_simple,COMMA) -> type_expr_simple . [ RPAR ] +## nsepseq(type_expr_simple,COMMA) -> type_expr_simple . COMMA nsepseq(type_expr_simple,COMMA) [ RPAR ] +## type_expr_simple -> LPAR type_expr_simple . ARROW type_expr_simple RPAR [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## LPAR type_expr_simple +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 211, spurious reduction of production option(type_expr_simple_args) -> +## In state 220, spurious reduction of production type_expr_simple -> Ident option(type_expr_simple_args) +## + + + +interactive_expr: True COLON LPAR WILD +## +## Ends in an error in state: 210. +## +## type_expr_simple -> LPAR . nsepseq(type_expr_simple,COMMA) RPAR [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA CAT BOOL_OR BOOL_AND ARROW ] +## type_expr_simple -> LPAR . type_expr_simple ARROW type_expr_simple RPAR [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## LPAR +## + + + +interactive_expr: True COLON WILD +## +## Ends in an error in state: 209. +## +## type_annotation_simple -> COLON . type_expr_simple [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## COLON +## + + + +interactive_expr: True EQEQ WILD +## +## Ends in an error in state: 281. +## +## bin_op(comp_expr_level,EQEQ,cat_expr_level) -> comp_expr_level EQEQ . cat_expr_level [ VBAR SEMI RPAR RBRACKET RBRACE Or NE LT LE GT GE EQEQ EOF COMMA BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## comp_expr_level EQEQ +## + + + +interactive_expr: True GE WILD +## +## Ends in an error in state: 279. +## +## bin_op(comp_expr_level,GE,cat_expr_level) -> comp_expr_level GE . cat_expr_level [ VBAR SEMI RPAR RBRACKET RBRACE Or NE LT LE GT GE EQEQ EOF COMMA BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## comp_expr_level GE +## + + + +interactive_expr: True GT WILD +## +## Ends in an error in state: 277. +## +## bin_op(comp_expr_level,GT,cat_expr_level) -> comp_expr_level GT . cat_expr_level [ VBAR SEMI RPAR RBRACKET RBRACE Or NE LT LE GT GE EQEQ EOF COMMA BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## comp_expr_level GT +## + + + +interactive_expr: True LE WILD +## +## Ends in an error in state: 275. +## +## bin_op(comp_expr_level,LE,cat_expr_level) -> comp_expr_level LE . cat_expr_level [ VBAR SEMI RPAR RBRACKET RBRACE Or NE LT LE GT GE EQEQ EOF COMMA BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## comp_expr_level LE +## + + + +interactive_expr: True LPAR True COMMA WILD +## +## Ends in an error in state: 242. +## +## nsepseq(expr,COMMA) -> expr COMMA . nsepseq(expr,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## expr COMMA +## + + + +interactive_expr: True LPAR True VBAR +## +## Ends in an error in state: 241. +## +## nsepseq(expr,COMMA) -> expr . [ RPAR ] +## nsepseq(expr,COMMA) -> expr . COMMA nsepseq(expr,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 244, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 301, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 302, spurious reduction of production expr -> base_cond__open(expr) +## + + + +interactive_expr: True LPAR WILD +## +## Ends in an error in state: 234. +## +## call_expr -> core_expr LPAR . nsepseq(expr,COMMA) RPAR [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## unit -> LPAR . RPAR [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## core_expr LPAR +## + + + +interactive_expr: True LT WILD +## +## Ends in an error in state: 273. +## +## bin_op(comp_expr_level,LT,cat_expr_level) -> comp_expr_level LT . cat_expr_level [ VBAR SEMI RPAR RBRACKET RBRACE Or NE LT LE GT GE EQEQ EOF COMMA BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## comp_expr_level LT +## + + + +interactive_expr: True MINUS True COLON LPAR Ident RPAR WILD +## +## Ends in an error in state: 270. +## +## bin_op(add_expr_level,MINUS,mult_expr_level) -> add_expr_level MINUS mult_expr_level . [ VBAR SEMI RPAR RBRACKET RBRACE PLUS Or NE MINUS LT LE GT GE EQEQ EOF COMMA CAT BOOL_OR BOOL_AND ARROW ] +## bin_op(mult_expr_level,Mod,unary_expr_level) -> mult_expr_level . Mod unary_expr_level [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA CAT BOOL_OR BOOL_AND ARROW ] +## bin_op(mult_expr_level,SLASH,unary_expr_level) -> mult_expr_level . SLASH unary_expr_level [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA CAT BOOL_OR BOOL_AND ARROW ] +## bin_op(mult_expr_level,TIMES,unary_expr_level) -> mult_expr_level . TIMES unary_expr_level [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## add_expr_level MINUS mult_expr_level +## + + + +interactive_expr: True MINUS WILD +## +## Ends in an error in state: 269. +## +## bin_op(add_expr_level,MINUS,mult_expr_level) -> add_expr_level MINUS . mult_expr_level [ VBAR SEMI RPAR RBRACKET RBRACE PLUS Or NE MINUS LT LE GT GE EQEQ EOF COMMA CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## add_expr_level MINUS +## + + + +interactive_expr: True Mod WILD +## +## Ends in an error in state: 267. +## +## bin_op(mult_expr_level,Mod,unary_expr_level) -> mult_expr_level Mod . unary_expr_level [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## mult_expr_level Mod +## + + + +interactive_expr: True NE WILD +## +## Ends in an error in state: 250. +## +## bin_op(comp_expr_level,NE,cat_expr_level) -> comp_expr_level NE . cat_expr_level [ VBAR SEMI RPAR RBRACKET RBRACE Or NE LT LE GT GE EQEQ EOF COMMA BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## comp_expr_level NE +## + + + +interactive_expr: True Or WILD +## +## Ends in an error in state: 245. +## +## bin_op(disj_expr_level,Or,conj_expr_level) -> disj_expr_level Or . conj_expr_level [ VBAR SEMI RPAR RBRACKET RBRACE Or EOF COMMA BOOL_OR ARROW ] +## +## The known suffix of the stack is as follows: +## disj_expr_level Or +## + + + +interactive_expr: True PLUS True COLON LPAR Ident RPAR WILD +## +## Ends in an error in state: 264. +## +## bin_op(add_expr_level,PLUS,mult_expr_level) -> add_expr_level PLUS mult_expr_level . [ VBAR SEMI RPAR RBRACKET RBRACE PLUS Or NE MINUS LT LE GT GE EQEQ EOF COMMA CAT BOOL_OR BOOL_AND ARROW ] +## bin_op(mult_expr_level,Mod,unary_expr_level) -> mult_expr_level . Mod unary_expr_level [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA CAT BOOL_OR BOOL_AND ARROW ] +## bin_op(mult_expr_level,SLASH,unary_expr_level) -> mult_expr_level . SLASH unary_expr_level [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA CAT BOOL_OR BOOL_AND ARROW ] +## bin_op(mult_expr_level,TIMES,unary_expr_level) -> mult_expr_level . TIMES unary_expr_level [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## add_expr_level PLUS mult_expr_level +## + + + +interactive_expr: True PLUS WILD +## +## Ends in an error in state: 263. +## +## bin_op(add_expr_level,PLUS,mult_expr_level) -> add_expr_level PLUS . mult_expr_level [ VBAR SEMI RPAR RBRACKET RBRACE PLUS Or NE MINUS LT LE GT GE EQEQ EOF COMMA CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## add_expr_level PLUS +## + + + +interactive_expr: True SLASH WILD +## +## Ends in an error in state: 265. +## +## bin_op(mult_expr_level,SLASH,unary_expr_level) -> mult_expr_level SLASH . unary_expr_level [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## mult_expr_level SLASH +## + + + +interactive_expr: True TIMES WILD +## +## Ends in an error in state: 231. +## +## bin_op(mult_expr_level,TIMES,unary_expr_level) -> mult_expr_level TIMES . unary_expr_level [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## mult_expr_level TIMES +## + + + +interactive_expr: True VBAR +## +## Ends in an error in state: 557. +## +## interactive_expr -> expr . EOF [ # ] +## +## The known suffix of the stack is as follows: +## expr +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 244, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 301, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 302, spurious reduction of production expr -> base_cond__open(expr) +## + + + +interactive_expr: True WILD +## +## Ends in an error in state: 233. +## +## call_expr -> core_expr . LPAR nsepseq(expr,COMMA) RPAR [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## call_expr -> core_expr . unit [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## call_expr_level_in -> core_expr . [ VBAR TIMES SLASH SEMI RPAR RBRACKET RBRACE PLUS Or NE Mod MINUS LT LE GT GE EQEQ EOF COMMA COLON CAT BOOL_OR BOOL_AND ARROW ] +## +## The known suffix of the stack is as follows: +## core_expr +## + + + +interactive_expr: WILD +## +## Ends in an error in state: 555. +## +## interactive_expr' -> . interactive_expr [ # ] +## +## The known suffix of the stack is as follows: +## +## + + + +contract: Attr WILD +## +## Ends in an error in state: 67. +## +## seq(Attr) -> Attr . seq(Attr) [ Let ] +## +## The known suffix of the stack is as follows: +## Attr +## + + + +contract: Let Ident COLON Ident SEMI +## +## Ends in an error in state: 206. +## +## let_binding -> Ident option(type_annotation) . EQ expr [ SEMI ] +## +## The known suffix of the stack is as follows: +## Ident option(type_annotation) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 8, spurious reduction of production core_type -> Ident +## In state 15, spurious reduction of production cartesian -> core_type +## In state 66, spurious reduction of production type_expr -> cartesian +## In state 75, spurious reduction of production type_annotation -> COLON type_expr +## In state 76, spurious reduction of production option(type_annotation) -> type_annotation +## + + + +contract: Let Ident EQ WILD +## +## Ends in an error in state: 207. +## +## let_binding -> Ident option(type_annotation) EQ . expr [ SEMI ] +## +## The known suffix of the stack is as follows: +## Ident option(type_annotation) EQ +## + + + +contract: Let Ident WILD +## +## Ends in an error in state: 205. +## +## let_binding -> Ident . option(type_annotation) EQ expr [ SEMI ] +## sub_irrefutable -> Ident . [ COMMA ] +## +## The known suffix of the stack is as follows: +## Ident +## + + + +contract: Let LBRACE Ident EQ Bytes COMMA Ident EQ Bytes COMMA WILD +## +## Ends in an error in state: 185. +## +## nsepseq(field_pattern,COMMA) -> field_pattern COMMA . nsepseq(field_pattern,COMMA) [ RBRACE ] +## seq(__anonymous_0(field_pattern,COMMA)) -> field_pattern COMMA . seq(__anonymous_0(field_pattern,COMMA)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_pattern COMMA +## + + + +contract: Let LBRACE Ident EQ Bytes COMMA Ident EQ Bytes WILD +## +## Ends in an error in state: 184. +## +## nsepseq(field_pattern,COMMA) -> field_pattern . [ RBRACE ] +## nsepseq(field_pattern,COMMA) -> field_pattern . COMMA nsepseq(field_pattern,COMMA) [ RBRACE ] +## seq(__anonymous_0(field_pattern,COMMA)) -> field_pattern . COMMA seq(__anonymous_0(field_pattern,COMMA)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_pattern +## + + + +contract: Let LBRACE Ident EQ Bytes COMMA WILD +## +## Ends in an error in state: 181. +## +## nsepseq(field_pattern,COMMA) -> field_pattern COMMA . nsepseq(field_pattern,COMMA) [ RBRACE ] +## nseq(__anonymous_0(field_pattern,COMMA)) -> field_pattern COMMA . seq(__anonymous_0(field_pattern,COMMA)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_pattern COMMA +## + + + +contract: Let LBRACE Ident EQ Bytes RBRACE COLON Ident SEMI +## +## Ends in an error in state: 316. +## +## let_binding -> record_pattern option(type_annotation) . EQ expr [ SEMI ] +## +## The known suffix of the stack is as follows: +## record_pattern option(type_annotation) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 8, spurious reduction of production core_type -> Ident +## In state 15, spurious reduction of production cartesian -> core_type +## In state 66, spurious reduction of production type_expr -> cartesian +## In state 75, spurious reduction of production type_annotation -> COLON type_expr +## In state 76, spurious reduction of production option(type_annotation) -> type_annotation +## + + + +contract: Let LBRACE Ident EQ Bytes RBRACE EQ WILD +## +## Ends in an error in state: 317. +## +## let_binding -> record_pattern option(type_annotation) EQ . expr [ SEMI ] +## +## The known suffix of the stack is as follows: +## record_pattern option(type_annotation) EQ +## + + + +contract: Let LBRACE Ident EQ Bytes RBRACE WILD +## +## Ends in an error in state: 315. +## +## let_binding -> record_pattern . option(type_annotation) EQ expr [ SEMI ] +## sub_irrefutable -> record_pattern . [ COMMA ] +## +## The known suffix of the stack is as follows: +## record_pattern +## + + + +contract: Let LBRACE Ident EQ Bytes WILD +## +## Ends in an error in state: 180. +## +## nsepseq(field_pattern,COMMA) -> field_pattern . [ RBRACE ] +## nsepseq(field_pattern,COMMA) -> field_pattern . COMMA nsepseq(field_pattern,COMMA) [ RBRACE ] +## nseq(__anonymous_0(field_pattern,COMMA)) -> field_pattern . COMMA seq(__anonymous_0(field_pattern,COMMA)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_pattern +## + + + +contract: Let LBRACE Ident EQ VBAR +## +## Ends in an error in state: 130. +## +## field_pattern -> Ident EQ . sub_pattern [ RBRACE COMMA ] +## +## The known suffix of the stack is as follows: +## Ident EQ +## + + + +contract: Let LBRACE Ident WILD +## +## Ends in an error in state: 129. +## +## field_pattern -> Ident . EQ sub_pattern [ RBRACE COMMA ] +## +## The known suffix of the stack is as follows: +## Ident +## + + + +contract: Let LBRACE WILD +## +## Ends in an error in state: 128. +## +## record_pattern -> LBRACE . sep_or_term_list(field_pattern,COMMA) RBRACE [ SEMI RPAR RBRACKET RBRACE EQ COMMA COLON ARROW ] +## +## The known suffix of the stack is as follows: +## LBRACE +## + + + +contract: Let LPAR C_Some VBAR +## +## Ends in an error in state: 141. +## +## constr_pattern -> C_Some . sub_pattern [ SEMI RPAR RBRACKET RBRACE COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## C_Some +## + + + +contract: Let LPAR Constr LBRACKET VBAR +## +## Ends in an error in state: 136. +## +## list__(sub_pattern) -> LBRACKET . option(sep_or_term_list(sub_pattern,SEMI)) RBRACKET [ SEMI RPAR RBRACKET RBRACE COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## LBRACKET +## + + + +contract: Let LPAR Constr LBRACKET WILD SEMI VBAR +## +## Ends in an error in state: 154. +## +## nsepseq(sub_pattern,SEMI) -> sub_pattern SEMI . nsepseq(sub_pattern,SEMI) [ RBRACKET ] +## nseq(__anonymous_0(sub_pattern,SEMI)) -> sub_pattern SEMI . seq(__anonymous_0(sub_pattern,SEMI)) [ RBRACKET ] +## +## The known suffix of the stack is as follows: +## sub_pattern SEMI +## + + + +contract: Let LPAR Constr LBRACKET WILD SEMI WILD SEMI VBAR +## +## Ends in an error in state: 156. +## +## nsepseq(sub_pattern,SEMI) -> sub_pattern SEMI . nsepseq(sub_pattern,SEMI) [ RBRACKET ] +## seq(__anonymous_0(sub_pattern,SEMI)) -> sub_pattern SEMI . seq(__anonymous_0(sub_pattern,SEMI)) [ RBRACKET ] +## +## The known suffix of the stack is as follows: +## sub_pattern SEMI +## + + + +contract: Let LPAR Constr LBRACKET WILD SEMI WILD WILD +## +## Ends in an error in state: 155. +## +## nsepseq(sub_pattern,SEMI) -> sub_pattern . [ RBRACKET ] +## nsepseq(sub_pattern,SEMI) -> sub_pattern . SEMI nsepseq(sub_pattern,SEMI) [ RBRACKET ] +## seq(__anonymous_0(sub_pattern,SEMI)) -> sub_pattern . SEMI seq(__anonymous_0(sub_pattern,SEMI)) [ RBRACKET ] +## +## The known suffix of the stack is as follows: +## sub_pattern +## + + + +contract: Let LPAR Constr LBRACKET WILD WILD +## +## Ends in an error in state: 153. +## +## nsepseq(sub_pattern,SEMI) -> sub_pattern . [ RBRACKET ] +## nsepseq(sub_pattern,SEMI) -> sub_pattern . SEMI nsepseq(sub_pattern,SEMI) [ RBRACKET ] +## nseq(__anonymous_0(sub_pattern,SEMI)) -> sub_pattern . SEMI seq(__anonymous_0(sub_pattern,SEMI)) [ RBRACKET ] +## +## The known suffix of the stack is as follows: +## sub_pattern +## + + + +contract: Let LPAR Constr LPAR VBAR +## +## Ends in an error in state: 135. +## +## par(ptuple) -> LPAR . ptuple RPAR [ SEMI RPAR RBRACKET RBRACE COMMA ARROW ] +## par(sub_pattern) -> LPAR . sub_pattern RPAR [ SEMI RPAR RBRACKET RBRACE COMMA ARROW ] +## unit -> LPAR . RPAR [ SEMI RPAR RBRACKET RBRACE COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## LPAR +## + + + +contract: Let LPAR Constr LPAR WILD COMMA Bytes ARROW +## +## Ends in an error in state: 173. +## +## par(ptuple) -> LPAR ptuple . RPAR [ SEMI RPAR RBRACKET RBRACE COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## LPAR ptuple +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 169, spurious reduction of production nsepseq(sub_pattern,COMMA) -> sub_pattern +## In state 172, spurious reduction of production tuple(sub_pattern) -> sub_pattern COMMA nsepseq(sub_pattern,COMMA) +## In state 165, spurious reduction of production ptuple -> tuple(sub_pattern) +## + + + +contract: Let LPAR Constr LPAR WILD WILD +## +## Ends in an error in state: 166. +## +## par(sub_pattern) -> LPAR sub_pattern . RPAR [ SEMI RPAR RBRACKET RBRACE COMMA ARROW ] +## tuple(sub_pattern) -> sub_pattern . COMMA nsepseq(sub_pattern,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## LPAR sub_pattern +## + + + +contract: Let LPAR Constr SEMI +## +## Ends in an error in state: 203. +## +## par(closed_irrefutable) -> LPAR closed_irrefutable . RPAR [ RPAR EQ COMMA COLON ] +## +## The known suffix of the stack is as follows: +## LPAR closed_irrefutable +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 140, spurious reduction of production constr_pattern -> Constr +## In state 202, spurious reduction of production closed_irrefutable -> constr_pattern +## + + + +contract: Let LPAR Constr VBAR +## +## Ends in an error in state: 140. +## +## constr_pattern -> Constr . sub_pattern [ SEMI RPAR RBRACKET RBRACE COMMA ARROW ] +## constr_pattern -> Constr . [ SEMI RPAR RBRACKET RBRACE COMMA ARROW ] +## +## The known suffix of the stack is as follows: +## Constr +## + + + +contract: Let LPAR RPAR COLON Ident SEMI +## +## Ends in an error in state: 307. +## +## let_binding -> unit option(type_annotation) . EQ expr [ SEMI ] +## +## The known suffix of the stack is as follows: +## unit option(type_annotation) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 8, spurious reduction of production core_type -> Ident +## In state 15, spurious reduction of production cartesian -> core_type +## In state 66, spurious reduction of production type_expr -> cartesian +## In state 75, spurious reduction of production type_annotation -> COLON type_expr +## In state 76, spurious reduction of production option(type_annotation) -> type_annotation +## + + + +contract: Let LPAR RPAR EQ WILD +## +## Ends in an error in state: 308. +## +## let_binding -> unit option(type_annotation) EQ . expr [ SEMI ] +## +## The known suffix of the stack is as follows: +## unit option(type_annotation) EQ +## + + + +contract: Let LPAR RPAR WILD +## +## Ends in an error in state: 306. +## +## let_binding -> unit . option(type_annotation) EQ expr [ SEMI ] +## sub_irrefutable -> unit . [ COMMA ] +## +## The known suffix of the stack is as follows: +## unit +## + + + +contract: Let LPAR VBAR +## +## Ends in an error in state: 126. +## +## par(closed_irrefutable) -> LPAR . closed_irrefutable RPAR [ RPAR EQ COMMA COLON ] +## unit -> LPAR . RPAR [ RPAR EQ COMMA COLON ] +## +## The known suffix of the stack is as follows: +## LPAR +## + + + +contract: Let LPAR WILD COLON WILD +## +## Ends in an error in state: 200. +## +## typed_pattern -> irrefutable COLON . type_expr [ RPAR ] +## +## The known suffix of the stack is as follows: +## irrefutable COLON +## + + + +contract: Let LPAR WILD COMMA Ident EQ +## +## Ends in an error in state: 199. +## +## closed_irrefutable -> irrefutable . [ RPAR ] +## typed_pattern -> irrefutable . COLON type_expr [ RPAR ] +## +## The known suffix of the stack is as follows: +## irrefutable +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 193, spurious reduction of production nsepseq(sub_irrefutable,COMMA) -> sub_irrefutable +## In state 198, spurious reduction of production tuple(sub_irrefutable) -> sub_irrefutable COMMA nsepseq(sub_irrefutable,COMMA) +## In state 190, spurious reduction of production irrefutable -> tuple(sub_irrefutable) +## + + + +contract: Let LPAR WILD RPAR COLON Ident SEMI +## +## Ends in an error in state: 320. +## +## let_binding -> par(closed_irrefutable) option(type_annotation) . EQ expr [ SEMI ] +## +## The known suffix of the stack is as follows: +## par(closed_irrefutable) option(type_annotation) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 8, spurious reduction of production core_type -> Ident +## In state 15, spurious reduction of production cartesian -> core_type +## In state 66, spurious reduction of production type_expr -> cartesian +## In state 75, spurious reduction of production type_annotation -> COLON type_expr +## In state 76, spurious reduction of production option(type_annotation) -> type_annotation +## + + + +contract: Let LPAR WILD RPAR EQ WILD +## +## Ends in an error in state: 321. +## +## let_binding -> par(closed_irrefutable) option(type_annotation) EQ . expr [ SEMI ] +## +## The known suffix of the stack is as follows: +## par(closed_irrefutable) option(type_annotation) EQ +## + + + +contract: Let LPAR WILD RPAR WILD +## +## Ends in an error in state: 319. +## +## let_binding -> par(closed_irrefutable) . option(type_annotation) EQ expr [ SEMI ] +## sub_irrefutable -> par(closed_irrefutable) . [ COMMA ] +## +## The known suffix of the stack is as follows: +## par(closed_irrefutable) +## + + + +contract: Let LPAR WILD WILD +## +## Ends in an error in state: 191. +## +## irrefutable -> sub_irrefutable . [ RPAR COLON ] +## tuple(sub_irrefutable) -> sub_irrefutable . COMMA nsepseq(sub_irrefutable,COMMA) [ RPAR COLON ] +## +## The known suffix of the stack is as follows: +## sub_irrefutable +## + + + +contract: Let VBAR +## +## Ends in an error in state: 72. +## +## let_declaration -> seq(Attr) Let . let_binding [ SEMI ] +## +## The known suffix of the stack is as follows: +## seq(Attr) Let +## + + + +contract: Let WILD COLON Ident SEMI +## +## Ends in an error in state: 77. +## +## let_binding -> WILD option(type_annotation) . EQ expr [ SEMI ] +## +## The known suffix of the stack is as follows: +## WILD option(type_annotation) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 8, spurious reduction of production core_type -> Ident +## In state 15, spurious reduction of production cartesian -> core_type +## In state 66, spurious reduction of production type_expr -> cartesian +## In state 75, spurious reduction of production type_annotation -> COLON type_expr +## In state 76, spurious reduction of production option(type_annotation) -> type_annotation +## + + + +contract: Let WILD COLON WILD +## +## Ends in an error in state: 74. +## +## type_annotation -> COLON . type_expr [ EQ ] +## +## The known suffix of the stack is as follows: +## COLON +## + + + +contract: Let WILD COMMA Ident COLON Ident SEMI +## +## Ends in an error in state: 311. +## +## let_binding -> tuple(sub_irrefutable) option(type_annotation) . EQ expr [ SEMI ] +## +## The known suffix of the stack is as follows: +## tuple(sub_irrefutable) option(type_annotation) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 8, spurious reduction of production core_type -> Ident +## In state 15, spurious reduction of production cartesian -> core_type +## In state 66, spurious reduction of production type_expr -> cartesian +## In state 75, spurious reduction of production type_annotation -> COLON type_expr +## In state 76, spurious reduction of production option(type_annotation) -> type_annotation +## + + + +contract: Let WILD COMMA Ident EQ WILD +## +## Ends in an error in state: 312. +## +## let_binding -> tuple(sub_irrefutable) option(type_annotation) EQ . expr [ SEMI ] +## +## The known suffix of the stack is as follows: +## tuple(sub_irrefutable) option(type_annotation) EQ +## + + + +contract: Let WILD COMMA Ident RPAR +## +## Ends in an error in state: 310. +## +## let_binding -> tuple(sub_irrefutable) . option(type_annotation) EQ expr [ SEMI ] +## +## The known suffix of the stack is as follows: +## tuple(sub_irrefutable) +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 193, spurious reduction of production nsepseq(sub_irrefutable,COMMA) -> sub_irrefutable +## In state 198, spurious reduction of production tuple(sub_irrefutable) -> sub_irrefutable COMMA nsepseq(sub_irrefutable,COMMA) +## + + + +contract: Let WILD COMMA VBAR +## +## Ends in an error in state: 192. +## +## tuple(sub_irrefutable) -> sub_irrefutable COMMA . nsepseq(sub_irrefutable,COMMA) [ RPAR EQ COLON ] +## +## The known suffix of the stack is as follows: +## sub_irrefutable COMMA +## + + + +contract: Let WILD COMMA WILD COMMA VBAR +## +## Ends in an error in state: 194. +## +## nsepseq(sub_irrefutable,COMMA) -> sub_irrefutable COMMA . nsepseq(sub_irrefutable,COMMA) [ RPAR EQ COLON ] +## +## The known suffix of the stack is as follows: +## sub_irrefutable COMMA +## + + + +contract: Let WILD COMMA WILD WILD +## +## Ends in an error in state: 193. +## +## nsepseq(sub_irrefutable,COMMA) -> sub_irrefutable . [ RPAR EQ COLON ] +## nsepseq(sub_irrefutable,COMMA) -> sub_irrefutable . COMMA nsepseq(sub_irrefutable,COMMA) [ RPAR EQ COLON ] +## +## The known suffix of the stack is as follows: +## sub_irrefutable +## + + + +contract: Let WILD EQ Bytes VBAR +## +## Ends in an error in state: 548. +## +## declaration -> let_declaration . SEMI [ Type Let EOF Attr ] +## +## The known suffix of the stack is as follows: +## let_declaration +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 233, spurious reduction of production call_expr_level_in -> core_expr +## In state 252, spurious reduction of production option(type_annotation_simple) -> +## In state 253, spurious reduction of production call_expr_level -> call_expr_level_in option(type_annotation_simple) +## In state 254, spurious reduction of production unary_expr_level -> call_expr_level +## In state 122, spurious reduction of production mult_expr_level -> unary_expr_level +## In state 230, spurious reduction of production add_expr_level -> mult_expr_level +## In state 262, spurious reduction of production cat_expr_level -> add_expr_level +## In state 283, spurious reduction of production comp_expr_level -> cat_expr_level +## In state 290, spurious reduction of production conj_expr_level -> comp_expr_level +## In state 297, spurious reduction of production disj_expr_level -> conj_expr_level +## In state 244, spurious reduction of production base_expr(expr) -> disj_expr_level +## In state 301, spurious reduction of production base_cond__open(expr) -> base_expr(expr) +## In state 302, spurious reduction of production expr -> base_cond__open(expr) +## In state 546, spurious reduction of production let_binding -> WILD option(type_annotation) EQ expr +## In state 547, spurious reduction of production let_declaration -> seq(Attr) Let let_binding +## + + + +contract: Let WILD EQ WILD +## +## Ends in an error in state: 78. +## +## let_binding -> WILD option(type_annotation) EQ . expr [ SEMI ] +## +## The known suffix of the stack is as follows: +## WILD option(type_annotation) EQ +## + + + +contract: Let WILD WILD +## +## Ends in an error in state: 73. +## +## let_binding -> WILD . option(type_annotation) EQ expr [ SEMI ] +## sub_irrefutable -> WILD . [ COMMA ] +## +## The known suffix of the stack is as follows: +## WILD +## + + + +contract: Type Ident EQ Constr DOT WILD +## +## Ends in an error in state: 12. +## +## core_type -> Constr DOT . Ident [ SEMI RPAR RBRACE EQ COMMA ] +## +## The known suffix of the stack is as follows: +## Constr DOT +## + + + +contract: Type Ident EQ Constr WILD +## +## Ends in an error in state: 11. +## +## core_type -> Constr . DOT Ident [ SEMI RPAR RBRACE EQ COMMA ] +## +## The known suffix of the stack is as follows: +## Constr +## + + + +contract: Type Ident EQ Ident ARROW WILD +## +## Ends in an error in state: 25. +## +## type_expr_func -> ARROW . cartesian [ SEMI RPAR EQ COMMA ] +## +## The known suffix of the stack is as follows: +## ARROW +## + + + +contract: Type Ident EQ Ident LPAR Ident COMMA WILD +## +## Ends in an error in state: 23. +## +## nsepseq(core_type,COMMA) -> core_type COMMA . nsepseq(core_type,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## core_type COMMA +## + + + +contract: Type Ident EQ Ident LPAR Ident RBRACE +## +## Ends in an error in state: 22. +## +## nsepseq(core_type,COMMA) -> core_type . [ RPAR ] +## nsepseq(core_type,COMMA) -> core_type . COMMA nsepseq(core_type,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## core_type +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 18, spurious reduction of production core_type -> Ident +## + + + +contract: Type Ident EQ Ident LPAR Ident WILD +## +## Ends in an error in state: 18. +## +## core_type -> Ident . [ RPAR RBRACE COMMA ] +## core_type -> Ident . par(__anonymous_1) [ RPAR RBRACE COMMA ] +## +## The known suffix of the stack is as follows: +## Ident +## + + + +contract: Type Ident EQ Ident LPAR LPAR Ident SEMI +## +## Ends in an error in state: 16. +## +## par(cartesian) -> LPAR cartesian . RPAR [ RPAR RBRACE COMMA ] +## +## The known suffix of the stack is as follows: +## LPAR cartesian +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 8, spurious reduction of production core_type -> Ident +## In state 15, spurious reduction of production cartesian -> core_type +## + + + +contract: Type Ident EQ Ident LPAR LPAR WILD +## +## Ends in an error in state: 10. +## +## par(cartesian) -> LPAR . cartesian RPAR [ RPAR RBRACE COMMA ] +## +## The known suffix of the stack is as follows: +## LPAR +## + + + +contract: Type Ident EQ Ident LPAR WILD +## +## Ends in an error in state: 9. +## +## par(__anonymous_1) -> LPAR . nsepseq(core_type,COMMA) RPAR [ SEMI RPAR RBRACE EQ COMMA ] +## +## The known suffix of the stack is as follows: +## LPAR +## + + + +contract: Type Ident EQ Ident RPAR +## +## Ends in an error in state: 69. +## +## declaration -> type_decl . SEMI [ Type Let EOF Attr ] +## +## The known suffix of the stack is as follows: +## type_decl +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 8, spurious reduction of production core_type -> Ident +## In state 15, spurious reduction of production cartesian -> core_type +## In state 66, spurious reduction of production type_expr -> cartesian +## In state 63, spurious reduction of production type_decl -> Type Ident EQ type_expr +## + + + +contract: Type Ident EQ Ident SEMI WILD +## +## Ends in an error in state: 552. +## +## declarations -> declaration . [ EOF ] +## declarations -> declaration . declarations [ EOF ] +## +## The known suffix of the stack is as follows: +## declaration +## + + + +contract: Type Ident EQ Ident WILD +## +## Ends in an error in state: 8. +## +## cartesian -> Ident . type_expr_func [ SEMI RPAR EQ COMMA ] +## core_type -> Ident . [ SEMI RPAR EQ COMMA ] +## core_type -> Ident . par(__anonymous_1) [ SEMI RPAR EQ COMMA ] +## +## The known suffix of the stack is as follows: +## Ident +## + + + +contract: Type Ident EQ LBRACE Ident COLON Ident RPAR +## +## Ends in an error in state: 56. +## +## nsepseq(field_decl,COMMA) -> field_decl . [ RBRACE ] +## nsepseq(field_decl,COMMA) -> field_decl . COMMA nsepseq(field_decl,COMMA) [ RBRACE ] +## nseq(__anonymous_0(field_decl,COMMA)) -> field_decl . COMMA seq(__anonymous_0(field_decl,COMMA)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_decl +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 18, spurious reduction of production core_type -> Ident +## In state 51, spurious reduction of production type_expr_field -> core_type +## In state 48, spurious reduction of production field_decl -> Ident COLON type_expr_field +## + + + +contract: Type Ident EQ LBRACE Ident COLON WILD +## +## Ends in an error in state: 47. +## +## field_decl -> Ident COLON . type_expr_field [ RBRACE COMMA ] +## +## The known suffix of the stack is as follows: +## Ident COLON +## + + + +contract: Type Ident EQ LBRACE Ident COMMA Ident COLON Ident RPAR +## +## Ends in an error in state: 60. +## +## nsepseq(field_decl,COMMA) -> field_decl . [ RBRACE ] +## nsepseq(field_decl,COMMA) -> field_decl . COMMA nsepseq(field_decl,COMMA) [ RBRACE ] +## seq(__anonymous_0(field_decl,COMMA)) -> field_decl . COMMA seq(__anonymous_0(field_decl,COMMA)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_decl +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 18, spurious reduction of production core_type -> Ident +## In state 51, spurious reduction of production type_expr_field -> core_type +## In state 48, spurious reduction of production field_decl -> Ident COLON type_expr_field +## + + + +contract: Type Ident EQ LBRACE Ident COMMA Ident COMMA WILD +## +## Ends in an error in state: 61. +## +## nsepseq(field_decl,COMMA) -> field_decl COMMA . nsepseq(field_decl,COMMA) [ RBRACE ] +## seq(__anonymous_0(field_decl,COMMA)) -> field_decl COMMA . seq(__anonymous_0(field_decl,COMMA)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_decl COMMA +## + + + +contract: Type Ident EQ LBRACE Ident COMMA WILD +## +## Ends in an error in state: 57. +## +## nsepseq(field_decl,COMMA) -> field_decl COMMA . nsepseq(field_decl,COMMA) [ RBRACE ] +## nseq(__anonymous_0(field_decl,COMMA)) -> field_decl COMMA . seq(__anonymous_0(field_decl,COMMA)) [ RBRACE ] +## +## The known suffix of the stack is as follows: +## field_decl COMMA +## + + + +contract: Type Ident EQ LBRACE Ident WILD +## +## Ends in an error in state: 46. +## +## field_decl -> Ident . [ RBRACE COMMA ] +## field_decl -> Ident . COLON type_expr_field [ RBRACE COMMA ] +## +## The known suffix of the stack is as follows: +## Ident +## + + + +contract: Type Ident EQ LBRACE WILD +## +## Ends in an error in state: 45. +## +## record_type -> LBRACE . sep_or_term_list(field_decl,COMMA) RBRACE [ SEMI RPAR RBRACE EQ COMMA ] +## +## The known suffix of the stack is as follows: +## LBRACE +## + + + +contract: Type Ident EQ LPAR Ident COMMA Ident COMMA WILD +## +## Ends in an error in state: 37. +## +## nsepseq(cartesian,COMMA) -> cartesian COMMA . nsepseq(cartesian,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## cartesian COMMA +## + + + +contract: Type Ident EQ LPAR Ident COMMA Ident RPAR WILD +## +## Ends in an error in state: 33. +## +## cartesian -> LPAR cartesian COMMA nsepseq(cartesian,COMMA) RPAR . option(type_expr_func) [ SEMI RPAR EQ COMMA ] +## +## The known suffix of the stack is as follows: +## LPAR cartesian COMMA nsepseq(cartesian,COMMA) RPAR +## + + + +contract: Type Ident EQ LPAR Ident COMMA Ident SEMI +## +## Ends in an error in state: 36. +## +## nsepseq(cartesian,COMMA) -> cartesian . [ RPAR ] +## nsepseq(cartesian,COMMA) -> cartesian . COMMA nsepseq(cartesian,COMMA) [ RPAR ] +## +## The known suffix of the stack is as follows: +## cartesian +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 8, spurious reduction of production core_type -> Ident +## In state 15, spurious reduction of production cartesian -> core_type +## + + + +contract: Type Ident EQ LPAR Ident COMMA WILD +## +## Ends in an error in state: 31. +## +## cartesian -> LPAR cartesian COMMA . nsepseq(cartesian,COMMA) RPAR option(type_expr_func) [ SEMI RPAR EQ COMMA ] +## +## The known suffix of the stack is as follows: +## LPAR cartesian COMMA +## + + + +contract: Type Ident EQ LPAR Ident RPAR WILD +## +## Ends in an error in state: 29. +## +## cartesian -> LPAR cartesian RPAR . type_expr_func [ SEMI RPAR EQ COMMA ] +## par(cartesian) -> LPAR cartesian RPAR . [ SEMI RPAR EQ COMMA ] +## +## The known suffix of the stack is as follows: +## LPAR cartesian RPAR +## + + + +contract: Type Ident EQ LPAR Ident SEMI +## +## Ends in an error in state: 28. +## +## cartesian -> LPAR cartesian . RPAR type_expr_func [ SEMI RPAR EQ COMMA ] +## cartesian -> LPAR cartesian . COMMA nsepseq(cartesian,COMMA) RPAR option(type_expr_func) [ SEMI RPAR EQ COMMA ] +## par(cartesian) -> LPAR cartesian . RPAR [ SEMI RPAR EQ COMMA ] +## +## The known suffix of the stack is as follows: +## LPAR cartesian +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 8, spurious reduction of production core_type -> Ident +## In state 15, spurious reduction of production cartesian -> core_type +## + + + +contract: Type Ident EQ LPAR WILD +## +## Ends in an error in state: 7. +## +## cartesian -> LPAR . cartesian RPAR type_expr_func [ SEMI RPAR EQ COMMA ] +## cartesian -> LPAR . cartesian COMMA nsepseq(cartesian,COMMA) RPAR option(type_expr_func) [ SEMI RPAR EQ COMMA ] +## par(cartesian) -> LPAR . cartesian RPAR [ SEMI RPAR EQ COMMA ] +## +## The known suffix of the stack is as follows: +## LPAR +## + + + +contract: Type Ident EQ VBAR Constr LPAR Ident RPAR WILD +## +## Ends in an error in state: 41. +## +## nsepseq(variant,VBAR) -> variant . [ SEMI RPAR RBRACE EQ COMMA ] +## nsepseq(variant,VBAR) -> variant . VBAR nsepseq(variant,VBAR) [ SEMI RPAR RBRACE EQ COMMA ] +## +## The known suffix of the stack is as follows: +## variant +## + + + +contract: Type Ident EQ VBAR Constr LPAR Ident SEMI +## +## Ends in an error in state: 39. +## +## variant -> Constr LPAR cartesian . RPAR [ VBAR SEMI RPAR RBRACE EQ COMMA ] +## +## The known suffix of the stack is as follows: +## Constr LPAR cartesian +## +## WARNING: This example involves spurious reductions. +## This implies that, although the LR(1) items shown above provide an +## accurate view of the past (what has been recognized so far), they +## may provide an INCOMPLETE view of the future (what was expected next). +## In state 8, spurious reduction of production core_type -> Ident +## In state 15, spurious reduction of production cartesian -> core_type +## + + + +contract: Type Ident EQ VBAR Constr LPAR WILD +## +## Ends in an error in state: 6. +## +## variant -> Constr LPAR . cartesian RPAR [ VBAR SEMI RPAR RBRACE EQ COMMA ] +## +## The known suffix of the stack is as follows: +## Constr LPAR +## + + + +contract: Type Ident EQ VBAR Constr VBAR WILD +## +## Ends in an error in state: 42. +## +## nsepseq(variant,VBAR) -> variant VBAR . nsepseq(variant,VBAR) [ SEMI RPAR RBRACE EQ COMMA ] +## +## The known suffix of the stack is as follows: +## variant VBAR +## + + + +contract: Type Ident EQ VBAR Constr WILD +## +## Ends in an error in state: 5. +## +## variant -> Constr . [ VBAR SEMI RPAR RBRACE EQ COMMA ] +## variant -> Constr . LPAR cartesian RPAR [ VBAR SEMI RPAR RBRACE EQ COMMA ] +## +## The known suffix of the stack is as follows: +## Constr +## + + + +contract: Type Ident EQ VBAR WILD +## +## Ends in an error in state: 4. +## +## sum_type -> VBAR . nsepseq(variant,VBAR) [ SEMI RPAR RBRACE EQ COMMA ] +## +## The known suffix of the stack is as follows: +## VBAR +## + + + +contract: Type Ident EQ WILD +## +## Ends in an error in state: 3. +## +## type_decl -> Type Ident EQ . type_expr [ SEMI ] +## +## The known suffix of the stack is as follows: +## Type Ident EQ +## + + + +contract: Type Ident WILD +## +## Ends in an error in state: 2. +## +## type_decl -> Type Ident . EQ type_expr [ SEMI ] +## +## The known suffix of the stack is as follows: +## Type Ident +## + + + +contract: Type WILD +## +## Ends in an error in state: 1. +## +## type_decl -> Type . Ident EQ type_expr [ SEMI ] +## +## The known suffix of the stack is as follows: +## Type +## + + + +contract: WILD +## +## Ends in an error in state: 0. +## +## contract' -> . contract [ # ] +## +## The known suffix of the stack is as follows: +## +## + + + diff --git a/src/passes/1-parser/shared/ParserAPI.ml b/src/passes/1-parser/shared/ParserAPI.ml index 9c0a0f96e..d12c234ca 100644 --- a/src/passes/1-parser/shared/ParserAPI.ml +++ b/src/passes/1-parser/shared/ParserAPI.ml @@ -103,6 +103,11 @@ module Make (Lexer: Lexer.S) let failure get_win checkpoint = let message = ParErr.message (state checkpoint) in + let message = if message = "\n" then + (string_of_int (state checkpoint)) ^ ": " + else + message + in match get_win () with Lexer.Nil -> assert false | Lexer.One invalid -> From 6c3879403b75aea25b93bb4c36e940628eefee48 Mon Sep 17 00:00:00 2001 From: Sander Spies Date: Fri, 31 Jan 2020 16:13:56 +0100 Subject: [PATCH 4/5] Enable incremental parser by default \o/ Fix test. --- src/bin/expect_tests/syntax_error_tests.ml | 2 +- src/passes/1-parser/cameligo.ml | 2 +- src/passes/1-parser/pascaligo.ml | 2 +- src/passes/1-parser/reasonligo.ml | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/bin/expect_tests/syntax_error_tests.ml b/src/bin/expect_tests/syntax_error_tests.ml index d3a735c3f..ccb76c858 100644 --- a/src/bin/expect_tests/syntax_error_tests.ml +++ b/src/bin/expect_tests/syntax_error_tests.ml @@ -4,7 +4,7 @@ let%expect_test _ = run_ligo_bad [ "compile-contract" ; "../../test/contracts/negative/error_syntax.ligo" ; "main" ] ; [%expect {| ligo: : Parse error in file "error_syntax.ligo", line 1, characters 16-17, after "bar" and before "-". - {} + 15: {} If you're not sure how to fix this error, you can diff --git a/src/passes/1-parser/cameligo.ml b/src/passes/1-parser/cameligo.ml index 2cd218370..575445a0a 100644 --- a/src/passes/1-parser/cameligo.ml +++ b/src/passes/1-parser/cameligo.ml @@ -23,7 +23,7 @@ module PreIO = ~offsets:true ~mode:`Point ~cmd:EvalOpt.Quiet - ~mono:true + ~mono:false end module Parser = diff --git a/src/passes/1-parser/pascaligo.ml b/src/passes/1-parser/pascaligo.ml index f3b63975c..10eeaa30d 100644 --- a/src/passes/1-parser/pascaligo.ml +++ b/src/passes/1-parser/pascaligo.ml @@ -23,7 +23,7 @@ module PreIO = ~offsets:true ~mode:`Point ~cmd:EvalOpt.Quiet - ~mono:true + ~mono:false end module Parser = diff --git a/src/passes/1-parser/reasonligo.ml b/src/passes/1-parser/reasonligo.ml index 753750fc4..17091363b 100644 --- a/src/passes/1-parser/reasonligo.ml +++ b/src/passes/1-parser/reasonligo.ml @@ -26,7 +26,7 @@ module PreIO = ~offsets:true ~mode:`Point ~cmd:EvalOpt.Quiet - ~mono:true + ~mono:false end module Parser = From bc9cb36d97ce8ad62ac59ea1887cea30ca589c98 Mon Sep 17 00:00:00 2001 From: Sander Spies Date: Fri, 31 Jan 2020 19:31:51 +0100 Subject: [PATCH 5/5] Typo. --- src/bin/expect_tests/syntax_error_tests.ml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/bin/expect_tests/syntax_error_tests.ml b/src/bin/expect_tests/syntax_error_tests.ml index ccb76c858..bf835d78b 100644 --- a/src/bin/expect_tests/syntax_error_tests.ml +++ b/src/bin/expect_tests/syntax_error_tests.ml @@ -3,7 +3,7 @@ open Cli_expect let%expect_test _ = run_ligo_bad [ "compile-contract" ; "../../test/contracts/negative/error_syntax.ligo" ; "main" ] ; [%expect {| - ligo: : Parse error in file "error_syntax.ligo", line 1, characters 16-17, after "bar" and before "-". + ligo: : Parse error in file "error_syntax.ligo", line 1, characters 16-17, after "bar" and before "-": 15: {}