represent ℕ constants directly

instead of as huge `succ (succ (succ ⋯))` terms

lib/Quox/Syntax/Term/Base.idr

@@ -88,8 +88,7 @@ mutual
 
     ||| natural numbers (temporary until 𝐖 gets added)
     NAT : (loc : Loc) -> Term d n
-    -- [todo] can these be elims?
-    Zero : (loc : Loc) -> Term d n
+    Nat : (val : Nat) -> (loc : Loc) -> Term d n
     Succ : (p : Term d n) -> (loc : Loc) -> Term d n
 
     ||| strings
@@ -324,10 +323,9 @@ public export %inline
 BVT : (i : Nat) -> (0 _ : LT i n) => (loc : Loc) -> Term d n
 BVT i loc = E $ BV i loc
 
-public export
-makeNat : Nat -> Loc -> Term d n
-makeNat 0 loc = Zero loc
-makeNat (S k) loc = Succ (makeNat k loc) loc
+public export %inline
+Zero : Loc -> Term d n
+Zero = Nat 0
 
 public export %inline
 enum : List TagVal -> Loc -> Term d n
@@ -379,7 +377,7 @@ Located (Term d n) where
   (Eq _ _ _ loc).loc    = loc
   (DLam _ loc).loc      = loc
   (NAT loc).loc         = loc
-  (Zero loc).loc        = loc
+  (Nat _ loc).loc       = loc
   (STRING loc).loc      = loc
   (Str _ loc).loc       = loc
   (Succ _ loc).loc      = loc
@@ -442,7 +440,7 @@ Relocatable (Term d n) where
   setLoc loc (Eq ty l r _) = Eq ty l r loc
   setLoc loc (DLam body _) = DLam body loc
   setLoc loc (NAT _) = NAT loc
-  setLoc loc (Zero _) = Zero loc
+  setLoc loc (Nat n _) = Nat n loc
   setLoc loc (Succ p _) = Succ p loc
   setLoc loc (STRING _) = STRING loc
   setLoc loc (Str s _) = Str s loc

lib/Quox/Syntax/Term/Pretty.idr

@@ -450,19 +450,9 @@ prettyTerm dnames tnames s@(DLam {}) =
   prettyLambda dnames tnames s
 
 prettyTerm dnames tnames (NAT _) = natD
-prettyTerm dnames tnames (Zero _) = hl Syntax "0"
-prettyTerm dnames tnames (Succ p _) = do
-  succD <- succD
-  let succ : Doc opts -> Eff Pretty (Doc opts)
-      succ t = prettyAppD succD [t]
-      toNat : Term d n -> Eff Pretty (Either (Doc opts) Nat)
-      toNat s with (pushSubsts' s)
-        _ | Zero _   = pure $ Right 0
-        _ | Succ d _ = bitraverse succ (pure . S) =<<
-                       toNat (assert_smaller s d)
-        _ | s'       = map Left . withPrec Arg $
-                       prettyTerm dnames tnames $ assert_smaller s s'
-  either succ (hl Syntax . text . show . S) =<< toNat p
+prettyTerm dnames tnames (Nat n _) = hl Syntax $ pshow n
+prettyTerm dnames tnames (Succ p _) =
+  prettyAppD !succD [!(withPrec Arg $ prettyTerm dnames tnames p)]
 
 prettyTerm dnames tnames (STRING _) = stringD
 prettyTerm dnames tnames (Str s _) = prettyStrLit s

lib/Quox/Syntax/Term/Subst.idr

@@ -274,8 +274,8 @@ mutual
       nclo $ DLam (body // th // ph) loc
     pushSubstsWith _ _ (NAT loc) =
       nclo $ NAT loc
-    pushSubstsWith _ _ (Zero loc) =
-      nclo $ Zero loc
+    pushSubstsWith _ _ (Nat n loc) =
+      nclo $ Nat n loc
     pushSubstsWith th ph (Succ n loc) =
       nclo $ Succ (n // th // ph) loc
     pushSubstsWith _ _ (STRING loc) =

lib/Quox/Syntax/Term/Tighten.idr

@@ -63,8 +63,8 @@ mutual
     DLam <$> tightenDS p body <*> pure loc
   tightenT' p (NAT loc) =
     pure $ NAT loc
-  tightenT' p (Zero loc) =
-    pure $ Zero loc
+  tightenT' p (Nat n loc) =
+    pure $ Nat n loc
   tightenT' p (Succ s loc) =
     Succ <$> tightenT p s <*> pure loc
   tightenT' p (STRING loc) =
@@ -188,8 +188,8 @@ mutual
     DLam <$> dtightenDS p body <*> pure loc
   dtightenT' p (NAT loc) =
     pure $ NAT loc
-  dtightenT' p (Zero loc) =
-    pure $ Zero loc
+  dtightenT' p (Nat n loc) =
+    pure $ Nat n loc
   dtightenT' p (Succ s loc) =
     Succ <$> dtightenT p s <*> pure loc
   dtightenT' p (STRING loc) =