File: .lake/packages/lean4/src/lean/Init/Meta.lean

full_name: _private.«.lake».packages.lean4.src.lean.Init.Meta.0.Lean.version.getMajor
code: @[extern "lean_version_get_major"]
private opaque version.getMajor (u : Unit) : Nat
goal: Nat

full_name: Lean.version.major
code: def version.major : Nat 
goal: Nat

full_name: _private.«.lake».packages.lean4.src.lean.Init.Meta.0.Lean.version.getMinor
code: @[extern "lean_version_get_minor"]
private opaque version.getMinor (u : Unit) : Nat
goal: Nat

full_name: Lean.version.minor
code: def version.minor : Nat 
goal: Nat

full_name: _private.«.lake».packages.lean4.src.lean.Init.Meta.0.Lean.version.getPatch
code: @[extern "lean_version_get_patch"]
private opaque version.getPatch (u : Unit) : Nat
goal: Nat

full_name: Lean.version.patch
code: def version.patch : Nat 
goal: Nat

full_name: Lean.getGithash
code: @[extern "lean_get_githash"]
opaque getGithash (u : Unit) : String
goal: String

full_name: Lean.githash
code: def githash : String 
goal: String

full_name: Lean.version.getIsRelease
code: @[extern "lean_version_get_is_release"]
opaque version.getIsRelease (u : Unit) : Bool
goal: Bool

full_name: Lean.version.isRelease
code: def version.isRelease : Bool 
goal: Bool

full_name: Lean.version.getSpecialDesc
code: /-- Additional version description like "nightly-2018-03-11" -/
@[extern "lean_version_get_special_desc"]
opaque version.getSpecialDesc (u : Unit) : String
goal: String

full_name: Lean.version.specialDesc
code: def version.specialDesc : String 
goal: String

full_name: Lean.versionStringCore
code: def versionStringCore 
goal: String

full_name: Lean.versionString
code: def versionString 
goal: String

full_name: Lean.origin
code: def origin 
goal: String

full_name: Lean.toolchain
code: def toolchain 
goal: String

full_name: Lean.Internal.isStage0
code: @[extern "lean_internal_is_stage0"]
opaque Internal.isStage0 (u : Unit) : Bool
goal: Bool

full_name: Lean.Internal.hasLLVMBackend
code: /--
This function can be used to detect whether the compiler has support for
generating LLVM instead of C. It is used by lake instead of the --features
flag in order to avoid having to run a compiler for this every time on startup.
See #2572.
-/
@[extern "lean_internal_has_llvm_backend"]
opaque Internal.hasLLVMBackend (u : Unit) : Bool
goal: Bool

full_name: Lean.isGreek
code: /-- Valid identifier names -/
def isGreek (c : Char) : Bool 
goal: Bool

full_name: Lean.isLetterLike
code: def isLetterLike (c : Char) : Bool 
goal: Bool

full_name: Lean.isNumericSubscript
code: def isNumericSubscript (c : Char) : Bool 
goal: Bool

full_name: Lean.isSubScriptAlnum
code: def isSubScriptAlnum (c : Char) : Bool 
goal: Bool

full_name: Lean.isIdFirst
code: def isIdFirst (c : Char) : Bool 
goal: Bool

full_name: Lean.isIdRest
code: def isIdRest (c : Char) : Bool 
goal: Bool

full_name: Lean.idBeginEscape
code: def idBeginEscape 
goal: Char

full_name: Lean.idEndEscape
code: def idEndEscape   
goal: Char

full_name: Lean.isIdBeginEscape
code: def isIdBeginEscape (c : Char) : Bool 
goal: Bool

full_name: Lean.isIdEndEscape
code: def isIdEndEscape (c : Char) : Bool 
goal: Bool

full_name: Lean.Name.getRoot
code: def getRoot : Name → Name
  
goal: Lean.Name → Lean.Name

full_name: Lean.Name.isInaccessibleUserName
code: @[export lean_is_inaccessible_user_name]
def isInaccessibleUserName : Name → Bool
  
goal: Lean.Name → Bool

full_name: Lean.Name.escapePart
code: def escapePart (s : String) : Option String 
goal: Option String

full_name: Lean.Name.toStringWithSep
code: def toStringWithSep : Name → String
  
goal: Lean.Name → String

full_name: Lean.Name.toStringWithSep.maybeEscape
code: def toStringWithSep : Name → String
  
goal: String

full_name: Lean.Name.toString.maybePseudoSyntax
code: protected def toString (n : Name) (escape := true) : String 
goal: Bool

full_name: Lean.Name.toString
code: protected def toString (n : Name) (escape := true) : String 
goal: String

full_name: Lean.Name.«instToString_.lake»
code: instance : ToString Name 
goal: ToString Lean.Name

full_name: _private.«.lake».packages.lean4.src.lean.Init.Meta.0.Lean.Name.hasNum
code: private def hasNum : Name → Bool
  
goal: Lean.Name → Bool

full_name: Lean.Name.reprPrec
code: protected def reprPrec (n : Name) (prec : Nat) : Std.Format 
goal: Std.Format

full_name: Lean.Name.«instRepr_.lake»
code: instance : Repr Name 
goal: Repr Lean.Name

full_name: Lean.Name.capitalize
code: def capitalize : Name → Name
  
goal: Lean.Name → Lean.Name

full_name: Lean.Name.replacePrefix
code: def replacePrefix : Name → Name → Name → Name
  
goal: Lean.Name → Lean.Name → Lean.Name → Lean.Name

full_name: Lean.Name.eraseSuffix?
code: /--
  `eraseSuffix? n s` return `n'` if `n` is of the form `n == n' ++ s`.
-/
def eraseSuffix? : Name → Name → Option Name
  
goal: Lean.Name → Lean.Name → Option Lean.Name

full_name: Lean.Name.modifyBase
code: /-- Remove macros scopes, apply `f`, and put them back -/
@[inline] def modifyBase (n : Name) (f : Name → Name) : Name 
goal: Lean.Name

full_name: Lean.Name.appendAfter
code: @[export lean_name_append_after]
def appendAfter (n : Name) (suffix : String) : Name 
goal: Lean.Name

full_name: Lean.Name.appendIndexAfter
code: @[export lean_name_append_index_after]
def appendIndexAfter (n : Name) (idx : Nat) : Name 
goal: Lean.Name

full_name: Lean.Name.appendBefore
code: @[export lean_name_append_before]
def appendBefore (n : Name) (pre : String) : Name 
goal: Lean.Name

full_name: Lean.Name.beq_iff_eq
code: protected theorem beq_iff_eq {m n : Name} : m == n ↔ m = n 
goal: (m == n) = true ↔ m = n

full_name: Lean.Name.«instLawfulBEq_.lake»
code: instance : LawfulBEq Name 
goal: LawfulBEq Lean.Name

full_name: Lean.Name.«instDecidableEq_.lake»
code: instance : DecidableEq Name 
goal: DecidableEq Lean.Name

full_name: Lean.NameGenerator.curr
code: @[inline] def curr (g : NameGenerator) : Name 
goal: Lean.Name

full_name: Lean.NameGenerator.next
code: @[inline] def next (g : NameGenerator) : NameGenerator 
goal: Lean.NameGenerator

full_name: Lean.NameGenerator.mkChild
code: @[inline] def mkChild (g : NameGenerator) : NameGenerator × NameGenerator 
goal: Lean.NameGenerator × Lean.NameGenerator

full_name: Lean.MonadNameGenerator.getNGen
code: class MonadNameGenerator (m : Type → Type) where
  getNGen : m NameGenerator
  setNGen : NameGenerator → m Unit
goal: m Lean.NameGenerator

full_name: Lean.MonadNameGenerator
code: class MonadNameGenerator (m : Type → Type) where
  getNGen : m NameGenerator
  setNGen : NameGenerator → m Unit
goal: Type

full_name: Lean.MonadNameGenerator.setNGen
code: class MonadNameGenerator (m : Type → Type) where
  getNGen : m NameGenerator
  setNGen : NameGenerator → m Unit
goal: Lean.NameGenerator → m Unit

full_name: Lean.mkFreshId
code: def mkFreshId {m : Type → Type} [Monad m] [MonadNameGenerator m] : m Name 
goal: m Lean.Name

full_name: Lean.monadNameGeneratorLift
code: instance monadNameGeneratorLift (m n : Type → Type) [MonadLift m n] [MonadNameGenerator m] : MonadNameGenerator n 
goal: Lean.MonadNameGenerator n

full_name: Lean.Syntax.«instReprPreresolved_.lake»
code: Repr
goal: Repr Lean.Syntax.Preresolved

full_name: Lean.Syntax.«instRepr_.lake»
code: Repr
goal: Repr Lean.Syntax

full_name: Lean.Syntax.«instReprTSyntax_.lake»
code: Repr
goal: {ks : Lean.SyntaxNodeKinds} → Repr (Lean.TSyntax ks)

full_name: Lean.Syntax.Term
code: abbrev Term 
goal: Type

full_name: Lean.Syntax.Command
code: abbrev Command 
goal: Type

full_name: Lean.Syntax.Level
code: protected abbrev Level 
goal: Type

full_name: Lean.Syntax.Tactic
code: protected abbrev Tactic 
goal: Type

full_name: Lean.Syntax.Prec
code: abbrev Prec 
goal: Type

full_name: Lean.Syntax.Prio
code: abbrev Prio 
goal: Type

full_name: Lean.Syntax.Ident
code: abbrev Ident 
goal: Type

full_name: Lean.Syntax.StrLit
code: abbrev StrLit 
goal: Type

full_name: Lean.Syntax.CharLit
code: abbrev CharLit 
goal: Type

full_name: Lean.Syntax.NameLit
code: abbrev NameLit 
goal: Type

full_name: Lean.Syntax.ScientificLit
code: abbrev ScientificLit 
goal: Type

full_name: Lean.Syntax.NumLit
code: abbrev NumLit 
goal: Type

full_name: Lean.Syntax.HygieneInfo
code: abbrev HygieneInfo 
goal: Type

full_name: Lean.TSyntax.«instCoeConsSyntaxNodeKindNil_.lake»
code: instance : Coe (TSyntax [k]) (TSyntax (k :: ks)) 
goal: Coe (Lean.TSyntax (k :: List.nil)) (Lean.TSyntax (k :: ks))

full_name: Lean.TSyntax.«instCoeConsSyntaxNodeKind_.lake»
code: instance : Coe (TSyntax ks) (TSyntax (k' :: ks)) 
goal: Coe (Lean.TSyntax ks) (Lean.TSyntax (k' :: ks))

full_name: Lean.TSyntax.instCoeIdentTerm
code: instance : Coe Ident Term 
goal: Coe Lean.Ident Lean.Term

full_name: Lean.TSyntax.instCoeDepTermMkIdentIdent
code: instance : CoeDep Term ⟨Syntax.ident info ss n res⟩ Ident 
goal: CoeDep Lean.Term { raw := Lean.Syntax.ident info ss n res } Lean.Ident

full_name: Lean.TSyntax.instCoeStrLitTerm
code: instance : Coe StrLit Term 
goal: Coe Lean.StrLit Lean.Term

full_name: Lean.TSyntax.instCoeNameLitTerm
code: instance : Coe NameLit Term 
goal: Coe Lean.NameLit Lean.Term

full_name: Lean.TSyntax.instCoeScientificLitTerm
code: instance : Coe ScientificLit Term 
goal: Coe Lean.ScientificLit Lean.Term

full_name: Lean.TSyntax.instCoeNumLitTerm
code: instance : Coe NumLit Term 
goal: Coe Lean.NumLit Lean.Term

full_name: Lean.TSyntax.instCoeCharLitTerm
code: instance : Coe CharLit Term 
goal: Coe Lean.CharLit Lean.Term

full_name: Lean.TSyntax.instCoeIdentLevel
code: instance : Coe Ident Syntax.Level 
goal: Coe Lean.Ident Lean.Syntax.Level

full_name: Lean.TSyntax.instCoeNumLitPrio
code: instance : Coe NumLit Prio 
goal: Coe Lean.NumLit Lean.Prio

full_name: Lean.TSyntax.instCoeNumLitPrec
code: instance : Coe NumLit Prec 
goal: Coe Lean.NumLit Lean.Prec

full_name: Lean.TSyntax.Compat.«instCoeTailSyntax_.lake»
code: scoped instance : CoeTail Syntax (TSyntax k) 
goal: CoeTail Lean.Syntax (Lean.TSyntax k)

full_name: Lean.TSyntax.Compat.«instCoeTailArraySyntaxTSyntaxArray_.lake»
code: scoped instance : CoeTail (Array Syntax) (TSyntaxArray k) 
goal: CoeTail (Array Lean.Syntax) (Lean.TSyntaxArray k)

full_name: Lean.Syntax.«instBEqPreresolved_.lake»
code: BEq
goal: BEq Lean.Syntax.Preresolved

full_name: Lean.Syntax.structEq
code: /-- Compare syntax structures modulo source info. -/
partial def structEq : Syntax → Syntax → Bool
  
goal: Lean.Syntax → Lean.Syntax → Bool

full_name: Lean.Syntax.«instBEq_.lake»
code: instance : BEq Lean.Syntax 
goal: BEq Lean.Syntax

full_name: Lean.Syntax.«instBEqTSyntax_.lake»
code: instance : BEq (Lean.TSyntax k) 
goal: BEq (Lean.TSyntax k)

full_name: Lean.Syntax.getTailInfo?
code: partial def getTailInfo? : Syntax → Option SourceInfo
  
goal: Lean.Syntax → Option Lean.SourceInfo

full_name: Lean.Syntax.getTailInfo
code: def getTailInfo (stx : Syntax) : SourceInfo 
goal: Lean.SourceInfo

full_name: Lean.Syntax.getTrailingSize
code: def getTrailingSize (stx : Syntax) : Nat 
goal: Nat

full_name: Lean.Syntax.getSubstring?
code: /--
  Return substring of original input covering `stx`.
  Result is meaningful only if all involved `SourceInfo.original`s refer to the same string (as is the case after parsing). -/
def getSubstring? (stx : Syntax) (withLeading := true) (withTrailing := true) : Option Substring 
goal: Option Substring

full_name: _private.«.lake».packages.lean4.src.lean.Init.Meta.0.Lean.Syntax.updateLast
code: @[specialize] private partial def updateLast {α} [Inhabited α] (a : Array α) (f : α → Option α) (i : Nat) : Option (Array α) 
goal: Option (Array α)

full_name: Lean.Syntax.setTailInfoAux
code: partial def setTailInfoAux (info : SourceInfo) : Syntax → Option Syntax
  
goal: Lean.Syntax → Option Lean.Syntax

full_name: Lean.Syntax.setTailInfo
code: def setTailInfo (stx : Syntax) (info : SourceInfo) : Syntax 
goal: Lean.Syntax

full_name: Lean.Syntax.unsetTrailing
code: def unsetTrailing (stx : Syntax) : Syntax 
goal: Lean.Syntax

full_name: _private.«.lake».packages.lean4.src.lean.Init.Meta.0.Lean.Syntax.updateFirst
code: @[specialize] private partial def updateFirst {α} [Inhabited α] (a : Array α) (f : α → Option α) (i : Nat) : Option (Array α) 
goal: Option (Array α)

full_name: Lean.Syntax.setHeadInfoAux
code: partial def setHeadInfoAux (info : SourceInfo) : Syntax → Option Syntax
  
goal: Lean.Syntax → Option Lean.Syntax

full_name: Lean.Syntax.setHeadInfo
code: def setHeadInfo (stx : Syntax) (info : SourceInfo) : Syntax 
goal: Lean.Syntax

full_name: Lean.Syntax.setInfo
code: def setInfo (info : SourceInfo) : Syntax → Syntax
  
goal: Lean.Syntax → Lean.Syntax

full_name: Lean.Syntax.getHead?
code: /-- Return the first atom/identifier that has position information -/
partial def getHead? : Syntax → Option Syntax
  
goal: Lean.Syntax → Option Lean.Syntax

full_name: Lean.Syntax.copyHeadTailInfoFrom
code: def copyHeadTailInfoFrom (target source : Syntax) : Syntax 
goal: Lean.Syntax

full_name: Lean.Syntax.mkSynthetic
code: /-- Ensure head position is synthetic. The server regards syntax as "original" only if both head and tail info are `original`. -/
def mkSynthetic (stx : Syntax) : Syntax 
goal: Lean.Syntax

full_name: Lean.withHeadRefOnly
code: /-- Use the head atom/identifier of the current `ref` as the `ref` -/
@[inline] def withHeadRefOnly {m : Type → Type} [Monad m] [MonadRef m] {α} (x : m α) : m α 
goal: m α

full_name: Lean.expandMacros
code: /--
  Expand macros in the given syntax.
  A node with kind `k` is visited only if `p k` is true.

  Note that the default value for `p` returns false for `by ...` nodes.
  This is a "hack". The tactic framework abuses the macro system to implement extensible tactics.
  For example, one can define
  ```lean
  syntax "my_trivial" : tactic -- extensible tactic

  macro_rules | `(tactic| my_trivial) => `(tactic| decide)
  macro_rules | `(tactic| my_trivial) => `(tactic| assumption)
  ```
  When the tactic evaluator finds the tactic `my_trivial`, it tries to evaluate the `macro_rule` expansions
  until one "works", i.e., the macro expansion is evaluated without producing an exception.
  We say this solution is a bit hackish because the term elaborator may invoke `expandMacros` with `(p := fun _ => true)`,
  and expand the tactic macros as just macros. In the example above, `my_trivial` would be replaced with `assumption`,
  `decide` would not be tried if `assumption` fails at tactic evaluation time.

  We are considering two possible solutions for this issue:
  1- A proper extensible tactic feature that does not rely on the macro system.

  2- Typed macros that know the syntax categories they're working in. Then, we would be able to select which
     syntactic categories are expanded by `expandMacros`.
-/
partial def expandMacros (stx : Syntax) (p : SyntaxNodeKind → Bool := fun k => k != `Lean.Parser.Term.byTactic) : MacroM Syntax 
goal: Lean.MacroM Lean.Syntax

full_name: Lean.mkIdentFrom
code: /--
  Create an identifier copying the position from `src`.
  To refer to a specific constant, use `mkCIdentFrom` instead. -/
def mkIdentFrom (src : Syntax) (val : Name) (canonical := false) : Ident 
goal: Lean.Ident

full_name: Lean.mkIdentFromRef
code: def mkIdentFromRef [Monad m] [MonadRef m] (val : Name) (canonical := false) : m Ident 
goal: m Lean.Ident

full_name: Lean.mkCIdentFrom
code: /--
  Create an identifier referring to a constant `c` copying the position from `src`.
  This variant of `mkIdentFrom` makes sure that the identifier cannot accidentally
  be captured. -/
def mkCIdentFrom (src : Syntax) (c : Name) (canonical := false) : Ident 
goal: Lean.Ident

full_name: Lean.mkCIdentFromRef
code: def mkCIdentFromRef [Monad m] [MonadRef m] (c : Name) (canonical := false) : m Syntax 
goal: m Lean.Syntax

full_name: Lean.mkCIdent
code: def mkCIdent (c : Name) : Ident 
goal: Lean.Ident

full_name: Lean.mkIdent
code: @[export lean_mk_syntax_ident]
def mkIdent (val : Name) : Ident 
goal: Lean.Ident

full_name: Lean.mkGroupNode
code: @[inline] def mkGroupNode (args : Array Syntax := #[]) : Syntax 
goal: Lean.Syntax

full_name: Lean.mkSepArray
code: def mkSepArray (as : Array Syntax) (sep : Syntax) : Array Syntax 
goal: Array Lean.Syntax

full_name: Lean.mkOptionalNode
code: def mkOptionalNode (arg : Option Syntax) : Syntax 
goal: Lean.Syntax

full_name: Lean.mkHole
code: def mkHole (ref : Syntax) (canonical := false) : Syntax 
goal: Lean.Syntax

full_name: Lean.Syntax.mkSep
code: def mkSep (a : Array Syntax) (sep : Syntax) : Syntax 
goal: Lean.Syntax

full_name: Lean.Syntax.SepArray.ofElems
code: def SepArray.ofElems {sep} (elems : Array Syntax) : SepArray sep 
goal: Lean.Syntax.SepArray sep

full_name: Lean.Syntax.SepArray.ofElemsUsingRef
code: def SepArray.ofElemsUsingRef [Monad m] [MonadRef m] {sep} (elems : Array Syntax) : m (SepArray sep) 
goal: m (Lean.Syntax.SepArray sep)

full_name: Lean.Syntax.«instCoeArraySepArray_.lake»
code: instance : Coe (Array Syntax) (SepArray sep) 
goal: Coe (Array Lean.Syntax) (Lean.Syntax.SepArray sep)

full_name: Lean.Syntax.TSepArray.ofElems
code: /--
Constructs a typed separated array from elements.
The given array does not include the separators.

Like `Syntax.SepArray.ofElems` but for typed syntax.
-/
def TSepArray.ofElems {sep} (elems : Array (TSyntax k)) : TSepArray k sep 
goal: Lean.Syntax.TSepArray k sep

full_name: Lean.Syntax.«instCoeTSyntaxArrayTSepArray_.lake»
code: instance : Coe (TSyntaxArray k) (TSepArray k sep) 
goal: Coe (Lean.TSyntaxArray k) (Lean.Syntax.TSepArray k sep)

full_name: Lean.Syntax.mkApp
code: /-- Create syntax representing a Lean term application, but avoid degenerate empty applications. -/
def mkApp (fn : Term) : (args : TSyntaxArray `term) → Term
  
goal: Lean.Term

full_name: Lean.Syntax.mkCApp
code: def mkCApp (fn : Name) (args : TSyntaxArray `term) : Term 
goal: Lean.Term

full_name: Lean.Syntax.mkLit
code: def mkLit (kind : SyntaxNodeKind) (val : String) (info := SourceInfo.none) : TSyntax kind 
goal: Lean.TSyntax (kind :: List.nil)

full_name: Lean.Syntax.mkCharLit
code: def mkCharLit (val : Char) (info := SourceInfo.none) : CharLit 
goal: Lean.CharLit

full_name: Lean.Syntax.mkStrLit
code: def mkStrLit (val : String) (info := SourceInfo.none) : StrLit 
goal: Lean.StrLit

full_name: Lean.Syntax.mkNumLit
code: def mkNumLit (val : String) (info := SourceInfo.none) : NumLit 
goal: Lean.NumLit

full_name: Lean.Syntax.mkScientificLit
code: def mkScientificLit (val : String) (info := SourceInfo.none) : TSyntax scientificLitKind 
goal: Lean.TSyntax (Lean.scientificLitKind :: List.nil)

full_name: Lean.Syntax.mkNameLit
code: def mkNameLit (val : String) (info := SourceInfo.none) : NameLit 
goal: Lean.NameLit

full_name: _private.«.lake».packages.lean4.src.lean.Init.Meta.0.Lean.Syntax.decodeBinLitAux
code: private partial def decodeBinLitAux (s : String) (i : String.Pos) (val : Nat) : Option Nat 
goal: Option Nat

full_name: _private.«.lake».packages.lean4.src.lean.Init.Meta.0.Lean.Syntax.decodeOctalLitAux
code: private partial def decodeOctalLitAux (s : String) (i : String.Pos) (val : Nat) : Option Nat 
goal: Option Nat

full_name: _private.«.lake».packages.lean4.src.lean.Init.Meta.0.Lean.Syntax.decodeHexDigit
code: private def decodeHexDigit (s : String) (i : String.Pos) : Option (Nat × String.Pos) 
goal: Option (Nat × String.Pos)

full_name: _private.«.lake».packages.lean4.src.lean.Init.Meta.0.Lean.Syntax.decodeHexLitAux
code: private partial def decodeHexLitAux (s : String) (i : String.Pos) (val : Nat) : Option Nat 
goal: Option Nat

full_name: _private.«.lake».packages.lean4.src.lean.Init.Meta.0.Lean.Syntax.decodeDecimalLitAux
code: private partial def decodeDecimalLitAux (s : String) (i : String.Pos) (val : Nat) : Option Nat 
goal: Option Nat

full_name: Lean.Syntax.decodeNatLitVal?
code: def decodeNatLitVal? (s : String) : Option Nat 
goal: Option Nat

full_name: Lean.Syntax.isLit?
code: def isLit? (litKind : SyntaxNodeKind) (stx : Syntax) : Option String 
goal: Option String

full_name: _private.«.lake».packages.lean4.src.lean.Init.Meta.0.Lean.Syntax.isNatLitAux
code: private def isNatLitAux (litKind : SyntaxNodeKind) (stx : Syntax) : Option Nat 
goal: Option Nat

full_name: Lean.Syntax.isNatLit?
code: def isNatLit? (s : Syntax) : Option Nat 
goal: Option Nat

full_name: Lean.Syntax.isFieldIdx?
code: def isFieldIdx? (s : Syntax) : Option Nat 
goal: Option Nat

full_name: Lean.Syntax.decodeScientificLitVal?.decodeExp
code: /-- Decodes a 'scientific number' string which is consumed by the `OfScientific` class.
  Takes as input a string such as `123`, `123.456e7` and returns a triple `(n, sign, e)` with value given by
  `n * 10^-e` if `sign` else `n * 10^e`.
-/
partial def decodeScientificLitVal? (s : String) : Option (Nat × Bool × Nat) 
goal: Option (Nat × Bool × Nat)

full_name: Lean.Syntax.decodeScientificLitVal?.decode
code: /-- Decodes a 'scientific number' string which is consumed by the `OfScientific` class.
  Takes as input a string such as `123`, `123.456e7` and returns a triple `(n, sign, e)` with value given by
  `n * 10^-e` if `sign` else `n * 10^e`.
-/
partial def decodeScientificLitVal? (s : String) : Option (Nat × Bool × Nat) 
goal: Option (Nat × Bool × Nat)

full_name: Lean.Syntax.decodeScientificLitVal?.decodeAfterDot
code: /-- Decodes a 'scientific number' string which is consumed by the `OfScientific` class.
  Takes as input a string such as `123`, `123.456e7` and returns a triple `(n, sign, e)` with value given by
  `n * 10^-e` if `sign` else `n * 10^e`.
-/
partial def decodeScientificLitVal? (s : String) : Option (Nat × Bool × Nat) 
goal: Option (Nat × Bool × Nat)

full_name: Lean.Syntax.decodeScientificLitVal?
code: /-- Decodes a 'scientific number' string which is consumed by the `OfScientific` class.
  Takes as input a string such as `123`, `123.456e7` and returns a triple `(n, sign, e)` with value given by
  `n * 10^-e` if `sign` else `n * 10^e`.
-/
partial def decodeScientificLitVal? (s : String) : Option (Nat × Bool × Nat) 
goal: Option (Nat × Bool × Nat)

full_name: Lean.Syntax.decodeScientificLitVal?.decodeAfterExp
code: /-- Decodes a 'scientific number' string which is consumed by the `OfScientific` class.
  Takes as input a string such as `123`, `123.456e7` and returns a triple `(n, sign, e)` with value given by
  `n * 10^-e` if `sign` else `n * 10^e`.
-/
partial def decodeScientificLitVal? (s : String) : Option (Nat × Bool × Nat) 
goal: Option (Nat × Bool × Nat)

full_name: Lean.Syntax.isScientificLit?
code: def isScientificLit? (stx : Syntax) : Option (Nat × Bool × Nat) 
goal: Option (Nat × Bool × Nat)

full_name: Lean.Syntax.isIdOrAtom?
code: def isIdOrAtom? : Syntax → Option String
  
goal: Lean.Syntax → Option String

full_name: Lean.Syntax.toNat
code: def toNat (stx : Syntax) : Nat 
goal: Nat

full_name: Lean.Syntax.decodeQuotedChar
code: def decodeQuotedChar (s : String) (i : String.Pos) : Option (Char × String.Pos) 
goal: Option (Char × String.Pos)

full_name: Lean.Syntax.decodeStringGap
code: /--
Decodes a valid string gap after the `\`.
Note that this function matches `"\" whitespace+` rather than
the more restrictive `"\" newline whitespace*` since this simplifies the implementation.
Justification: this does not overlap with any other sequences beginning with `\`.
-/
def decodeStringGap (s : String) (i : String.Pos) : Option String.Pos 
goal: Option String.Pos

full_name: Lean.Syntax.decodeStrLitAux
code: partial def decodeStrLitAux (s : String) (i : String.Pos) (acc : String) : Option String 
goal: Option String

full_name: Lean.Syntax.decodeRawStrLitAux
code: /--
Takes a raw string literal, counts the number of `#`'s after the `r`, and interprets it as a string.
The position `i` should start at `1`, which is the character after the leading `r`.
The algorithm is simple: we are given `r##...#"...string..."##...#` with zero or more `#`s.
By counting the number of leading `#`'s, we can extract the `...string...`.
-/
partial def decodeRawStrLitAux (s : String) (i : String.Pos) (num : Nat) : String 
goal: String

full_name: Lean.Syntax.decodeStrLit
code: /--
Takes the string literal lexical syntax parsed by the parser and interprets it as a string.
This is where escape sequences are processed for example.
The string `s` is is either a plain string literal or a raw string literal.

If it returns `none` then the string literal is ill-formed, which indicates a bug in the parser.
The function is not required to return `none` if the string literal is ill-formed.
-/
def decodeStrLit (s : String) : Option String 
goal: Option String

full_name: Lean.Syntax.isStrLit?
code: /--
If the provided `Syntax` is a string literal, returns the string it represents.

Even if the `Syntax` is a `str` node, the function may return `none` if its internally ill-formed.
The parser should always create well-formed `str` nodes.
-/
def isStrLit? (stx : Syntax) : Option String 
goal: Option String

full_name: Lean.Syntax.decodeCharLit
code: def decodeCharLit (s : String) : Option Char 
goal: Option Char

full_name: Lean.Syntax.isCharLit?
code: def isCharLit? (stx : Syntax) : Option Char 
goal: Option Char

full_name: _private.«.lake».packages.lean4.src.lean.Init.Meta.0.Lean.Syntax.splitNameLitAux
code: private partial def splitNameLitAux (ss : Substring) (acc : List Substring) : List Substring 
goal: List Substring

full_name: Lean.Syntax.splitNameLit
code: /-- Split a name literal (without the backtick) into its dot-separated components. For example,
`foo.bla.«bo.o»` ↦ `["foo", "bla", "«bo.o»"]`. If the literal cannot be parsed, return `[]`. -/
def splitNameLit (ss : Substring) : List Substring 
goal: List Substring

full_name: Substring.toName
code: def _root_.Substring.toName (s : Substring) : Name 
goal: Lean.Name

full_name: String.toName
code: /--
Converts a `String` to a hierarchical `Name` after splitting it at the dots.

`"a.b".toName` is the name `a.b`, not `«a.b»`. For the latter, use `Name.mkSimple`.
-/
def _root_.String.toName (s : String) : Name 
goal: Lean.Name

full_name: Lean.Syntax.decodeNameLit
code: def decodeNameLit (s : String) : Option Name 
goal: Option Lean.Name

full_name: Lean.Syntax.isNameLit?
code: def isNameLit? (stx : Syntax) : Option Name 
goal: Option Lean.Name

full_name: Lean.Syntax.hasArgs
code: def hasArgs : Syntax → Bool
  
goal: Lean.Syntax → Bool

full_name: Lean.Syntax.isAtom
code: def isAtom : Syntax → Bool
  
goal: Lean.Syntax → Bool

full_name: Lean.Syntax.isToken
code: def isToken (token : String) : Syntax → Bool
  
goal: Lean.Syntax → Bool

full_name: Lean.Syntax.isNone
code: def isNone (stx : Syntax) : Bool 
goal: Bool

full_name: Lean.Syntax.getOptionalIdent?
code: def getOptionalIdent? (stx : Syntax) : Option Name 
goal: Option Lean.Name

full_name: Lean.Syntax.findAux
code: partial def findAux (p : Syntax → Bool) : Syntax → Option Syntax
  
goal: Lean.Syntax → Option Lean.Syntax

full_name: Lean.Syntax.find?
code: def find? (stx : Syntax) (p : Syntax → Bool) : Option Syntax 
goal: Option Lean.Syntax

full_name: Lean.TSyntax.getNat
code: def getNat (s : NumLit) : Nat 
goal: Nat

full_name: Lean.TSyntax.getId
code: def getId (s : Ident) : Name 
goal: Lean.Name

full_name: Lean.TSyntax.getScientific
code: def getScientific (s : ScientificLit) : Nat × Bool × Nat 
goal: Nat × Bool × Nat

full_name: Lean.TSyntax.getString
code: def getString (s : StrLit) : String 
goal: String

full_name: Lean.TSyntax.getChar
code: def getChar (s : CharLit) : Char 
goal: Char

full_name: Lean.TSyntax.getName
code: def getName (s : NameLit) : Name 
goal: Lean.Name

full_name: Lean.TSyntax.getHygieneInfo
code: def getHygieneInfo (s : HygieneInfo) : Name 
goal: Lean.Name

full_name: Lean.TSyntax.Compat.«instCoeTailArraySyntaxTSepArray_.lake»
code: scoped instance : CoeTail (Array Syntax) (Syntax.TSepArray k sep) 
goal: CoeTail (Array Lean.Syntax) (Lean.Syntax.TSepArray k sep)

full_name: Lean.HygieneInfo.mkIdent
code: def HygieneInfo.mkIdent (s : HygieneInfo) (val : Name) (canonical := false) : Ident 
goal: Lean.Ident

full_name: Lean.Quote
code: /-- Reflect a runtime datum back to surface syntax (best-effort). -/
class Quote (α : Type) (k : SyntaxNodeKind := `term) where
  quote : α → TSyntax k
goal: Type

full_name: Lean.Quote.quote
code: /-- Reflect a runtime datum back to surface syntax (best-effort). -/
class Quote (α : Type) (k : SyntaxNodeKind := `term) where
  quote : α → TSyntax k
goal: α → Lean.TSyntax (k :: List.nil)

full_name: Lean.instQuoteOfCoeHTCTTSyntaxConsSyntaxNodeKindNil
code: instance [Quote α k] [CoeHTCT (TSyntax k) (TSyntax [k'])] : Quote α k' 
goal: Lean.Quote α k'

full_name: Lean.instQuoteTermMkStr1
code: instance : Quote Term 
goal: Lean.Quote Lean.Term

full_name: Lean.instQuoteBoolMkStr1
code: instance : Quote Bool 
goal: Lean.Quote Bool

full_name: Lean.instQuoteCharCharLitKind
code: instance : Quote Char charLitKind 
goal: Lean.Quote Char Lean.charLitKind

full_name: Lean.instQuoteStringStrLitKind
code: instance : Quote String strLitKind 
goal: Lean.Quote String Lean.strLitKind

full_name: Lean.instQuoteNatNumLitKind
code: instance : Quote Nat numLitKind 
goal: Lean.Quote Nat Lean.numLitKind

full_name: Lean.instQuoteSubstringMkStr1
code: instance : Quote Substring 
goal: Lean.Quote Substring

full_name: _private.«.lake».packages.lean4.src.lean.Init.Meta.0.Lean.getEscapedNameParts?
code: private def getEscapedNameParts? (acc : List String) : Name → Option (List String)
  
goal: Lean.Name → Option (List String)

full_name: Lean.quoteNameMk
code: def quoteNameMk : Name → Term
  
goal: Lean.Name → Lean.Term

full_name: Lean.instQuoteNameMkStr1
code: instance : Quote Name `term 
goal: Lean.Quote Lean.Name

full_name: Lean.instQuoteProdMkStr1
code: instance [Quote α `term] [Quote β `term] : Quote (α × β) `term 
goal: Lean.Quote (α × β)

full_name: _private.«.lake».packages.lean4.src.lean.Init.Meta.0.Lean.quoteList
code: private def quoteList [Quote α `term] : List α → Term
  
goal: List α → Lean.Term

full_name: Lean.instQuoteListMkStr1
code: instance [Quote α `term] : Quote (List α) `term 
goal: Lean.Quote (List α)

full_name: _private.«.lake».packages.lean4.src.lean.Init.Meta.0.Lean.quoteArray
code: private def quoteArray [Quote α `term] (xs : Array α) : Term 
goal: Lean.Term

full_name: _private.«.lake».packages.lean4.src.lean.Init.Meta.0.Lean.quoteArray.go
code: private def quoteArray [Quote α `term] (xs : Array α) : Term 
goal: Lean.Term

full_name: Lean.instQuoteArrayMkStr1
code: instance [Quote α `term] : Quote (Array α) `term 
goal: Lean.Quote (Array α)

full_name: Lean.Option.hasQuote
code: instance Option.hasQuote {α : Type} [Quote α `term] : Quote (Option α) `term 
goal: Lean.Quote (Option α)

full_name: Lean.evalPrec
code: /-- Evaluator for `prec` DSL -/
def evalPrec (stx : Syntax) : MacroM Nat 
goal: Lean.MacroM Nat

full_name: Lean.«_aux_.lake_packages_lean4_src_lean_Init_Meta___macroRules_Lean_Parser_Syntax_addPrec_1»
code: macro_rules
  | `(prec| $a + $b) => do `(prec| $(quote <| (← evalPrec a) + (← evalPrec b)):num)
goal: Lean.Macro

full_name: Lean.«_aux_.lake_packages_lean4_src_lean_Init_Meta___macroRules_Lean_Parser_Syntax_subPrec_1»
code: macro_rules
  | `(prec| $a - $b) => do `(prec| $(quote <| (← evalPrec a) - (← evalPrec b)):num)
goal: Lean.Macro

full_name: Lean.termEval_prec_
code: macro "eval_prec " p:prec:max : term => return quote (k := `term) (← evalPrec p)
goal: Lean.ParserDescr

full_name: Lean.«_aux_.lake_packages_lean4_src_lean_Init_Meta___macroRules_Lean_termEval_prec__1»
code: macro "eval_prec " p:prec:max : term => return quote (k := `term) (← evalPrec p)
goal: Lean.Macro

full_name: Lean.evalPrio
code: /-- Evaluator for `prio` DSL -/
def evalPrio (stx : Syntax) : MacroM Nat 
goal: Lean.MacroM Nat

full_name: Lean.«_aux_.lake_packages_lean4_src_lean_Init_Meta___macroRules_Lean_Parser_Syntax_addPrio_1»
code: macro_rules
  | `(prio| $a + $b) => do `(prio| $(quote <| (← evalPrio a) + (← evalPrio b)):num)
goal: Lean.Macro

full_name: Lean.«_aux_.lake_packages_lean4_src_lean_Init_Meta___macroRules_Lean_Parser_Syntax_subPrio_1»
code: macro_rules
  | `(prio| $a - $b) => do `(prio| $(quote <| (← evalPrio a) - (← evalPrio b)):num)
goal: Lean.Macro

full_name: Lean.termEval_prio_
code: macro "eval_prio " p:prio:max : term => return quote (k := `term) (← evalPrio p)
goal: Lean.ParserDescr

full_name: Lean.«_aux_.lake_packages_lean4_src_lean_Init_Meta___macroRules_Lean_termEval_prio__1»
code: macro "eval_prio " p:prio:max : term => return quote (k := `term) (← evalPrio p)
goal: Lean.Macro

full_name: Lean.evalOptPrio
code: def evalOptPrio : Option (TSyntax `prio) → MacroM Nat
  
goal: Option (Lean.TSyntax (Lean.Name.mkStr1 "prio" :: List.nil)) → Lean.MacroM Nat

full_name: Array.getSepElems
code: abbrev getSepElems 
goal: Array α

full_name: _private.«.lake».packages.lean4.src.lean.Init.Meta.0.Array.filterSepElemsMAux
code: private partial def filterSepElemsMAux {m : Type → Type} [Monad m] (a : Array Syntax) (p : Syntax → m Bool) (i : Nat) (acc : Array Syntax) : m (Array Syntax) 
goal: m (Array Lean.Syntax)

full_name: Array.filterSepElemsM
code: def filterSepElemsM {m : Type → Type} [Monad m] (a : Array Syntax) (p : Syntax → m Bool) : m (Array Syntax) 
goal: m (Array Lean.Syntax)

full_name: Array.filterSepElems
code: def filterSepElems (a : Array Syntax) (p : Syntax → Bool) : Array Syntax 
goal: Array Lean.Syntax

full_name: _private.«.lake».packages.lean4.src.lean.Init.Meta.0.Array.mapSepElemsMAux
code: private partial def mapSepElemsMAux {m : Type → Type} [Monad m] (a : Array Syntax) (f : Syntax → m Syntax) (i : Nat) (acc : Array Syntax) : m (Array Syntax) 
goal: m (Array Lean.Syntax)

full_name: Array.mapSepElemsM
code: def mapSepElemsM {m : Type → Type} [Monad m] (a : Array Syntax) (f : Syntax → m Syntax) : m (Array Syntax) 
goal: m (Array Lean.Syntax)

full_name: Array.mapSepElems
code: def mapSepElems (a : Array Syntax) (f : Syntax → Syntax) : Array Syntax 
goal: Array Lean.Syntax

full_name: Lean.Syntax.SepArray.getElems
code: def SepArray.getElems (sa : SepArray sep) : Array Syntax 
goal: Array Lean.Syntax

full_name: Lean.Syntax.TSepArray.getElems
code: def TSepArray.getElems (sa : TSepArray k sep) : TSyntaxArray k 
goal: Lean.TSyntaxArray k

full_name: Lean.Syntax.TSepArray.push
code: def TSepArray.push (sa : TSepArray k sep) (e : TSyntax k) : TSepArray k sep 
goal: Lean.Syntax.TSepArray k sep

full_name: Lean.Syntax.«instEmptyCollectionSepArray_.lake»
code: instance : EmptyCollection (SepArray sep) 
goal: EmptyCollection (Lean.Syntax.SepArray sep)

full_name: Lean.Syntax.«instEmptyCollectionTSepArray_.lake»
code: instance : EmptyCollection (TSepArray sep k) 
goal: EmptyCollection (Lean.Syntax.TSepArray sep k)

full_name: Lean.Syntax.«instCoeOutSepArrayArray_.lake»
code: instance : CoeOut (SepArray sep) (Array Syntax) 
goal: CoeOut (Lean.Syntax.SepArray sep) (Array Lean.Syntax)

full_name: Lean.Syntax.«instCoeOutTSepArrayTSyntaxArray_.lake»
code: instance : CoeOut (TSepArray k sep) (TSyntaxArray k) 
goal: CoeOut (Lean.Syntax.TSepArray k sep) (Lean.TSyntaxArray k)

full_name: Lean.Syntax.«instCoeTSyntaxArrayOfTSyntax_.lake»
code: instance [Coe (TSyntax k) (TSyntax k')] : Coe (TSyntaxArray k) (TSyntaxArray k') 
goal: Coe (Lean.TSyntaxArray k) (Lean.TSyntaxArray k')

full_name: Lean.Syntax.«instCoeOutTSyntaxArrayArray_.lake»
code: instance : CoeOut (TSyntaxArray k) (Array Syntax) 
goal: CoeOut (Lean.TSyntaxArray k) (Array Lean.Syntax)

full_name: Lean.Syntax.instCoeIdentTSyntaxConsSyntaxNodeKindMkStr4Nil
code: instance : Coe Ident (TSyntax `Lean.Parser.Command.declId) 
goal: Coe Lean.Ident (Lean.TSyntax (Lean.Name.mkStr4 "Lean" "Parser" "Command" "declId" :: List.nil))

full_name: Lean.Syntax.instCoeTermTSyntaxConsSyntaxNodeKindMkStr4Nil
code: instance : Coe (Lean.Term) (Lean.TSyntax `Lean.Parser.Term.funBinder) 
goal: Coe Lean.Term (Lean.TSyntax (Lean.Name.mkStr4 "Lean" "Parser" "Term" "funBinder" :: List.nil))

full_name: _private.«.lake».packages.lean4.src.lean.Init.Meta.0.Lean.Syntax.decodeInterpStrQuotedChar
code: private def decodeInterpStrQuotedChar (s : String) (i : String.Pos) : Option (Char × String.Pos) 
goal: Option (Char × String.Pos)

full_name: _private.«.lake».packages.lean4.src.lean.Init.Meta.0.Lean.Syntax.decodeInterpStrLit
code: private partial def decodeInterpStrLit (s : String) : Option String 
goal: Option String

full_name: _private.«.lake».packages.lean4.src.lean.Init.Meta.0.Lean.Syntax.decodeInterpStrLit.loop
code: private partial def decodeInterpStrLit (s : String) : Option String 
goal: Option String

full_name: Lean.Syntax.isInterpolatedStrLit?
code: partial def isInterpolatedStrLit? (stx : Syntax) : Option String 
goal: Option String

full_name: Lean.Syntax.getSepArgs
code: def getSepArgs (stx : Syntax) : Array Syntax 
goal: Array Lean.Syntax

full_name: Lean.TSyntax.expandInterpolatedStrChunks
code: def expandInterpolatedStrChunks (chunks : Array Syntax) (mkAppend : Syntax → Syntax → MacroM Syntax) (mkElem : Syntax → MacroM Syntax) : MacroM Syntax 
goal: Lean.MacroM Lean.Syntax

full_name: Lean.TSyntax.expandInterpolatedStr
code: def expandInterpolatedStr (interpStr : TSyntax interpolatedStrKind) (type : Term) (toTypeFn : Term) : MacroM Term 
goal: Lean.MacroM Lean.Term

full_name: Lean.TSyntax.getDocString
code: def getDocString (stx : TSyntax `Lean.Parser.Command.docComment) : String 
goal: String

full_name: Lean.Meta.«instReprConfig_.lake»
code: Repr
goal: Repr Lean.Meta.DSimp.Config

full_name: Lean.Meta.«instReprTransparencyMode_.lake»
code: Repr
goal: Repr Lean.Meta.TransparencyMode

full_name: Lean.Meta.«instReprEtaStructMode_.lake»
code: Repr
goal: Repr Lean.Meta.EtaStructMode

full_name: Lean.Meta.«instReprConfig_.lake_1»
code: Repr
goal: Repr Lean.Meta.Simp.Config

full_name: Lean.Meta.Occurrences.contains
code: def Occurrences.contains : Occurrences → Nat → Bool
  
goal: Lean.Meta.Occurrences → Nat → Bool

full_name: Lean.Meta.Occurrences.isAll
code: def Occurrences.isAll : Occurrences → Bool
  
goal: Lean.Meta.Occurrences → Bool

full_name: Lean.Meta.ApplyNewGoals.nonDependentFirst
code: /--
Controls which new mvars are turned in to goals by the `apply` tactic.
- `nonDependentFirst`  mvars that don't depend on other goals appear first in the goal list.
- `nonDependentOnly` only mvars that don't depend on other goals are added to goal list.
- `all` all unassigned mvars are added to the goal list.
-/
-- TODO: Consider renaming to `Apply.NewGoals`
inductive ApplyNewGoals where
  | nonDependentFirst | nonDependentOnly | all
goal: Lean.Meta.ApplyNewGoals

full_name: Lean.Meta.ApplyNewGoals
code: /--
Controls which new mvars are turned in to goals by the `apply` tactic.
- `nonDependentFirst`  mvars that don't depend on other goals appear first in the goal list.
- `nonDependentOnly` only mvars that don't depend on other goals are added to goal list.
- `all` all unassigned mvars are added to the goal list.
-/
-- TODO: Consider renaming to `Apply.NewGoals`
inductive ApplyNewGoals where
  | nonDependentFirst | nonDependentOnly | all
goal: Type

full_name: Lean.Meta.ApplyNewGoals.nonDependentOnly
code: /--
Controls which new mvars are turned in to goals by the `apply` tactic.
- `nonDependentFirst`  mvars that don't depend on other goals appear first in the goal list.
- `nonDependentOnly` only mvars that don't depend on other goals are added to goal list.
- `all` all unassigned mvars are added to the goal list.
-/
-- TODO: Consider renaming to `Apply.NewGoals`
inductive ApplyNewGoals where
  | nonDependentFirst | nonDependentOnly | all
goal: Lean.Meta.ApplyNewGoals

full_name: Lean.Meta.ApplyNewGoals.all
code: /--
Controls which new mvars are turned in to goals by the `apply` tactic.
- `nonDependentFirst`  mvars that don't depend on other goals appear first in the goal list.
- `nonDependentOnly` only mvars that don't depend on other goals are added to goal list.
- `all` all unassigned mvars are added to the goal list.
-/
-- TODO: Consider renaming to `Apply.NewGoals`
inductive ApplyNewGoals where
  | nonDependentFirst | nonDependentOnly | all
goal: Lean.Meta.ApplyNewGoals

full_name: Lean.Meta.ApplyConfig.approx
code: /-- Configures the behaviour of the `apply` tactic. -/
-- TODO: Consider renaming to `Apply.Config`
structure ApplyConfig where
  newGoals := ApplyNewGoals.nonDependentFirst
  /--
  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.
  -/
  synthAssignedInstances := true
  /--
  If `allowSynthFailures` is `true`, then `apply` will return instance implicit arguments
  for which typeclass search failed as new goals.
  -/
  allowSynthFailures := false
  /--
  If `approx := true`, then we turn on `isDefEq` approximations. That is, we use
  the `approxDefEq` combinator.
  -/
  approx : Bool := true
goal: Bool

full_name: Lean.Meta.ApplyConfig.newGoals
code: /-- Configures the behaviour of the `apply` tactic. -/
-- TODO: Consider renaming to `Apply.Config`
structure ApplyConfig where
  newGoals := ApplyNewGoals.nonDependentFirst
  /--
  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.
  -/
  synthAssignedInstances := true
  /--
  If `allowSynthFailures` is `true`, then `apply` will return instance implicit arguments
  for which typeclass search failed as new goals.
  -/
  allowSynthFailures := false
  /--
  If `approx := true`, then we turn on `isDefEq` approximations. That is, we use
  the `approxDefEq` combinator.
  -/
  approx : Bool := true
goal: Lean.Meta.ApplyNewGoals

full_name: Lean.Meta.ApplyConfig.synthAssignedInstances
code: /-- Configures the behaviour of the `apply` tactic. -/
-- TODO: Consider renaming to `Apply.Config`
structure ApplyConfig where
  newGoals := ApplyNewGoals.nonDependentFirst
  /--
  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.
  -/
  synthAssignedInstances := true
  /--
  If `allowSynthFailures` is `true`, then `apply` will return instance implicit arguments
  for which typeclass search failed as new goals.
  -/
  allowSynthFailures := false
  /--
  If `approx := true`, then we turn on `isDefEq` approximations. That is, we use
  the `approxDefEq` combinator.
  -/
  approx : Bool := true
goal: Bool

full_name: Lean.Meta.ApplyConfig.allowSynthFailures
code: /-- Configures the behaviour of the `apply` tactic. -/
-- TODO: Consider renaming to `Apply.Config`
structure ApplyConfig where
  newGoals := ApplyNewGoals.nonDependentFirst
  /--
  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.
  -/
  synthAssignedInstances := true
  /--
  If `allowSynthFailures` is `true`, then `apply` will return instance implicit arguments
  for which typeclass search failed as new goals.
  -/
  allowSynthFailures := false
  /--
  If `approx := true`, then we turn on `isDefEq` approximations. That is, we use
  the `approxDefEq` combinator.
  -/
  approx : Bool := true
goal: Bool

full_name: Lean.Meta.ApplyConfig
code: /-- Configures the behaviour of the `apply` tactic. -/
-- TODO: Consider renaming to `Apply.Config`
structure ApplyConfig where
  newGoals := ApplyNewGoals.nonDependentFirst
  /--
  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.
  -/
  synthAssignedInstances := true
  /--
  If `allowSynthFailures` is `true`, then `apply` will return instance implicit arguments
  for which typeclass search failed as new goals.
  -/
  allowSynthFailures := false
  /--
  If `approx := true`, then we turn on `isDefEq` approximations. That is, we use
  the `approxDefEq` combinator.
  -/
  approx : Bool := true
goal: Type

full_name: Lean.Meta.Rewrite.NewGoals
code: abbrev NewGoals 
goal: Type

full_name: Lean.Meta.Rewrite.Config.newGoals
code: structure Config where
  transparency : TransparencyMode := .reducible
  offsetCnstrs : Bool := true
  occs : Occurrences := .all
  newGoals : NewGoals := .nonDependentFirst
goal: Lean.Meta.Rewrite.NewGoals

full_name: Lean.Meta.Rewrite.Config.occs
code: structure Config where
  transparency : TransparencyMode := .reducible
  offsetCnstrs : Bool := true
  occs : Occurrences := .all
  newGoals : NewGoals := .nonDependentFirst
goal: Lean.Meta.Occurrences

full_name: Lean.Meta.Rewrite.Config.offsetCnstrs
code: structure Config where
  transparency : TransparencyMode := .reducible
  offsetCnstrs : Bool := true
  occs : Occurrences := .all
  newGoals : NewGoals := .nonDependentFirst
goal: Bool

full_name: Lean.Meta.Rewrite.Config.transparency
code: structure Config where
  transparency : TransparencyMode := .reducible
  offsetCnstrs : Bool := true
  occs : Occurrences := .all
  newGoals : NewGoals := .nonDependentFirst
goal: Lean.Meta.TransparencyMode

full_name: Lean.Meta.Rewrite.Config
code: structure Config where
  transparency : TransparencyMode := .reducible
  offsetCnstrs : Bool := true
  occs : Occurrences := .all
  newGoals : NewGoals := .nonDependentFirst
goal: Type

full_name: Lean.Meta.Omega.OmegaConfig.splitDisjunctions
code: /-- Configures the behaviour of the `omega` tactic. -/
structure OmegaConfig where
  /--
  Split disjunctions in the context.

  Note that with `splitDisjunctions := false` omega will not be able to solve `x = y` goals
  as these are usually handled by introducing `¬ x = y` as a hypothesis, then replacing this with
  `x < y ∨ x > y`.

  On the other hand, `omega` does not currently detect disjunctions which, when split,
  introduce no new useful information, so the presence of irrelevant disjunctions in the context
  can significantly increase run time.
  -/
  splitDisjunctions : Bool := true
  /--
  Whenever `((a - b : Nat) : Int)` is found, register the disjunction
  `b ≤ a ∧ ((a - b : Nat) : Int) = a - b ∨ a < b ∧ ((a - b : Nat) : Int) = 0`
  for later splitting.
  -/
  splitNatSub : Bool := true
  /--
  Whenever `Int.natAbs a` is found, register the disjunction
  `0 ≤ a ∧ Int.natAbs a = a ∨ a < 0 ∧ Int.natAbs a = - a` for later splitting.
  -/
  splitNatAbs : Bool := true
  /--
  Whenever `min a b` or `max a b` is found, rewrite in terms of the definition
  `if a ≤ b ...`, for later case splitting.
  -/
  splitMinMax : Bool := true
goal: Bool

full_name: Lean.Meta.Omega.OmegaConfig.splitMinMax
code: /-- Configures the behaviour of the `omega` tactic. -/
structure OmegaConfig where
  /--
  Split disjunctions in the context.

  Note that with `splitDisjunctions := false` omega will not be able to solve `x = y` goals
  as these are usually handled by introducing `¬ x = y` as a hypothesis, then replacing this with
  `x < y ∨ x > y`.

  On the other hand, `omega` does not currently detect disjunctions which, when split,
  introduce no new useful information, so the presence of irrelevant disjunctions in the context
  can significantly increase run time.
  -/
  splitDisjunctions : Bool := true
  /--
  Whenever `((a - b : Nat) : Int)` is found, register the disjunction
  `b ≤ a ∧ ((a - b : Nat) : Int) = a - b ∨ a < b ∧ ((a - b : Nat) : Int) = 0`
  for later splitting.
  -/
  splitNatSub : Bool := true
  /--
  Whenever `Int.natAbs a` is found, register the disjunction
  `0 ≤ a ∧ Int.natAbs a = a ∨ a < 0 ∧ Int.natAbs a = - a` for later splitting.
  -/
  splitNatAbs : Bool := true
  /--
  Whenever `min a b` or `max a b` is found, rewrite in terms of the definition
  `if a ≤ b ...`, for later case splitting.
  -/
  splitMinMax : Bool := true
goal: Bool

full_name: Lean.Meta.Omega.OmegaConfig.splitNatSub
code: /-- Configures the behaviour of the `omega` tactic. -/
structure OmegaConfig where
  /--
  Split disjunctions in the context.

  Note that with `splitDisjunctions := false` omega will not be able to solve `x = y` goals
  as these are usually handled by introducing `¬ x = y` as a hypothesis, then replacing this with
  `x < y ∨ x > y`.

  On the other hand, `omega` does not currently detect disjunctions which, when split,
  introduce no new useful information, so the presence of irrelevant disjunctions in the context
  can significantly increase run time.
  -/
  splitDisjunctions : Bool := true
  /--
  Whenever `((a - b : Nat) : Int)` is found, register the disjunction
  `b ≤ a ∧ ((a - b : Nat) : Int) = a - b ∨ a < b ∧ ((a - b : Nat) : Int) = 0`
  for later splitting.
  -/
  splitNatSub : Bool := true
  /--
  Whenever `Int.natAbs a` is found, register the disjunction
  `0 ≤ a ∧ Int.natAbs a = a ∨ a < 0 ∧ Int.natAbs a = - a` for later splitting.
  -/
  splitNatAbs : Bool := true
  /--
  Whenever `min a b` or `max a b` is found, rewrite in terms of the definition
  `if a ≤ b ...`, for later case splitting.
  -/
  splitMinMax : Bool := true
goal: Bool

full_name: Lean.Meta.Omega.OmegaConfig
code: /-- Configures the behaviour of the `omega` tactic. -/
structure OmegaConfig where
  /--
  Split disjunctions in the context.

  Note that with `splitDisjunctions := false` omega will not be able to solve `x = y` goals
  as these are usually handled by introducing `¬ x = y` as a hypothesis, then replacing this with
  `x < y ∨ x > y`.

  On the other hand, `omega` does not currently detect disjunctions which, when split,
  introduce no new useful information, so the presence of irrelevant disjunctions in the context
  can significantly increase run time.
  -/
  splitDisjunctions : Bool := true
  /--
  Whenever `((a - b : Nat) : Int)` is found, register the disjunction
  `b ≤ a ∧ ((a - b : Nat) : Int) = a - b ∨ a < b ∧ ((a - b : Nat) : Int) = 0`
  for later splitting.
  -/
  splitNatSub : Bool := true
  /--
  Whenever `Int.natAbs a` is found, register the disjunction
  `0 ≤ a ∧ Int.natAbs a = a ∨ a < 0 ∧ Int.natAbs a = - a` for later splitting.
  -/
  splitNatAbs : Bool := true
  /--
  Whenever `min a b` or `max a b` is found, rewrite in terms of the definition
  `if a ≤ b ...`, for later case splitting.
  -/
  splitMinMax : Bool := true
goal: Type

full_name: Lean.Meta.Omega.OmegaConfig.splitNatAbs
code: /-- Configures the behaviour of the `omega` tactic. -/
structure OmegaConfig where
  /--
  Split disjunctions in the context.

  Note that with `splitDisjunctions := false` omega will not be able to solve `x = y` goals
  as these are usually handled by introducing `¬ x = y` as a hypothesis, then replacing this with
  `x < y ∨ x > y`.

  On the other hand, `omega` does not currently detect disjunctions which, when split,
  introduce no new useful information, so the presence of irrelevant disjunctions in the context
  can significantly increase run time.
  -/
  splitDisjunctions : Bool := true
  /--
  Whenever `((a - b : Nat) : Int)` is found, register the disjunction
  `b ≤ a ∧ ((a - b : Nat) : Int) = a - b ∨ a < b ∧ ((a - b : Nat) : Int) = 0`
  for later splitting.
  -/
  splitNatSub : Bool := true
  /--
  Whenever `Int.natAbs a` is found, register the disjunction
  `0 ≤ a ∧ Int.natAbs a = a ∨ a < 0 ∧ Int.natAbs a = - a` for later splitting.
  -/
  splitNatAbs : Bool := true
  /--
  Whenever `min a b` or `max a b` is found, rewrite in terms of the definition
  `if a ≤ b ...`, for later case splitting.
  -/
  splitMinMax : Bool := true
goal: Bool

full_name: Lean.Meta.CheckTactic.CheckGoalType
code: /--
Type used to lift an arbitrary value into a type parameter so it can
appear in a proof goal.

It is used by the #check_tactic command.
-/
inductive CheckGoalType {α : Sort u} : (val : α) → Prop where
| intro : (val : α) → CheckGoalType val
goal: Prop

full_name: Lean.Meta.CheckTactic.CheckGoalType.intro
code: /--
Type used to lift an arbitrary value into a type parameter so it can
appear in a proof goal.

It is used by the #check_tactic command.
-/
inductive CheckGoalType {α : Sort u} : (val : α) → Prop where
| intro : (val : α) → CheckGoalType val
goal: Lean.Meta.CheckTactic.CheckGoalType val

full_name: Lean.Parser.Tactic.tacticErw__
code: macro "erw" s:rwRuleSeq loc:(location)? : tactic =>
  `(tactic| rw (config := { transparency := .default }) $s $(loc)?)
goal: Lean.ParserDescr

full_name: Lean.Parser.Tactic.«_aux_.lake_packages_lean4_src_lean_Init_Meta___macroRules_Lean_Parser_Tactic_tacticErw___1»
code: macro "erw" s:rwRuleSeq loc:(location)? : tactic =>
  `(tactic| rw (config := { transparency := .default }) $s $(loc)?)
goal: Lean.Macro

full_name: Lean.Parser.Tactic.simpAllKind
code: syntax simpAllKind := atomic(" (" &"all") " := " &"true" ")"
goal: Lean.ParserDescr

full_name: Lean.Parser.Tactic.dsimpKind
code: syntax dsimpKind   := atomic(" (" &"dsimp") " := " &"true" ")"
goal: Lean.ParserDescr

full_name: Lean.Parser.Tactic.«_aux_.lake_packages_lean4_src_lean_Init_Meta___macroRules_Lean_Parser_Tactic_declareSimpLikeTactic_1»
code: macro (name := declareSimpLikeTactic) doc?:(docComment)?
    "declare_simp_like_tactic" opt:((simpAllKind <|> dsimpKind)?)
    ppSpace tacName:ident ppSpace tacToken:str ppSpace updateCfg:term : command => do
  let (kind, tkn, stx) ←
    if opt.raw.isNone then
      pure (← `(``simp), ← `("simp"), ← `($[$doc?:docComment]? syntax (name := $tacName) $tacToken:str (config)? (discharger)? (&" only")? (" [" (simpStar <|> simpErase <|> simpLemma),* "]")? (location)? : tactic))
    else if opt.raw[0].getKind == ``simpAllKind then
      pure (← `(``simpAll), ← `("simp_all"), ← `($[$doc?:docComment]? syntax (name := $tacName) $tacToken:str (config)? (discharger)? (&" only")? (" [" (simpErase <|> simpLemma),* "]")? : tactic))
    else
      pure (← `(``dsimp), ← `("dsimp"), ← `($[$doc?:docComment]? syntax (name := $tacName) $tacToken:str (config)? (discharger)? (&" only")? (" [" (simpErase <|> simpLemma),* "]")? (location)? : tactic))
  `($stx:command
    @[macro $tacName] def expandSimp : Macro := fun s => do
      let c ← match s[1][0] with
        | `(config| (config := $$c)) => `(config| (config := $updateCfg $$c))
        | _ => `(config| (config := $updateCfg {}))
      let s := s.setKind $kind
      let s := s.setArg 0 (mkAtomFrom s[0] $tkn (canonical := true))
      let r := s.setArg 1 (mkNullNode #[c])
      return r)
goal: Lean.Macro

full_name: Lean.Parser.Tactic.declareSimpLikeTactic
code: macro (name := declareSimpLikeTactic) doc?:(docComment)?
    "declare_simp_like_tactic" opt:((simpAllKind <|> dsimpKind)?)
    ppSpace tacName:ident ppSpace tacToken:str ppSpace updateCfg:term : command => do
  let (kind, tkn, stx) ←
    if opt.raw.isNone then
      pure (← `(``simp), ← `("simp"), ← `($[$doc?:docComment]? syntax (name := $tacName) $tacToken:str (config)? (discharger)? (&" only")? (" [" (simpStar <|> simpErase <|> simpLemma),* "]")? (location)? : tactic))
    else if opt.raw[0].getKind == ``simpAllKind then
      pure (← `(``simpAll), ← `("simp_all"), ← `($[$doc?:docComment]? syntax (name := $tacName) $tacToken:str (config)? (discharger)? (&" only")? (" [" (simpErase <|> simpLemma),* "]")? : tactic))
    else
      pure (← `(``dsimp), ← `("dsimp"), ← `($[$doc?:docComment]? syntax (name := $tacName) $tacToken:str (config)? (discharger)? (&" only")? (" [" (simpErase <|> simpLemma),* "]")? (location)? : tactic))
  `($stx:command
    @[macro $tacName] def expandSimp : Macro := fun s => do
      let c ← match s[1][0] with
        | `(config| (config := $$c)) => `(config| (config := $updateCfg $$c))
        | _ => `(config| (config := $updateCfg {}))
      let s := s.setKind $kind
      let s := s.setArg 0 (mkAtomFrom s[0] $tkn (canonical := true))
      let r := s.setArg 1 (mkNullNode #[c])
      return r)
goal: Lean.ParserDescr

full_name: Lean.Parser.Tactic.expandSimp._@..lake.packages.lean4.src.lean.Init.Meta._hyg.16100
code: /-- `simp!` is shorthand for `simp` with `autoUnfold := true`.
This will rewrite with all equation lemmas, which can be used to
partially evaluate many definitions. -/
declare_simp_like_tactic simpAutoUnfold "simp! " fun (c : Lean.Meta.Simp.Config) => { c with autoUnfold := true }
goal: Lean.Macro

full_name: Lean.Parser.Tactic.simpAutoUnfold
code: /-- `simp!` is shorthand for `simp` with `autoUnfold := true`.
This will rewrite with all equation lemmas, which can be used to
partially evaluate many definitions. -/
declare_simp_like_tactic simpAutoUnfold "simp! " fun (c : Lean.Meta.Simp.Config) => { c with autoUnfold := true }
goal: Lean.ParserDescr

full_name: Lean.Parser.Tactic.simpArith
code: /-- `simp_arith` is shorthand for `simp` with `arith := true` and `decide := true`.
This enables the use of normalization by linear arithmetic. -/
declare_simp_like_tactic simpArith "simp_arith " fun (c : Lean.Meta.Simp.Config) => { c with arith := true, decide := true }
goal: Lean.ParserDescr

full_name: Lean.Parser.Tactic.expandSimp._@..lake.packages.lean4.src.lean.Init.Meta._hyg.16906
code: /-- `simp_arith` is shorthand for `simp` with `arith := true` and `decide := true`.
This enables the use of normalization by linear arithmetic. -/
declare_simp_like_tactic simpArith "simp_arith " fun (c : Lean.Meta.Simp.Config) => { c with arith := true, decide := true }
goal: Lean.Macro

full_name: Lean.Parser.Tactic.expandSimp._@..lake.packages.lean4.src.lean.Init.Meta._hyg.17804
code: /-- `simp_arith!` is shorthand for `simp_arith` with `autoUnfold := true`.
This will rewrite with all equation lemmas, which can be used to
partially evaluate many definitions. -/
declare_simp_like_tactic simpArithAutoUnfold "simp_arith! " fun (c : Lean.Meta.Simp.Config) => { c with arith := true, autoUnfold := true, decide := true }
goal: Lean.Macro

full_name: Lean.Parser.Tactic.simpArithAutoUnfold
code: /-- `simp_arith!` is shorthand for `simp_arith` with `autoUnfold := true`.
This will rewrite with all equation lemmas, which can be used to
partially evaluate many definitions. -/
declare_simp_like_tactic simpArithAutoUnfold "simp_arith! " fun (c : Lean.Meta.Simp.Config) => { c with arith := true, autoUnfold := true, decide := true }
goal: Lean.ParserDescr

full_name: Lean.Parser.Tactic.expandSimp._@..lake.packages.lean4.src.lean.Init.Meta._hyg.18786
code: /-- `simp_all!` is shorthand for `simp_all` with `autoUnfold := true`.
This will rewrite with all equation lemmas, which can be used to
partially evaluate many definitions. -/
declare_simp_like_tactic (all := true) simpAllAutoUnfold "simp_all! " fun (c : Lean.Meta.Simp.ConfigCtx) => { c with autoUnfold := true }
goal: Lean.Macro

full_name: Lean.Parser.Tactic.simpAllAutoUnfold
code: /-- `simp_all!` is shorthand for `simp_all` with `autoUnfold := true`.
This will rewrite with all equation lemmas, which can be used to
partially evaluate many definitions. -/
declare_simp_like_tactic (all := true) simpAllAutoUnfold "simp_all! " fun (c : Lean.Meta.Simp.ConfigCtx) => { c with autoUnfold := true }
goal: Lean.ParserDescr

full_name: Lean.Parser.Tactic.simpAllArith
code: /-- `simp_all_arith` combines the effects of `simp_all` and `simp_arith`. -/
declare_simp_like_tactic (all := true) simpAllArith "simp_all_arith " fun (c : Lean.Meta.Simp.ConfigCtx) => { c with arith := true, decide := true }
goal: Lean.ParserDescr

full_name: Lean.Parser.Tactic.expandSimp._@..lake.packages.lean4.src.lean.Init.Meta._hyg.19582
code: /-- `simp_all_arith` combines the effects of `simp_all` and `simp_arith`. -/
declare_simp_like_tactic (all := true) simpAllArith "simp_all_arith " fun (c : Lean.Meta.Simp.ConfigCtx) => { c with arith := true, decide := true }
goal: Lean.Macro

full_name: Lean.Parser.Tactic.expandSimp._@..lake.packages.lean4.src.lean.Init.Meta._hyg.20470
code: /-- `simp_all_arith!` combines the effects of `simp_all`, `simp_arith` and `simp!`. -/
declare_simp_like_tactic (all := true) simpAllArithAutoUnfold "simp_all_arith! " fun (c : Lean.Meta.Simp.ConfigCtx) => { c with arith := true, autoUnfold := true, decide := true }
goal: Lean.Macro

full_name: Lean.Parser.Tactic.simpAllArithAutoUnfold
code: /-- `simp_all_arith!` combines the effects of `simp_all`, `simp_arith` and `simp!`. -/
declare_simp_like_tactic (all := true) simpAllArithAutoUnfold "simp_all_arith! " fun (c : Lean.Meta.Simp.ConfigCtx) => { c with arith := true, autoUnfold := true, decide := true }
goal: Lean.ParserDescr

full_name: Lean.Parser.Tactic.dsimpAutoUnfold
code: /-- `dsimp!` is shorthand for `dsimp` with `autoUnfold := true`.
This will rewrite with all equation lemmas, which can be used to
partially evaluate many definitions. -/
declare_simp_like_tactic (dsimp := true) dsimpAutoUnfold "dsimp! " fun (c : Lean.Meta.DSimp.Config) => { c with autoUnfold := true }
goal: Lean.ParserDescr

full_name: Lean.Parser.Tactic.expandSimp._@..lake.packages.lean4.src.lean.Init.Meta._hyg.21442
code: /-- `dsimp!` is shorthand for `dsimp` with `autoUnfold := true`.
This will rewrite with all equation lemmas, which can be used to
partially evaluate many definitions. -/
declare_simp_like_tactic (dsimp := true) dsimpAutoUnfold "dsimp! " fun (c : Lean.Meta.DSimp.Config) => { c with autoUnfold := true }
goal: Lean.Macro