File: .lake/packages/lean4/src/lean/Lean/Elab/Tactic/Basic.lean

full_name: Lean.Elab.admitGoal
code: /-- Assign `mvarId := sorry` -/
def admitGoal (mvarId : MVarId) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: Lean.Elab.goalsToMessageData
code: def goalsToMessageData (goals : List MVarId) : MessageData 
goal: Lean.MessageData

full_name: Lean.Elab.Term.reportUnsolvedGoals
code: def Term.reportUnsolvedGoals (goals : List MVarId) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: Lean.Elab.Tactic.Context.elaborator
code: structure Context where
  /-- Declaration name of the executing elaborator, used by `mkTacticInfo` to persist it in the info tree -/
  elaborator : Name
  /--
    If `true`, enable "error recovery" in some tactics. For example, `cases` tactic
    admits unsolved alternatives when `recover == true`. The combinator `withoutRecover <tac>` disables
    "error recovery" while executing `<tac>`. This is useful for tactics such as `first | ... | ...`.
  -/
  recover    : Bool := true
goal: Lean.Name

full_name: Lean.Elab.Tactic.Context
code: structure Context where
  /-- Declaration name of the executing elaborator, used by `mkTacticInfo` to persist it in the info tree -/
  elaborator : Name
  /--
    If `true`, enable "error recovery" in some tactics. For example, `cases` tactic
    admits unsolved alternatives when `recover == true`. The combinator `withoutRecover <tac>` disables
    "error recovery" while executing `<tac>`. This is useful for tactics such as `first | ... | ...`.
  -/
  recover    : Bool := true
goal: Type

full_name: Lean.Elab.Tactic.Context.recover
code: structure Context where
  /-- Declaration name of the executing elaborator, used by `mkTacticInfo` to persist it in the info tree -/
  elaborator : Name
  /--
    If `true`, enable "error recovery" in some tactics. For example, `cases` tactic
    admits unsolved alternatives when `recover == true`. The combinator `withoutRecover <tac>` disables
    "error recovery" while executing `<tac>`. This is useful for tactics such as `first | ... | ...`.
  -/
  recover    : Bool := true
goal: Bool

full_name: Lean.Elab.Tactic.TacticM
code: abbrev TacticM 
goal: Type

full_name: Lean.Elab.Tactic.Tactic
code: abbrev Tactic  
goal: Type

full_name: Lean.Elab.Tactic.instMonadTacticM
code: @[always_inline]
instance : Monad TacticM 
goal: Monad Lean.Elab.Tactic.TacticM

full_name: Lean.Elab.Tactic.getGoals
code: def getGoals : TacticM (List MVarId) 
goal: Lean.Elab.Tactic.TacticM (List Lean.MVarId)

full_name: Lean.Elab.Tactic.setGoals
code: def setGoals (mvarIds : List MVarId) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.pruneSolvedGoals
code: def pruneSolvedGoals : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.getUnsolvedGoals
code: def getUnsolvedGoals : TacticM (List MVarId) 
goal: Lean.Elab.Tactic.TacticM (List Lean.MVarId)

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Basic.0.Lean.Elab.Tactic.TacticM.runCore
code: @[inline] private def TacticM.runCore (x : TacticM α) (ctx : Context) (s : State) : TermElabM (α × State) 
goal: Lean.Elab.TermElabM (α × Lean.Elab.Tactic.State)

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Basic.0.Lean.Elab.Tactic.TacticM.runCore'
code: @[inline] private def TacticM.runCore' (x : TacticM α) (ctx : Context) (s : State) : TermElabM α 
goal: Lean.Elab.TermElabM α

full_name: Lean.Elab.Tactic.run
code: def run (mvarId : MVarId) (x : TacticM Unit) : TermElabM (List MVarId) 
goal: Lean.Elab.TermElabM (List Lean.MVarId)

full_name: Lean.Elab.Tactic.saveState
code: protected def saveState : TacticM SavedState 
goal: Lean.Elab.Tactic.TacticM Lean.Elab.Tactic.SavedState

full_name: Lean.Elab.Tactic.SavedState.restore
code: def SavedState.restore (b : SavedState) (restoreInfo := false) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.withRestoreOrSaveFull
code: @[specialize, inherit_doc Term.withRestoreOrSaveFull]
def withRestoreOrSaveFull (reusableResult? : Option (α × SavedState))
    (tacSnap? : Option (Language.SnapshotBundle Tactic.TacticParsedSnapshot)) (act : TacticM α) :
    TacticM (α × SavedState) 
goal: Lean.Elab.Tactic.TacticM (α × Lean.Elab.Tactic.SavedState)

full_name: Lean.Elab.Tactic.getCurrMacroScope
code: protected def getCurrMacroScope : TacticM MacroScope 
goal: Lean.Elab.Tactic.TacticM Lean.MacroScope

full_name: Lean.Elab.Tactic.getMainModule
code: protected def getMainModule     : TacticM Name       
goal: Lean.Elab.Tactic.TacticM Lean.Name

full_name: Lean.Elab.Tactic.mkTacticAttribute
code: unsafe def mkTacticAttribute : IO (KeyedDeclsAttribute Tactic) 
goal: IO (Lean.KeyedDeclsAttribute Lean.Elab.Tactic.Tactic)

full_name: Lean.Elab.Tactic.tacticElabAttribute
code: @[builtin_init mkTacticAttribute] opaque tacticElabAttribute : KeyedDeclsAttribute Tactic
goal: Lean.KeyedDeclsAttribute Lean.Elab.Tactic.Tactic

full_name: Lean.Elab.Tactic.mkTacticInfo
code: def mkTacticInfo (mctxBefore : MetavarContext) (goalsBefore : List MVarId) (stx : Syntax) : TacticM Info 
goal: Lean.Elab.Tactic.TacticM Lean.Elab.Info

full_name: Lean.Elab.Tactic.mkInitialTacticInfo
code: def mkInitialTacticInfo (stx : Syntax) : TacticM (TacticM Info) 
goal: Lean.Elab.Tactic.TacticM (Lean.Elab.Tactic.TacticM Lean.Elab.Info)

full_name: Lean.Elab.Tactic.withTacticInfoContext
code: @[inline] def withTacticInfoContext (stx : Syntax) (x : TacticM α) : TacticM α 
goal: Lean.Elab.Tactic.TacticM α

full_name: Lean.Elab.Tactic.EvalTacticFailure
code: /--
  Auxiliary datastructure for capturing exceptions at `evalTactic`.
-/
structure EvalTacticFailure where
  exception : Exception
  state : SavedState
goal: Type

full_name: Lean.Elab.Tactic.EvalTacticFailure.state
code: /--
  Auxiliary datastructure for capturing exceptions at `evalTactic`.
-/
structure EvalTacticFailure where
  exception : Exception
  state : SavedState
goal: Lean.Elab.Tactic.SavedState

full_name: Lean.Elab.Tactic.EvalTacticFailure.exception
code: /--
  Auxiliary datastructure for capturing exceptions at `evalTactic`.
-/
structure EvalTacticFailure where
  exception : Exception
  state : SavedState
goal: Lean.Exception

full_name: Lean.Elab.Tactic.evalTactic.expandEval
code: partial def evalTactic (stx : Syntax) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.evalTactic.throwExs
code: partial def evalTactic (stx : Syntax) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.evalTactic.eval
code: partial def evalTactic (stx : Syntax) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.evalTactic.handleEx
code: partial def evalTactic (stx : Syntax) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.evalTactic
code: partial def evalTactic (stx : Syntax) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.throwNoGoalsToBeSolved
code: def throwNoGoalsToBeSolved : TacticM α 
goal: Lean.Elab.Tactic.TacticM α

full_name: Lean.Elab.Tactic.done
code: def done : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.focus
code: def focus (x : TacticM α) : TacticM α 
goal: Lean.Elab.Tactic.TacticM α

full_name: Lean.Elab.Tactic.focusAndDone
code: def focusAndDone (tactic : TacticM α) : TacticM α 
goal: Lean.Elab.Tactic.TacticM α

full_name: Lean.Elab.Tactic.closeUsingOrAdmit
code: /-- Close the main goal using the given tactic. If it fails, log the error and `admit` -/
def closeUsingOrAdmit (tac : TacticM Unit) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.instMonadBacktrackSavedStateTacticM
code: instance : MonadBacktrack SavedState TacticM 
goal: Lean.MonadBacktrack Lean.Elab.Tactic.SavedState Lean.Elab.Tactic.TacticM

full_name: Lean.Elab.Tactic.tryCatch
code: @[inline] protected def tryCatch {α} (x : TacticM α) (h : Exception → TacticM α) : TacticM α 
goal: Lean.Elab.Tactic.TacticM α

full_name: Lean.Elab.Tactic.instMonadExceptExceptionTacticM
code: instance : MonadExcept Exception TacticM 
goal: MonadExcept Lean.Exception Lean.Elab.Tactic.TacticM

full_name: Lean.Elab.Tactic.withoutRecover
code: /-- Execute `x` with error recovery disabled -/
def withoutRecover (x : TacticM α) : TacticM α 
goal: Lean.Elab.Tactic.TacticM α

full_name: Lean.Elab.Tactic.orElse
code: @[inline] protected def orElse (x : TacticM α) (y : Unit → TacticM α) : TacticM α 
goal: Lean.Elab.Tactic.TacticM α

full_name: Lean.Elab.Tactic.instOrElseTacticM
code: instance : OrElse (TacticM α) 
goal: OrElse (Lean.Elab.Tactic.TacticM α)

full_name: Lean.Elab.Tactic.instAlternativeTacticM
code: instance : Alternative TacticM 
goal: Alternative Lean.Elab.Tactic.TacticM

full_name: Lean.Elab.Tactic.saveTacticInfoForToken
code: /--
  Save the current tactic state for a token `stx`.
  This method is a no-op if `stx` has no position information.
  We use this method to save the tactic state at punctuation such as `;`
-/
def saveTacticInfoForToken (stx : Syntax) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.withMacroExpansion
code: /-- Elaborate `x` with `stx` on the macro stack -/
@[inline]
def withMacroExpansion (beforeStx afterStx : Syntax) (x : TacticM α) : TacticM α 
goal: Lean.Elab.Tactic.TacticM α

full_name: Lean.Elab.Tactic.adaptExpander
code: /-- Adapt a syntax transformation to a regular tactic evaluator. -/
def adaptExpander (exp : Syntax → TacticM Syntax) : Tactic 
goal: Lean.Elab.Tactic.Tactic

full_name: Lean.Elab.Tactic.appendGoals
code: /-- Add the given goals at the end of the current goals collection. -/
def appendGoals (mvarIds : List MVarId) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.replaceMainGoal
code: /-- Discard the first goal and replace it by the given list of goals,
keeping the other goals. -/
def replaceMainGoal (mvarIds : List MVarId) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.getMainGoal.loop
code: /-- Return the first goal. -/
def getMainGoal : TacticM MVarId 
goal: List Lean.MVarId → Lean.Elab.Tactic.TacticM Lean.MVarId

full_name: Lean.Elab.Tactic.getMainGoal
code: /-- Return the first goal. -/
def getMainGoal : TacticM MVarId 
goal: Lean.Elab.Tactic.TacticM Lean.MVarId

full_name: Lean.Elab.Tactic.getMainDecl
code: /-- Return the main goal metavariable declaration. -/
def getMainDecl : TacticM MetavarDecl 
goal: Lean.Elab.Tactic.TacticM Lean.MetavarDecl

full_name: Lean.Elab.Tactic.getMainTag
code: /-- Return the main goal tag. -/
def getMainTag : TacticM Name 
goal: Lean.Elab.Tactic.TacticM Lean.Name

full_name: Lean.Elab.Tactic.getMainTarget
code: /-- Return expected type for the main goal. -/
def getMainTarget : TacticM Expr 
goal: Lean.Elab.Tactic.TacticM Lean.Expr

full_name: Lean.Elab.Tactic.withMainContext
code: /-- Execute `x` using the main goal local context and instances -/
def withMainContext (x : TacticM α) : TacticM α 
goal: Lean.Elab.Tactic.TacticM α

full_name: Lean.Elab.Tactic.evalTacticAt
code: /-- Evaluate `tac` at `mvarId`, and return the list of resulting subgoals. -/
def evalTacticAt (tac : Syntax) (mvarId : MVarId) : TacticM (List MVarId) 
goal: Lean.Elab.Tactic.TacticM (List Lean.MVarId)

full_name: Lean.Elab.Tactic.evalTacticAtRaw
code: /--
Like `evalTacticAt`, but without restoring the goal list or pruning solved goals.
Useful when these tasks are already being done in an outer loop.
-/
def evalTacticAtRaw (tac : Syntax) (mvarId : MVarId) : TacticM (List MVarId) 
goal: Lean.Elab.Tactic.TacticM (List Lean.MVarId)

full_name: Lean.Elab.Tactic.ensureHasNoMVars
code: def ensureHasNoMVars (e : Expr) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.closeMainGoal
code: /-- Close main goal using the given expression. If `checkUnassigned == true`, then `val` must not contain unassigned metavariables. -/
def closeMainGoal (val : Expr) (checkUnassigned := true): TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.liftMetaMAtMain
code: @[inline] def liftMetaMAtMain (x : MVarId → MetaM α) : TacticM α 
goal: Lean.Elab.Tactic.TacticM α

full_name: Lean.Elab.Tactic.liftMetaTacticAux
code: @[inline] def liftMetaTacticAux (tac : MVarId → MetaM (α × List MVarId)) : TacticM α 
goal: Lean.Elab.Tactic.TacticM α

full_name: Lean.Elab.Tactic.liftMetaTactic
code: /-- Get the mvarid of the main goal, run the given `tactic`,
then set the new goals to be the resulting goal list.-/
@[inline] def liftMetaTactic (tactic : MVarId → MetaM (List MVarId)) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.liftMetaTactic1
code: @[inline] def liftMetaTactic1 (tactic : MVarId → MetaM (Option MVarId)) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.liftMetaFinishingTactic
code: /-- Analogue of `liftMetaTactic` for tactics that do not return any goals. -/
@[inline] def liftMetaFinishingTactic (tac : MVarId → MetaM Unit) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.tryTactic?
code: def tryTactic? (tactic : TacticM α) : TacticM (Option α) 
goal: Lean.Elab.Tactic.TacticM (Option α)

full_name: Lean.Elab.Tactic.tryTactic
code: def tryTactic (tactic : TacticM α) : TacticM Bool 
goal: Lean.Elab.Tactic.TacticM Bool

full_name: Lean.Elab.Tactic.tagUntaggedGoals
code: /--
  Use `parentTag` to tag untagged goals at `newGoals`.
  If there are multiple new untagged goals, they are named using `<parentTag>.<newSuffix>_<idx>` where `idx > 0`.
  If there is only one new untagged goal, then we just use `parentTag` -/
def tagUntaggedGoals (parentTag : Name) (newSuffix : Name) (newGoals : List MVarId) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.getNameOfIdent'
code: def getNameOfIdent' (id : Syntax) : Name 
goal: Lean.Name

full_name: Lean.Elab.Tactic.withCaseRef
code: /--
  Use position of `=> $body` for error messages.
  If there is a line break before `body`, the message will be displayed on `=>` only,
  but the "full range" for the info view will still include `body`. -/
def withCaseRef [Monad m] [MonadRef m] (arrow body : Syntax) (x : m α) : m α 
goal: m α

full_name: Lean.Elab.Tactic.initFn._@..lake.packages.lean4.src.lean.Lean.Elab.Tactic.Basic._hyg.8235
code: builtin_initialize registerTraceClass `Elab.tactic
goal: IO Unit

full_name: Lean.Elab.Tactic.initFn._@..lake.packages.lean4.src.lean.Lean.Elab.Tactic.Basic._hyg.8288
code: builtin_initialize registerTraceClass `Elab.tactic.backtrack
goal: IO Unit