module Quox.Syntax.Term.Pretty import Quox.Syntax.Term.Base import Quox.Syntax.Term.Subst import Quox.Context import Quox.Pretty import Data.Vect import Derive.Prelude %default total %language ElabReflection export prettyUniverse : {opts : _} -> Universe -> Eff Pretty (Doc opts) prettyUniverse = hl Universe . text . show export prettyTerm : {opts : _} -> BContext d -> BContext n -> Term d n -> Eff Pretty (Doc opts) export prettyElim : {opts : _} -> BContext d -> BContext n -> Elim d n -> Eff Pretty (Doc opts) private BTelescope : Nat -> Nat -> Type BTelescope = Telescope' BindName private superscript : String -> String superscript = pack . map sup . unpack where sup : Char -> Char sup c = case c of '0' => '⁰'; '1' => '¹'; '2' => '²'; '3' => '³'; '4' => '⁴' '5' => '⁵'; '6' => '⁶'; '7' => '⁷'; '8' => '⁸'; '9' => '⁹'; _ => c private PiBind : Nat -> Nat -> Type PiBind d n = (Qty, BindName, Term d n) private pbname : PiBind d n -> BindName 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 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 splitPi binds cod = MkSplitPi {binds, cod} private prettyPiBind1 : {opts : _} -> Qty -> BindName -> BContext d -> BContext n -> Term d n -> Eff Pretty (Doc opts) prettyPiBind1 pi (BN Unused _) dnames tnames s = hcat <$> sequence [prettyQty pi, dotD, withPrec Arg $ assert_total prettyTerm dnames tnames s] prettyPiBind1 pi x dnames tnames s = hcat <$> sequence [prettyQty pi, dotD, hl Delim $ text "(", hsep <$> sequence [prettyTBind x, hl Delim $ text ":", withPrec Outer $ assert_total prettyTerm dnames tnames s], hl Delim $ text ")"] private prettyPiBinds : {opts : _} -> BContext d -> BContext n -> Telescope (PiBind d) n n' -> Eff Pretty (SnocList (Doc opts)) prettyPiBinds _ _ [<] = pure [<] prettyPiBinds dnames tnames (binds :< (q, x, t)) = let tnames' = tnames . map pbname binds in [|prettyPiBinds dnames tnames binds :< prettyPiBind1 q x dnames tnames' t|] private SigBind : Nat -> Nat -> Type 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 n' -> Term d n' -> SplitSig d n splitSig binds (Sig fst snd _) = splitSig (binds :< (snd.name, fst)) $ assert_smaller snd $ pushSubsts' snd.term splitSig binds last = MkSplitSig {binds, last} private prettySigBind1 : {opts : _} -> BindName -> BContext d -> BContext n -> Term d n -> Eff Pretty (Doc opts) prettySigBind1 (BN Unused _) dnames tnames s = withPrec InTimes $ assert_total prettyTerm dnames tnames s prettySigBind1 x dnames tnames s = hcat <$> sequence [hl Delim $ text "(", hsep <$> sequence [prettyTBind x, hl Delim $ text ":", withPrec Outer $ assert_total prettyTerm dnames tnames s], hl Delim $ text ")"] private prettySigBinds : {opts : _} -> BContext d -> BContext n -> Telescope (SigBind d) n n' -> Eff Pretty (SnocList (Doc opts)) prettySigBinds _ _ [<] = pure [<] prettySigBinds dnames tnames (binds :< (x, t)) = let tnames' = tnames . map fst binds in [|prettySigBinds dnames tnames binds :< prettySigBind1 x dnames tnames' t|] private prettyTypeLine : {opts : _} -> BContext d -> BContext n -> DScopeTerm d n -> Eff Pretty (Doc opts) prettyTypeLine dnames tnames (S _ (N body)) = withPrec Arg (prettyTerm dnames tnames body) prettyTypeLine dnames tnames (S [< i] (Y body)) = parens =<< do i' <- prettyDBind i ty' <- withPrec Outer $ prettyTerm (dnames :< i) tnames body pure $ sep [hsep [i', !darrowD], ty'] private data NameSort = T | D %runElab derive "NameSort" [Eq] private NameChunks : Type 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 body : Term dinner ninner private splitLams : Term d n -> SplitLams d n splitLams s = go [<] [<] [<] (pushSubsts' s) where push : NameSort -> BindName -> NameChunks -> NameChunks push s y [<] = [< (s, [< y])] push s y (xss :< (s', xs)) = if s == s' then xss :< (s', xs :< y) else xss :< (s', xs) :< (s, [< y]) go : BTelescope d d' -> BTelescope n n' -> SnocList (NameSort, SnocList BindName) -> 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 go dnames tnames chunks (DLam b _) = go (dnames :< b.name) tnames (push D b.name chunks) $ assert_smaller b $ pushSubsts' b.term go dnames tnames chunks s = MkSplitLams dnames tnames chunks s private splitTuple : SnocList (Term d n) -> Term d n -> SnocList (Term d n) splitTuple ss p@(Pair t1 t2 _) = splitTuple (ss :< t1) $ assert_smaller p $ pushSubsts' t2 splitTuple ss t = ss :< t private prettyTArg : {opts : _} -> BContext d -> BContext n -> Term d n -> Eff Pretty (Doc opts) prettyTArg dnames tnames s = withPrec Arg $ assert_total prettyTerm dnames tnames s private prettyDArg : {opts : _} -> BContext d -> Dim d -> Eff Pretty (Doc opts) prettyDArg dnames p = [|atD <+> withPrec Arg (prettyDim dnames p)|] private splitApps : Elim d n -> (Elim d n, List (Either (Dim d) (Term d n))) splitApps e = go [] (pushSubsts' e) where go : List (Either (Dim d) (Term d n)) -> Elim d n -> (Elim d n, List (Either (Dim d) (Term d n))) go xs e@(App f s _) = go (Right s :: xs) $ assert_smaller e $ pushSubsts' f go xs e@(DApp f p _) = go (Left p :: xs) $ assert_smaller e $ pushSubsts' f go xs s = (s, xs) private prettyDTApps : {opts : _} -> BContext d -> BContext n -> Elim d n -> List (Either (Dim d) (Term d n)) -> Eff Pretty (Doc opts) prettyDTApps dnames tnames f xs = do f <- withPrec Arg $ assert_total prettyElim dnames tnames f xs <- for xs $ either (prettyDArg dnames) (prettyTArg dnames tnames) parensIfM App =<< prettyAppD f xs private record CaseArm opts d n where constructor MkCaseArm pat : Doc opts dbinds : BTelescope d dinner -- 🍴 tbinds : BTelescope n ninner body : Term dinner ninner parameters {opts : LayoutOpts} (dnames : BContext d) (tnames : BContext n) private prettyCaseArm : CaseArm opts d n -> Eff Pretty (Doc opts) prettyCaseArm (MkCaseArm pat dbinds tbinds body) = do body <- withPrec Outer $ assert_total prettyTerm (dnames . dbinds) (tnames . tbinds) body header <- (pat <++>) <$> darrowD pure $ ifMultiline (header <++> body) (vsep [header, !(indentD body)]) private prettyCaseBody : List (CaseArm opts d n) -> Eff Pretty (List (Doc opts)) prettyCaseBody xs = traverse prettyCaseArm xs private prettyCompPat : {opts : _} -> DimConst -> BindName -> Eff Pretty (Doc opts) prettyCompPat e x = [|prettyDimConst e <++> prettyDBind x|] private prettyCompArm : {opts : _} -> BContext d -> BContext n -> DimConst -> DScopeTerm d n -> Eff Pretty (Doc opts) prettyCompArm dnames tnames e s = prettyCaseArm dnames tnames $ MkCaseArm !(prettyCompPat e s.name) [< s.name] [<] s.term private layoutComp : {opts : _} -> (typq : List (Doc opts)) -> (val, r : Doc opts) -> (arms : List (Doc opts)) -> Eff Pretty (Doc opts) layoutComp typq val r arms = do comp <- compD; lb <- hl Delim "{"; rb <- hl Delim "}" ind <- askAt INDENT pure $ ifMultiline (hsep $ concat {t = List} [[comp], typq, [val, r, lb], arms, [rb]]) $ (comp <++> vsep [sep typq, val, r <++> lb, indent ind $ vsep arms, rb]) <|> (vsep $ (comp ::) $ map (indent ind) $ concat {t = List} [typq, [val, r <++> lb], map (indent ind) arms, [rb]]) export prettyEnum : {opts : _} -> List String -> Eff Pretty (Doc opts) prettyEnum cases = tightBraces =<< fillSeparateTight !commaD <$> traverse (hl Constant . Doc.text . quoteTag) cases private prettyCaseRet : {opts : _} -> BContext d -> BContext n -> ScopeTerm d n -> Eff Pretty (Doc opts) prettyCaseRet dnames tnames body = withPrec Outer $ case body of S _ (N tm) => assert_total prettyTerm dnames tnames tm S [< x] (Y tm) => do header <- [|prettyTBind x <++> darrowD|] body <- assert_total prettyTerm dnames (tnames :< x) tm hangDSingle header body private prettyCase_ : {opts : _} -> BContext d -> BContext n -> Doc opts -> Elim d n -> ScopeTerm d n -> List (CaseArm opts d n) -> Eff Pretty (Doc opts) prettyCase_ dnames tnames intro head ret body = do head <- withPrec Outer $ assert_total prettyElim dnames tnames head ret <- prettyCaseRet dnames tnames ret bodys <- prettyCaseBody dnames tnames body return <- returnD; of_ <- ofD lb <- hl Delim "{"; rb <- hl Delim "}"; semi <- semiD ind <- askAt INDENT parensIfM Outer $ ifMultiline (hsep [intro, head, return, ret, of_, lb, hseparateTight semi bodys, rb]) (vsep [intro <++> head, return <++> ret, of_ <++> lb, indent ind $ vseparateTight semi bodys, rb]) private prettyCase : {opts : _} -> BContext d -> BContext n -> Qty -> Elim d n -> ScopeTerm d n -> List (CaseArm opts d n) -> Eff Pretty (Doc opts) prettyCase dnames tnames qty head ret body = prettyCase_ dnames tnames ![|caseD <+> prettyQty qty|] head ret body private LetBinder : Nat -> Nat -> Type LetBinder d n = (Qty, BindName, Elim d n) private LetExpr : Nat -> Nat -> Nat -> Type LetExpr d n n' = (Telescope (LetBinder d) n n', Term d n') -- [todo] factor out this and the untyped version somehow export splitLet : Telescope (LetBinder d) n n' -> Term d n' -> Exists (LetExpr d n) splitLet ys t@(Let qty rhs body _) = splitLet (ys :< (qty, body.name, rhs)) (assert_smaller t body.term) splitLet ys t = Evidence _ (ys, t) private covering prettyLets : {opts : LayoutOpts} -> BContext d -> BContext a -> Telescope (LetBinder d) a b -> Eff Pretty (SnocList (Doc opts)) prettyLets dnames xs lets = snd <$> go lets where peelAnn : forall d, n. Elim d n -> Maybe (Term d n, Term d n) peelAnn (Ann tm ty _) = Just (tm, ty) peelAnn e = Nothing letHeader : Qty -> BindName -> Eff Pretty (Doc opts) letHeader qty x = do lett <- [|letD <+> prettyQty qty|] x <- prettyTBind x pure $ lett <++> x letBody : forall n. BContext n -> Doc opts -> Elim d n -> Eff Pretty (Doc opts) letBody tnames hdr e = case peelAnn e of Just (tm, ty) => do ty <- withPrec Outer $ assert_total prettyTerm dnames tnames ty tm <- withPrec Outer $ assert_total prettyTerm dnames tnames tm colon <- colonD; eq <- cstD; d <- askAt INDENT pure $ hangSingle d (hangSingle d hdr (colon <++> ty)) (eq <++> tm) Nothing => do e <- withPrec Outer $ assert_total prettyElim dnames tnames e eq <- cstD; d <- askAt INDENT inn <- inD pure $ ifMultiline (hsep [hdr, eq, e, inn]) (vsep [hdr, indent d $ hsep [eq, e, inn]]) go : forall b. Telescope (LetBinder d) a b -> Eff Pretty (BContext b, SnocList (Doc opts)) go [<] = pure (xs, [<]) go (lets :< (qty, x, rhs)) = do (ys, docs) <- go lets doc <- letBody ys !(letHeader qty x) rhs pure (ys :< x, docs :< doc) private isDefaultDir : Dim d -> Dim d -> Bool isDefaultDir (K Zero _) (K One _) = True isDefaultDir _ _ = False -- [fixme] use telescopes in Scoped private toTel : BContext s -> BTelescope n (s + n) toTel [<] = [<] toTel (ctx :< x) = toTel ctx :< x private prettyTyCasePat : {opts : _} -> (k : TyConKind) -> BContext (arity k) -> Eff Pretty (Doc opts) prettyTyCasePat KTYPE [<] = typeD prettyTyCasePat KIOState [<] = ioStateD prettyTyCasePat KPi [< a, b] = parens . hsep =<< sequence [prettyTBind a, arrowD, prettyTBind b] prettyTyCasePat KSig [< a, b] = parens . hsep =<< sequence [prettyTBind a, timesD, prettyTBind b] prettyTyCasePat KEnum [<] = hl Syntax $ text "{}" prettyTyCasePat KEq [< a0, a1, a, l, r] = hsep <$> sequence (eqD :: map prettyTBind [a0, a1, a, l, r]) prettyTyCasePat KNat [<] = natD prettyTyCasePat KString [<] = stringD prettyTyCasePat KBOX [< a] = bracks =<< prettyTBind a prettyLambda : {opts : _} -> BContext d -> BContext n -> Term d n -> Eff Pretty (Doc opts) prettyLambda dnames tnames s = parensIfM Outer =<< do let MkSplitLams {dnames = ds, tnames = ts, chunks, body} = splitLams s hangDSingle !(header chunks) !(assert_total prettyTerm (dnames . ds) (tnames . ts) body) where introChar : NameSort -> Eff Pretty (Doc opts) introChar T = lamD introChar D = dlamD prettyBind : NameSort -> BindName -> Eff Pretty (Doc opts) prettyBind T = prettyTBind prettyBind D = prettyDBind header1 : NameSort -> List BindName -> Eff Pretty (Doc opts) header1 s xs = hsep <$> sequence [introChar s, sep <$> traverse (prettyBind s) xs, darrowD] header : NameChunks -> Eff Pretty (Doc opts) header cs = sep <$> traverse (\(s, xs) => header1 s (toList xs)) (toList cs) prettyDisp : {opts : _} -> Universe -> Eff Pretty (Maybe (Doc opts)) prettyDisp 0 = pure Nothing prettyDisp u = map Just $ hl Universe =<< ifUnicode (text $ superscript $ show u) (text $ "^" ++ show u) prettyTerm dnames tnames (TYPE l _) = do type <- hl Syntax . text =<< ifUnicode "★" "Type" level <- prettyDisp l pure $ maybe type (type <+>) level prettyTerm dnames tnames (IOState _) = ioStateD prettyTerm dnames tnames (Pi qty arg res _) = parensIfM Outer =<< do let MkSplitPi {binds, cod} = splitPi [< (qty, res.name, arg)] res.term arr <- arrowD lines <- map (<++> arr) <$> prettyPiBinds dnames tnames binds let tnames = tnames . map pbname binds cod <- withPrec Outer $ prettyTerm dnames tnames (assert_smaller res cod) pure $ sepSingle $ toList $ lines :< cod prettyTerm dnames tnames s@(Lam {}) = prettyLambda dnames tnames s prettyTerm dnames tnames (Sig fst snd _) = parensIfM Times =<< do let MkSplitSig {binds, last} = splitSig [< (snd.name, fst)] snd.term times <- timesD lines <- map (<++> times) <$> prettySigBinds dnames tnames binds let tnames = tnames . map Builtin.fst binds last <- withPrec InTimes $ prettyTerm dnames tnames (assert_smaller snd last) pure $ sepSingle $ toList $ lines :< last prettyTerm dnames tnames p@(Pair fst snd _) = parens =<< do let elems = splitTuple [< fst] snd lines <- for elems $ \t => withPrec Outer $ prettyTerm dnames tnames $ assert_smaller p t pure $ separateTight !commaD lines prettyTerm dnames tnames (Enum cases _) = prettyEnum $ SortedSet.toList cases prettyTerm dnames tnames (Tag tag _) = prettyTag tag prettyTerm dnames tnames (Eq (S _ (N ty)) l r _) = parensIfM Eq =<< do l <- withPrec InEq $ prettyTerm dnames tnames l r <- withPrec InEq $ prettyTerm dnames tnames r ty <- withPrec InEq $ prettyTerm dnames tnames ty pure $ sep [l <++> !eqndD, r <++> !colonD, ty] prettyTerm dnames tnames (Eq ty l r _) = parensIfM App =<< do ty <- prettyTypeLine dnames tnames ty l <- withPrec Arg $ prettyTerm dnames tnames l r <- withPrec Arg $ prettyTerm dnames tnames r prettyAppD !eqD [ty, l, r] prettyTerm dnames tnames s@(DLam {}) = prettyLambda dnames tnames s prettyTerm dnames tnames (NAT _) = natD prettyTerm dnames tnames (Nat n _) = hl Syntax $ pshow n prettyTerm dnames tnames (Succ p _) = parensIfM App =<< prettyAppD !succD [!(withPrec Arg $ prettyTerm dnames tnames p)] prettyTerm dnames tnames (STRING _) = stringD prettyTerm dnames tnames (Str s _) = prettyStrLit s prettyTerm dnames tnames (BOX qty ty _) = bracks . hcat =<< sequence [prettyQty qty, dotD, withPrec Outer $ prettyTerm dnames tnames ty] prettyTerm dnames tnames (Box val _) = bracks =<< withPrec Outer (prettyTerm dnames tnames val) prettyTerm dnames tnames (Let qty rhs body _) = do let Evidence _ (lets, body) = splitLet [< (qty, body.name, rhs)] body.term heads <- prettyLets dnames tnames lets let tnames = tnames . map (\(_, x, _) => x) lets body <- withPrec Outer $ assert_total prettyTerm dnames tnames body let lines = toList $ heads :< body pure $ ifMultiline (hsep lines) (vsep lines) prettyTerm dnames tnames (E e) = case the (Elim d n) (pushSubsts' e) of Ann tm _ _ => assert_total prettyTerm dnames tnames tm _ => assert_total prettyElim dnames tnames e prettyTerm dnames tnames t0@(CloT (Sub t ph)) = prettyTerm dnames tnames $ assert_smaller t0 $ pushSubstsWith' id ph t prettyTerm dnames tnames t0@(DCloT (Sub t ph)) = prettyTerm dnames tnames $ assert_smaller t0 $ pushSubstsWith' ph id t prettyElim dnames tnames (F x u _) = do x <- prettyFree x u <- prettyDisp u pure $ maybe x (x <+>) u prettyElim dnames tnames (B i _) = prettyTBind $ tnames !!! i prettyElim dnames tnames e@(App {}) = let (f, xs) = splitApps e in prettyDTApps dnames tnames f xs prettyElim dnames tnames (CasePair qty pair ret body _) = do let [< x, y] = body.names pat <- parens . hsep =<< sequence [[|prettyTBind x <+> commaD|], prettyTBind y] prettyCase dnames tnames qty pair ret [MkCaseArm pat [<] [< x, y] body.term] prettyElim dnames tnames (Fst pair _) = parensIfM App =<< do pair <- prettyTArg dnames tnames (E pair) prettyAppD !fstD [pair] prettyElim dnames tnames (Snd pair _) = parensIfM App =<< do pair <- prettyTArg dnames tnames (E pair) prettyAppD !sndD [pair] prettyElim dnames tnames (CaseEnum qty tag ret arms _) = do arms <- for (SortedMap.toList arms) $ \(tag, body) => pure $ MkCaseArm !(prettyTag tag) [<] [<] body prettyCase dnames tnames qty tag ret arms prettyElim dnames tnames (CaseNat qty qtyIH nat ret zero succ _) = do let zarm = MkCaseArm !zeroD [<] [<] zero [< p, ih] = succ.names spat0 <- [|succD <++> prettyTBind p|] ihpat0 <- map hcat $ sequence [prettyQty qtyIH, dotD, prettyTBind ih] spat <- if ih.val == Unused then pure spat0 else pure $ hsep [spat0 <+> !commaD, ihpat0] let sarm = MkCaseArm spat [<] [< p, ih] succ.term prettyCase dnames tnames qty nat ret [zarm, sarm] prettyElim dnames tnames (CaseBox qty box ret body _) = do pat <- bracks =<< prettyTBind body.name let arm = MkCaseArm pat [<] [< body.name] body.term prettyCase dnames tnames qty box ret [arm] prettyElim dnames tnames e@(DApp {}) = let (f, xs) = splitApps e in prettyDTApps dnames tnames f xs prettyElim dnames tnames (Ann tm ty _) = case the (Term d n) (pushSubsts' tm) of E e => assert_total prettyElim dnames tnames e _ => do tm <- withPrec AnnL $ assert_total prettyTerm dnames tnames tm ty <- withPrec Outer $ assert_total prettyTerm dnames tnames ty parensIfM Outer =<< hangDSingle (tm <++> !annD) ty prettyElim dnames tnames (Coe ty p q val _) = parensIfM App =<< do ty <- prettyTypeLine dnames tnames ty p <- prettyDArg dnames p q <- prettyDArg dnames q val <- prettyTArg dnames tnames val prettyAppD !coeD [ty, sep [p, q], val] prettyElim dnames tnames e@(Comp ty p q val r zero one _) = parensIfM App =<< do ty <- assert_total $ prettyTypeLine dnames tnames $ SN ty pq <- sep <$> sequence [prettyDArg dnames p, prettyDArg dnames q] val <- prettyTArg dnames tnames val r <- prettyDArg dnames r arm0 <- [|prettyCompArm dnames tnames Zero zero <+> semiD|] arm1 <- prettyCompArm dnames tnames One one ind <- askAt INDENT layoutComp [ty, pq] val r [arm0, arm1] prettyElim dnames tnames (TypeCase ty ret arms def _) = do arms <- for (toList arms) $ \(k ** body) => do pat <- prettyTyCasePat k body.names pure $ MkCaseArm pat [<] (toTel body.names) body.term let darm = MkCaseArm !undD [<] [<] def prettyCase_ dnames tnames !typecaseD ty (SN ret) $ arms ++ [darm] prettyElim dnames tnames e0@(CloE (Sub e ph)) = prettyElim dnames tnames $ assert_smaller e0 $ pushSubstsWith' id ph e prettyElim dnames tnames e0@(DCloE (Sub e ph)) = prettyElim dnames tnames $ assert_smaller e0 $ pushSubstsWith' ph id e