ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: .lake/packages/lean4/src/lean/Lean/Server/ImportCompletion.lean

full_name: ImportCompletion.ImportTrie
code: abbrev ImportTrie 
goal: Type

full_name: ImportCompletion.AvailableImports
code: abbrev AvailableImports 
goal: Type

full_name: ImportCompletion.AvailableImports.toImportTrie
code: def AvailableImports.toImportTrie (imports : AvailableImports) : ImportTrie 
goal: ImportCompletion.ImportTrie

full_name: ImportCompletion.determinePartialHeaderCompletions
code: def determinePartialHeaderCompletions
    (headerStx : Syntax)
    (completionPos : String.Pos)
    : Option Syntax 
goal: Option Lean.Syntax

full_name: ImportCompletion.isImportNameCompletionRequest
code: /-- Checks whether `completionPos` points at the position after an incomplete `import` statement. -/
def isImportNameCompletionRequest (headerStx : Syntax) (completionPos : String.Pos) : Bool 
goal: Bool

full_name: ImportCompletion.isImportCmdCompletionRequest
code: /-- Checks whether `completionPos` points at a free space in the header. -/
def isImportCmdCompletionRequest (headerStx : Syntax) (completionPos : String.Pos) : Bool 
goal: Bool

full_name: ImportCompletion.computePartialImportCompletions
code: def computePartialImportCompletions
    (headerStx : Syntax)
    (completionPos : String.Pos)
    (availableImports : ImportTrie)
    : Array Name 
goal: Array Lean.Name

full_name: ImportCompletion.isImportCompletionRequest
code: def isImportCompletionRequest (text : FileMap) (headerStx : Syntax) (params : CompletionParams) : Bool 
goal: Bool

full_name: ImportCompletion.collectAvailableImportsFromLake
code: def collectAvailableImportsFromLake : IO (Option AvailableImports) 
goal: IO (Option ImportCompletion.AvailableImports)

full_name: ImportCompletion.collectAvailableImportsFromSrcSearchPath
code: def collectAvailableImportsFromSrcSearchPath : IO AvailableImports 
goal: IO ImportCompletion.AvailableImports

full_name: ImportCompletion.collectAvailableImports
code: def collectAvailableImports : IO AvailableImports 
goal: IO ImportCompletion.AvailableImports

full_name: ImportCompletion.addCompletionItemData
code: /--
Sets the `data?` field of every `CompletionItem` in `completionList` using `params`. Ensures that
`completionItem/resolve` requests can be routed to the correct file worker even for
`CompletionItem`s produced by the import completion.
-/
def addCompletionItemData (completionList : CompletionList) (params : CompletionParams)
    : CompletionList 
goal: Lean.Lsp.CompletionList

full_name: ImportCompletion.find
code: def find (text : FileMap) (headerStx : Syntax) (params : CompletionParams) (availableImports : AvailableImports) : CompletionList 
goal: Lean.Lsp.CompletionList

full_name: ImportCompletion.computeCompletions
code: def computeCompletions (text : FileMap) (headerStx : Syntax) (params : CompletionParams)
    : IO CompletionList 
goal: IO Lean.Lsp.CompletionList
File: .lake/packages/lean4/src/lean/Lean/Runtime.lean

full_name: Lean.closureMaxArgsFn
code: @[extern "lean_closure_max_args"]
opaque closureMaxArgsFn : Unit → Nat
goal: Unit → Nat

full_name: Lean.maxSmallNatFn
code: @[extern "lean_max_small_nat"]
opaque maxSmallNatFn : Unit → Nat
goal: Unit → Nat

full_name: Lean.closureMaxArgs
code: def closureMaxArgs : Nat 
goal: Nat

full_name: Lean.maxSmallNat
code: def maxSmallNat : Nat 
goal: Nat
File: .lake/packages/lean4/src/lean/Lean/DocString.lean

full_name: Lean.findDocString?
code: /--
Finds the docstring for a name, taking tactic alternate forms and documentation extensions into
account.

Use `Lean.findSimpleDocString?` to look up the raw docstring without resolving alternate forms or
including extensions.
-/
def findDocString? (env : Environment) (declName : Name) (includeBuiltin := true) : IO (Option String) 
goal: IO (Option String)
File: .lake/packages/lean4/src/lean/Lean/Linter/Basic.lean

full_name: Lean.Linter.initFn._@..lake.packages.lean4.src.lean.Lean.Linter.Basic._hyg.6
code: register_builtin_option linter.all : Bool := {
  defValue := false
  descr := "enable all linters"
}
goal: IO (Lean.Option Bool)

full_name: Lean.Linter.linter.all
code: register_builtin_option linter.all : Bool := {
  defValue := false
  descr := "enable all linters"
}
goal: Lean.Option Bool

full_name: Lean.Linter.getLinterAll
code: def getLinterAll (o : Options) (defValue := linter.all.defValue) : Bool 
goal: Bool

full_name: Lean.Linter.getLinterValue
code: def getLinterValue (opt : Lean.Option Bool) (o : Options) : Bool 
goal: Bool
File: .lake/packages/lean4/src/lean/Lean/Server/Rpc/Deriving.lean

full_name: Lean.Server.RpcEncodable.isOptField
code: def isOptField (n : Name) : Bool 
goal: Bool

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Server.Rpc.Deriving.0.Lean.Server.RpcEncodable.deriveStructureInstance
code: private def deriveStructureInstance (indVal : InductiveVal) (params : Array Expr)
    (encInstBinders : Array (TSyntax ``bracketedBinder)) : TermElabM Command 
goal: Lean.Elab.TermElabM Lean.Command

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Server.Rpc.Deriving.0.Lean.Server.RpcEncodable.matchAltTerm
code: private def matchAltTerm 
goal: Lean.Parser.Parser

full_name: Lean.Server.RpcEncodable.«instCoeTSyntaxConsSyntaxNodeKindStrNumAnonymousOfNatNatNilMkStr4_.lake»
code: instance : Coe (TSyntax ``matchAltTerm) (TSyntax ``Parser.Term.matchAlt) 
goal: Coe
  (Lean.TSyntax
    (((((`_private.«.lake».packages.lean4.src.lean.Lean.Server.Rpc.Deriving.num 0).str "Lean").str "Server").str
          "RpcEncodable").str
      "matchAltTerm"))
  (Lean.TSyntax `Lean.Parser.Term.matchAlt)

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Server.Rpc.Deriving.0.Lean.Server.RpcEncodable.deriveInductiveInstance
code: private def deriveInductiveInstance (indVal : InductiveVal) (params : Array Expr)
    (encInstBinders : Array (TSyntax ``bracketedBinder)) : TermElabM Command 
goal: Lean.Elab.TermElabM Lean.Command

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Server.Rpc.Deriving.0.Lean.Server.RpcEncodable.deriveInstance
code: /-- Creates an `RpcEncodablePacket` for `typeName`. For structures, the packet is a structure
with the same field names. For inductives, it mirrors the inductive structure with every field
of every ctor replaced by `Json`. Then `RpcEncodable typeName` is instantiated
using the `RpcEncodablePacket`. -/
private def deriveInstance (declNames : Array Name) : CommandElabM Bool 
goal: Lean.Elab.Command.CommandElabM Bool

full_name: Lean.Server.RpcEncodable.initFn._@..lake.packages.lean4.src.lean.Lean.Server.Rpc.Deriving._hyg.4931
code: initialize
  registerDerivingHandler ``RpcEncodable deriveInstance
  registerTraceClass `Elab.Deriving.RpcEncodable
goal: IO Unit
File: .lake/packages/lean4/src/lean/Lean/Linter/Util.lean

full_name: Lean.Linter.logLint
code: def logLint [Monad m] [MonadLog m] [AddMessageContext m] [MonadOptions m]
    (linterOption : Lean.Option Bool) (stx : Syntax) (msg : MessageData) : m Unit 
goal: m Unit

full_name: Lean.Linter.logLintIf
code: /-- If `linterOption` is true, print a linter warning message at the position determined by `stx`.
-/
def logLintIf [Monad m] [MonadLog m] [AddMessageContext m] [MonadOptions m]
    (linterOption : Lean.Option Bool) (stx : Syntax) (msg : MessageData) : m Unit 
goal: m Unit

full_name: Lean.Linter.collectMacroExpansions?
code: /-- Go upwards through the given `tree` starting from the smallest node that
contains the given `range` and collect all `MacroExpansionInfo`s on the way up.
The result is `some []` if no `MacroExpansionInfo` was found on the way and
`none` if no `InfoTree` node was found that covers the given `range`.

Return the result reversed, s.t. the macro expansion that would be applied to
the original syntax first is the first element of the returned list. -/
def collectMacroExpansions? {m} [Monad m] (range : String.Range) (tree : Elab.InfoTree) : m <| Option <| List Elab.MacroExpansionInfo 
goal: m (Option (List Lean.Elab.MacroExpansionInfo))

full_name: Lean.Linter.collectMacroExpansions?.go
code: /-- Go upwards through the given `tree` starting from the smallest node that
contains the given `range` and collect all `MacroExpansionInfo`s on the way up.
The result is `some []` if no `MacroExpansionInfo` was found on the way and
`none` if no `InfoTree` node was found that covers the given `range`.

Return the result reversed, s.t. the macro expansion that would be applied to
the original syntax first is the first element of the returned list. -/
def collectMacroExpansions? {m} [Monad m] (range : String.Range) (tree : Elab.InfoTree) : m <| Option <| List Elab.MacroExpansionInfo 
goal: m (Option (Option (List Lean.Elab.MacroExpansionInfo)))
File: .lake/packages/lean4/src/lean/Lean/Linter/ConstructorAsVariable.lean

full_name: Lean.Linter.linter.constructorNameAsVariable
code: /--
A linter that warns when bound variable names are the same as constructor names for their types,
modulo namespaces.
 -/
register_builtin_option linter.constructorNameAsVariable : Bool := {
  defValue := true,
  descr := "enable the linter that warns when bound variable names are nullary constructor names"
}
goal: Lean.Option Bool

full_name: Lean.Linter.initFn._@..lake.packages.lean4.src.lean.Lean.Linter.ConstructorAsVariable._hyg.9
code: /--
A linter that warns when bound variable names are the same as constructor names for their types,
modulo namespaces.
 -/
register_builtin_option linter.constructorNameAsVariable : Bool := {
  defValue := true,
  descr := "enable the linter that warns when bound variable names are nullary constructor names"
}
goal: IO (Lean.Option Bool)

full_name: Lean.Linter.constructorNameAsVariable
code: /--
Reports when bound variables' names overlap with constructor names for their type. This is to warn
especially new users that they have built a pattern that matches anything, rather than one that
matches a particular constructor. Use `linter.constructorNameAsVariable` to disable.
-/
def constructorNameAsVariable : Linter 
goal: Lean.Linter

full_name: Lean.Linter.initFn._@..lake.packages.lean4.src.lean.Lean.Linter.ConstructorAsVariable._hyg.1348
code: builtin_initialize addLinter constructorNameAsVariable
goal: IO Unit
File: .lake/packages/lean4/src/lean/Lean/Linter/Builtin.lean

full_name: Lean.Linter.initFn._@..lake.packages.lean4.src.lean.Lean.Linter.Builtin._hyg.6
code: register_builtin_option linter.suspiciousUnexpanderPatterns : Bool := {
  defValue := true,
  descr := "enable the 'suspicious unexpander patterns' linter"
}
goal: IO (Lean.Option Bool)

full_name: Lean.Linter.linter.suspiciousUnexpanderPatterns
code: register_builtin_option linter.suspiciousUnexpanderPatterns : Bool := {
  defValue := true,
  descr := "enable the 'suspicious unexpander patterns' linter"
}
goal: Lean.Option Bool

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

full_name: Lean.Linter.suspiciousUnexpanderPatterns
code: def suspiciousUnexpanderPatterns : Linter 
goal: Lean.Linter

full_name: Lean.Linter.initFn._@..lake.packages.lean4.src.lean.Lean.Linter.Builtin._hyg.2307
code: builtin_initialize addLinter suspiciousUnexpanderPatterns
goal: IO Unit
File: .lake/packages/lean4/src/lean/Lean/Widget/Basic.lean

full_name: Lean.Widget.«instTypeNameInfoWithCtx_.lake»
code: TypeName
goal: TypeName Lean.Elab.InfoWithCtx

full_name: Lean.Widget.instImpl._@..lake.packages.lean4.src.lean.Lean.Widget.Basic._hyg.5
code: TypeName
goal: TypeName Lean.Elab.InfoWithCtx

full_name: Lean.Widget.inst._@..lake.packages.lean4.src.lean.Lean.Widget.Basic._hyg.5
code: TypeName
goal: TypeName Lean.Elab.InfoWithCtx

full_name: Lean.Widget.inst._@..lake.packages.lean4.src.lean.Lean.Widget.Basic._hyg.28
code: TypeName
goal: TypeName Lean.MessageData

full_name: Lean.Widget.«instTypeNameMessageData_.lake»
code: TypeName
goal: TypeName Lean.MessageData

full_name: Lean.Widget.instImpl._@..lake.packages.lean4.src.lean.Lean.Widget.Basic._hyg.28
code: TypeName
goal: TypeName Lean.MessageData

full_name: Lean.Widget.instImpl._@..lake.packages.lean4.src.lean.Lean.Widget.Basic._hyg.51
code: TypeName
goal: TypeName Lean.LocalContext

full_name: Lean.Widget.«instTypeNameLocalContext_.lake»
code: TypeName
goal: TypeName Lean.LocalContext

full_name: Lean.Widget.inst._@..lake.packages.lean4.src.lean.Lean.Widget.Basic._hyg.51
code: TypeName
goal: TypeName Lean.LocalContext

full_name: Lean.Widget.inst._@..lake.packages.lean4.src.lean.Lean.Widget.Basic._hyg.74
code: TypeName
goal: TypeName Lean.Elab.ContextInfo

full_name: Lean.Widget.instImpl._@..lake.packages.lean4.src.lean.Lean.Widget.Basic._hyg.74
code: TypeName
goal: TypeName Lean.Elab.ContextInfo

full_name: Lean.Widget.«instTypeNameContextInfo_.lake»
code: TypeName
goal: TypeName Lean.Elab.ContextInfo

full_name: Lean.Widget.«instTypeNameTermInfo_.lake»
code: TypeName
goal: TypeName Lean.Elab.TermInfo

full_name: Lean.Widget.inst._@..lake.packages.lean4.src.lean.Lean.Widget.Basic._hyg.97
code: TypeName
goal: TypeName Lean.Elab.TermInfo

full_name: Lean.Widget.instImpl._@..lake.packages.lean4.src.lean.Lean.Widget.Basic._hyg.97
code: TypeName
goal: TypeName Lean.Elab.TermInfo
File: .lake/packages/lean4/src/lean/Lean/AuxRecursor.lean

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

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

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

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

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

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

full_name: Lean.mkCasesOnName
code: def mkCasesOnName (indDeclName : Name) : Name 
goal: Lean.Name

full_name: Lean.mkRecOnName
code: def mkRecOnName (indDeclName : Name) : Name   
goal: Lean.Name

full_name: Lean.mkBRecOnName
code: def mkBRecOnName (indDeclName : Name) : Name  
goal: Lean.Name

full_name: Lean.mkBInductionOnName
code: def mkBInductionOnName (indDeclName : Name) : Name  
goal: Lean.Name

full_name: Lean.mkBelowName
code: def mkBelowName (indDeclName : Name) : Name 
goal: Lean.Name

full_name: Lean.mkIBelowName
code: def mkIBelowName (indDeclName : Name) : Name 
goal: Lean.Name

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.AuxRecursor._hyg.70
code: builtin_initialize auxRecExt : TagDeclarationExtension ← mkTagDeclarationExtension
goal: IO Lean.TagDeclarationExtension

full_name: Lean.auxRecExt
code: builtin_initialize auxRecExt : TagDeclarationExtension ← mkTagDeclarationExtension
goal: Lean.TagDeclarationExtension

full_name: Lean.markAuxRecursor
code: def markAuxRecursor (env : Environment) (declName : Name) : Environment 
goal: Lean.Environment

full_name: Lean.isAuxRecursor
code: @[export lean_is_aux_recursor]
def isAuxRecursor (env : Environment) (declName : Name) : Bool 
goal: Bool

full_name: Lean.isAuxRecursorWithSuffix
code: def isAuxRecursorWithSuffix (env : Environment) (declName : Name) (suffix : String) : Bool 
goal: Bool

full_name: Lean.isCasesOnRecursor
code: def isCasesOnRecursor (env : Environment) (declName : Name) : Bool 
goal: Bool

full_name: Lean.isRecOnRecursor
code: def isRecOnRecursor (env : Environment) (declName : Name) : Bool 
goal: Bool

full_name: Lean.isBRecOnRecursor
code: def isBRecOnRecursor (env : Environment) (declName : Name) : Bool 
goal: Bool

full_name: Lean.noConfusionExt
code: builtin_initialize noConfusionExt : TagDeclarationExtension ← mkTagDeclarationExtension
goal: Lean.TagDeclarationExtension

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.AuxRecursor._hyg.193
code: builtin_initialize noConfusionExt : TagDeclarationExtension ← mkTagDeclarationExtension
goal: IO Lean.TagDeclarationExtension

full_name: Lean.markNoConfusion
code: def markNoConfusion (env : Environment) (n : Name) : Environment 
goal: Lean.Environment

full_name: Lean.isNoConfusion
code: @[export lean_is_no_confusion]
def isNoConfusion (env : Environment) (n : Name) : Bool 
goal: Bool
File: .lake/packages/lean4/src/lean/Lean/PrettyPrinter/Basic.lean

full_name: Lean.PrettyPrinter.backtrackExceptionId
code: builtin_initialize backtrackExceptionId : InternalExceptionId ← registerInternalExceptionId `backtrackFormatter
goal: Lean.InternalExceptionId

full_name: Lean.PrettyPrinter.initFn._@..lake.packages.lean4.src.lean.Lean.PrettyPrinter.Basic._hyg.5
code: builtin_initialize backtrackExceptionId : InternalExceptionId ← registerInternalExceptionId `backtrackFormatter
goal: IO Lean.InternalExceptionId

full_name: Lean.PrettyPrinter.runForNodeKind
code: unsafe def runForNodeKind {α} (attr : KeyedDeclsAttribute α) (k : SyntaxNodeKind) (interp : ParserDescr → CoreM α) : CoreM α 
goal: Lean.CoreM α
File: .lake/packages/lean4/src/lean/Lean/PrettyPrinter/Delaborator/FieldNotation.lean

full_name: _private.«.lake».packages.lean4.src.lean.Lean.PrettyPrinter.Delaborator.FieldNotation.0.Lean.PrettyPrinter.Delaborator.projInfo
code: /--
If this constant is a structure projection that could delaborate using dot notation,
returns the field name, the number of parameters before the structure argument, and whether this is a parent projection.
Otherwise it fails.
-/
private def projInfo (c : Name) : MetaM (Name × Nat × Bool) 
goal: Lean.MetaM (Lean.Name × Nat × Bool)

full_name: _private.«.lake».packages.lean4.src.lean.Lean.PrettyPrinter.Delaborator.FieldNotation.0.Lean.PrettyPrinter.Delaborator.typeMatchesBaseName
code: /--
Like `Lean.Elab.Term.typeMatchesBaseName` but does not use `Function` for pi types.
-/
private def typeMatchesBaseName (type : Expr) (baseName : Name) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: _private.«.lake».packages.lean4.src.lean.Lean.PrettyPrinter.Delaborator.FieldNotation.0.Lean.PrettyPrinter.Delaborator.generalizedFieldInfo
code: /--
If this constant application could delaborate using generalized field notation with little confusion,
returns the field name and the index for the argument to be used as the object of the field notation.
Otherwise it fails.
-/
private def generalizedFieldInfo (c : Name) (args : Array Expr) : MetaM (Name × Nat) 
goal: Lean.MetaM (Lean.Name × Nat)

full_name: Lean.PrettyPrinter.Delaborator.fieldNotationCandidate?
code: /--
If `f` is a function that can be used for field notation,
returns the field name to use and the argument index for the object of the field notation.
-/
def fieldNotationCandidate? (f : Expr) (args : Array Expr) (useGeneralizedFieldNotation : Bool) : MetaM (Option (Name × Nat)) 
goal: Lean.MetaM (Option (Lean.Name × Nat))

full_name: Lean.PrettyPrinter.Delaborator.parentProj?
code: /--
Returns the field name of the projection if `e` is an application that is a projection to a parent structure.
If `explicit` is `true`, then requires that the structure have no parameters.
-/
def parentProj? (explicit : Bool) (e : Expr) : MetaM (Option Name) 
goal: Lean.MetaM (Option Lean.Name)

full_name: Lean.PrettyPrinter.Delaborator.isParentProj
code: /--
Returns `true` if `e` is an application that is a projection to a parent structure.
If `explicit` is `true`, then requires that the structure have no parameters.
-/
def isParentProj (explicit : Bool) (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool
File: .lake/packages/lean4/src/lean/Lean/PrettyPrinter/Delaborator/Attributes.lean

full_name: Lean.ppUsingAnonymousConstructorAttr
code: builtin_initialize ppUsingAnonymousConstructorAttr : TagAttribute ←
  registerTagAttribute `pp_using_anonymous_constructor "mark structure to be pretty printed using `⟨a,b,c⟩` notation"
goal: Lean.TagAttribute

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.PrettyPrinter.Delaborator.Attributes._hyg.5
code: builtin_initialize ppUsingAnonymousConstructorAttr : TagAttribute ←
  registerTagAttribute `pp_using_anonymous_constructor "mark structure to be pretty printed using `⟨a,b,c⟩` notation"
goal: IO Lean.TagAttribute

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.PrettyPrinter.Delaborator.Attributes._hyg.33
code: builtin_initialize ppNoDotAttr : TagAttribute ←
  registerTagAttribute `pp_nodot "mark declaration to never be pretty printed using field notation"
goal: IO Lean.TagAttribute

full_name: Lean.ppNoDotAttr
code: builtin_initialize ppNoDotAttr : TagAttribute ←
  registerTagAttribute `pp_nodot "mark declaration to never be pretty printed using field notation"
goal: Lean.TagAttribute

full_name: Lean.hasPPUsingAnonymousConstructorAttribute
code: /--
Returns whether or not the given declaration has the `@[pp_using_anonymous_constructor]` attribute.
-/
def hasPPUsingAnonymousConstructorAttribute (env : Environment) (declName : Name) : Bool 
goal: Bool

full_name: Lean.hasPPNoDotAttribute
code: /--
Returns whether or not the given declaration has the `@[pp_nodot]` attribute.
-/
def hasPPNoDotAttribute (env : Environment) (declName : Name) : Bool 
goal: Bool
File: .lake/packages/lean4/src/lean/Lean/InternalExceptionId.lean

full_name: Lean.InternalExceptionId
code: /-- Internal exception identifier -/
structure InternalExceptionId where
  idx : Nat := 0
  deriving Inhabited, BEq
goal: Type

full_name: Lean.InternalExceptionId.idx
code: /-- Internal exception identifier -/
structure InternalExceptionId where
  idx : Nat := 0
  deriving Inhabited, BEq
goal: Nat

full_name: Lean.instBEqInternalExceptionId
code: /-- Internal exception identifier -/
structure InternalExceptionId where
  idx : Nat := 0
  deriving Inhabited, BEq
goal: BEq Lean.InternalExceptionId

full_name: Lean.instInhabitedInternalExceptionId
code: /-- Internal exception identifier -/
structure InternalExceptionId where
  idx : Nat := 0
  deriving Inhabited, BEq
goal: Inhabited Lean.InternalExceptionId

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.InternalExceptionId._hyg.89
code: /-- Internal exceptions registered in the system. -/
builtin_initialize internalExceptionsRef : IO.Ref (Array Name) ← IO.mkRef #[]
goal: IO (IO.Ref (Array Lean.Name))

full_name: Lean.internalExceptionsRef
code: /-- Internal exceptions registered in the system. -/
builtin_initialize internalExceptionsRef : IO.Ref (Array Name) ← IO.mkRef #[]
goal: IO.Ref (Array Lean.Name)

full_name: Lean.registerInternalExceptionId
code: /--
Register a new internal exception in the system.
Each internal exception has a unique index.
Throw an exception if the given name is not unique.
This method is usually invoked using the `initialize` command.
-/
def registerInternalExceptionId (name : Name) : IO InternalExceptionId 
goal: IO Lean.InternalExceptionId

full_name: Lean.InternalExceptionId.toString
code: /-- Convert internal exception id into the message "internal exception #<idx>"-/
def InternalExceptionId.toString (id : InternalExceptionId) : String 
goal: String

full_name: Lean.InternalExceptionId.getName
code: /-- Retrieve the name used to register the internal exception. -/
def InternalExceptionId.getName (id : InternalExceptionId) : IO Name 
goal: IO Lean.Name