rhi/quox
rhi/quox
1
0
Fork 0
Code Issues 15 Pull requests 1 Releases Wiki Activity

"1.(x: A) → B" instead of "(1.x: A) → B"

Browse source 
also "1.A → B"
This commit is contained in:
rhiannon morris 2023-03-18 23:27:27 +01:00
parent ebf6aefb1d
commit 8f0f0c1891
10 changed files with 101 additions and 110 deletions
Download patch file Download diff file Expand all files Collapse all files

18
tests/Tests/Parser.idr
View file

@ -140,21 +140,25 @@ tests = "parser" :- [
],
"binders" :- [
parsesAs term "(1.x : A) → B x" $
parsesAs term "1.(x : A) → B x" $
Pi One (Just "x") (V "A") (V "B" :@ V "x"),
parsesAs term "(1.x : A) -> B x" $
parsesAs term "1.(x : A) -> B x" $
Pi One (Just "x") (V "A") (V "B" :@ V "x"),
parsesAs term "(ω.x : A) → B x" $
parsesAs term "ω.(x : A) → B x" $
Pi Any (Just "x") (V "A") (V "B" :@ V "x"),
parsesAs term "(#.x : A) -> B x" $
parsesAs term "#.(x : A) -> B x" $
Pi Any (Just "x") (V "A") (V "B" :@ V "x"),
parseFails term "(x : A) → B x",
parseFails term "(1 ω.x : A) → B x",
parsesAs term "1.A → B"
(Pi One Nothing (V "A") (V "B")),
parsesAs term "1.(List A) → List B"
(Pi One Nothing (V "List" :@ V "A") (V "List" :@ V "B")),
parseFails term "1.List A → List B",
parsesAs term "(x : A) × B x" $
Sig (Just "x") (V "A") (V "B" :@ V "x"),
parsesAs term "(x : A) ** B x" $
Sig (Just "x") (V "A") (V "B" :@ V "x"),
parseFails term "(1.x : A) × B x",
parseFails term "1.(x : A) × B x",
parsesAs term "A × B" $
Sig Nothing (V "A") (V "B"),
parsesAs term "A ** B" $
@ -185,7 +189,7 @@ tests = "parser" :- [
Pair (Pair (V "x") (V "y")) (V "z"),
parsesAs term "(f x, g @y)" $
Pair (V "f" :@ V "x") (V "g" :% V "y"),
parsesAs term "((x : A) × B, (0.x : C) → D)" $
parsesAs term "((x : A) × B, 0.(x : C) → D)" $
Pair (Sig (Just "x") (V "A") (V "B"))
(Pi Zero (Just "x") (V "C") (V "D")),
parsesAs term "(λ x ⇒ x, δ i ⇒ e @i)" $

33
tests/Tests/PrettyTerm.idr
View file

@ -93,17 +93,17 @@ tests = "pretty printing terms" :- [
testPrettyT [<] [<] (Arr One (FT "A") (FT "B")) "A ⊸ B" "A -o B",
testPrettyT [<] [<]
(Pi_ One "x" (FT "A") (E $ F "B" :@ BVT 0))
"(1.x : A) → B x"
"(1.x : A) -> B x",
"1.(x : A) → B x"
"1.(x : A) -> B x",
testPrettyT [<] [<]
(Pi_ Zero "A" (TYPE 0) $ Arr Any (BVT 0) (BVT 0))
"(0.A : ★₀) → (ω._ : A) → A"
"(0.A : Type0) -> (#._ : A) -> A",
"0.(A : ★₀) → ω.(_ : A) → A"
"0.(A : Type0) -> #.(_ : A) -> A",
todo #"print (and parse) the below as "(A ↠ A) ↠ A""#,
testPrettyT [<] [<]
(Arr Any (Arr Any (FT "A") (FT "A")) (FT "A"))
"(ω._ : (ω._ : A) → A) → A"
"(#._ : (#._ : A) -> A) -> A",
"ω.(_ : ω.(_ : A) → A) → A"
"#.(_ : #.(_ : A) -> A) -> A",
todo "non-dependent, left and right nested"
],
@ -128,8 +128,8 @@ tests = "pretty printing terms" :- [
testPrettyT1 [<] [<] (Pair (Pair (FT "A") (FT "B")) (FT "C")) "((A, B), C)",
testPrettyT [<] [<]
(Pair ([< "x"] :\\ BVT 0) (Arr One (FT "B₁") (FT "B₂")))
"(λ x ⇒ x, (1._ : B₁) → B₂)"
"(fun x => x, (1._ : B₁) -> B₂)"
"(λ x ⇒ x, 1.(_ : B₁) → B₂)"
"(fun x => x, 1.(_ : B₁) -> B₂)"
],
"enum types" :- [
@ -152,20 +152,19 @@ tests = "pretty printing terms" :- [
todo "equality types",
"case" :- [
note "todo: print using case1 and caseω???",
testPrettyE [<] [<]
(CasePair One (F "a") (SN $ TYPE 1) (SN $ TYPE 0))
"case 1.a return _ ⇒ ★₁ of { (_, _) ⇒ ★₀ }"
"case 1.a return _ => Type1 of { (_, _) => Type0 }",
"case1 a return _ ⇒ ★₁ of { (_, _) ⇒ ★₀ }"
"case1 a return _ => Type1 of { (_, _) => Type0 }",
testPrettyT [<] [<]
([< "u"] :\\
E (CaseEnum One (F "u")
(SY [< "x"] $ Eq0 (enum ["tt"]) (BVT 0) (Tag "tt"))
(fromList [("tt", [< Unused] :\\% Tag "tt")])))
"λ u ⇒ case 1.u return x ⇒ x ≡ 'tt : {tt} of { 'tt ⇒ δ _ ⇒ 'tt }"
"λ u ⇒ case1 u return x ⇒ x ≡ 'tt : {tt} of { 'tt ⇒ δ _ ⇒ 'tt }"
"""
fun u =>
case 1.u return x => x == 'tt : {tt} of { 'tt => dfun _ => 'tt }
case1 u return x => x == 'tt : {tt} of { 'tt => dfun _ => 'tt }
"""
],
@ -181,11 +180,11 @@ tests = "pretty printing terms" :- [
"(α :: a) :: A",
testPrettyE [<] [<]
(([< "x"] :\\ BVT 0) :# Arr One (FT "A") (FT "A"))
"(λ x ⇒ x) ∷ (1._ : A) → A"
"(fun x => x) :: (1._ : A) -> A",
"(λ x ⇒ x) ∷ 1.(_ : A) → A"
"(fun x => x) :: 1.(_ : A) -> A",
testPrettyE [<] [<]
(Arr One (FT "A") (FT "A") :# TYPE 7)
"((1._ : A) → A) ∷ ★₇"
"((1._ : A) -> A) :: Type7"
"(1.(_ : A) → A) ∷ ★₇"
"(1.(_ : A) -> A) :: Type7"
]
]