File: .lake/packages/lean4/src/lean/Lean/PrettyPrinter.lean

full_name: Lean.PPContext.runCoreM
code: def PPContext.runCoreM {α : Type} (ppCtx : PPContext) (x : CoreM α) : IO α 
goal: IO α

full_name: Lean.PPContext.runMetaM
code: def PPContext.runMetaM {α : Type} (ppCtx : PPContext) (x : MetaM α) : IO α 
goal: IO α

full_name: Lean.PrettyPrinter.ppCategory
code: def ppCategory (cat : Name) (stx : Syntax) : CoreM Format 
goal: Lean.CoreM Lean.Format

full_name: Lean.PrettyPrinter.ppTerm
code: def ppTerm (stx : Term) : CoreM Format 
goal: Lean.CoreM Lean.Format

full_name: Lean.PrettyPrinter.ppUsing
code: def ppUsing (e : Expr) (delab : Expr → MetaM Term) : MetaM Format 
goal: Lean.MetaM Lean.Format

full_name: Lean.PrettyPrinter.ppExpr
code: def ppExpr (e : Expr) : MetaM Format 
goal: Lean.MetaM Lean.Format

full_name: Lean.PrettyPrinter.ppExprWithInfos
code: /-- Return a `fmt` representing pretty-printed `e` together with a map from tags in `fmt`
to `Elab.Info` nodes produced by the delaborator at various subexpressions of `e`. -/
def ppExprWithInfos (e : Expr) (optsPerPos : Delaborator.OptionsPerPos := {}) (delab := Delaborator.delab)
    : MetaM FormatWithInfos 
goal: Lean.MetaM Lean.FormatWithInfos

full_name: Lean.PrettyPrinter.ppExprLegacy
code: @[export lean_pp_expr]
def ppExprLegacy (env : Environment) (mctx : MetavarContext) (lctx : LocalContext) (opts : Options) (e : Expr) : IO Format 
goal: IO Lean.Format

full_name: Lean.PrettyPrinter.ppTactic
code: def ppTactic (stx : TSyntax `tactic) : CoreM Format 
goal: Lean.CoreM Lean.Format

full_name: Lean.PrettyPrinter.ppCommand
code: def ppCommand (stx : Syntax.Command) : CoreM Format 
goal: Lean.CoreM Lean.Format

full_name: Lean.PrettyPrinter.ppModule
code: def ppModule (stx : TSyntax ``Parser.Module.module) : CoreM Format 
goal: Lean.CoreM Lean.Format

full_name: Lean.PrettyPrinter.ppSignature
code: /-- Pretty-prints a declaration `c` as `c.{<levels>} <params> : <type>`. -/
def ppSignature (c : Name) : MetaM FormatWithInfos 
goal: Lean.MetaM Lean.FormatWithInfos

full_name: _private.«.lake».packages.lean4.src.lean.Lean.PrettyPrinter.0.Lean.PrettyPrinter.noContext
code: private partial def noContext : MessageData → MessageData
  
goal: Lean.MessageData → Lean.MessageData

full_name: _private.«.lake».packages.lean4.src.lean.Lean.PrettyPrinter.0.Lean.PrettyPrinter.withoutContext
code: private def withoutContext {m} [MonadExcept Exception m] (x : m α) : m α 
goal: m α

full_name: Lean.PrettyPrinter.initFn._@..lake.packages.lean4.src.lean.Lean.PrettyPrinter._hyg.765
code: builtin_initialize
  ppFnsRef.set {
    ppExprWithInfos := fun ctx e => ctx.runMetaM <| withoutContext <| ppExprWithInfos e,
    ppTerm := fun ctx stx => ctx.runCoreM <| withoutContext <| ppTerm stx,
    ppLevel := fun ctx l => return l.format (mvars := getPPMVars ctx.opts),
    ppGoal := fun ctx mvarId => ctx.runMetaM <| withoutContext <| Meta.ppGoal mvarId
  }
goal: IO Unit

full_name: Lean.PrettyPrinter.initFn._@..lake.packages.lean4.src.lean.Lean.PrettyPrinter._hyg.834
code: builtin_initialize
  registerTraceClass `PrettyPrinter
goal: IO Unit

full_name: Lean.PrettyPrinter.registerParserCompilers
code: @[builtin_init]
unsafe def registerParserCompilers : IO Unit 
goal: IO Unit

full_name: Lean.MessageData.ofFormatWithInfosM
code: /--
Turns a `MetaM FormatWithInfos` into a `MessageData.lazy` which will run the monadic value.
Uses the `pp.tagAppFns` option to annotate constants with terminfo,
which is necessary for seeing the type on mouse hover.
-/
def ofFormatWithInfosM (fmt : MetaM FormatWithInfos) : MessageData 
goal: Lean.MessageData

full_name: Lean.MessageData.ofLazyM
code: /--
Turns a `MetaM MessageData` into a `MessageData.lazy` which will run the monadic value.
The optional array of expressions is used to set the `hasSyntheticSorry` fields, and should
comprise the expressions that are included in the message data.
-/
def ofLazyM (f : MetaM MessageData) (es : Array Expr := #[]) : MessageData 
goal: Lean.MessageData

full_name: Lean.MessageData.ofConst
code: /-- Pretty print a const expression using `delabConst` and generate terminfo.
This function avoids inserting `@` if the constant is for a function whose first
argument is implicit, which is what the default `toMessageData` for `Expr` does.
Panics if `e` is not a constant. -/
def ofConst (e : Expr) : MessageData 
goal: Lean.MessageData

full_name: Lean.MessageData.signature
code: /-- Generates `MessageData` for a declaration `c` as `c.{<levels>} <params> : <type>`, with terminfo. -/
def signature (c : Name) : MessageData 
goal: Lean.MessageData