remove inject stuff

injecting from m to (n+m) is just id ::: id ::: ... ::: shift n.
specifically, injecting from 0 is just the shift. so.

lib/Quox/Typing/Context.idr

@@ -3,6 +3,7 @@ module Quox.Typing.Context
 import Quox.Syntax
 import Quox.Context
 import Quox.Pretty
+import public Data.Singleton
 
 %default total
 
@@ -27,6 +28,8 @@ DimAssign = Context' DimConst
 public export
 record TyContext q d n where
   constructor MkTyContext
+  {auto dimLen  : Singleton d}
+  {auto termLen : Singleton n}
   dctx   : DimEq d
   dnames : NContext d
   tctx   : TContext q d n
@@ -39,6 +42,7 @@ public export
 record EqContext q n where
   constructor MkEqContext
   {dimLen : Nat}
+  {auto termLen : Singleton n}
   dassign : DimAssign dimLen -- only used for printing
   dnames  : NContext dimLen -- only used for printing
   tctx    : TContext q 0 n
@@ -56,6 +60,11 @@ namespace TContext
   zeroFor : IsQty q => Context tm n -> QOutput q n
   zeroFor ctx = zero <$ ctx
 
+private
+extendLen : Telescope a from to -> Singleton from -> Singleton to
+extendLen [<]        x = x
+extendLen (tel :< _) x = [|S $ extendLen tel x|]
+
 namespace TyContext
   public export %inline
   empty : TyContext q 0 0
@@ -65,9 +74,15 @@ namespace TyContext
   export %inline
   extendTyN : Telescope (\n => (q, BaseName, Term q d n)) from to ->
               TyContext q d from -> TyContext q d to
-  extendTyN xss ctx =
+  extendTyN xss (MkTyContext {termLen, dctx, dnames, tctx, tnames, qtys}) =
     let (qs, xs, ss) = unzip3 xss in
-    {qtys $= (. qs), tctx $= (. ss), tnames $= (. xs)} ctx
+    MkTyContext {
+      dctx, dnames,
+      termLen = extendLen xss termLen,
+      tctx    = tctx . ss,
+      tnames  = tnames . xs,
+      qtys    = qtys . qs
+    }
 
   export %inline
   extendTy : q -> BaseName -> Term q d n -> TyContext q d n ->
@@ -76,11 +91,28 @@ namespace TyContext
 
   export %inline
   extendDim : BaseName -> TyContext q d n -> TyContext q (S d) n
-  extendDim x = {dctx $= (:<? Nothing), dnames $= (:< x), tctx $= pushD}
+  extendDim x (MkTyContext {dimLen, dctx, dnames, tctx, tnames, qtys}) =
+    MkTyContext {
+      dctx   = dctx :<? Nothing,
+      dnames = dnames :< x,
+      dimLen = [|S dimLen|],
+      tctx   = pushD tctx,
+      tnames, qtys
+    }
 
   export %inline
   eqDim : Dim d -> Dim d -> TyContext q d n -> TyContext q d n
-  eqDim p q = {dctx $= set p q}
+  eqDim p q = {dctx $= set p q, dimLen $= id, termLen $= id}
+
+  export
+  injectT : TyContext q d n -> Term q 0 0 -> Term q d n
+  injectT (MkTyContext {dimLen = Val d, termLen = Val n, _}) tm =
+    tm // shift0 d // shift0 n
+
+  export
+  injectE : TyContext q d n -> Elim q 0 0 -> Elim q d n
+  injectE (MkTyContext {dimLen = Val d, termLen = Val n, _}) el =
+    el // shift0 d // shift0 n
 
 
 namespace QOutput
@@ -106,6 +138,7 @@ makeDAssign (K e ::: th) = makeDAssign th :< e
 export
 makeEqContext' : {d : Nat} -> TyContext q d n -> DSubst d 0 -> EqContext q n
 makeEqContext' ctx th = MkEqContext {
+  termLen = ctx.termLen,
   dassign = makeDAssign th,
   dnames  = ctx.dnames,
   tctx    = map (// th) ctx.tctx,
@@ -128,9 +161,15 @@ namespace EqContext
   export %inline
   extendTyN : Telescope (\n => (q, BaseName, Term q 0 n)) from to ->
               EqContext q from -> EqContext q to
-  extendTyN tel ctx =
-    let (qs, xs, ss) = unzip3 tel in
-    {qtys $= (. qs), tctx $= (. ss), tnames $= (. xs)} ctx
+  extendTyN xss (MkEqContext {termLen, dassign, dnames, tctx, tnames, qtys}) =
+    let (qs, xs, ss) = unzip3 xss in
+    MkEqContext {
+      termLen = extendLen xss termLen,
+      tctx    = tctx . ss,
+      tnames  = tnames . xs,
+      qtys    = qtys . qs,
+      dassign, dnames
+    }
 
   export %inline
   extendTy : q -> BaseName -> Term q 0 n -> EqContext q n -> EqContext q (S n)
@@ -138,7 +177,9 @@ namespace EqContext
 
   export %inline
   extendDim : BaseName -> DimConst -> EqContext q n -> EqContext q n
-  extendDim x e ctx = {dassign $= (:< e), dnames $= (:< x)} ctx
+  extendDim x e (MkEqContext {dassign, dnames, tctx, tnames, qtys}) =
+    MkEqContext {dassign = dassign :< e, dnames = dnames :< x,
+                 tctx, tnames, qtys}
 
   export
   toTyContext : (e : EqContext q n) -> TyContext q e.dimLen n
@@ -149,6 +190,14 @@ namespace EqContext
       dnames, tnames, qtys
     }
 
+  export
+  injectT : EqContext q n -> Term q 0 0 -> Term q 0 n
+  injectT (MkEqContext {termLen = Val n, _}) tm = tm // shift0 n
+
+  export
+  injectE : EqContext q n -> Elim q 0 0 -> Elim q 0 n
+  injectE (MkEqContext {termLen = Val n, _}) el = el // shift0 n
+
 
 parameters {auto _ : (Eq q, PrettyHL q, IsQty q)} (unicode : Bool)
   private