print non-dependent function types as "π.A → B"

lib/Quox/Syntax/Term/Pretty.idr

@@ -165,8 +165,12 @@ parameters (showSubsts : Bool)
   where
     prettyM (TYPE l) =
       parensIfM App $ !typeD <+> hl Syntax !(prettyUnivSuffix l)
-    prettyM (Pi qty s (S [< x] t)) =
-      prettyBindType (Just qty) x s !arrowD t.term
+    prettyM (Pi qty s (S _ (N t))) = do
+      dom <- pretty0M $ MkWithQty qty s
+      cod <- withPrec AnnR $ prettyM t
+      parensIfM AnnR $ asep [dom <++> !arrowD, cod]
+    prettyM (Pi qty s (S [< x] (Y t))) =
+      prettyBindType (Just qty) x s !arrowD t
     prettyM (Lam (S x t)) =
       let GotLams {names, body, _} = getLams' x t.term Refl in
       prettyLams (Just !lamD) T (toSnocList' names) body

tests/Tests/PrettyTerm.idr

@@ -97,13 +97,13 @@ tests = "pretty printing terms" :- [
       "1.(x : A) -> B x",
     testPrettyT [<] [<]
       (Pi_ Zero "A" (TYPE 0) $ Arr Any (BVT 0) (BVT 0))
-      "0.(A : ★₀) → ω.(_ : A) → A"
-      "0.(A : Type0) -> #.(_ : A) -> A",
+      "0.(A : ★₀) → ω.A → A"
+      "0.(A : Type0) -> #.A -> A",
     todo #"print (and parse) the below as "(A ↠ A) ↠ A""#,
     testPrettyT [<] [<]
       (Arr Any (Arr Any (FT "A") (FT "A")) (FT "A"))
-      "ω.(_ : ω.(_ : A) → A) → A"
-      "#.(_ : #.(_ : A) -> A) -> A",
+      "ω.(ω.A → A) → A"
+      "#.(#.A -> A) -> A",
     todo "non-dependent, left and right nested"
   ],
 
@@ -128,8 +128,8 @@ tests = "pretty printing terms" :- [
     testPrettyT1 [<] [<] (Pair (Pair (FT "A") (FT "B")) (FT "C")) "((A, B), C)",
     testPrettyT [<] [<]
       (Pair ([< "x"] :\\ BVT 0) (Arr One (FT "B₁") (FT "B₂")))
-      "(λ x ⇒ x, 1.(_ : B₁) → B₂)"
-      "(fun x => x, 1.(_ : B₁) -> B₂)"
+      "(λ x ⇒ x, 1.B₁ → B₂)"
+      "(fun x => x, 1.B₁ -> B₂)"
   ],
 
   "enum types" :- [
@@ -180,11 +180,11 @@ tests = "pretty printing terms" :- [
       "(α :: a) :: A",
     testPrettyE [<] [<]
       (([< "x"] :\\ BVT 0) :# Arr One (FT "A") (FT "A"))
-      "(λ x ⇒ x) ∷ 1.(_ : A) → A"
-      "(fun x => x) :: 1.(_ : A) -> A",
+      "(λ x ⇒ x) ∷ 1.A → A"
+      "(fun x => x) :: 1.A -> A",
     testPrettyE [<] [<]
       (Arr One (FT "A") (FT "A") :# TYPE 7)
-      "(1.(_ : A) → A) ∷ ★₇"
-      "(1.(_ : A) -> A) :: Type7"
+      "(1.A → A) ∷ ★₇"
+      "(1.A -> A) :: Type7"
   ]
 ]