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/Syntax/Term/Subst.idr

@@ -299,77 +299,3 @@ mutual
       pushSubstsWith th (comp th ps ph) e
     pushSubstsWith th ph (DCloE e ps) =
       pushSubstsWith (ps . th) ph e
-
-
-parameters {0 d', n' : Nat}
- mutual
-  namespace Term
-    export
-    inject : Term q d n -> Term q (d + d') (n + n')
-    inject (TYPE l) = TYPE l
-    inject (Pi qty arg res) = Pi qty (inject arg) (inject res)
-    inject (Lam body) = Lam (inject body)
-    inject (Sig fst snd) = Sig (inject fst) (inject snd)
-    inject (Pair fst snd) = Pair (inject fst) (inject snd)
-    inject (Enum cases) = Enum cases
-    inject (Tag tag) = Tag tag
-    inject (Eq ty l r) = Eq (inject ty) (inject l) (inject r)
-    inject (DLam body) = DLam (inject body)
-    inject (E e) = E (inject e)
-    inject (CloT tm th) = CloT (inject tm) (inject th)
-    inject (DCloT tm th) = DCloT (inject tm) (inject th)
-
-  namespace Elim
-    export
-    inject : Elim q d n -> Elim q (d + d') (n + n')
-    inject (F x) = F x
-    inject (B i) = B $ inject i
-    inject (fun :@ arg) = (inject fun) :@ (inject arg)
-    inject (CasePair qty pair ret body) =
-      CasePair qty (inject pair) (inject ret) (inject body)
-    inject (CaseEnum qty tag ret arms) =
-      CaseEnum qty (inject tag) (inject ret)
-        (assert_total $ map inject arms)
-    inject (fun :% arg) = (inject fun) :% (inject arg)
-    inject (tm :# ty) = (inject tm) :# (inject ty)
-    inject (CloE el th) = CloE (inject el) (inject th)
-    inject (DCloE el th) = DCloE (inject el) (inject th)
-
-  namespace ScopeTerm
-    export
-    inject : ScopeTermN s q d n -> ScopeTermN s q (d + d') (n + n')
-    inject (S names (N body)) = S names (N (inject body))
-    inject (S names (Y body)) {s, n} =
-      S names $ Y $ rewrite plusAssociative s n n' in inject body
-
-  namespace DScopeTerm
-    export
-    inject : DScopeTermN s q d n -> DScopeTermN s q (d + d') (n + n')
-    inject (S names (N body)) = S names (N (inject body))
-    inject (S names (Y body)) {s, d} =
-      S names $ Y $ rewrite plusAssociative s d d' in inject body
-
-  namespace TSubst
-    export
-    inject : TSubst q d from to -> TSubst q (d + d') (from + n') (to + n')
-    inject (Shift by) = Shift $ inject by
-    inject (t ::: th) = inject t ::: inject th
-
-  namespace DSubst
-    export
-    inject : DSubst from to -> DSubst (from + d') (to + d')
-    inject (Shift by) = Shift $ inject by
-    inject (p ::: th) = inject p ::: inject th
-
-
--- [fixme]
--- Error: Linearity checking failed on metavar Quox.Syntax.Term.Subst.{b:7362}
--- (Int not a function type)
-{-
-%transform "Term.inject" Term.inject t = believe_me t
-%transform "Elim.inject" Elim.inject e = believe_me e
-%transform "ScopeTerm.inject" ScopeTerm.inject t = believe_me t
-%transform "DScopeTerm.inject" DScopeTerm.inject t = believe_me t
-%transform "TSubst.inject" TSubst.inject th = believe_me th
-%transform "DSubst.inject" DSubst.inject th = believe_me th
--}