File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/Apply.lean

full_name: Lean.Meta.getExpectedNumArgsAux
code: /--
  Compute the number of expected arguments and whether the result type is of the form
  (?m ...) where ?m is an unassigned metavariable.
-/
def getExpectedNumArgsAux (e : Expr) : MetaM (Nat × Bool) 
goal: Lean.MetaM (Nat × Bool)

full_name: Lean.Meta.getExpectedNumArgs
code: def getExpectedNumArgs (e : Expr) : MetaM Nat 
goal: Lean.MetaM Nat

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.Tactic.Apply.0.Lean.Meta.throwApplyError
code: private def throwApplyError {α} (mvarId : MVarId) (eType : Expr) (targetType : Expr) : MetaM α 
goal: Lean.MetaM α

full_name: Lean.Meta.synthAppInstances
code: def synthAppInstances (tacticName : Name) (mvarId : MVarId) (newMVars : Array Expr) (binderInfos : Array BinderInfo)
    (synthAssignedInstances : Bool) (allowSynthFailures : Bool) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: Lean.Meta.appendParentTag
code: def appendParentTag (mvarId : MVarId) (newMVars : Array Expr) (binderInfos : Array BinderInfo) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: Lean.Meta.postprocessAppMVars
code: /--
If `synthAssignedInstances` is `true`, then `apply` will synthesize instance implicit arguments
even if they have assigned by `isDefEq`, and then check whether the synthesized value matches the
one inferred. The `congr` tactic sets this flag to false.
-/
def postprocessAppMVars (tacticName : Name) (mvarId : MVarId) (newMVars : Array Expr) (binderInfos : Array BinderInfo)
    (synthAssignedInstances := true) (allowSynthFailures := false) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.Tactic.Apply.0.Lean.Meta.dependsOnOthers
code: private def dependsOnOthers (mvar : Expr) (otherMVars : Array Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.Tactic.Apply.0.Lean.Meta.partitionDependentMVars
code: /-- Partitions the given mvars in to two arrays (non-deps, deps)
according to whether the given mvar depends on other mvars in the array.-/
private def partitionDependentMVars (mvars : Array Expr) : MetaM (Array MVarId × Array MVarId) 
goal: Lean.MetaM (Array Lean.MVarId × Array Lean.MVarId)

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.Tactic.Apply.0.Lean.Meta.reorderGoals
code: private def reorderGoals (mvars : Array Expr) : ApplyNewGoals → MetaM (List MVarId)
  
goal: Lean.Meta.ApplyNewGoals → Lean.MetaM (List Lean.MVarId)

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.Tactic.Apply.0.Lean.Meta.isDefEqApply
code: /-- Custom `isDefEq` for the `apply` tactic -/
private def isDefEqApply (cfg : ApplyConfig) (a b : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.MVarId.apply
code: /--
Close the given goal using `apply e`.
-/
def _root_.Lean.MVarId.apply (mvarId : MVarId) (e : Expr) (cfg : ApplyConfig := {}) : MetaM (List MVarId) 
goal: Lean.MetaM (List Lean.MVarId)

full_name: Lean.MVarId.apply.go
code: /--
Close the given goal using `apply e`.
-/
def _root_.Lean.MVarId.apply (mvarId : MVarId) (e : Expr) (cfg : ApplyConfig := {}) : MetaM (List MVarId) 
goal: Lean.MetaM (Array Lean.Expr × Array Lean.BinderInfo)

full_name: Lean.Meta.apply
code: @[deprecated MVarId.apply (since := "2022-07-15")]
def apply (mvarId : MVarId) (e : Expr) (cfg : ApplyConfig := {}) : MetaM (List MVarId) 
goal: Lean.MetaM (List Lean.MVarId)

full_name: Lean.MVarId.applyConst
code: /-- Short-hand for applying a constant to the goal. -/
def _root_.Lean.MVarId.applyConst (mvar : MVarId) (c : Name) (cfg : ApplyConfig := {}) : MetaM (List MVarId) 
goal: Lean.MetaM (List Lean.MVarId)

full_name: Lean.MVarId.splitAndCore.go
code: partial def splitAndCore (mvarId : MVarId) : MetaM (List MVarId) 
goal: StateRefT' IO.RealWorld (Array Lean.MVarId) Lean.MetaM Lean.Expr

full_name: Lean.MVarId.splitAndCore
code: partial def splitAndCore (mvarId : MVarId) : MetaM (List MVarId) 
goal: Lean.MetaM (List Lean.MVarId)

full_name: Lean.MVarId.splitAnd
code: /--
Apply `And.intro` as much as possible to goal `mvarId`.
-/
abbrev splitAnd (mvarId : MVarId) : MetaM (List MVarId) 
goal: Lean.MetaM (List Lean.MVarId)

full_name: Lean.Meta.splitAnd
code: @[deprecated splitAnd] -- 2024-03-17
def _root_.Lean.Meta.splitAnd (mvarId : MVarId) : MetaM (List MVarId) 
goal: Lean.MetaM (List Lean.MVarId)

full_name: Lean.MVarId.exfalso
code: def exfalso (mvarId : MVarId) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.MVarId.nthConstructor
code: /--
Apply the `n`-th constructor of the target type,
checking that it is an inductive type,
and that there are the expected number of constructors.
-/
def nthConstructor
    (name : Name) (idx : Nat) (expected? : Option Nat := none) (goal : MVarId) :
    MetaM (List MVarId) 
goal: Lean.MetaM (List Lean.MVarId)

full_name: Lean.MVarId.iffOfEq
code: /--
Try to convert an `Iff` into an `Eq` by applying `iff_of_eq`.
If successful, returns the new goal, and otherwise returns the original `MVarId`.

This may be regarded as being a special case of `Lean.MVarId.liftReflToEq`, specifically for `Iff`.
-/
def iffOfEq (mvarId : MVarId) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.MVarId.propext
code: /--
Try to convert an `Eq` into an `Iff` by applying `propext`.
If successful, then returns then new goal, otherwise returns the original `MVarId`.
-/
def propext (mvarId : MVarId) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.MVarId.proofIrrelHeq
code: /--
Try to close the goal using `proof_irrel_heq`. Returns whether or not it succeeds.

We need to be somewhat careful not to assign metavariables while doing this, otherwise we might
specialize `Sort _` to `Prop`.
-/
def proofIrrelHeq (mvarId : MVarId) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.MVarId.subsingletonElim
code: /--
Try to close the goal using `Subsingleton.elim`. Returns whether or not it succeeds.

We are careful to apply `Subsingleton.elim` in a way that does not assign any metavariables.
This is to prevent the `Subsingleton Prop` instance from being used as justification to specialize
`Sort _` to `Prop`.
-/
def subsingletonElim (mvarId : MVarId) : MetaM Bool 
goal: Lean.MetaM Bool