quox/tests/Tests/Parser.idr

582 lines
23 KiB
Idris
Raw Normal View History

2023-03-04 15:02:51 -05:00
module Tests.Parser
import Quox.Parser
import Data.List
import Data.String
import TAP
import Language.Reflection
%language ElabReflection
2023-03-04 15:02:51 -05:00
public export
data Failure =
ParseError Parser.Error
2023-03-04 15:02:51 -05:00
| WrongResult String
| ExpectedFail String
export
ToInfo Parser.Error where
2023-03-04 15:02:51 -05:00
toInfo (LexError err) =
[("type", "LexError"), ("info", show err)]
toInfo (ParseError errs) =
("type", "ParseError") ::
map (bimap show show) ([1 .. length errs] `zip` toList errs)
export
ToInfo Failure where
toInfo (ParseError err) =
toInfo err
2023-03-04 15:02:51 -05:00
toInfo (WrongResult got) =
[("type", "WrongResult"), ("got", got)]
toInfo (ExpectedFail got) =
[("type", "ExpectedFail"), ("got", got)]
parameters {auto _ : (Show a, Eq a)} {c : Bool} (grm : FileName -> Grammar c a)
parsesWith : String -> (a -> Bool) -> Test
parsesWith inp p = test (ltrim inp) $ do
res <- mapFst ParseError $ lexParseWith (grm "<test>") inp
unless (p res) $ Left $ WrongResult $ show res
2023-03-04 15:02:51 -05:00
parsesAs : String -> a -> Test
parsesAs inp exp = parsesWith inp (== exp)
2023-03-04 15:02:51 -05:00
%macro
parseMatch : String -> TTImp -> Elab Test
parseMatch inp pat =
parsesWith inp <$> check `(\case ~(pat) => True; _ => False)
2023-03-04 15:02:51 -05:00
parseFails : String -> Test
parseFails inp = test "\{ltrim inp} # fails" $ do
either (const $ Right ()) (Left . ExpectedFail . show) $
lexParseWith (grm "test") inp
2023-03-04 15:02:51 -05:00
export
tests : Test
tests = "parser" :- [
"pattern vars" :- [
parseMatch patVar "_" `(Unused _),
parseMatch patVar "F" `(PV "F" _),
parseFails patVar "a.b.c"
2023-03-04 15:02:51 -05:00
],
"names" :- [
parsesAs (const qname) "x"
2024-04-11 16:08:07 -04:00
(MkPName [<] "x"),
parsesAs (const qname) "Data.List.length"
2024-04-11 16:08:07 -04:00
(MkPName [< "Data", "List"] "length"),
parseFails (const qname) "_"
2023-03-04 15:02:51 -05:00
],
"dimensions" :- [
parseMatch dim "0" `(K Zero _),
parseMatch dim "1" `(K One _),
2023-05-21 14:09:34 -04:00
parseMatch dim "𝑖" `(V "𝑖" {}),
2023-03-04 15:02:51 -05:00
parseFails dim "M.x",
parseFails dim "_"
],
"quantities" :- [
parseMatch qty "0" `(PQ Zero _),
parseMatch qty "1" `(PQ One _),
parseMatch qty "ω" `(PQ Any _),
parseMatch qty "#" `(PQ Any _),
2023-03-04 15:02:51 -05:00
parseFails qty "anythingElse",
parseFails qty "_"
],
"enum types" :- [
parseMatch term #"{}"# `(Enum [] _),
parseMatch term #"{a}"# `(Enum ["a"] _),
parseMatch term #"{a,}"# `(Enum ["a"] _),
parseMatch term #"{a.b.c.d}"# `(Enum ["a.b.c.d"] _),
parseMatch term #"{"hel lo"}"# `(Enum ["hel lo"] _),
parseMatch term #"{a, b}"# `(Enum ["a", "b"] _),
parseMatch term #"{a, b,}"# `(Enum ["a", "b"] _),
parseMatch term #"{a, b, ","}"# `(Enum ["a", "b", ","] _),
2023-03-04 15:02:51 -05:00
parseFails term #"{,}"#
],
"tags" :- [
parseMatch term #" 'a "# `(Tag "a" _),
parseMatch term #" 'abc "# `(Tag "abc" _),
parseMatch term #" '"abc" "# `(Tag "abc" _),
parseMatch term #" '"a b c" "# `(Tag "a b c" _),
note "application to two arguments",
parseMatch term #" 'a b c "#
2023-05-21 14:09:34 -04:00
`(App (App (Tag "a" _) (V "b" {}) _) (V "c" {}) _)
2023-03-04 15:02:51 -05:00
],
"universes" :- [
2023-05-21 14:09:34 -04:00
parseMatch term "★⁰" `(TYPE 0 _),
parseMatch term "★1" `(TYPE 1 _),
parseMatch term "★ 2" `(TYPE 2 _),
2023-05-21 14:09:34 -04:00
parseMatch term "Type³" `(TYPE 3 _),
parseMatch term "Type4" `(TYPE 4 _),
parseMatch term "Type 100" `(TYPE 100 _),
parseMatch term "(Type 1000)" `(TYPE 1000 _),
2023-05-21 14:33:42 -04:00
parseMatch term "Type" `(TYPE 0 _),
parseMatch term "" `(TYPE 0 _)
2023-03-04 15:02:51 -05:00
],
"applications" :- [
parseMatch term "f"
2023-05-21 14:09:34 -04:00
`(V "f" {}),
parseMatch term "f.x.y"
2024-04-11 16:08:07 -04:00
`(V (MkPName [< "f", "x"] "y") {}),
parseMatch term "f x"
2023-05-21 14:09:34 -04:00
`(App (V "f" {}) (V "x" {}) _),
parseMatch term "f x y"
2023-05-21 14:09:34 -04:00
`(App (App (V "f" {}) (V "x" {}) _) (V "y" {}) _),
parseMatch term "(f x) y"
2023-05-21 14:09:34 -04:00
`(App (App (V "f" {}) (V "x" {}) _) (V "y" {}) _),
parseMatch term "f (g x)"
2023-05-21 14:09:34 -04:00
`(App (V "f" {}) (App (V "g" {}) (V "x" {}) _) _),
parseMatch term "f (g x) y"
2023-05-21 14:09:34 -04:00
`(App (App (V "f" {}) (App (V "g" {}) (V "x" {}) _) _) (V "y" {}) _),
parseMatch term "f @p"
2023-05-21 14:09:34 -04:00
`(DApp (V "f" {}) (V "p" {}) _),
parseMatch term "f x @p y"
`(App (DApp (App (V "f" {}) (V "x" {}) _) (V "p" {}) _) (V "y" {}) _),
parseMatch term "fst e"
`(Fst (V "e" {}) _),
parseMatch term "snd e"
`(Snd (V "e" {}) _),
parseMatch term "(fst e) x"
`(App (Fst (V "e" {}) _) (V "x" {}) _),
parseMatch term "fst e x"
`(App (Fst (V "e" {}) _) (V "x" {}) _)
2023-03-04 15:02:51 -05:00
],
"annotations" :- [
parseMatch term "f :: A"
2023-05-21 14:09:34 -04:00
`(Ann (V "f" {}) (V "A" {}) _),
parseMatch term "f ∷ A"
2023-05-21 14:09:34 -04:00
`(Ann (V "f" {}) (V "A" {}) _),
parseMatch term "f x y ∷ A B C"
2023-05-21 14:09:34 -04:00
`(Ann (App (App (V "f" {}) (V "x" {}) _) (V "y" {}) _)
(App (App (V "A" {}) (V "B" {}) _) (V "C" {}) _) _),
parseMatch term "Type 0 ∷ Type 1 ∷ Type 2"
`(Ann (TYPE 0 _) (Ann (TYPE 1 _) (TYPE 2 _) _) _)
2023-03-04 15:02:51 -05:00
],
"binders" :- [
parseMatch term "1.(x : A) → B x"
2023-05-21 14:09:34 -04:00
`(Pi (PQ One _) (PV "x" _) (V "A" {}) (App (V "B" {}) (V "x" {}) _) _),
parseMatch term "1.(x : A) -> B x"
2023-05-21 14:09:34 -04:00
`(Pi (PQ One _) (PV "x" _) (V "A" {}) (App (V "B" {}) (V "x" {}) _) _),
parseMatch term "ω.(x : A) → B x"
2023-05-21 14:09:34 -04:00
`(Pi (PQ Any _) (PV "x" _) (V "A" {}) (App (V "B" {}) (V "x" {}) _) _),
parseMatch term "#.(x : A) -> B x"
2023-05-21 14:09:34 -04:00
`(Pi (PQ Any _) (PV "x" _) (V "A" {}) (App (V "B" {}) (V "x" {}) _) _),
parseMatch term "1.(x y : A) -> B x"
2023-05-21 14:09:34 -04:00
`(Pi (PQ One _) (PV "x" _) (V "A" {})
(Pi (PQ One _) (PV "y" _) (V "A" {})
(App (V "B" {}) (V "x" {}) _) _) _),
parseMatch term "(x : A) → B x"
`(Pi (PQ One _) (PV "x" _) (V "A" {}) (App (V "B" {}) (V "x" {}) _) _),
parseMatch term "1.A → B"
2023-05-21 14:09:34 -04:00
`(Pi (PQ One _) (Unused _) (V "A" {}) (V "B" {}) _),
parseMatch term "A → B"
`(Pi (PQ One _) (Unused _) (V "A" {}) (V "B" {}) _),
parseMatch term "A → B → C"
`(Pi (PQ One _) (Unused _) (V "A" {})
(Pi (PQ One _) (Unused _) (V "B" {}) (V "C" {}) _) _),
parseMatch term "1.(List A) → List B"
`(Pi (PQ One _) (Unused _)
2023-05-21 14:09:34 -04:00
(App (V "List" {}) (V "A" {}) _)
(App (V "List" {}) (V "B" {}) _) _),
parseMatch term "0.★⁰ → ★⁰"
`(Pi (PQ Zero _) (Unused _) (TYPE 0 _) (TYPE 0 _) _),
parseFails term "1.List A → List B",
parseMatch term "(x : A) × B x"
2023-05-21 14:09:34 -04:00
`(Sig (PV "x" _) (V "A" {}) (App (V "B" {}) (V "x" {}) _) _),
parseMatch term "(x : A) ** B x"
2023-05-21 14:09:34 -04:00
`(Sig (PV "x" _) (V "A" {}) (App (V "B" {}) (V "x" {}) _) _),
parseMatch term "(x y : A) × B" $
2023-05-21 14:09:34 -04:00
`(Sig (PV "x" _) (V "A" {}) (Sig (PV "y" _) (V "A" {}) (V "B" {}) _) _),
parseFails term "1.(x : A) × B x",
parseMatch term "A × B"
2023-05-21 14:09:34 -04:00
`(Sig (Unused _) (V "A" {}) (V "B" {}) _),
parseMatch term "A ** B"
2023-05-21 14:09:34 -04:00
`(Sig (Unused _) (V "A" {}) (V "B" {}) _),
parseMatch term "A × B × C" $
2023-05-21 14:09:34 -04:00
`(Sig (Unused _) (V "A" {}) (Sig (Unused _) (V "B" {}) (V "C" {}) _) _),
parseMatch term "(A × B) × C" $
`(Sig (Unused _) (Sig (Unused _) (V "A" {}) (V "B" {}) _) (V "C" {}) _),
parseMatch term "A × B → C" $
`(Pi (PQ One _) (Unused _)
(Sig (Unused _) (V "A" {}) (V "B" {}) _)
(V "C" {}) _),
parseMatch term "A → B × C" $
`(Pi (PQ One _) (Unused _)
(V "A" {})
(Sig (Unused _) (V "B" {}) (V "C" {}) _) _),
parseMatch term "A → B × C → D" $
`(Pi (PQ One _) (Unused _)
(V "A" {})
(Pi (PQ One _) (Unused _)
(Sig (Unused _) (V "B" {}) (V "C" {}) _)
(V "D" {}) _) _)
2023-03-04 15:02:51 -05:00
],
"lambdas" :- [
parseMatch term "λ x ⇒ x"
2023-05-21 14:09:34 -04:00
`(Lam (PV "x" _) (V "x" {}) _),
parseMatch term "fun x => x"
2023-05-21 14:09:34 -04:00
`(Lam (PV "x" _) (V "x" {}) _),
parseMatch term "δ i ⇒ x @i"
2023-05-21 14:09:34 -04:00
`(DLam (PV "i" _) (DApp (V "x" {}) (V "i" {}) _) _),
parseMatch term "dfun i => x @i"
2023-05-21 14:09:34 -04:00
`(DLam (PV "i" _) (DApp (V "x" {}) (V "i" {}) _) _),
parseMatch term "λ x y z ⇒ x z y"
`(Lam (PV "x" _)
(Lam (PV "y" _)
(Lam (PV "z" _)
2023-05-21 14:09:34 -04:00
(App (App (V "x" {}) (V "z" {}) _) (V "y" {}) _) _) _) _)
2023-03-04 15:02:51 -05:00
],
"pairs" :- [
parseMatch term "(x, y)"
2023-05-21 14:09:34 -04:00
`(Pair (V "x" {}) (V "y" {}) _),
parseMatch term "(x, y, z)"
2023-05-21 14:09:34 -04:00
`(Pair (V "x" {}) (Pair (V "y" {}) (V "z" {}) _) _),
parseMatch term "((x, y), z)"
2023-05-21 14:09:34 -04:00
`(Pair (Pair (V "x" {}) (V "y" {}) _) (V "z" {}) _),
parseMatch term "(f x, g @y)"
2023-05-21 14:09:34 -04:00
`(Pair (App (V "f" {}) (V "x" {}) _) (DApp (V "g" {}) (V "y" {}) _) _),
parseMatch term "((x : A) × B, 0.(x : C) → D)"
2023-05-21 14:09:34 -04:00
`(Pair (Sig (PV "x" _) (V "A" {}) (V "B" {}) _)
(Pi (PQ Zero _) (PV "x" _) (V "C" {}) (V "D" {}) _) _),
parseMatch term "(λ x ⇒ x, δ i ⇒ e @i)"
2023-05-21 14:09:34 -04:00
`(Pair (Lam (PV "x" _) (V "x" {}) _)
(DLam (PV "i" _) (DApp (V "e" {}) (V "i" {}) _) _) _),
parseMatch term "(x,)" `(V "x" {}), -- i GUESS
2023-03-04 15:02:51 -05:00
parseFails term "(,y)",
parseFails term "(x,,y)"
],
"equality type" :- [
parseMatch term "Eq (i ⇒ A) s t"
2023-05-21 14:09:34 -04:00
`(Eq (PV "i" _, V "A" {}) (V "s" {}) (V "t" {}) _),
parseMatch term "Eq (i ⇒ A (B @i)) (f x) (g y)"
2023-05-21 14:09:34 -04:00
`(Eq (PV "i" _, App (V "A" {}) (DApp (V "B" {}) (V "i" {}) _) _)
(App (V "f" {}) (V "x" {}) _)
(App (V "g" {}) (V "y" {}) _) _),
parseMatch term "Eq A s t"
2023-05-21 14:09:34 -04:00
`(Eq (Unused _, V "A" {}) (V "s" {}) (V "t" {}) _),
parseMatch term "s ≡ t : A"
2023-05-21 14:09:34 -04:00
`(Eq (Unused _, V "A" {}) (V "s" {}) (V "t" {}) _),
parseMatch term "s == t : A"
2023-05-21 14:09:34 -04:00
`(Eq (Unused _, V "A" {}) (V "s" {}) (V "t" {}) _),
parseMatch term "f x ≡ g y : A B"
2023-05-21 14:09:34 -04:00
`(Eq (Unused _, App (V "A" {}) (V "B" {}) _)
(App (V "f" {}) (V "x" {}) _)
(App (V "g" {}) (V "y" {}) _) _),
parseMatch term "(A × B) ≡ (A' × B') : ★¹"
`(Eq (Unused _, TYPE 1 _)
2023-05-21 14:09:34 -04:00
(Sig (Unused _) (V "A" {}) (V "B" {}) _)
(Sig (Unused _) (V "A'" {}) (V "B'" {}) _) _),
note "A × (B ≡ A' × B' : ★¹)",
parseMatch term "A × B ≡ A' × B' : ★¹"
`(Sig (Unused _) (V "A" {})
(Eq (Unused _, TYPE 1 _)
2023-05-21 14:09:34 -04:00
(V "B" {}) (Sig (Unused _) (V "A'" {}) (V "B'" {}) _) _) _),
2023-03-04 15:02:51 -05:00
parseFails term "Eq",
parseFails term "Eq s t",
parseFails term "s ≡ t",
parseFails term ""
],
2023-03-26 08:40:54 -04:00
"naturals" :- [
2023-11-02 13:14:22 -04:00
parseMatch term "" `(NAT _),
parseMatch term "Nat" `(NAT _),
parseMatch term "zero" `(Nat 0 _),
2023-05-21 14:09:34 -04:00
parseMatch term "succ n" `(Succ (V "n" {}) _),
parseMatch term "3" `(Nat 3 _),
parseMatch term "succ (succ 1)" `(Succ (Succ (Nat 1 _) _) _),
parseFails term "succ succ 5",
2023-03-26 08:40:54 -04:00
parseFails term "succ"
],
2023-03-31 13:11:35 -04:00
"box" :- [
parseMatch term "[1.]"
2023-11-02 13:14:22 -04:00
`(BOX (PQ One _) (NAT _) _),
parseMatch term "[ω. × ]"
2023-11-02 13:14:22 -04:00
`(BOX (PQ Any _) (Sig (Unused _) (NAT _) (NAT _) _) _),
parseMatch term "[a]" `(Box (V "a" {}) _),
parseMatch term "[0]" `(Box (Nat 0 _) _),
parseMatch term "[1]" `(Box (Nat 1 _) _)
2023-03-31 13:11:35 -04:00
],
"coe" :- [
parseMatch term "coe A @p @q x"
2023-05-21 14:09:34 -04:00
`(Coe (Unused _, V "A" {}) (V "p" {}) (V "q" {}) (V "x" {}) _),
parseMatch term "coe (i ⇒ A) @p @q x"
2023-05-21 14:09:34 -04:00
`(Coe (PV "i" _, V "A" {}) (V "p" {}) (V "q" {}) (V "x" {}) _),
parseMatch term "coe A x"
2023-05-21 14:09:34 -04:00
`(Coe (Unused _, V "A" {}) (K Zero _) (K One _) (V "x" {}) _),
parseFails term "coe A @p @q",
parseFails term "coe (i ⇒ A) @p q x"
],
"comp" :- [
parseMatch term "comp A @p @q s @r { 0 𝑗 ⇒ s₀; 1 𝑘 ⇒ s₁ }"
2023-05-21 14:09:34 -04:00
`(Comp (Unused _, V "A" {}) (V "p" {}) (V "q" {}) (V "s" {}) (V "r" {})
(PV "𝑗" _, V "s₀" {}) (PV "𝑘" _, V "s₁" {}) _),
parseMatch term "comp (𝑖 ⇒ A) @p @q s @r { 0 𝑗 ⇒ s₀; 1 𝑘 ⇒ s₁ }"
2023-05-21 14:09:34 -04:00
`(Comp (PV "𝑖" _, V "A" {}) (V "p" {}) (V "q" {}) (V "s" {}) (V "r" {})
(PV "𝑗" _, V "s₀" {}) (PV "𝑘" _, V "s₁" {}) _),
parseMatch term "comp A @p @q s @r { 1 𝑗 ⇒ s₀; 0 𝑘 ⇒ s₁; }"
2023-05-21 14:09:34 -04:00
`(Comp (Unused _, V "A" {}) (V "p" {}) (V "q" {}) (V "s" {}) (V "r" {})
(PV "𝑘" _, V "s₁" {}) (PV "𝑗" _, V "s₀" {}) _),
parseMatch term "comp A s @r { 0 𝑗 ⇒ s₀; 1 𝑘 ⇒ s₁ }"
2023-05-21 14:09:34 -04:00
`(Comp (Unused _, V "A" {}) (K Zero _) (K One _) (V "s" {}) (V "r" {})
(PV "𝑗" _, V "s₀" {}) (PV "𝑘" _, 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 { }"
],
2023-03-04 15:02:51 -05:00
"case" :- [
parseMatch term
"case1 f s return x ⇒ A x of { (l, r) ⇒ r l }"
2023-05-21 14:09:34 -04:00
`(Case (PQ One _) (App (V "f" {}) (V "s" {}) _)
(PV "x" _, App (V "A" {}) (V "x" {}) _)
(CasePair (PV "l" _, PV "r" _)
2023-05-21 14:09:34 -04:00
(App (V "r" {}) (V "l" {}) _) _) _),
parseMatch term
"case1 f s return x => A x of { (l, r) ⇒ r l; }"
2023-05-21 14:09:34 -04:00
`(Case (PQ One _) (App (V "f" {}) (V "s" {}) _)
(PV "x" _, App (V "A" {}) (V "x" {}) _)
(CasePair (PV "l" _, PV "r" _)
2023-05-21 14:09:34 -04:00
(App (V "r" {}) (V "l" {}) _) _) _),
parseMatch term
"case 1. f s return x ⇒ A x of { (l, r) ⇒ r l }"
`(Case (PQ One _) (App (V "f" {}) (V "s" {}) _)
(PV "x" _, App (V "A" {}) (V "x" {}) _)
(CasePair (PV "l" _, PV "r" _)
(App (V "r" {}) (V "l" {}) _) _) _),
parseMatch term
"caseω f s return x ⇒ A x of { (l, r) ⇒ r l }"
`(Case (PQ Any _) (App (V "f" {}) (V "s" {}) _)
(PV "x" _, App (V "A" {}) (V "x" {}) _)
(CasePair (PV "l" _, PV "r" _)
(App (V "r" {}) (V "l" {}) _) _) _),
parseMatch term
"case0 f s return x ⇒ A x of { (l, r) ⇒ r l }"
`(Case (PQ Zero _) (App (V "f" {}) (V "s" {}) _)
(PV "x" _, App (V "A" {}) (V "x" {}) _)
(CasePair (PV "l" _, PV "r" _)
(App (V "r" {}) (V "l" {}) _) _) _),
parseMatch term
"case f s return x ⇒ A x of { (l, r) ⇒ r l }"
2023-05-21 14:09:34 -04:00
`(Case (PQ One _) (App (V "f" {}) (V "s" {}) _)
(PV "x" _, App (V "A" {}) (V "x" {}) _)
(CasePair (PV "l" _, PV "r" _)
2023-05-21 14:09:34 -04:00
(App (V "r" {}) (V "l" {}) _) _) _),
parseMatch term
"case1 t return A of { 'x ⇒ p; 'y ⇒ q; 'z ⇒ r }"
2023-05-21 14:09:34 -04:00
`(Case (PQ One _) (V "t" {})
(Unused _, V "A" {})
(CaseEnum [(PT "x" _, V "p" {}),
(PT "y" _, V "q" {}),
(PT "z" _, V "r" {})] _) _),
parseMatch term "caseω t return A of {}"
2023-05-21 14:09:34 -04:00
`(Case (PQ Any _) (V "t" {}) (Unused _, V "A" {}) (CaseEnum [] _) _),
parseMatch term "case# t return A of {}"
2023-05-21 14:09:34 -04:00
`(Case (PQ Any _) (V "t" {}) (Unused _, V "A" {}) (CaseEnum [] _) _),
parseMatch term "caseω n return A of { 0 ⇒ a; succ n' ⇒ b }"
2023-05-21 14:09:34 -04:00
`(Case (PQ Any _) (V "n" {}) (Unused _, V "A" {})
(CaseNat (V "a" {}) (PV "n'" _, PQ Zero _, Unused _, V "b" {}) _) _),
parseMatch term "caseω n return of { succ _, 1.ih ⇒ ih; zero ⇒ 0; }"
2023-11-02 13:14:22 -04:00
`(Case (PQ Any _) (V "n" {}) (Unused _, NAT _)
(CaseNat (Nat 0 _) (Unused _, PQ One _, PV "ih" _, V "ih" {}) _) _),
parseMatch term "caseω n return of { succ _, ω.ih ⇒ ih; zero ⇒ 0; }"
2023-11-02 13:14:22 -04:00
`(Case (PQ Any _) (V "n" {}) (Unused _, NAT _)
(CaseNat (Nat 0 _) (Unused _, PQ Any _, PV "ih" _, V "ih" {}) _) _),
parseMatch term "caseω n return of { succ _, ih ⇒ ih; zero ⇒ 0; }"
2023-11-02 13:14:22 -04:00
`(Case (PQ Any _) (V "n" {}) (Unused _, NAT _)
(CaseNat (Nat 0 _) (Unused _, PQ One _, PV "ih" _, V "ih" {}) _) _),
2023-03-26 08:40:54 -04:00
parseFails term "caseω n return A of { zero ⇒ a }",
parseFails term "caseω n return of { succ ⇒ 5 }",
parseMatch term
"case1 f s return x ⇒ A x of { (l, r) ⇒ r l } x"
`(App
(Case (PQ One _) (App (V "f" {}) (V "s" {}) _)
(PV "x" _, App (V "A" {}) (V "x" {}) _)
(CasePair (PV "l" _, PV "r" _)
(App (V "r" {}) (V "l" {}) _) _) _)
(V "x" {}) _)
2023-03-06 05:35:57 -05:00
],
2023-12-04 12:48:25 -05:00
"let" :- [
parseMatch term "let x = y in z"
`(Let (PQ One _, PV "x" {}, V "y" {}) (V "z" {}) _),
2023-12-04 17:27:59 -05:00
parseMatch term "let x = y; in z"
`(Let (PQ One _, PV "x" {}, V "y" {}) (V "z" {}) _),
2023-12-04 12:48:25 -05:00
parseMatch term "let0 x = y in z"
`(Let (PQ Zero _, PV "x" {}, V "y" {}) (V "z" {}) _),
parseMatch term "let1 x = y in z"
`(Let (PQ One _, PV "x" {}, V "y" {}) (V "z" {}) _),
parseMatch term "letω x = y in z"
`(Let (PQ Any _, PV "x" {}, V "y" {}) (V "z" {}) _),
parseMatch term "letω x : X = y in z"
`(Let (PQ Any _, PV "x" {}, Ann (V "y" {}) (V "X" {}) _) (V "z" {}) _),
2023-12-04 17:27:59 -05:00
parseMatch term "let ω.x = y in z"
`(Let (PQ Any _, PV "x" {}, V "y" {}) (V "z" {}) _),
2023-12-04 12:48:25 -05:00
parseMatch term "let x = y1 y2 in z1 z2"
`(Let (PQ One _, PV "x" {},
(App (V "y1" {}) (V "y2" {}) _))
(App (V "z1" {}) (V "z2" {}) _) _),
parseMatch term "let x = a in let y = b in z"
`(Let (PQ One _, PV "x" {}, V "a" {})
(Let (PQ One _, PV "y" {}, V "b" {}) (V "z" {}) _) _),
2023-12-04 17:27:59 -05:00
parseMatch term "let x = a; y = b in z"
`(Let (PQ One _, PV "x" {}, V "a" {})
(Let (PQ One _, PV "y" {}, V "b" {}) (V "z" {}) _) _),
parseMatch term "letω x = a; y = b in z"
`(Let (PQ Any _, PV "x" {}, V "a" {})
(Let (PQ Any _, PV "y" {}, V "b" {}) (V "z" {}) _) _),
parseMatch term "letω x = a; y = b; in z"
`(Let (PQ Any _, PV "x" {}, V "a" {})
(Let (PQ Any _, PV "y" {}, V "b" {}) (V "z" {}) _) _),
parseMatch term "let ω.x = a; 1.y = b in z"
`(Let (PQ Any _, PV "x" {}, V "a" {})
(Let (PQ One _, PV "y" {}, V "b" {}) (V "z" {}) _) _),
2023-12-04 12:48:25 -05:00
parseMatch term "let x = y in z ∷ Z"
`(Let (PQ One _, PV "x" {}, V "y" {})
(Ann (V "z" {}) (V "Z" {}) _) _),
parseMatch term "let x = y in z₁ ≡ z₂ : Z"
`(Let (PQ One _, PV "x" {}, V "y" {})
2023-12-04 17:27:59 -05:00
(Eq (Unused _, V "Z" {}) (V "z₁" {}) (V "z₂" {}) _) _),
parseFails term "let1 1.x = y in z",
parseFails term "let x = y",
parseFails term "let x in z"
2023-12-04 12:48:25 -05:00
],
2023-11-05 14:49:02 -05:00
"definitions" :-
let definition = flip definition [] in [
parseMatch definition "defω x : {a} × {b} = ('a, 'b);"
`(MkPDef (PQ Any _) "x"
(PConcrete
(Just (Sig (Unused _) (Enum ["a"] _) (Enum ["b"] _) _))
2023-11-05 14:49:02 -05:00
(Pair (Tag "a" _) (Tag "b" _) _)) _ _ _ _),
parseMatch definition "def# x : {a} ** {b} = ('a, 'b)"
`(MkPDef (PQ Any _) "x"
(PConcrete
(Just (Sig (Unused _) (Enum ["a"] _) (Enum ["b"] _) _))
2023-11-05 14:49:02 -05:00
(Pair (Tag "a" _) (Tag "b" _) _)) _ _ _ _),
parseMatch definition "def ω.x : {a} × {b} = ('a, 'b)"
`(MkPDef (PQ Any _) "x"
(PConcrete
(Just (Sig (Unused _) (Enum ["a"] _) (Enum ["b"] _) _))
2023-11-05 14:49:02 -05:00
(Pair (Tag "a" _) (Tag "b" _) _)) _ _ _ _),
parseMatch definition "def x : {a} × {b} = ('a, 'b)"
`(MkPDef (PQ Any _) "x"
(PConcrete
(Just (Sig (Unused _) (Enum ["a"] _) (Enum ["b"] _) _))
2023-11-05 14:49:02 -05:00
(Pair (Tag "a" _) (Tag "b" _) _)) _ _ _ _),
2023-05-21 14:09:34 -04:00
parseMatch definition "def0 A : ★⁰ = {a, b, c}"
`(MkPDef (PQ Zero _) "A"
2023-11-05 14:49:02 -05:00
(PConcrete (Just $ TYPE 0 _) (Enum ["a", "b", "c"] _)) _ _ _ _),
parseMatch definition "postulate yeah : "
2023-11-05 14:49:02 -05:00
`(MkPDef (PQ Any _) "yeah" (PPostulate (NAT _)) _ _ _ _),
parseMatch definition "postulateω yeah : "
2023-11-05 14:49:02 -05:00
`(MkPDef (PQ Any _) "yeah" (PPostulate (NAT _)) _ _ _ _),
parseMatch definition "postulate0 FileHandle : ★"
2023-11-05 14:49:02 -05:00
`(MkPDef (PQ Zero _) "FileHandle" (PPostulate (TYPE 0 _)) _ _ _ _),
parseFails definition "postulate not-a-postulate : = 69",
parseFails definition "postulate not-a-postulate = 69",
parseFails definition "def not-a-def : "
],
"top level" :- [
2023-05-21 14:09:34 -04:00
parseMatch input "def0 A : ★⁰ = {}; def0 B : ★¹ = A;"
2023-11-05 14:49:02 -05:00
`([PD $ PDef $ MkPDef (PQ Zero _) "A"
(PConcrete (Just $ TYPE 0 _) (Enum [] _)) PSucceed False Nothing _,
PD $ PDef $ MkPDef (PQ Zero _) "B"
(PConcrete (Just $ TYPE 1 _) (V "A" {})) PSucceed False Nothing _]),
2023-05-21 14:09:34 -04:00
parseMatch input "def0 A : ★⁰ = {} def0 B : ★¹ = A" $
2023-11-05 14:49:02 -05:00
`([PD $ PDef $ MkPDef (PQ Zero _) "A"
(PConcrete (Just $ TYPE 0 _) (Enum [] _)) PSucceed False Nothing _,
PD $ PDef $ MkPDef (PQ Zero _) "B"
(PConcrete (Just $ TYPE 1 _) (V "A" {})) PSucceed False Nothing _]),
note "empty input",
parsesAs input "" [],
parseFails input ";;;;;;;;;;;;;;;;;;;;;;;;;;",
parseMatch input "namespace a {}"
2023-11-05 14:49:02 -05:00
`([PD $ PNs $ MkPNamespace [< "a"] [] PSucceed _]),
parseMatch input "namespace a.b.c {}"
2023-11-05 14:49:02 -05:00
`([PD $ PNs $ MkPNamespace [< "a", "b", "c"] [] PSucceed _]),
parseMatch input "namespace a {namespace b {}}"
2023-11-05 14:49:02 -05:00
`([PD (PNs $ MkPNamespace [< "a"]
[PNs $ MkPNamespace [< "b"] [] PSucceed _] PSucceed _)]),
parseMatch input "namespace a {def x = 't ∷ {t}}"
2023-11-05 14:49:02 -05:00
`([PD (PNs $ MkPNamespace [< "a"]
[PDef $ MkPDef (PQ Any _) "x"
(PConcrete Nothing (Ann (Tag "t" _) (Enum ["t"] _) _))
PSucceed False Nothing _]
PSucceed _)]),
parseMatch input "namespace a {def x : {t} = 't} def y = a.x"
2023-11-05 14:49:02 -05:00
`([PD (PNs $ MkPNamespace [< "a"]
[PDef $ MkPDef (PQ Any _) "x"
(PConcrete (Just (Enum ["t"] _)) (Tag "t" _))
PSucceed False Nothing _]
PSucceed _),
PD (PDef $ MkPDef (PQ Any _) "y"
2024-04-11 16:08:07 -04:00
(PConcrete Nothing (V (MkPName [< "a"] "x") Nothing _))
2023-11-05 14:49:02 -05:00
PSucceed False Nothing _)]),
parseMatch input #" load "a.quox"; def b = a.b "#
`([PLoad "a.quox" _,
2023-11-05 14:49:02 -05:00
PD (PDef $ MkPDef (PQ Any _) "b"
2024-04-12 15:49:15 -04:00
(PConcrete Nothing (V (MkPName [< "a"] "b") Nothing _))
PSucceed False Nothing _)]),
parseMatch input #" #[main] postulate hi : String "#
`([PD (PDef $ MkPDef (PQ Any _) "hi"
(PPostulate (STRING _))
PSucceed True Nothing _)]),
parseMatch input #" #[compile-scheme "hi"] postulate hi : String "#
`([PD (PDef $ MkPDef (PQ Any _) "hi"
(PPostulate (STRING _))
PSucceed False (Just "hi") _)]),
parseMatch input #" #[main] #[compile-scheme "hi"] postulate hi : String "#
`([PD (PDef $ MkPDef (PQ Any _) "hi"
(PPostulate (STRING _))
PSucceed True (Just "hi") _)]),
parseMatch input #" #[fail] def hi = "hi!!!! uwu" "#
`([PD (PDef $ MkPDef (PQ Any _) "hi"
(PConcrete Nothing (Str "hi!!!! uwu" _))
PFailAny False Nothing _)]),
parseMatch input #" #[fail "type"] def hi = "hi!!!! uwu" "#
`([PD (PDef $ MkPDef (PQ Any _) "hi"
(PConcrete Nothing (Str "hi!!!! uwu" _))
(PFailMatch "type") False Nothing _)]),
parseMatch input #" #[fail] namespace ns { } "#
`([PD (PNs $ MkPNamespace [< "ns"] [] PFailAny _)]),
parseFails input #" #[fail 69] namespace ns { } "#,
parseFails input "#[main]",
parseFails input "#[main] namespace a { } ",
parseFails input #" #[not-an-attr] postulate hi : String "#,
parseFails input #" #[log pop] postulate hi : String "#,
parseMatch input #" #![log pop] "#
`([PD (PPrag (PLogPop _))]),
parseMatch input #" #![log (all, 5)] "#
`([PD (PPrag (PLogPush [SetAll (Element 5 _)] _))]),
parseMatch input #" #![log (default, 69)] "#
`([PD (PPrag (PLogPush [SetDefault (Element 69 _)] _))]),
parseMatch input #" #![log (whnf, 100)] "#
`([PD (PPrag (PLogPush [SetCat (Element "whnf" _) (Element 100 _)] _))]),
parseMatch input #" #![log (all, 5) (default, 69) (whnf, 100)] "#
`([PD (PPrag (PLogPush
[SetAll (Element 5 _), SetDefault (Element 69 _),
SetCat (Element "whnf" _) (Element 100 _)] _))]),
parseFails input #" #![log] "#,
parseFails input #" #![log (non-category, 5)] "#,
parseFails input #" #![log (whnf, 50000000)] "#,
parseFails input #" #![log [0.★⁵]] "#,
parseFails input #" #![main] "#
2023-03-04 15:02:51 -05:00
]
]