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

lib/Quox/Syntax/Subst.idr

@@ -8,8 +8,10 @@ import Quox.Pretty
 import Data.Nat
 import Data.List
 import Data.SnocVect
+import Derive.Prelude
 
 %default total
+%language ElabReflection
 
 
 public export
@@ -35,8 +37,9 @@ repr (Shift by) = ([], by.nat)
 repr (t ::: th) = let (ts, i) = repr th in (t::ts, i)
 
 
-export Eq  (f to) => Eq  (Subst f from to) where (==) = (==) `on` repr
-export Ord (f to) => Ord (Subst f from to) where compare = compare `on` repr
+export Eq   (f to) => Eq   (Subst f from to) where (==) = (==) `on` repr
+export Ord  (f to) => Ord  (Subst f from to) where compare = compare `on` repr
+export Show (f to) => Show (Subst f from to) where show = show . repr
 
 
 infixl 8 //
@@ -155,3 +158,30 @@ prettySubstM pr names bnd op cl th =
 export
 PrettyHL (f to) => PrettyHL (Subst f from to) where
   prettyM th = prettySubstM prettyM (!ask).tnames TVar "[" "]" th
+
+
+export
+eqShape : Subst env from1 to -> Subst env from2 to -> Maybe (from1 = from2)
+eqShape (Shift by) (Shift bz) = eqLen by bz
+eqShape (Shift by) (t ::: th) = Nothing
+eqShape (t ::: th) (Shift by) = Nothing
+eqShape (t ::: th) (x ::: ph) = cong S <$> eqShape th ph
+
+
+public export
+record WithSubst tm env n where
+  constructor Sub
+  term  : tm from
+  subst : Lazy (Subst env from n)
+
+export
+(forall n. Eq (tm n), Eq (env n)) => Eq (WithSubst tm env n) where
+  Sub t1 s1 == Sub t2 s2 =
+    case eqShape s1 s2 of
+      Just Refl => t1 == t2 && s1 == s2
+      Nothing   => False
+
+export %hint
+ShowWithSubst : (forall n. Show (tm n), Show (env n)) =>
+                Show (WithSubst tm env n)
+ShowWithSubst = deriveShow