ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: .lake/packages/lean4/src/lean/Lean/Compiler/IR/SimpCase.lean

full_name: Lean.IR.ensureHasDefault
code: def ensureHasDefault (alts : Array Alt) : Array Alt 
goal: Array Lean.IR.Alt

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.IR.SimpCase.0.Lean.IR.getOccsOf
code: private def getOccsOf (alts : Array Alt) (i : Nat) : Nat 
goal: Nat

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.IR.SimpCase.0.Lean.IR.maxOccs
code: private def maxOccs (alts : Array Alt) : Alt × Nat 
goal: Lean.IR.Alt × Nat

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.IR.SimpCase.0.Lean.IR.addDefault
code: private def addDefault (alts : Array Alt) : Array Alt 
goal: Array Lean.IR.Alt

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.IR.SimpCase.0.Lean.IR.filterUnreachable
code: private def filterUnreachable (alts : Array Alt) : Array Alt 
goal: Array Lean.IR.Alt

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.IR.SimpCase.0.Lean.IR.mkSimpCase
code: private def mkSimpCase (tid : Name) (x : VarId) (xType : IRType) (alts : Array Alt) : FnBody 
goal: Lean.IR.FnBody

full_name: Lean.IR.FnBody.simpCase
code: partial def FnBody.simpCase (b : FnBody) : FnBody 
goal: Lean.IR.FnBody

full_name: Lean.IR.Decl.simpCase
code: /-- Simplify `case`
  - Remove unreachable branches.
  - Remove `case` if there is only one branch.
  - Merge most common branches using `Alt.default`. -/
def Decl.simpCase (d : Decl) : Decl 
goal: Lean.IR.Decl
File: .lake/packages/lean4/src/lean/Lean/Compiler/IR/Sorry.lean

full_name: Lean.IR.Sorry.State
code: structure State where
  localSorryMap : NameMap Name := {}
  modified : Bool := false
goal: Type

full_name: Lean.IR.Sorry.State.localSorryMap
code: structure State where
  localSorryMap : NameMap Name := {}
  modified : Bool := false
goal: Lean.NameMap Lean.Name

full_name: Lean.IR.Sorry.State.modified
code: structure State where
  localSorryMap : NameMap Name := {}
  modified : Bool := false
goal: Bool

full_name: Lean.IR.Sorry.M
code: abbrev M 
goal: Type

full_name: Lean.IR.Sorry.visitExpr.getSorryDepFor?
code: def visitExpr : Expr → ExceptT Name M Unit
  
goal: ExceptT Lean.Name Lean.IR.Sorry.M Unit

full_name: Lean.IR.Sorry.visitExpr
code: def visitExpr : Expr → ExceptT Name M Unit
  
goal: Lean.IR.Expr → ExceptT Lean.Name Lean.IR.Sorry.M Unit

full_name: Lean.IR.Sorry.visitFndBody
code: partial def visitFndBody (b : FnBody) : ExceptT Name M Unit 
goal: ExceptT Lean.Name Lean.IR.Sorry.M Unit

full_name: Lean.IR.Sorry.visitDecl
code: def visitDecl (d : Decl) : M Unit 
goal: Lean.IR.Sorry.M Unit

full_name: Lean.IR.Sorry.collect
code: partial def collect (decls : Array Decl) : M Unit 
goal: Lean.IR.Sorry.M Unit

full_name: Lean.IR.updateSorryDep
code: def updateSorryDep (decls : Array Decl) : CompilerM (Array Decl) 
goal: Lean.IR.CompilerM (Array Lean.IR.Decl)
File: .lake/packages/lean4/src/lean/Lean/Compiler/IR/UnboxResult.lean

full_name: Lean.IR.UnboxResult.unboxAttr
code: builtin_initialize unboxAttr : TagAttribute ←
  registerTagAttribute `unbox "compiler tries to unbox result values if their types are tagged with `[unbox]`" fun declName => do
    let cinfo ← getConstInfo declName;
    match cinfo with
    | ConstantInfo.inductInfo v =>
      if v.isRec then throwError "recursive inductive datatypes are not supported"
      else pure ()
    | _ => throwError "constant must be an inductive type"
goal: Lean.TagAttribute

full_name: Lean.IR.UnboxResult.initFn._@..lake.packages.lean4.src.lean.Lean.Compiler.IR.UnboxResult._hyg.4
code: builtin_initialize unboxAttr : TagAttribute ←
  registerTagAttribute `unbox "compiler tries to unbox result values if their types are tagged with `[unbox]`" fun declName => do
    let cinfo ← getConstInfo declName;
    match cinfo with
    | ConstantInfo.inductInfo v =>
      if v.isRec then throwError "recursive inductive datatypes are not supported"
      else pure ()
    | _ => throwError "constant must be an inductive type"
goal: IO Lean.TagAttribute

full_name: Lean.IR.UnboxResult.hasUnboxAttr
code: def hasUnboxAttr (env : Environment) (n : Name) : Bool 
goal: Bool
File: .lake/packages/lean4/src/lean/Lean/Compiler/IR/ElimDeadVars.lean

full_name: Lean.IR.reshapeWithoutDead.reshape
code: partial def reshapeWithoutDead (bs : Array FnBody) (term : FnBody) : FnBody 
goal: Lean.IR.FnBody

full_name: Lean.IR.reshapeWithoutDead
code: partial def reshapeWithoutDead (bs : Array FnBody) (term : FnBody) : FnBody 
goal: Lean.IR.FnBody

full_name: Lean.IR.FnBody.elimDead
code: partial def FnBody.elimDead (b : FnBody) : FnBody 
goal: Lean.IR.FnBody

full_name: Lean.IR.Decl.elimDead
code: /-- Eliminate dead let-declarations and join points -/
def Decl.elimDead (d : Decl) : Decl 
goal: Lean.IR.Decl
File: .lake/packages/lean4/src/lean/Lean/Compiler/IR/CtorLayout.lean

full_name: Lean.IR.CtorFieldInfo.scalar
code: inductive CtorFieldInfo where
  | irrelevant
  | object (i : Nat)
  | usize  (i : Nat)
  | scalar (sz : Nat) (offset : Nat) (type : IRType)
goal: Lean.IR.CtorFieldInfo

full_name: Lean.IR.CtorFieldInfo.irrelevant
code: inductive CtorFieldInfo where
  | irrelevant
  | object (i : Nat)
  | usize  (i : Nat)
  | scalar (sz : Nat) (offset : Nat) (type : IRType)
goal: Lean.IR.CtorFieldInfo

full_name: Lean.IR.CtorFieldInfo
code: inductive CtorFieldInfo where
  | irrelevant
  | object (i : Nat)
  | usize  (i : Nat)
  | scalar (sz : Nat) (offset : Nat) (type : IRType)
goal: Type

full_name: Lean.IR.CtorFieldInfo.object
code: inductive CtorFieldInfo where
  | irrelevant
  | object (i : Nat)
  | usize  (i : Nat)
  | scalar (sz : Nat) (offset : Nat) (type : IRType)
goal: Lean.IR.CtorFieldInfo

full_name: Lean.IR.CtorFieldInfo.usize
code: inductive CtorFieldInfo where
  | irrelevant
  | object (i : Nat)
  | usize  (i : Nat)
  | scalar (sz : Nat) (offset : Nat) (type : IRType)
goal: Lean.IR.CtorFieldInfo

full_name: Lean.IR.CtorFieldInfo.format
code: def format : CtorFieldInfo → Format
  
goal: Lean.IR.CtorFieldInfo → Lean.Format

full_name: Lean.IR.CtorFieldInfo.instToFormat
code: instance : ToFormat CtorFieldInfo 
goal: Lean.ToFormat Lean.IR.CtorFieldInfo

full_name: Lean.IR.CtorLayout.numUSize
code: structure CtorLayout where
  cidx       : Nat
  fieldInfo  : List CtorFieldInfo
  numObjs    : Nat
  numUSize   : Nat
  scalarSize : Nat
goal: Nat

full_name: Lean.IR.CtorLayout.scalarSize
code: structure CtorLayout where
  cidx       : Nat
  fieldInfo  : List CtorFieldInfo
  numObjs    : Nat
  numUSize   : Nat
  scalarSize : Nat
goal: Nat

full_name: Lean.IR.CtorLayout.cidx
code: structure CtorLayout where
  cidx       : Nat
  fieldInfo  : List CtorFieldInfo
  numObjs    : Nat
  numUSize   : Nat
  scalarSize : Nat
goal: Nat

full_name: Lean.IR.CtorLayout
code: structure CtorLayout where
  cidx       : Nat
  fieldInfo  : List CtorFieldInfo
  numObjs    : Nat
  numUSize   : Nat
  scalarSize : Nat
goal: Type

full_name: Lean.IR.CtorLayout.fieldInfo
code: structure CtorLayout where
  cidx       : Nat
  fieldInfo  : List CtorFieldInfo
  numObjs    : Nat
  numUSize   : Nat
  scalarSize : Nat
goal: List Lean.IR.CtorFieldInfo

full_name: Lean.IR.CtorLayout.numObjs
code: structure CtorLayout where
  cidx       : Nat
  fieldInfo  : List CtorFieldInfo
  numObjs    : Nat
  numUSize   : Nat
  scalarSize : Nat
goal: Nat

full_name: Lean.IR.getCtorLayout
code: @[extern "lean_ir_get_ctor_layout"]
opaque getCtorLayout (env : @& Environment) (ctorName : @& Name) : Except String CtorLayout
goal: Except String Lean.IR.CtorLayout
File: .lake/packages/lean4/src/lean/Lean/Compiler/IR/PushProj.lean

full_name: Lean.IR.pushProjs
code: partial def pushProjs (bs : Array FnBody) (alts : Array Alt) (altsF : Array IndexSet) (ctx : Array FnBody) (ctxF : IndexSet) : Array FnBody × Array Alt 
goal: Array Lean.IR.FnBody × Array Lean.IR.Alt

full_name: Lean.IR.FnBody.pushProj
code: partial def FnBody.pushProj (b : FnBody) : FnBody 
goal: Lean.IR.FnBody

full_name: Lean.IR.Decl.pushProj
code: /-- Push projections inside `case` branches. -/
def Decl.pushProj (d : Decl) : Decl 
goal: Lean.IR.Decl
File: .lake/packages/lean4/src/lean/Lean/Compiler/FFI.lean

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.FFI.0.Lean.Compiler.FFI.getLeancExtraFlags
code: @[extern "lean_get_leanc_extra_flags"]
private opaque getLeancExtraFlags : Unit → String
goal: Unit → String

full_name: Lean.Compiler.FFI.getCFlags
code: /-- Return C compiler flags for including Lean's headers. -/
def getCFlags (leanSysroot : FilePath) : Array String 
goal: Array String

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.FFI.0.Lean.Compiler.FFI.getLeancInternalFlags
code: @[extern "lean_get_leanc_internal_flags"]
private opaque getLeancInternalFlags : Unit → String
goal: Unit → String

full_name: Lean.Compiler.FFI.getInternalCFlags
code: /-- Return C compiler flags needed to use the C compiler bundled with the Lean toolchain. -/
def getInternalCFlags (leanSysroot : FilePath) : Array String 
goal: Array String

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.FFI.0.Lean.Compiler.FFI.getBuiltinLinkerFlags
code: @[extern "lean_get_linker_flags"]
private opaque getBuiltinLinkerFlags (linkStatic : Bool) : String
goal: String

full_name: Lean.Compiler.FFI.getLinkerFlags
code: /-- Return linker flags for linking against Lean's libraries. -/
def getLinkerFlags (leanSysroot : FilePath) (linkStatic := true) : Array String 
goal: Array String

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.FFI.0.Lean.Compiler.FFI.getBuiltinInternalLinkerFlags
code: @[extern "lean_get_internal_linker_flags"]
private opaque getBuiltinInternalLinkerFlags : Unit → String
goal: Unit → String

full_name: Lean.Compiler.FFI.getInternalLinkerFlags
code: /-- Return linker flags needed to use the linker bundled with the Lean toolchain. -/
def getInternalLinkerFlags (leanSysroot : FilePath) : Array String 
goal: Array String
File: .lake/packages/lean4/src/lean/Lean/Compiler/AtMostOnce.lean

full_name: Lean.Compiler.atMostOnce.AtMostOnceData.result
code: structure AtMostOnceData where
  found : Bool
  result : Bool
goal: Bool

full_name: Lean.Compiler.atMostOnce.AtMostOnceData
code: structure AtMostOnceData where
  found : Bool
  result : Bool
goal: Type

full_name: Lean.Compiler.atMostOnce.AtMostOnceData.found
code: structure AtMostOnceData where
  found : Bool
  result : Bool
goal: Bool

full_name: Lean.Compiler.atMostOnce.Visitor
code: def Visitor 
goal: Type

full_name: Lean.Compiler.atMostOnce.seq
code: @[inline] def seq (f g : Visitor) : Visitor 
goal: Lean.Compiler.atMostOnce.Visitor

full_name: Lean.Compiler.atMostOnce.instAndThenVisitor
code: instance : AndThen Visitor 
goal: AndThen Lean.Compiler.atMostOnce.Visitor

full_name: Lean.Compiler.atMostOnce.skip
code: @[inline] def skip : Visitor 
goal: Lean.Compiler.atMostOnce.Visitor

full_name: Lean.Compiler.atMostOnce.visitFVar
code: @[inline] def visitFVar (x y : FVarId) : Visitor
  
goal: Lean.Compiler.atMostOnce.Visitor

full_name: Lean.Compiler.atMostOnce.visit
code: def visit (x : FVarId) : Expr → Visitor
  
goal: Lean.Expr → Lean.Compiler.atMostOnce.Visitor

full_name: Lean.Compiler.atMostOnce
code: /-- Return true iff the free variable with id `x` occurs at most once in `e` -/
@[export lean_at_most_once]
def atMostOnce (e : Expr) (x : FVarId) : Bool 
goal: Bool
File: .lake/packages/lean4/src/lean/Lean/Compiler/IR.lean

full_name: Lean.IR.initFn._@..lake.packages.lean4.src.lean.Lean.Compiler.IR._hyg.6
code: register_builtin_option compiler.reuse : Bool := {
  defValue := true
  descr    := "heuristically insert reset/reuse instruction pairs"
}
goal: IO (Lean.Option Bool)

full_name: Lean.IR.compiler.reuse
code: register_builtin_option compiler.reuse : Bool := {
  defValue := true
  descr    := "heuristically insert reset/reuse instruction pairs"
}
goal: Lean.Option Bool

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.IR.0.Lean.IR.compileAux
code: private def compileAux (decls : Array Decl) : CompilerM Unit 
goal: Lean.IR.CompilerM Unit

full_name: Lean.IR.compile
code: @[export lean_ir_compile]
def compile (env : Environment) (opts : Options) (decls : Array Decl) : Log × (Except String Environment) 
goal: Lean.IR.Log × Except String Lean.Environment

full_name: Lean.IR.addBoxedVersionAux
code: def addBoxedVersionAux (decl : Decl) : CompilerM Unit 
goal: Lean.IR.CompilerM Unit

full_name: Lean.IR.addBoxedVersion
code: @[export lean_ir_add_boxed_version]
def addBoxedVersion (env : Environment) (decl : Decl) : Except String Environment 
goal: Except String Lean.Environment
File: .lake/packages/lean4/src/lean/Lean/Compiler/BorrowedAnnotation.lean

full_name: Lean.markBorrowed
code: def markBorrowed (e : Expr) : Expr 
goal: Lean.Expr

full_name: Lean.isMarkedBorrowed
code: @[export lean_is_marked_borrowed]
def isMarkedBorrowed (e : Expr) : Bool 
goal: Bool
File: .lake/packages/lean4/src/lean/Lean/Compiler/ClosedTermCache.lean

full_name: Lean.ClosedTermCache
code: structure ClosedTermCache where
  map        : PHashMap Expr Name := {}
  constNames : NameSet := {}
  deriving Inhabited
goal: Type

full_name: Lean.ClosedTermCache.map
code: structure ClosedTermCache where
  map        : PHashMap Expr Name := {}
  constNames : NameSet := {}
  deriving Inhabited
goal: Lean.PHashMap Lean.Expr Lean.Name

full_name: Lean.ClosedTermCache.constNames
code: structure ClosedTermCache where
  map        : PHashMap Expr Name := {}
  constNames : NameSet := {}
  deriving Inhabited
goal: Lean.NameSet

full_name: Lean.instInhabitedClosedTermCache
code: structure ClosedTermCache where
  map        : PHashMap Expr Name := {}
  constNames : NameSet := {}
  deriving Inhabited
goal: Inhabited Lean.ClosedTermCache

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.Compiler.ClosedTermCache._hyg.51
code: builtin_initialize closedTermCacheExt : EnvExtension ClosedTermCache ← registerEnvExtension (pure {})
goal: IO (Lean.EnvExtension Lean.ClosedTermCache)

full_name: Lean.closedTermCacheExt
code: builtin_initialize closedTermCacheExt : EnvExtension ClosedTermCache ← registerEnvExtension (pure {})
goal: Lean.EnvExtension Lean.ClosedTermCache

full_name: Lean.cacheClosedTermName
code: @[export lean_cache_closed_term_name]
def cacheClosedTermName (env : Environment) (e : Expr) (n : Name) : Environment 
goal: Lean.Environment

full_name: Lean.getClosedTermName?
code: @[export lean_get_closed_term_name]
def getClosedTermName? (env : Environment) (e : Expr) : Option Name 
goal: Option Lean.Name

full_name: Lean.isClosedTermName
code: def isClosedTermName (env : Environment) (n : Name) : Bool 
goal: Bool
File: .lake/packages/lean4/src/lean/Lean/Compiler/Options.lean

full_name: Lean.Compiler.compiler.check
code: register_builtin_option compiler.check : Bool := {
  defValue := true
  group    := "compiler"
  descr    := "type check code after each compiler step (this is useful for debugging purses)"
}
goal: Lean.Option Bool

full_name: Lean.Compiler.initFn._@..lake.packages.lean4.src.lean.Lean.Compiler.Options._hyg.6
code: register_builtin_option compiler.check : Bool := {
  defValue := true
  group    := "compiler"
  descr    := "type check code after each compiler step (this is useful for debugging purses)"
}
goal: IO (Lean.Option Bool)
File: .lake/packages/lean4/src/lean/Lean/Compiler/NeverExtractAttr.lean

full_name: Lean.neverExtractAttr
code: builtin_initialize neverExtractAttr : TagAttribute ←
  registerTagAttribute `never_extract "instruct the compiler that function applications using the tagged declaration should not be extracted when they are closed terms, nor common subexpression should be performed. This is useful for declarations that have implicit effects."
goal: Lean.TagAttribute

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.Compiler.NeverExtractAttr._hyg.4
code: builtin_initialize neverExtractAttr : TagAttribute ←
  registerTagAttribute `never_extract "instruct the compiler that function applications using the tagged declaration should not be extracted when they are closed terms, nor common subexpression should be performed. This is useful for declarations that have implicit effects."
goal: IO Lean.TagAttribute

full_name: Lean.hasNeverExtractAttribute.visit
code: @[export lean_has_never_extract_attribute]
partial def hasNeverExtractAttribute (env : Environment) (n : Name) : Bool 
goal: Bool

full_name: Lean.hasNeverExtractAttribute
code: @[export lean_has_never_extract_attribute]
partial def hasNeverExtractAttribute (env : Environment) (n : Name) : Bool 
goal: Bool
File: .lake/packages/lean4/src/lean/Lean/Server/CompletionItemData.lean

full_name: Lean.Lsp.CompletionItemData.params
code: /-- Used in `CompletionItem.data?`. -/
structure CompletionItemData where
  params : CompletionParams
  deriving FromJson, ToJson
goal: Lean.Lsp.CompletionParams

full_name: Lean.Lsp.CompletionItemData
code: /-- Used in `CompletionItem.data?`. -/
structure CompletionItemData where
  params : CompletionParams
  deriving FromJson, ToJson
goal: Type

full_name: Lean.Lsp.instFromJsonCompletionItemData
code: FromJson
goal: Lean.FromJson Lean.Lsp.CompletionItemData

full_name: Lean.Lsp.instToJsonCompletionItemData
code: ToJson
goal: Lean.ToJson Lean.Lsp.CompletionItemData

full_name: Lean.Lsp.CompletionItem.getFileSource!
code: /--
Yields the file source of `item` by attempting to parse `item.data?` to `CompletionItemData` and
obtaining the original file source from its `params` fields. Panics if `item.data?` is not present
or cannot be parsed to `CompletionItemData`.
Used when `completionItem/resolve` requests pass the watchdog to decide which file worker to forward
the request to.
Since this function can panic and clients typically send `completionItem/resolve` requests for every
selected completion item, all completion items returned by the server in `textDocument/completion`
requests must have a `data?` field that can be parsed to `CompletionItemData`.
-/
def CompletionItem.getFileSource! (item : CompletionItem) : DocumentUri 
goal: Lean.Lsp.DocumentUri

full_name: Lean.Lsp.«instFileSourceCompletionItem_.lake»
code: instance : FileSource CompletionItem 
goal: Lean.Lsp.FileSource Lean.Lsp.CompletionItem
File: .lake/packages/lean4/src/lean/Lean/Server/GoTo.lean

full_name: Lean.Server.GoToKind
code: inductive GoToKind
  | declaration | definition | type
  deriving BEq, ToJson, FromJson
goal: Type

full_name: Lean.Server.GoToKind.declaration
code: inductive GoToKind
  | declaration | definition | type
  deriving BEq, ToJson, FromJson
goal: Lean.Server.GoToKind

full_name: Lean.Server.GoToKind.type
code: inductive GoToKind
  | declaration | definition | type
  deriving BEq, ToJson, FromJson
goal: Lean.Server.GoToKind

full_name: Lean.Server.GoToKind.definition
code: inductive GoToKind
  | declaration | definition | type
  deriving BEq, ToJson, FromJson
goal: Lean.Server.GoToKind

full_name: Lean.Server.instBEqGoToKind
code: BEq
goal: BEq Lean.Server.GoToKind

full_name: Lean.Server.instToJsonGoToKind
code: ToJson
goal: Lean.ToJson Lean.Server.GoToKind

full_name: Lean.Server.instFromJsonGoToKind
code: FromJson
goal: Lean.FromJson Lean.Server.GoToKind

full_name: Lean.Server.documentUriFromModule
code: /-- Finds the URI corresponding to `modName` in `searchSearchPath`. -/
def documentUriFromModule (srcSearchPath : SearchPath) (modName : Name)
    : IO (Option DocumentUri) 
goal: IO (Option Lean.Lsp.DocumentUri)

full_name: Lean.Server.moduleFromDocumentUri
code: /-- Finds the module name corresponding to `uri` in `srcSearchPath`. -/
def moduleFromDocumentUri (srcSearchPath : SearchPath) (uri : DocumentUri)
    : IO (Option Name) 
goal: IO (Option Lean.Name)

full_name: Lean.Server.locationLinksFromDecl
code: def locationLinksFromDecl (srcSearchPath : SearchPath) (uri : DocumentUri) (n : Name)
    (originRange? : Option Range) : MetaM (Array LocationLink) 
goal: Lean.MetaM (Array Lean.Lsp.LocationLink)
File: .lake/packages/lean4/src/lean/Lean/Server/Snapshots.lean

full_name: Lean.Server.Snapshots.initFn._@..lake.packages.lean4.src.lean.Lean.Server.Snapshots._hyg.6
code: builtin_initialize dummyTacticCache : IO.Ref Tactic.Cache ← IO.mkRef {}
goal: IO (IO.Ref Lean.Elab.Tactic.Cache)

full_name: Lean.Server.Snapshots.dummyTacticCache
code: builtin_initialize dummyTacticCache : IO.Ref Tactic.Cache ← IO.mkRef {}
goal: IO.Ref Lean.Elab.Tactic.Cache

full_name: Lean.Server.Snapshots.Snapshot.stx
code: /-- What Lean knows about the world after the header and each command. -/
structure Snapshot where
  stx : Syntax
  mpState : Parser.ModuleParserState
  cmdState : Command.State
goal: Lean.Syntax

full_name: Lean.Server.Snapshots.Snapshot.cmdState
code: /-- What Lean knows about the world after the header and each command. -/
structure Snapshot where
  stx : Syntax
  mpState : Parser.ModuleParserState
  cmdState : Command.State
goal: Lean.Elab.Command.State

full_name: Lean.Server.Snapshots.Snapshot
code: /-- What Lean knows about the world after the header and each command. -/
structure Snapshot where
  stx : Syntax
  mpState : Parser.ModuleParserState
  cmdState : Command.State
goal: Type

full_name: Lean.Server.Snapshots.Snapshot.mpState
code: /-- What Lean knows about the world after the header and each command. -/
structure Snapshot where
  stx : Syntax
  mpState : Parser.ModuleParserState
  cmdState : Command.State
goal: Lean.Parser.ModuleParserState

full_name: Lean.Server.Snapshots.Snapshot.endPos
code: def endPos (s : Snapshot) : String.Pos 
goal: String.Pos

full_name: Lean.Server.Snapshots.Snapshot.env
code: def env (s : Snapshot) : Environment 
goal: Lean.Environment

full_name: Lean.Server.Snapshots.Snapshot.msgLog
code: def msgLog (s : Snapshot) : MessageLog 
goal: Lean.MessageLog

full_name: Lean.Server.Snapshots.Snapshot.infoTree
code: def infoTree (s : Snapshot) : InfoTree 
goal: Lean.Elab.InfoTree

full_name: Lean.Server.Snapshots.Snapshot.isAtEnd
code: def isAtEnd (s : Snapshot) : Bool 
goal: Bool

full_name: Lean.Server.Snapshots.Snapshot.runCommandElabM
code: /-- Use the command state in the given snapshot to run a `CommandElabM`.-/
def runCommandElabM (snap : Snapshot) (meta : DocumentMeta) (c : CommandElabM α) : EIO Exception α 
goal: EIO Lean.Exception α

full_name: Lean.Server.Snapshots.Snapshot.runCoreM
code: /-- Run a `CoreM` computation using the data in the given snapshot.-/
def runCoreM (snap : Snapshot) (meta : DocumentMeta) (c : CoreM α) : EIO Exception α 
goal: EIO Lean.Exception α

full_name: Lean.Server.Snapshots.Snapshot.runTermElabM
code: /-- Run a `TermElabM` computation using the data in the given snapshot.-/
def runTermElabM (snap : Snapshot) (meta : DocumentMeta) (c : TermElabM α) : EIO Exception α 
goal: EIO Lean.Exception α