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

full_name: Lean.pp.analyze
code: register_builtin_option pp.analyze : Bool := {
  defValue := false
  group    := "pp.analyze"
  descr    := "(pretty printer analyzer) determine annotations sufficient to ensure round-tripping"
}
goal: Lean.Option Bool

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.PrettyPrinter.Delaborator.TopDownAnalyze._hyg.8
code: register_builtin_option pp.analyze : Bool := {
  defValue := false
  group    := "pp.analyze"
  descr    := "(pretty printer analyzer) determine annotations sufficient to ensure round-tripping"
}
goal: IO (Lean.Option Bool)

full_name: Lean.pp.analyze.checkInstances
code: register_builtin_option pp.analyze.checkInstances : Bool := {
  -- TODO: It would be great to make this default to `true`, but currently, `MessageData` does not
  -- include the `LocalInstances`, so this will be very over-aggressive in inserting instances
  -- that would otherwise be easy to synthesize. We may consider threading the instances in the future,
  -- or at least tracking a bool for whether the instances have been lost.
  defValue := false
  group    := "pp.analyze"
  descr    := "(pretty printer analyzer) confirm that instances can be re-synthesized"
}
goal: Lean.Option Bool

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.PrettyPrinter.Delaborator.TopDownAnalyze._hyg.50
code: register_builtin_option pp.analyze.checkInstances : Bool := {
  -- TODO: It would be great to make this default to `true`, but currently, `MessageData` does not
  -- include the `LocalInstances`, so this will be very over-aggressive in inserting instances
  -- that would otherwise be easy to synthesize. We may consider threading the instances in the future,
  -- or at least tracking a bool for whether the instances have been lost.
  defValue := false
  group    := "pp.analyze"
  descr    := "(pretty printer analyzer) confirm that instances can be re-synthesized"
}
goal: IO (Lean.Option Bool)

full_name: Lean.pp.analyze.typeAscriptions
code: register_builtin_option pp.analyze.typeAscriptions : Bool := {
  defValue := true
  group    := "pp.analyze"
  descr    := "(pretty printer analyzer) add type ascriptions when deemed necessary"
}
goal: Lean.Option Bool

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.PrettyPrinter.Delaborator.TopDownAnalyze._hyg.92
code: register_builtin_option pp.analyze.typeAscriptions : Bool := {
  defValue := true
  group    := "pp.analyze"
  descr    := "(pretty printer analyzer) add type ascriptions when deemed necessary"
}
goal: IO (Lean.Option Bool)

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.PrettyPrinter.Delaborator.TopDownAnalyze._hyg.134
code: register_builtin_option pp.analyze.trustSubst : Bool := {
  defValue := false
  group    := "pp.analyze"
  descr    := "(pretty printer analyzer) always 'pretend' applications that can delab to ▸ are 'regular'"
}
goal: IO (Lean.Option Bool)

full_name: Lean.pp.analyze.trustSubst
code: register_builtin_option pp.analyze.trustSubst : Bool := {
  defValue := false
  group    := "pp.analyze"
  descr    := "(pretty printer analyzer) always 'pretend' applications that can delab to ▸ are 'regular'"
}
goal: Lean.Option Bool

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.PrettyPrinter.Delaborator.TopDownAnalyze._hyg.176
code: register_builtin_option pp.analyze.trustOfNat : Bool := {
  defValue := true
  group    := "pp.analyze"
  descr    := "(pretty printer analyzer) always 'pretend' `OfNat.ofNat` applications can elab bottom-up"
}
goal: IO (Lean.Option Bool)

full_name: Lean.pp.analyze.trustOfNat
code: register_builtin_option pp.analyze.trustOfNat : Bool := {
  defValue := true
  group    := "pp.analyze"
  descr    := "(pretty printer analyzer) always 'pretend' `OfNat.ofNat` applications can elab bottom-up"
}
goal: Lean.Option Bool

full_name: Lean.pp.analyze.trustOfScientific
code: register_builtin_option pp.analyze.trustOfScientific : Bool := {
  defValue := true
  group    := "pp.analyze"
  descr    := "(pretty printer analyzer) always 'pretend' `OfScientific.ofScientific` applications can elab bottom-up"
}
goal: Lean.Option Bool

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.PrettyPrinter.Delaborator.TopDownAnalyze._hyg.218
code: register_builtin_option pp.analyze.trustOfScientific : Bool := {
  defValue := true
  group    := "pp.analyze"
  descr    := "(pretty printer analyzer) always 'pretend' `OfScientific.ofScientific` applications can elab bottom-up"
}
goal: IO (Lean.Option Bool)

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.PrettyPrinter.Delaborator.TopDownAnalyze._hyg.260
code: register_builtin_option pp.analyze.trustSubtypeMk : Bool := {
  defValue := true
  group    := "pp.analyze"
  descr    := "(pretty printer analyzer) assume the implicit arguments of Subtype.mk can be inferred"
}
goal: IO (Lean.Option Bool)

full_name: Lean.pp.analyze.trustSubtypeMk
code: register_builtin_option pp.analyze.trustSubtypeMk : Bool := {
  defValue := true
  group    := "pp.analyze"
  descr    := "(pretty printer analyzer) assume the implicit arguments of Subtype.mk can be inferred"
}
goal: Lean.Option Bool

full_name: Lean.pp.analyze.trustId
code: register_builtin_option pp.analyze.trustId : Bool := {
  defValue := true
  group    := "pp.analyze"
  descr    := "(pretty printer analyzer) always assume an implicit `fun x => x` can be inferred"
}
goal: Lean.Option Bool

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.PrettyPrinter.Delaborator.TopDownAnalyze._hyg.302
code: register_builtin_option pp.analyze.trustId : Bool := {
  defValue := true
  group    := "pp.analyze"
  descr    := "(pretty printer analyzer) always assume an implicit `fun x => x` can be inferred"
}
goal: IO (Lean.Option Bool)

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.PrettyPrinter.Delaborator.TopDownAnalyze._hyg.344
code: register_builtin_option pp.analyze.trustKnownFOType2TypeHOFuns : Bool := {
  defValue := true
  group    := "pp.analyze"
  descr    := "(pretty printer analyzer) omit higher-order functions whose values seem to be knownType2Type"
}
goal: IO (Lean.Option Bool)

full_name: Lean.pp.analyze.trustKnownFOType2TypeHOFuns
code: register_builtin_option pp.analyze.trustKnownFOType2TypeHOFuns : Bool := {
  defValue := true
  group    := "pp.analyze"
  descr    := "(pretty printer analyzer) omit higher-order functions whose values seem to be knownType2Type"
}
goal: Lean.Option Bool

full_name: Lean.pp.analyze.omitMax
code: register_builtin_option pp.analyze.omitMax : Bool := {
  defValue := true
  group    := "pp.analyze"
  descr    := "(pretty printer analyzer) omit universe `max` annotations (these constraints can actually hurt)"
}
goal: Lean.Option Bool

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.PrettyPrinter.Delaborator.TopDownAnalyze._hyg.386
code: register_builtin_option pp.analyze.omitMax : Bool := {
  defValue := true
  group    := "pp.analyze"
  descr    := "(pretty printer analyzer) omit universe `max` annotations (these constraints can actually hurt)"
}
goal: IO (Lean.Option Bool)

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.PrettyPrinter.Delaborator.TopDownAnalyze._hyg.428
code: register_builtin_option pp.analyze.knowsType : Bool := {
  defValue := true
  group    := "pp.analyze"
  descr    := "(pretty printer analyzer) assume the type of the original expression is known"
}
goal: IO (Lean.Option Bool)

full_name: Lean.pp.analyze.knowsType
code: register_builtin_option pp.analyze.knowsType : Bool := {
  defValue := true
  group    := "pp.analyze"
  descr    := "(pretty printer analyzer) assume the type of the original expression is known"
}
goal: Lean.Option Bool

full_name: Lean.pp.analyze.explicitHoles
code: register_builtin_option pp.analyze.explicitHoles : Bool := {
  defValue := false
  group    := "pp.analyze"
  descr    := "(pretty printer analyzer) use `_` for explicit arguments that can be inferred"
}
goal: Lean.Option Bool

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.PrettyPrinter.Delaborator.TopDownAnalyze._hyg.470
code: register_builtin_option pp.analyze.explicitHoles : Bool := {
  defValue := false
  group    := "pp.analyze"
  descr    := "(pretty printer analyzer) use `_` for explicit arguments that can be inferred"
}
goal: IO (Lean.Option Bool)

full_name: Lean.getPPAnalyze
code: def getPPAnalyze                            (o : Options) : Bool 
goal: Bool

full_name: Lean.getPPAnalyzeCheckInstances
code: def getPPAnalyzeCheckInstances              (o : Options) : Bool 
goal: Bool

full_name: Lean.getPPAnalyzeTypeAscriptions
code: def getPPAnalyzeTypeAscriptions             (o : Options) : Bool 
goal: Bool

full_name: Lean.getPPAnalyzeTrustSubst
code: def getPPAnalyzeTrustSubst                  (o : Options) : Bool 
goal: Bool

full_name: Lean.getPPAnalyzeTrustOfNat
code: def getPPAnalyzeTrustOfNat                  (o : Options) : Bool 
goal: Bool

full_name: Lean.getPPAnalyzeTrustOfScientific
code: def getPPAnalyzeTrustOfScientific           (o : Options) : Bool 
goal: Bool

full_name: Lean.getPPAnalyzeTrustId
code: def getPPAnalyzeTrustId                     (o : Options) : Bool 
goal: Bool

full_name: Lean.getPPAnalyzeTrustSubtypeMk
code: def getPPAnalyzeTrustSubtypeMk              (o : Options) : Bool 
goal: Bool

full_name: Lean.getPPAnalyzeTrustKnownFOType2TypeHOFuns
code: def getPPAnalyzeTrustKnownFOType2TypeHOFuns (o : Options) : Bool 
goal: Bool

full_name: Lean.getPPAnalyzeOmitMax
code: def getPPAnalyzeOmitMax                     (o : Options) : Bool 
goal: Bool

full_name: Lean.getPPAnalyzeKnowsType
code: def getPPAnalyzeKnowsType                   (o : Options) : Bool 
goal: Bool

full_name: Lean.getPPAnalyzeExplicitHoles
code: def getPPAnalyzeExplicitHoles               (o : Options) : Bool 
goal: Bool

full_name: Lean.getPPAnalysisSkip
code: def getPPAnalysisSkip            (o : Options) : Bool 
goal: Bool

full_name: Lean.getPPAnalysisHole
code: def getPPAnalysisHole            (o : Options) : Bool 
goal: Bool

full_name: Lean.getPPAnalysisNamedArg
code: def getPPAnalysisNamedArg        (o : Options) : Bool 
goal: Bool

full_name: Lean.getPPAnalysisLetVarType
code: def getPPAnalysisLetVarType      (o : Options) : Bool 
goal: Bool

full_name: Lean.getPPAnalysisNeedsType
code: def getPPAnalysisNeedsType       (o : Options) : Bool 
goal: Bool

full_name: Lean.getPPAnalysisBlockImplicit
code: def getPPAnalysisBlockImplicit   (o : Options) : Bool 
goal: Bool

full_name: Lean.getPPAnalysisNoDot
code: def getPPAnalysisNoDot           (o : Options) : Bool 
goal: Bool

full_name: Lean.PrettyPrinter.Delaborator.returnsPi
code: def returnsPi (motive : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.PrettyPrinter.Delaborator.isNonConstFun
code: def isNonConstFun (motive : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.PrettyPrinter.Delaborator.isSimpleHOFun
code: def isSimpleHOFun (motive : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.PrettyPrinter.Delaborator.isType2Type
code: def isType2Type (motive : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.PrettyPrinter.Delaborator.isFOLike
code: def isFOLike (motive : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.PrettyPrinter.Delaborator.isIdLike
code: def isIdLike (arg : Expr) : Bool 
goal: Bool

full_name: Lean.PrettyPrinter.Delaborator.isStructureInstance
code: def isStructureInstance (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.hasMVarAtCurrDepth
code: partial def hasMVarAtCurrDepth (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.hasLevelMVarAtCurrDepth
code: partial def hasLevelMVarAtCurrDepth (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: _private.«.lake».packages.lean4.src.lean.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.0.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.valUnknown
code: private def valUnknown (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: _private.«.lake».packages.lean4.src.lean.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.0.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.typeUnknown
code: private def typeUnknown (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.isHBinOp
code: def isHBinOp (e : Expr) : Bool 
goal: Bool

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.replaceLPsWithVars
code: def replaceLPsWithVars (e : Expr) : MetaM Expr 
goal: Lean.MetaM Lean.Expr

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.isDefEqAssigning
code: def isDefEqAssigning (t s : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.checkpointDefEq
code: def checkpointDefEq (t s : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.isHigherOrder
code: def isHigherOrder (type : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.isFunLike
code: def isFunLike (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.isSubstLike
code: def isSubstLike (e : Expr) : Bool 
goal: Bool

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.nameNotRoundtrippable.containsNum
code: def nameNotRoundtrippable (n : Name) : Bool 
goal: Lean.Name → Bool

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.nameNotRoundtrippable
code: def nameNotRoundtrippable (n : Name) : Bool 
goal: Bool

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.mvarName
code: def mvarName (mvar : Expr) : MetaM Name 
goal: Lean.MetaM Lean.Name

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.containsBadMax
code: def containsBadMax : Level → Bool
  
goal: Lean.Level → Bool

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.instInhabitedContext
code: structure Context where
  knowsType   : Bool
  knowsLevel  : Bool -- only constants look at this
  inBottomUp  : Bool := false
  parentIsApp : Bool := false
  subExpr     : SubExpr
  deriving Inhabited
goal: Inhabited Lean.PrettyPrinter.Delaborator.TopDownAnalyze.Context

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.Context.subExpr
code: structure Context where
  knowsType   : Bool
  knowsLevel  : Bool -- only constants look at this
  inBottomUp  : Bool := false
  parentIsApp : Bool := false
  subExpr     : SubExpr
  deriving Inhabited
goal: Lean.SubExpr

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.Context.parentIsApp
code: structure Context where
  knowsType   : Bool
  knowsLevel  : Bool -- only constants look at this
  inBottomUp  : Bool := false
  parentIsApp : Bool := false
  subExpr     : SubExpr
  deriving Inhabited
goal: Bool

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.Context
code: structure Context where
  knowsType   : Bool
  knowsLevel  : Bool -- only constants look at this
  inBottomUp  : Bool := false
  parentIsApp : Bool := false
  subExpr     : SubExpr
  deriving Inhabited
goal: Type

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.Context.knowsLevel
code: structure Context where
  knowsType   : Bool
  knowsLevel  : Bool -- only constants look at this
  inBottomUp  : Bool := false
  parentIsApp : Bool := false
  subExpr     : SubExpr
  deriving Inhabited
goal: Bool

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.Context.inBottomUp
code: structure Context where
  knowsType   : Bool
  knowsLevel  : Bool -- only constants look at this
  inBottomUp  : Bool := false
  parentIsApp : Bool := false
  subExpr     : SubExpr
  deriving Inhabited
goal: Bool

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.Context.knowsType
code: structure Context where
  knowsType   : Bool
  knowsLevel  : Bool -- only constants look at this
  inBottomUp  : Bool := false
  parentIsApp : Bool := false
  subExpr     : SubExpr
  deriving Inhabited
goal: Bool

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.State
code: structure State where
  annotations : OptionsPerPos := {}
  postponed   : Array (Expr × Expr) := #[]
goal: Type

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.State.postponed
code: structure State where
  annotations : OptionsPerPos := {}
  postponed   : Array (Expr × Expr) := #[]
goal: Array (Lean.Expr × Lean.Expr)

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.State.annotations
code: structure State where
  annotations : OptionsPerPos := {}
  postponed   : Array (Expr × Expr) := #[]
goal: Lean.PrettyPrinter.Delaborator.OptionsPerPos

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.AnalyzeM
code: abbrev AnalyzeM 
goal: Type

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.instMonadReaderOfSubExprAnalyzeM
code: instance (priority := low) : MonadReaderOf SubExpr AnalyzeM 
goal: MonadReaderOf Lean.SubExpr Lean.PrettyPrinter.Delaborator.TopDownAnalyze.AnalyzeM

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.instMonadWithReaderOfSubExprAnalyzeM
code: instance (priority := low) : MonadWithReaderOf SubExpr AnalyzeM 
goal: MonadWithReaderOf Lean.SubExpr Lean.PrettyPrinter.Delaborator.TopDownAnalyze.AnalyzeM

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.tryUnify
code: def tryUnify (e₁ e₂ : Expr) : AnalyzeM Unit 
goal: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.AnalyzeM Unit

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.inspectOutParams.inspectAux
code: partial def inspectOutParams (arg mvar : Expr) : AnalyzeM Unit 
goal: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.AnalyzeM Unit

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.inspectOutParams
code: partial def inspectOutParams (arg mvar : Expr) : AnalyzeM Unit 
goal: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.AnalyzeM Unit

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.isTrivialBottomUp
code: partial def isTrivialBottomUp (e : Expr) : AnalyzeM Bool 
goal: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.AnalyzeM Bool

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.canBottomUp
code: partial def canBottomUp (e : Expr) (mvar? : Option Expr := none) (fuel : Nat := 10) : AnalyzeM Bool 
goal: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.AnalyzeM Bool

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.withKnowing
code: def withKnowing (knowsType knowsLevel : Bool) (x : AnalyzeM α) : AnalyzeM α 
goal: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.AnalyzeM α

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.analyzeFailureId
code: builtin_initialize analyzeFailureId : InternalExceptionId ← registerInternalExceptionId `analyzeFailure
goal: Lean.InternalExceptionId

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.initFn._@..lake.packages.lean4.src.lean.Lean.PrettyPrinter.Delaborator.TopDownAnalyze._hyg.3554
code: builtin_initialize analyzeFailureId : InternalExceptionId ← registerInternalExceptionId `analyzeFailure
goal: IO Lean.InternalExceptionId

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.checkKnowsType
code: def checkKnowsType : AnalyzeM Unit 
goal: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.AnalyzeM Unit

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.annotateBoolAt
code: def annotateBoolAt (n : Name) (pos : Pos) : AnalyzeM Unit 
goal: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.AnalyzeM Unit

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.annotateBool
code: def annotateBool (n : Name) : AnalyzeM Unit 
goal: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.AnalyzeM Unit

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.Context.mvars
code: structure App.Context where
  f               : Expr
  fType           : Expr
  args            : Array Expr
  mvars           : Array Expr
  bInfos          : Array BinderInfo
  forceRegularApp : Bool
goal: Array Lean.Expr

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.Context.forceRegularApp
code: structure App.Context where
  f               : Expr
  fType           : Expr
  args            : Array Expr
  mvars           : Array Expr
  bInfos          : Array BinderInfo
  forceRegularApp : Bool
goal: Bool

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.Context
code: structure App.Context where
  f               : Expr
  fType           : Expr
  args            : Array Expr
  mvars           : Array Expr
  bInfos          : Array BinderInfo
  forceRegularApp : Bool
goal: Type

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.Context.f
code: structure App.Context where
  f               : Expr
  fType           : Expr
  args            : Array Expr
  mvars           : Array Expr
  bInfos          : Array BinderInfo
  forceRegularApp : Bool
goal: Lean.Expr

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.Context.fType
code: structure App.Context where
  f               : Expr
  fType           : Expr
  args            : Array Expr
  mvars           : Array Expr
  bInfos          : Array BinderInfo
  forceRegularApp : Bool
goal: Lean.Expr

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.Context.bInfos
code: structure App.Context where
  f               : Expr
  fType           : Expr
  args            : Array Expr
  mvars           : Array Expr
  bInfos          : Array BinderInfo
  forceRegularApp : Bool
goal: Array Lean.BinderInfo

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.Context.args
code: structure App.Context where
  f               : Expr
  fType           : Expr
  args            : Array Expr
  mvars           : Array Expr
  bInfos          : Array BinderInfo
  forceRegularApp : Bool
goal: Array Lean.Expr

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.State.bottomUps
code: structure App.State where
  bottomUps       : Array Bool
  higherOrders    : Array Bool
  funBinders      : Array Bool
  provideds       : Array Bool
  namedArgs       : Array Name := #[]
goal: Array Bool

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.State.provideds
code: structure App.State where
  bottomUps       : Array Bool
  higherOrders    : Array Bool
  funBinders      : Array Bool
  provideds       : Array Bool
  namedArgs       : Array Name := #[]
goal: Array Bool

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.State.funBinders
code: structure App.State where
  bottomUps       : Array Bool
  higherOrders    : Array Bool
  funBinders      : Array Bool
  provideds       : Array Bool
  namedArgs       : Array Name := #[]
goal: Array Bool

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.State.namedArgs
code: structure App.State where
  bottomUps       : Array Bool
  higherOrders    : Array Bool
  funBinders      : Array Bool
  provideds       : Array Bool
  namedArgs       : Array Name := #[]
goal: Array Lean.Name

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.State.higherOrders
code: structure App.State where
  bottomUps       : Array Bool
  higherOrders    : Array Bool
  funBinders      : Array Bool
  provideds       : Array Bool
  namedArgs       : Array Name := #[]
goal: Array Bool

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.State
code: structure App.State where
  bottomUps       : Array Bool
  higherOrders    : Array Bool
  funBinders      : Array Bool
  provideds       : Array Bool
  namedArgs       : Array Name := #[]
goal: Type

full_name: Lean.PrettyPrinter.Delaborator.TopDownAnalyze.AnalyzeAppM
code: abbrev AnalyzeAppM 
goal: Type

full_name: Lean.PrettyPrinter.Delaborator.topDownAnalyze
code: def topDownAnalyze (e : Expr) : MetaM OptionsPerPos 
goal: Lean.MetaM Lean.PrettyPrinter.Delaborator.OptionsPerPos

full_name: Lean.PrettyPrinter.Delaborator.initFn._@..lake.packages.lean4.src.lean.Lean.PrettyPrinter.Delaborator.TopDownAnalyze._hyg.10796
code: builtin_initialize
  registerTraceClass `pp.analyze
  registerTraceClass `pp.analyze.annotate (inherited := true)
  registerTraceClass `pp.analyze.tryUnify (inherited := true)
  registerTraceClass `pp.analyze.error (inherited := true)
goal: IO Unit