rewrite parser

previously it backtracked too much, so instead of giving a useful
parse error, it just said "expected end of input" at the beginning of
the problem toplevel. which, if it's a namespace, could be way off.

tests/Tests/Parser.idr

@@ -53,18 +53,18 @@ parameters {c : Bool} {auto _ : Show a} (grm : Grammar c a)
 export
 tests : Test
 tests = "parser" :- [
-  "bound names" :- [
-    parsesAs bname "_" Nothing,
-    parsesAs bname "F" (Just "F"),
-    parseFails bname "a.b.c"
+  "pattern vars" :- [
+    parsesAs patVar "_" Nothing,
+    parsesAs patVar "F" (Just "F"),
+    parseFails patVar "a.b.c"
   ],
 
   "names" :- [
-    parsesAs name "x"
+    parsesAs qname "x"
       (MakePName [<] "x"),
-    parsesAs name "Data.String.length"
+    parsesAs qname "Data.String.length"
       (MakePName [< "Data", "String"] "length"),
-    parseFails name "_"
+    parseFails qname "_"
   ],
 
   "dimensions" :- [
@@ -219,9 +219,14 @@ tests = "parser" :- [
     parsesAs term "f x y ≡ g y z : A B C" $
       Eq (Nothing, V "A" :@ V "B" :@ V "C")
          (V "f" :@ V "x" :@ V "y") (V "g" :@ V "y" :@ V "z"),
-    parsesAs term "A × B ≡ A' × B' : ★₁" $
+    parsesAs term "(A × B) ≡ (A' × B') : ★₁" $
       Eq (Nothing, TYPE 1)
          (Sig Nothing (V "A") (V "B")) (Sig Nothing (V "A'") (V "B'")),
+    note "A × (B ≡ A' × B' : ★₁)",
+    parsesAs term "A × B ≡ A' × B' : ★₁" $
+      Sig Nothing (V "A") $
+        Eq (Nothing, TYPE 1)
+           (V "B") (Sig Nothing (V "A'") (V "B'")),
     parseFails term "Eq",
     parseFails term "Eq s t",
     parseFails term "s ≡ t",
@@ -233,7 +238,9 @@ tests = "parser" :- [
     parsesAs term "Nat" Nat,
     parsesAs term "zero" Zero,
     parsesAs term "succ n" (Succ $ V "n"),
-    parsesAs term "3" (Succ (Succ (Succ Zero))),
+    parsesAs term "3" (fromNat 3),
+    parsesAs term "succ (succ 5)" (fromNat 7),
+    parseFails term "succ succ 5",
     parseFails term "succ"
   ],
 
@@ -245,6 +252,28 @@ tests = "parser" :- [
     parsesAs term "[1]" $ Box (Succ Zero)
   ],
 
+  "coe" :- [
+    parsesAs term "coe [A] @p @q x" $
+      Coe (Nothing, V "A") (V "p") (V "q") (V "x"),
+    parsesAs term "coe [i ⇒ A] @p @q x" $
+      Coe (Just "i", V "A") (V "p") (V "q") (V "x"),
+    parseFails term "coe [A] @p @q",
+    parseFails term "coe A @p @q x",
+    parseFails term "coe [i ⇒ A] @p q x"
+  ],
+
+  "comp" :- [
+    parsesAs term "comp [A] @p @q s @r { 0 𝑗 ⇒ s₀; 1 𝑘 ⇒ s₁ }" $
+      Comp (Nothing, V "A") (V "p") (V "q") (V "s") (V "r")
+        (Just "𝑗", V "s₀") (Just "𝑘", V "s₁"),
+    parsesAs term "comp [A] @p @q s @r { 1 𝑗 ⇒ s₀; 0 𝑘 ⇒ s₁; }" $
+      Comp (Nothing, V "A") (V "p") (V "q") (V "s") (V "r")
+        (Just "𝑘", V "s₁") (Just "𝑗", V "s₀"),
+    parseFails term "comp [A] @p @q s @r { 1 𝑗 ⇒ s₀; 1 𝑘 ⇒ s₁; }",
+    parseFails term "comp [A] @p @q s @r { 0 𝑗 ⇒ s₀ }",
+    parseFails term "comp [A] @p @q s @r { }"
+  ],
+
   "case" :- [
     parsesAs term
       "case1 f s return x ⇒ A x of { (l, r) ⇒ add l r }" $
@@ -310,11 +339,8 @@ tests = "parser" :- [
     parsesAs input "def0 A : ★₀ = {} def0 B : ★₁ = A" $
       [PD $ PDef $ MkPDef Zero "A" (Just $ TYPE 0) (Enum []),
        PD $ PDef $ MkPDef Zero "B" (Just $ TYPE 1) (V "A")],
-    parsesAs input "def0 A : ★₀ = {};;; def0 B : ★₁ = A" $
-      [PD $ PDef $ MkPDef Zero "A" (Just $ TYPE 0) (Enum []),
-       PD $ PDef $ MkPDef Zero "B" (Just $ TYPE 1) (V "A")],
     parsesAs input "" [] {label = "[empty input]"},
-    parsesAs input ";;;;;;;;;;;;;;;;;;;;;;;;;;" [],
+    parseFails input ";;;;;;;;;;;;;;;;;;;;;;;;;;",
     parsesAs input "namespace a {}" [PD $ PNs $ MkPNamespace [< "a"] []],
     parsesAs input "namespace a.b.c {}"
       [PD $ PNs $ MkPNamespace [< "a", "b", "c"] []],