refactor core syntax slightly to derive Eq/Show
add a new `WithSubst tm env to` record that packages a `tm from` with a `Subst env from to`, and write instances for just that. the rest of the AST can be derived
This commit is contained in:
parent
7e079a9668
commit
30fa93ab4e
13 changed files with 184 additions and 269 deletions
|
|
@ -237,27 +237,27 @@ tests = "equality & subtyping" :- [
|
|||
testEq "[#0]{} = [#0] : A" $
|
||||
equalT (extendTy Any "x" (FT "A") empty)
|
||||
(FT "A")
|
||||
(CloT (BVT 0) id)
|
||||
(CloT (Sub (BVT 0) id))
|
||||
(BVT 0),
|
||||
testEq "[#0]{a} = [a] : A" $
|
||||
equalT empty (FT "A")
|
||||
(CloT (BVT 0) (F "a" ::: id))
|
||||
(CloT (Sub (BVT 0) (F "a" ::: id)))
|
||||
(FT "a"),
|
||||
testEq "[#0]{a,b} = [a] : A" $
|
||||
equalT empty (FT "A")
|
||||
(CloT (BVT 0) (F "a" ::: F "b" ::: id))
|
||||
(CloT (Sub (BVT 0) (F "a" ::: F "b" ::: id)))
|
||||
(FT "a"),
|
||||
testEq "[#1]{a,b} = [b] : A" $
|
||||
equalT empty (FT "A")
|
||||
(CloT (BVT 1) (F "a" ::: F "b" ::: id))
|
||||
(CloT (Sub (BVT 1) (F "a" ::: F "b" ::: id)))
|
||||
(FT "b"),
|
||||
testEq "(λy ⇒ [#1]){a} = λy ⇒ [a] : B ⇾ A (N)" $
|
||||
equalT empty (Arr Zero (FT "B") (FT "A"))
|
||||
(CloT (Lam $ S [< "y"] $ N $ BVT 0) (F "a" ::: id))
|
||||
(CloT (Sub (Lam $ S [< "y"] $ N $ BVT 0) (F "a" ::: id)))
|
||||
(Lam $ S [< "y"] $ N $ FT "a"),
|
||||
testEq "(λy ⇒ [#1]){a} = λy ⇒ [a] : B ⇾ A (Y)" $
|
||||
equalT empty (Arr Zero (FT "B") (FT "A"))
|
||||
(CloT ([< "y"] :\\ BVT 1) (F "a" ::: id))
|
||||
(CloT (Sub ([< "y"] :\\ BVT 1) (F "a" ::: id)))
|
||||
([< "y"] :\\ FT "a")
|
||||
],
|
||||
|
||||
|
|
@ -265,12 +265,12 @@ tests = "equality & subtyping" :- [
|
|||
testEq "★₀‹𝟎› = ★₀ : ★₁" $
|
||||
equalTD 1
|
||||
(extendDim "𝑗" empty)
|
||||
(TYPE 1) (DCloT (TYPE 0) (K Zero ::: id)) (TYPE 0),
|
||||
(TYPE 1) (DCloT (Sub (TYPE 0) (K Zero ::: id))) (TYPE 0),
|
||||
testEq "(δ i ⇒ a)‹𝟎› = (δ i ⇒ a) : (a ≡ a : A)" $
|
||||
equalTD 1
|
||||
(extendDim "𝑗" empty)
|
||||
(Eq0 (FT "A") (FT "a") (FT "a"))
|
||||
(DCloT ([< "i"] :\\% FT "a") (K Zero ::: id))
|
||||
(DCloT (Sub ([< "i"] :\\% FT "a") (K Zero ::: id)))
|
||||
([< "i"] :\\% FT "a"),
|
||||
note "it is hard to think of well-typed terms with big dctxs"
|
||||
],
|
||||
|
|
@ -504,10 +504,10 @@ tests = "equality & subtyping" :- [
|
|||
|
||||
"elim closure" :- [
|
||||
testEq "#0{a} = a" $
|
||||
equalE empty (CloE (BV 0) (F "a" ::: id)) (F "a"),
|
||||
equalE empty (CloE (Sub (BV 0) (F "a" ::: id))) (F "a"),
|
||||
testEq "#1{a} = #0" $
|
||||
equalE (extendTy Any "x" (FT "A") empty)
|
||||
(CloE (BV 1) (F "a" ::: id)) (BV 0)
|
||||
(CloE (Sub (BV 1) (F "a" ::: id))) (BV 0)
|
||||
],
|
||||
|
||||
"elim d-closure" :- [
|
||||
|
|
@ -515,41 +515,42 @@ tests = "equality & subtyping" :- [
|
|||
testEq "(eq-AB #0)‹𝟎› = eq-AB 𝟎" $
|
||||
equalED 1
|
||||
(extendDim "𝑖" empty)
|
||||
(DCloE (F "eq-AB" :% BV 0) (K Zero ::: id))
|
||||
(DCloE (Sub (F "eq-AB" :% BV 0) (K Zero ::: id)))
|
||||
(F "eq-AB" :% K Zero),
|
||||
testEq "(eq-AB #0)‹𝟎› = A" $
|
||||
equalED 1
|
||||
(extendDim "𝑖" empty)
|
||||
(DCloE (F "eq-AB" :% BV 0) (K Zero ::: id)) (F "A"),
|
||||
(DCloE (Sub (F "eq-AB" :% BV 0) (K Zero ::: id))) (F "A"),
|
||||
testEq "(eq-AB #0)‹𝟏› = B" $
|
||||
equalED 1
|
||||
(extendDim "𝑖" empty)
|
||||
(DCloE (F "eq-AB" :% BV 0) (K One ::: id)) (F "B"),
|
||||
(DCloE (Sub (F "eq-AB" :% BV 0) (K One ::: id))) (F "B"),
|
||||
testNeq "(eq-AB #0)‹𝟏› ≠ A" $
|
||||
equalED 1
|
||||
(extendDim "𝑖" empty)
|
||||
(DCloE (F "eq-AB" :% BV 0) (K One ::: id)) (F "A"),
|
||||
(DCloE (Sub (F "eq-AB" :% BV 0) (K One ::: id))) (F "A"),
|
||||
testEq "(eq-AB #0)‹#0,𝟎› = (eq-AB #0)" $
|
||||
equalED 2
|
||||
(extendDim "𝑗" $ extendDim "𝑖" empty)
|
||||
(DCloE (F "eq-AB" :% BV 0) (BV 0 ::: K Zero ::: id))
|
||||
(DCloE (Sub (F "eq-AB" :% BV 0) (BV 0 ::: K Zero ::: id)))
|
||||
(F "eq-AB" :% BV 0),
|
||||
testNeq "(eq-AB #0)‹𝟎› ≠ (eq-AB 𝟎)" $
|
||||
equalED 2
|
||||
(extendDim "𝑗" $ extendDim "𝑖" empty)
|
||||
(DCloE (F "eq-AB" :% BV 0) (BV 0 ::: K Zero ::: id))
|
||||
(DCloE (Sub (F "eq-AB" :% BV 0) (BV 0 ::: K Zero ::: id)))
|
||||
(F "eq-AB" :% K Zero),
|
||||
testEq "#0‹𝟎› = #0 # term and dim vars distinct" $
|
||||
equalED 1
|
||||
(extendTy Any "x" (FT "A") $ extendDim "𝑖" empty)
|
||||
(DCloE (BV 0) (K Zero ::: id)) (BV 0),
|
||||
(DCloE (Sub (BV 0) (K Zero ::: id))) (BV 0),
|
||||
testEq "a‹𝟎› = a" $
|
||||
equalED 1 (extendDim "𝑖" empty) (DCloE (F "a") (K Zero ::: id)) (F "a"),
|
||||
equalED 1 (extendDim "𝑖" empty)
|
||||
(DCloE (Sub (F "a") (K Zero ::: id))) (F "a"),
|
||||
testEq "(f [a])‹𝟎› = f‹𝟎› [a]‹𝟎›" $
|
||||
let th = K Zero ::: id in
|
||||
equalED 1 (extendDim "𝑖" empty)
|
||||
(DCloE (F "f" :@ FT "a") th)
|
||||
(DCloE (F "f") th :@ DCloT (FT "a") th)
|
||||
(DCloE (Sub (F "f" :@ FT "a") th))
|
||||
(DCloE (Sub (F "f") th) :@ DCloT (Sub (FT "a") th))
|
||||
],
|
||||
|
||||
"clashes" :- [
|
||||
|
|
|
|||
|
|
@ -2,7 +2,6 @@ module Tests.FromPTerm
|
|||
|
||||
import Quox.Parser.FromParser
|
||||
import Quox.Parser
|
||||
import TermImpls
|
||||
import TypingImpls
|
||||
import Tests.Parser as TParser
|
||||
import TAP
|
||||
|
|
|
|||
|
|
@ -2,7 +2,6 @@ module Tests.Reduce
|
|||
|
||||
import Quox.Syntax as Lib
|
||||
import Quox.Equal
|
||||
import TermImpls
|
||||
import TypingImpls
|
||||
import TAP
|
||||
|
||||
|
|
@ -67,34 +66,34 @@ tests = "whnf" :- [
|
|||
|
||||
"elim closure" :- [
|
||||
testWhnf "x{}" (ctx [< ("A", Nat)])
|
||||
(CloE (BV 0) id)
|
||||
(CloE (Sub (BV 0) id))
|
||||
(BV 0),
|
||||
testWhnf "x{a/x}" empty
|
||||
(CloE (BV 0) (F "a" ::: id))
|
||||
(CloE (Sub (BV 0) (F "a" ::: id)))
|
||||
(F "a"),
|
||||
testWhnf "x{x/x,a/y}" (ctx [< ("A", Nat)])
|
||||
(CloE (BV 0) (BV 0 ::: F "a" ::: id))
|
||||
(CloE (Sub (BV 0) (BV 0 ::: F "a" ::: id)))
|
||||
(BV 0),
|
||||
testWhnf "x{(y{a/y})/x}" empty
|
||||
(CloE (BV 0) ((CloE (BV 0) (F "a" ::: id)) ::: id))
|
||||
(CloE (Sub (BV 0) ((CloE (Sub (BV 0) (F "a" ::: id))) ::: id)))
|
||||
(F "a"),
|
||||
testWhnf "(x y){f/x,a/y}" empty
|
||||
(CloE (BV 0 :@ BVT 1) (F "f" ::: F "a" ::: id))
|
||||
(CloE (Sub (BV 0 :@ BVT 1) (F "f" ::: F "a" ::: id)))
|
||||
(F "f" :@ FT "a"),
|
||||
testWhnf "([y] ∷ [x]){A/x}" (ctx [< ("A", Nat)])
|
||||
(CloE (BVT 1 :# BVT 0) (F "A" ::: id))
|
||||
(CloE (Sub (BVT 1 :# BVT 0) (F "A" ::: id)))
|
||||
(BV 0),
|
||||
testWhnf "([y] ∷ [x]){A/x,a/y}" empty
|
||||
(CloE (BVT 1 :# BVT 0) (F "A" ::: F "a" ::: id))
|
||||
(CloE (Sub (BVT 1 :# BVT 0) (F "A" ::: F "a" ::: id)))
|
||||
(F "a")
|
||||
],
|
||||
|
||||
"term closure" :- [
|
||||
testWhnf "(λy. x){a/x}" empty
|
||||
(CloT (Lam $ S [< "y"] $ N $ BVT 0) (F "a" ::: id))
|
||||
(CloT (Sub (Lam $ S [< "y"] $ N $ BVT 0) (F "a" ::: id)))
|
||||
(Lam $ S [< "y"] $ N $ FT "a"),
|
||||
testWhnf "(λy. y){a/x}" empty
|
||||
(CloT ([< "y"] :\\ BVT 0) (F "a" ::: id))
|
||||
(CloT (Sub ([< "y"] :\\ BVT 0) (F "a" ::: id)))
|
||||
([< "y"] :\\ BVT 0)
|
||||
],
|
||||
|
||||
|
|
@ -112,8 +111,8 @@ tests = "whnf" :- [
|
|||
F "a" :@
|
||||
E ((([< "x"] :\\ BVT 0) :# Arr One (FT "A") (FT "A")) :@ FT "a"),
|
||||
testNoStep "λx. [y [x]]{x/x,a/y}" (ctx [< ("A", Nat)]) $
|
||||
[< "x"] :\\ CloT (E $ BV 1 :@ BVT 0) (BV 0 ::: F "a" ::: id),
|
||||
[< "x"] :\\ CloT (Sub (E $ BV 1 :@ BVT 0) (BV 0 ::: F "a" ::: id)),
|
||||
testNoStep "f ([y [x]]{x/x,a/y})" (ctx [< ("A", Nat)]) $
|
||||
F "f" :@ CloT (E $ BV 1 :@ BVT 0) (BV 0 ::: F "a" ::: id)
|
||||
F "f" :@ CloT (Sub (E $ BV 1 :@ BVT 0) (BV 0 ::: F "a" ::: id))
|
||||
]
|
||||
]
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue