squash warnings

lib/Quox/Syntax/Term/Pretty.idr

@@ -58,11 +58,12 @@ pbname (_, x, _) = x
 private
 record SplitPi d n where
   constructor MkSplitPi
+  {0 inner : Nat}
   binds : Telescope (PiBind d) n inner
   cod   : Term d inner
 
 private
-splitPi : Telescope (PiBind d) n inner -> Term d inner -> SplitPi d n
+splitPi : Telescope (PiBind d) n n' -> Term d n' -> SplitPi d n
 splitPi binds (Pi qty arg res _) =
   splitPi (binds :< (qty, res.name, arg)) $
     assert_smaller res $ pushSubsts' res.term
@@ -87,7 +88,7 @@ prettyPiBind1 pi x dnames tnames s = hcat <$> sequence
 private
 prettyPiBinds : {opts : _} ->
                 BContext d -> BContext n ->
-                Telescope (PiBind d) n inner ->
+                Telescope (PiBind d) n n' ->
                 Eff Pretty (SnocList (Doc opts))
 prettyPiBinds _ _ [<] = pure [<]
 prettyPiBinds dnames tnames (binds :< (q, x, t)) =
@@ -103,11 +104,12 @@ SigBind d n = (BindName, Term d n)
 private
 record SplitSig d n where
   constructor MkSplitSig
+  {0 inner : Nat}
   binds : Telescope (SigBind d) n inner
   last  : Term d inner
 
 private
-splitSig : Telescope (SigBind d) n inner -> Term d inner -> SplitSig d n
+splitSig : Telescope (SigBind d) n n' -> Term d n' -> SplitSig d n
 splitSig binds (Sig fst snd _) =
   splitSig (binds :< (snd.name, fst)) $
     assert_smaller snd $ pushSubsts' snd.term
@@ -129,7 +131,7 @@ prettySigBind1 x dnames tnames s = hcat <$> sequence
 private
 prettySigBinds : {opts : _} ->
                  BContext d -> BContext n ->
-                 Telescope (SigBind d) n inner ->
+                 Telescope (SigBind d) n n' ->
                  Eff Pretty (SnocList (Doc opts))
 prettySigBinds _ _ [<] = pure [<]
 prettySigBinds dnames tnames (binds :< (x, t)) =
@@ -163,6 +165,7 @@ NameChunks = SnocList (NameSort, SnocList BindName)
 private
 record SplitLams d n where
   constructor MkSplitLams
+  {0 dinner, ninner : Nat}
   dnames : BTelescope d dinner
   tnames : BTelescope n ninner
   chunks : NameChunks
@@ -178,9 +181,9 @@ where
     if s == s' then xss :< (s', xs :< y)
     else xss :< (s', xs) :< (s, [< y])
 
-  go : BTelescope d dinner -> BTelescope n ninner ->
+  go : BTelescope d d' -> BTelescope n n' ->
        SnocList (NameSort, SnocList BindName) ->
-       Term dinner ninner -> SplitLams d n
+       Term d' n' -> SplitLams d n
   go dnames tnames chunks (Lam b _) =
     go dnames (tnames :< b.name) (push T b.name chunks) $
        assert_smaller b $ pushSubsts' b.term
@@ -235,6 +238,7 @@ prettyDTApps dnames tnames f xs = do
 private
 record CaseArm opts d n where
   constructor MkCaseArm
+  {0 dinner, ninner : Nat}
   pat    : Doc opts
   dbinds : BTelescope d dinner -- 🍴
   tbinds : BTelescope n ninner

lib/Quox/Syntax/Term/Subst.idr

@@ -10,7 +10,7 @@ import Data.SnocVect
 namespace CanDSubst
   public export
   interface CanDSubst (0 tm : TermLike) where
-    (//) : tm dfrom n -> Lazy (DSubst dfrom dto) -> tm dto n
+    (//) : tm d1 n -> Lazy (DSubst d1 d2) -> tm d2 n
 
 ||| does the minimal reasonable work:
 ||| - deletes the closure around an atomic constant like `TYPE`
@@ -25,7 +25,7 @@ CanDSubst Term where
   s                // th       = DCloT $ Sub s th
 
 private
-subDArgs : Elim dfrom n -> DSubst dfrom dto -> Elim dto n
+subDArgs : Elim d1 n -> DSubst d1 d2 -> Elim d2 n
 subDArgs (DApp f d loc) th = DApp (subDArgs f th) (d // th) loc
 subDArgs e              th = DCloE $ Sub e th
 
@@ -47,16 +47,16 @@ CanDSubst Elim where
 
 namespace DSubst.ScopeTermN
   export %inline
-  (//) : ScopeTermN s dfrom n -> Lazy (DSubst dfrom dto) ->
-         ScopeTermN s dto n
+  (//) : ScopeTermN s d1 n -> Lazy (DSubst d1 d2) ->
+         ScopeTermN s d2 n
   S ns (Y body) // th = S ns $ Y $ body // th
   S ns (N body) // th = S ns $ N $ body // th
 
 namespace DSubst.DScopeTermN
   export %inline
   (//) : {s : Nat} ->
-         DScopeTermN s dfrom n -> Lazy (DSubst dfrom dto) ->
-         DScopeTermN s dto n
+         DScopeTermN s d1 n -> Lazy (DSubst d1 d2) ->
+         DScopeTermN s d2 n
   S ns (Y body) // th = S ns $ Y $ body // pushN s th
   S ns (N body) // th = S ns $ N $ body // th
 
@@ -83,7 +83,7 @@ CanSubstSelf (Elim d) where
 namespace CanTSubst
   public export
   interface CanTSubst (0 tm : TermLike) where
-    (//) : tm d from -> Lazy (TSubst d from to) -> tm d to
+    (//) : tm d n1 -> Lazy (TSubst d n1 n2) -> tm d n2
 
 ||| does the minimal reasonable work:
 ||| - deletes the closure around an atomic constant like `TYPE`
@@ -103,16 +103,15 @@ CanTSubst Term where
 namespace ScopeTermN
   export %inline
   (//) : {s : Nat} ->
-         ScopeTermN s d from -> Lazy (TSubst d from to) ->
-         ScopeTermN s d to
+         ScopeTermN s d n1 -> Lazy (TSubst d n1 n2) ->
+         ScopeTermN s d n2
   S ns (Y body) // th = S ns $ Y $ body // pushN s th
   S ns (N body) // th = S ns $ N $ body // th
 
 namespace DScopeTermN
   export %inline
   (//) : {s : Nat} ->
-         DScopeTermN s d from -> Lazy (TSubst d from to) ->
-         DScopeTermN s d to
+         DScopeTermN s d n1 -> Lazy (TSubst d n1 n2) -> DScopeTermN s d n2
   S ns (Y body) // th = S ns $ Y $ body // map (// shift s) th
   S ns (N body) // th = S ns $ N $ body // th
 
@@ -125,8 +124,7 @@ export %inline
 
 
 export %inline
-comp : DSubst dfrom dto -> TSubst dfrom from mid -> TSubst dto mid to ->
-       TSubst dto from to
+comp : DSubst d1 d2 -> TSubst d1 n1 mid -> TSubst d2 mid n2 -> TSubst d2 n1 n2
 comp th ps ph = map (// th) ps . ph
 
 
@@ -205,8 +203,8 @@ public export
 CloTest tm = forall d, n. tm d n -> Bool
 
 interface PushSubsts (0 tm : TermLike) (0 isClo : CloTest tm) | tm where
-  pushSubstsWith : DSubst dfrom dto -> TSubst dto from to ->
-                   tm dfrom from -> Subset (tm dto to) (No . isClo)
+  pushSubstsWith : DSubst d1 d2 -> TSubst d2 n1 n2 ->
+                   tm d1 n1 -> Subset (tm d2 n2) (No . isClo)
 
 public export
 0 NotClo : {isClo : CloTest tm} -> PushSubsts tm isClo => Pred (tm d n)
@@ -230,8 +228,7 @@ parameters {0 isClo : CloTest tm} {auto _ : PushSubsts tm isClo}
   pushSubsts s = pushSubstsWith id id s
 
   export %inline
-  pushSubstsWith' : DSubst dfrom dto -> TSubst dto from to ->
-                    tm dfrom from -> tm dto to
+  pushSubstsWith' : DSubst d1 d2 -> TSubst d2 n1 n2 -> tm d1 n1 -> tm d2 n2
   pushSubstsWith' th ph x = fst $ pushSubstsWith th ph x
 
   export %inline

lib/Quox/Syntax/Term/Tighten.idr

@@ -8,10 +8,10 @@ import public Quox.OPE
 
 
 export
-Tighten (Shift from) where
+Tighten (Shift f) where
   -- `OPE m n` is a spicy `m ≤ n`,
-  -- and `Shift from n` is a (different) spicy `from ≤ n`
-  -- so the value is `from ≤ m` (as a `Shift`), if that is the case
+  -- and `Shift f n` is a (different) spicy `f ≤ n`
+  -- so the value is `f ≤ m` (as a `Shift`), if that is the case
   tighten _        SZ      = Nothing
   tighten Id       by      = Just by
   tighten (Drop p) (SS by) = tighten p by
@@ -26,12 +26,12 @@ Tighten Dim where
 
 export
 tightenSub : (forall m, n. OPE m n -> env n -> Maybe (env m)) ->
-             OPE to1 to2 -> Subst env from to2 -> Maybe (Subst env from to1)
+             OPE t1 t2 -> Subst env f t2 -> Maybe (Subst env f t1)
 tightenSub f p (Shift by) = [|Shift $ tighten p by|]
 tightenSub f p (t ::: th) = [|f p t !::: tightenSub f p th|]
 
 export
-Tighten env => Tighten (Subst env from) where
+Tighten env => Tighten (Subst env f) where
   tighten p th = tightenSub tighten p th