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

full_name: Lean.ParserCompiler.instInhabitedCombinatorAttribute
code: structure CombinatorAttribute where
  impl : AttributeImpl
  ext  : SimplePersistentEnvExtension (Name × Name) (NameMap Name)
  deriving Inhabited
goal: Inhabited Lean.ParserCompiler.CombinatorAttribute

full_name: Lean.ParserCompiler.CombinatorAttribute
code: structure CombinatorAttribute where
  impl : AttributeImpl
  ext  : SimplePersistentEnvExtension (Name × Name) (NameMap Name)
  deriving Inhabited
goal: Type

full_name: Lean.ParserCompiler.CombinatorAttribute.ext
code: structure CombinatorAttribute where
  impl : AttributeImpl
  ext  : SimplePersistentEnvExtension (Name × Name) (NameMap Name)
  deriving Inhabited
goal: Lean.SimplePersistentEnvExtension (Lean.Name × Lean.Name) (Lean.NameMap Lean.Name)

full_name: Lean.ParserCompiler.CombinatorAttribute.impl
code: structure CombinatorAttribute where
  impl : AttributeImpl
  ext  : SimplePersistentEnvExtension (Name × Name) (NameMap Name)
  deriving Inhabited
goal: Lean.AttributeImpl

full_name: Lean.ParserCompiler.registerCombinatorAttribute
code: def registerCombinatorAttribute (name : Name) (descr : String) (ref : Name := by exact decl_name%)
    : IO CombinatorAttribute 
goal: IO Lean.ParserCompiler.CombinatorAttribute

full_name: Lean.ParserCompiler.CombinatorAttribute.getDeclFor?
code: def getDeclFor? (attr : CombinatorAttribute) (env : Environment) (parserDecl : Name) : Option Name 
goal: Option Lean.Name

full_name: Lean.ParserCompiler.CombinatorAttribute.setDeclFor
code: def setDeclFor (attr : CombinatorAttribute) (env : Environment) (parserDecl : Name) (decl : Name) : Environment 
goal: Lean.Environment

full_name: Lean.ParserCompiler.CombinatorAttribute.runDeclFor
code: unsafe def runDeclFor {α} (attr : CombinatorAttribute) (parserDecl : Name) : CoreM α 
goal: Lean.CoreM α
File: .lake/packages/lean4/src/lean/Lean/Eval.lean

full_name: Lean.MetaEval
code: /--
`Eval` extension that gives access to the current environment & options.
The basic `Eval` class is in the prelude and should not depend on these
types.
-/
class MetaEval (α : Type u) where
  eval : Environment → Options → α → (hideUnit : Bool) → IO Environment
goal: Type u

full_name: Lean.MetaEval.eval
code: /--
`Eval` extension that gives access to the current environment & options.
The basic `Eval` class is in the prelude and should not depend on these
types.
-/
class MetaEval (α : Type u) where
  eval : Environment → Options → α → (hideUnit : Bool) → IO Environment
goal: Lean.Environment → Lean.Options → α → Bool → IO Lean.Environment

full_name: Lean.instMetaEvalOfEval
code: instance {α : Type u} [Eval α] : MetaEval α 
goal: Lean.MetaEval α

full_name: Lean.runMetaEval
code: def runMetaEval {α : Type u} [MetaEval α] (env : Environment) (opts : Options) (a : α) : IO (String × Except IO.Error Environment) 
goal: IO (String × Except IO.Error Lean.Environment)
File: .lake/packages/lean4/src/lean/Lean/Parser/Level.lean

full_name: Lean.Parser.initFn._@..lake.packages.lean4.src.lean.Lean.Parser.Level._hyg.5
code: builtin_initialize
  registerBuiltinParserAttribute `builtin_level_parser ``Category.level
goal: IO Unit

full_name: Lean.Parser.levelParser
code: @[inline] def levelParser (rbp : Nat := 0) : Parser 
goal: Lean.Parser.Parser

full_name: Lean.Parser.Level.paren
code: @[builtin_level_parser] def paren  
goal: Lean.Parser.Parser

full_name: Lean.Parser.Level.max
code: @[builtin_level_parser] def max    
goal: Lean.Parser.Parser

full_name: Lean.Parser.Level.imax
code: @[builtin_level_parser] def imax   
goal: Lean.Parser.Parser

full_name: Lean.Parser.Level.hole
code: @[builtin_level_parser] def hole   
goal: Lean.Parser.Parser

full_name: Lean.Parser.Level.num
code: @[builtin_level_parser] def num    
goal: Lean.Parser.Parser

full_name: Lean.Parser.Level.ident
code: @[builtin_level_parser] def ident  
goal: Lean.Parser.Parser

full_name: Lean.Parser.Level.addLit
code: @[builtin_level_parser] def addLit 
goal: Lean.Parser.TrailingParser
File: .lake/packages/lean4/src/lean/Lean/Parser/StrInterpolation.lean

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

full_name: Lean.Parser.interpolatedStrFn
code: partial def interpolatedStrFn (p : ParserFn) : ParserFn 
goal: Lean.Parser.ParserFn

full_name: Lean.Parser.interpolatedStrFn.parse
code: partial def interpolatedStrFn (p : ParserFn) : ParserFn 
goal: Lean.Parser.ParserState

full_name: Lean.Parser.interpolatedStrNoAntiquot
code: @[inline] def interpolatedStrNoAntiquot (p : Parser) : Parser 
goal: Lean.Parser.Parser

full_name: Lean.Parser.interpolatedStr
code: /-- The parser `interpolatedStr(p)` parses a string literal like `"foo"` (see `str`), but the string
may also contain `{}` escapes, and within the escapes the parser `p` is used. For example,
`interpolatedStr(term)` will parse `"foo {2 + 2}"`, where `2 + 2` is parsed as a term rather than
as a string. Note that the full Lean term grammar is available here, including string literals,
so for example `"foo {"bar" ++ "baz"}"` is a legal interpolated string (which evaluates to
`foo barbaz`).

This parser has arity 1, and returns a `interpolatedStrKind` with an odd number of arguments,
alternating between chunks of literal text and results from `p`. The literal chunks contain
uninterpreted substrings of the input. For example, `"foo\n{2 + 2}"` would have three arguments:
an atom `"foo\n{`, the parsed `2 + 2` term, and then the atom `}"`. -/
def interpolatedStr (p : Parser) : Parser 
goal: Lean.Parser.Parser
File: .lake/packages/lean4/src/lean/Lean/Parser/Attr.lean

full_name: Lean.Parser.initFn._@..lake.packages.lean4.src.lean.Lean.Parser.Attr._hyg.4
code: builtin_initialize
  registerBuiltinParserAttribute `builtin_prio_parser ``Category.prio .both
  registerBuiltinDynamicParserAttribute `prio_parser `prio
goal: IO Unit

full_name: Lean.Parser.initFn._@..lake.packages.lean4.src.lean.Lean.Parser.Attr._hyg.106
code: builtin_initialize
  registerBuiltinParserAttribute `builtin_attr_parser ``Category.attr .symbol
  registerBuiltinDynamicParserAttribute `attr_parser `attr
goal: IO Unit

full_name: Lean.Parser.priorityParser
code: @[inline] def priorityParser (rbp : Nat := 0) : Parser 
goal: Lean.Parser.Parser

full_name: Lean.Parser.attrParser
code: @[inline] def attrParser (rbp : Nat := 0) : Parser 
goal: Lean.Parser.Parser

full_name: Lean.Parser.Priority.numPrio
code: @[builtin_prio_parser] def numPrio  
goal: Lean.Parser.Parser

full_name: Lean.Parser.Attr.simple
code: @[builtin_attr_parser] def simple     
goal: Lean.Parser.Parser

full_name: Lean.Parser.Attr.macro
code: @[builtin_attr_parser] def «macro»    
goal: Lean.Parser.Parser

full_name: Lean.Parser.Attr.export
code: @[builtin_attr_parser] def «export»   
goal: Lean.Parser.Parser

full_name: Lean.Parser.Attr.recursor
code: @[builtin_attr_parser] def recursor         
goal: Lean.Parser.Parser

full_name: Lean.Parser.Attr.class
code: @[builtin_attr_parser] def «class»          
goal: Lean.Parser.Parser

full_name: Lean.Parser.Attr.instance
code: @[builtin_attr_parser] def «instance»       
goal: Lean.Parser.Parser

full_name: Lean.Parser.Attr.default_instance
code: @[builtin_attr_parser] def default_instance 
goal: Lean.Parser.Parser

full_name: Lean.Parser.Attr.specialize
code: @[builtin_attr_parser] def «specialize»     
goal: Lean.Parser.Parser

full_name: Lean.Parser.Attr.externEntry
code: def externEntry 
goal: Lean.Parser.Parser

full_name: Lean.Parser.Attr.extern
code: @[builtin_attr_parser] def extern     
goal: Lean.Parser.Parser

full_name: Lean.Parser.Attr.tactic_alt
code: /--
Declare this tactic to be an alias or alternative form of an existing tactic.

This has the following effects:
 * The alias relationship is saved
 * The docstring is taken from the original tactic, if present
-/
@[builtin_attr_parser] def «tactic_alt» 
goal: Lean.Parser.Parser

full_name: Lean.Parser.Attr.tactic_tag
code: /--
Add one or more tags to a tactic.

Tags should be applied to the canonical names for tactics.
-/
@[builtin_attr_parser] def «tactic_tag» 
goal: Lean.Parser.Parser
File: .lake/packages/lean4/src/lean/Lean/LazyInitExtension.lean

full_name: Lean.LazyInitExtension
code: structure LazyInitExtension (m : Type → Type) (α : Type) where
  ext : EnvExtension (Option α)
  fn  : m α
goal: Type

full_name: Lean.LazyInitExtension.ext
code: structure LazyInitExtension (m : Type → Type) (α : Type) where
  ext : EnvExtension (Option α)
  fn  : m α
goal: Lean.EnvExtension (Option α)

full_name: Lean.LazyInitExtension.fn
code: structure LazyInitExtension (m : Type → Type) (α : Type) where
  ext : EnvExtension (Option α)
  fn  : m α
goal: m α

full_name: Lean.instInhabitedLazyInitExtensionOfMonad
code: instance [Monad m] [Inhabited α] : Inhabited (LazyInitExtension m α) 
goal: Inhabited (Lean.LazyInitExtension m α)

full_name: Lean.registerLazyInitExtension
code: /--
  Register an environment extension for storing the result of `fn`.
  We initialize the extension with `none`, and `fn` is executed the
  first time `LazyInit.get` is executed.

  This kind of extension is useful for avoiding work duplication in
  scenarios where a thunk cannot be used because the computation depends
  on state from the `m` monad. For example, we may want to "cache" a collection
  of theorems as a `SimpLemmas` object.  -/
def registerLazyInitExtension (fn : m α) : IO (LazyInitExtension m α) 
goal: IO (Lean.LazyInitExtension m α)

full_name: Lean.LazyInitExtension.get
code: def LazyInitExtension.get [MonadEnv m] [Monad m] (init : LazyInitExtension m α) : m α 
goal: m α
File: .lake/packages/lean4/src/lean/Lean/LoadDynlib.lean

full_name: Lean.loadDynlib
code: /--
Dynamically loads a shared library so that its symbols can be used by
the Lean interpreter (e.g., for interpreting `@[extern]` declarations).
Equivalent to passing `--load-dynlib=lib` to `lean`.

Note that Lean never unloads libraries.
-/
@[extern "lean_load_dynlib"]
opaque loadDynlib (path : @& System.FilePath) : IO Unit
goal: IO Unit
File: .lake/packages/lean4/src/lean/Lean/ImportingFlag.lean

full_name: _private.«.lake».packages.lean4.src.lean.Lean.ImportingFlag.0.Lean.importingRef
code: private builtin_initialize importingRef : IO.Ref Bool ← IO.mkRef false
goal: IO.Ref Bool

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.ImportingFlag._hyg.4
code: private builtin_initialize importingRef : IO.Ref Bool ← IO.mkRef false
goal: IO (IO.Ref Bool)

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.ImportingFlag._hyg.27
code: private builtin_initialize runInitializersRef : IO.Ref Bool ← IO.mkRef false
goal: IO (IO.Ref Bool)

full_name: _private.«.lake».packages.lean4.src.lean.Lean.ImportingFlag.0.Lean.runInitializersRef
code: private builtin_initialize runInitializersRef : IO.Ref Bool ← IO.mkRef false
goal: IO.Ref Bool

full_name: Lean.enableInitializersExecution
code: /--
By default the `initialize` code is not executed when importing .olean files.
When this flag is set to `true`, the initializers are executed.
This method is meant to be used by the Lean frontend only.
Remark: it is not safe to run `initialize` code when using multiple threads.
Remark: Any loaded native Lean code must match its imported version. In particular,
  no two versions of the same module may be loaded when this flag is set.
  No native code may be loaded after its module has been imported.
Remark: Compacted module regions must not be freed when using this flag as the
  cached initializer results may reference objects in them.
Remark: The Lean frontend executes this method at startup time.
-/
@[export lean_enable_initializer_execution]
unsafe def enableInitializersExecution : IO Unit 
goal: IO Unit

full_name: Lean.isInitializerExecutionEnabled
code: def isInitializerExecutionEnabled : IO Bool 
goal: IO Bool

full_name: Lean.initializing
code: /--
We say Lean is "initializing" when it is executing `builtin_initialize` declarations or importing modules.
Recall that Lean executes `initialize` declarations while importing modules.
-/
def initializing : IO Bool 
goal: IO Bool

full_name: Lean.withImporting
code: /--
Execute `x` with "importing" flag turned on.
When the "importing" flag is set to true, we allow user-extensions defined with with
the `initialize` command to update global references.
IMPORTANT: There is no semaphore controlling the access to these global references.
We assume these global references are updated by a single execution thread.
This is true in the Lean frontend where we process the `import` commands at the beginning
of the execution only. Users must make sure that when `importModules` is used, there is only
one execution thread accessing the global references.
-/
def withImporting (x : IO α) : IO α 
goal: IO α
File: .lake/packages/lean4/src/lean/Lean/BuiltinDocAttr.lean

full_name: Lean.declareBuiltinDocStringAndRanges
code: def declareBuiltinDocStringAndRanges (declName : Name) : AttrM Unit 
goal: Lean.AttrM Unit

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.BuiltinDocAttr._hyg.208
code: builtin_initialize
  registerBuiltinAttribute {
    name  := `builtin_doc
    descr := "make the docs and location of this declaration available as a builtin"
    add   := fun decl stx _ => do
      Attribute.Builtin.ensureNoArgs stx
      declareBuiltinDocStringAndRanges decl
  }
goal: IO Unit
File: .lake/packages/lean4/src/lean/Lean/Util/RecDepth.lean

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.Util.RecDepth._hyg.6
code: register_builtin_option maxRecDepth : Nat := {
  defValue := defaultMaxRecDepth
  descr    := "maximum recursion depth for many Lean procedures"
}
goal: IO (Lean.Option Nat)

full_name: Lean.maxRecDepth
code: register_builtin_option maxRecDepth : Nat := {
  defValue := defaultMaxRecDepth
  descr    := "maximum recursion depth for many Lean procedures"
}
goal: Lean.Option Nat
File: .lake/packages/lean4/src/lean/Lean/Util/Recognizers.lean

full_name: Lean.Expr.const?
code: @[inline] def const? (e : Expr) : Option (Name × List Level) 
goal: Option (Lean.Name × List Lean.Level)

full_name: Lean.Expr.app1?
code: @[inline] def app1? (e : Expr) (fName : Name) : Option Expr 
goal: Option Lean.Expr

full_name: Lean.Expr.app2?
code: @[inline] def app2? (e : Expr) (fName : Name) : Option (Expr × Expr) 
goal: Option (Lean.Expr × Lean.Expr)

full_name: Lean.Expr.app3?
code: @[inline] def app3? (e : Expr) (fName : Name) : Option (Expr × Expr × Expr) 
goal: Option (Lean.Expr × Lean.Expr × Lean.Expr)

full_name: Lean.Expr.app4?
code: @[inline] def app4? (e : Expr) (fName : Name) : Option (Expr × Expr × Expr × Expr) 
goal: Option (Lean.Expr × Lean.Expr × Lean.Expr × Lean.Expr)

full_name: Lean.Expr.eq?
code: @[inline] def eq? (p : Expr) : Option (Expr × Expr × Expr) 
goal: Option (Lean.Expr × Lean.Expr × Lean.Expr)

full_name: Lean.Expr.ne?
code: @[inline] def ne? (p : Expr) : Option (Expr × Expr × Expr) 
goal: Option (Lean.Expr × Lean.Expr × Lean.Expr)

full_name: Lean.Expr.iff?
code: @[inline] def iff? (p : Expr) : Option (Expr × Expr) 
goal: Option (Lean.Expr × Lean.Expr)

full_name: Lean.Expr.eqOrIff?
code: @[inline] def eqOrIff? (p : Expr) : Option (Expr × Expr) 
goal: Option (Lean.Expr × Lean.Expr)

full_name: Lean.Expr.not?
code: @[inline] def not? (p : Expr) : Option Expr 
goal: Option Lean.Expr

full_name: Lean.Expr.notNot?
code: @[inline] def notNot? (p : Expr) : Option Expr 
goal: Option Lean.Expr

full_name: Lean.Expr.and?
code: @[inline] def and? (p : Expr) : Option (Expr × Expr) 
goal: Option (Lean.Expr × Lean.Expr)

full_name: Lean.Expr.heq?
code: @[inline] def heq? (p : Expr) : Option (Expr × Expr × Expr × Expr) 
goal: Option (Lean.Expr × Lean.Expr × Lean.Expr × Lean.Expr)

full_name: Lean.Expr.natAdd?
code: def natAdd? (e : Expr) : Option (Expr × Expr) 
goal: Option (Lean.Expr × Lean.Expr)

full_name: Lean.Expr.arrow?
code: @[inline] def arrow? : Expr → Option (Expr × Expr)
  
goal: Lean.Expr → Option (Lean.Expr × Lean.Expr)

full_name: Lean.Expr.isEq
code: def isEq (e : Expr) 
goal: Bool

full_name: Lean.Expr.isHEq
code: def isHEq (e : Expr) 
goal: Bool

full_name: Lean.Expr.isIte
code: def isIte (e : Expr) 
goal: Bool

full_name: Lean.Expr.isDIte
code: def isDIte (e : Expr) 
goal: Bool

full_name: Lean.Expr.listLit?.loop
code: partial def listLit? (e : Expr) : Option (Expr × List Expr) 
goal: Option (Lean.Expr × List Lean.Expr)

full_name: Lean.Expr.listLit?
code: partial def listLit? (e : Expr) : Option (Expr × List Expr) 
goal: Option (Lean.Expr × List Lean.Expr)

full_name: Lean.Expr.arrayLit?
code: def arrayLit? (e : Expr) : Option (Expr × List Expr) 
goal: Option (Lean.Expr × List Lean.Expr)

full_name: Lean.Expr.prod?
code: /-- Recognize `α × β` -/
def prod? (e : Expr) : Option (Expr × Expr) 
goal: Option (Lean.Expr × Lean.Expr)
File: .lake/packages/lean4/src/lean/Lean/Util/Paths.lean

full_name: Lean.LeanPaths.oleanPath
code: structure LeanPaths where
  oleanPath       : SearchPath
  srcPath         : SearchPath
  loadDynlibPaths : Array FilePath := #[]
  deriving ToJson, FromJson
goal: Lean.SearchPath

full_name: Lean.LeanPaths.loadDynlibPaths
code: structure LeanPaths where
  oleanPath       : SearchPath
  srcPath         : SearchPath
  loadDynlibPaths : Array FilePath := #[]
  deriving ToJson, FromJson
goal: Array System.FilePath

full_name: Lean.LeanPaths.srcPath
code: structure LeanPaths where
  oleanPath       : SearchPath
  srcPath         : SearchPath
  loadDynlibPaths : Array FilePath := #[]
  deriving ToJson, FromJson
goal: Lean.SearchPath

full_name: Lean.LeanPaths
code: structure LeanPaths where
  oleanPath       : SearchPath
  srcPath         : SearchPath
  loadDynlibPaths : Array FilePath := #[]
  deriving ToJson, FromJson
goal: Type

full_name: Lean.instToJsonLeanPaths
code: ToJson
goal: Lean.ToJson Lean.LeanPaths

full_name: Lean.instFromJsonLeanPaths
code: FromJson
goal: Lean.FromJson Lean.LeanPaths

full_name: Lean.initSrcSearchPath
code: def initSrcSearchPath (pkgSearchPath : SearchPath := ∅) : IO SearchPath 
goal: IO Lean.SearchPath
File: .lake/packages/lean4/src/lean/Lean/Util/TestExtern.lean

full_name: testExternCmd
code: syntax (name := testExternCmd) "test_extern " term : command
goal: Lean.ParserDescr

full_name: elabTestExtern
code: @[command_elab testExternCmd] unsafe def elabTestExtern : CommandElab
  
goal: Lean.Elab.Command.CommandElab
File: .lake/packages/lean4/src/lean/Lean/Util/ShareCommon.lean

full_name: Lean.ShareCommon.objectFactory
code: def objectFactory 
goal: ShareCommon.StateFactory

full_name: Lean.ShareCommon.persistentObjectFactory
code: def persistentObjectFactory 
goal: ShareCommon.StateFactory

full_name: Lean.ShareCommon.ShareCommonT
code: abbrev ShareCommonT 
goal: Type (max u_1 u_2)

full_name: Lean.ShareCommon.PShareCommonT
code: abbrev PShareCommonT 
goal: Type (max u_1 u_2)

full_name: Lean.ShareCommon.ShareCommonM
code: abbrev ShareCommonM 
goal: Type u_1

full_name: Lean.ShareCommon.PShareCommonM
code: abbrev PShareCommonM 
goal: Type u_1

full_name: Lean.ShareCommon.ShareCommonT.withShareCommon
code: @[specialize] def ShareCommonT.withShareCommon [Monad m] (a : α) : ShareCommonT m α 
goal: Lean.ShareCommon.ShareCommonT m α

full_name: Lean.ShareCommon.PShareCommonT.withShareCommon
code: @[specialize] def PShareCommonT.withShareCommon [Monad m] (a : α) : PShareCommonT m α 
goal: Lean.ShareCommon.PShareCommonT m α

full_name: Lean.ShareCommon.ShareCommonT.monadShareCommon
code: instance ShareCommonT.monadShareCommon [Monad m] : MonadShareCommon (ShareCommonT m) 
goal: MonadShareCommon (Lean.ShareCommon.ShareCommonT m)

full_name: Lean.ShareCommon.PShareCommonT.monadShareCommon
code: instance PShareCommonT.monadShareCommon [Monad m] : MonadShareCommon (PShareCommonT m) 
goal: MonadShareCommon (Lean.ShareCommon.PShareCommonT m)

full_name: Lean.ShareCommon.ShareCommonT.run
code: @[inline] def ShareCommonT.run [Monad m] : ShareCommonT m α → m α 
goal: Lean.ShareCommon.ShareCommonT m α → m α

full_name: Lean.ShareCommon.PShareCommonT.run
code: @[inline] def PShareCommonT.run [Monad m] : PShareCommonT m α → m α 
goal: Lean.ShareCommon.PShareCommonT m α → m α

full_name: Lean.ShareCommon.ShareCommonM.run
code: @[inline] def ShareCommonM.run : ShareCommonM α → α 
goal: Lean.ShareCommon.ShareCommonM α → α

full_name: Lean.ShareCommon.PShareCommonM.run
code: @[inline] def PShareCommonM.run : PShareCommonM α → α 
goal: Lean.ShareCommon.PShareCommonM α → α

full_name: Lean.ShareCommon.shareCommon
code: def shareCommon (a : α) : α 
goal: α
File: .lake/packages/lean4/src/lean/Lean/Util/ForEachExpr.lean

full_name: Lean.ForEachExpr.visit
code: def visit (g : Expr → m Bool) (e : Expr) : MonadCacheT Expr Unit m Unit 
goal: Lean.MonadCacheT Lean.Expr Unit m Unit

full_name: Lean.Expr.forEach'
code: /-- Apply `f` to each sub-expression of `e`. If `f t` returns false, then t's children are not visited. -/
@[inline] def Expr.forEach' (e : Expr) (f : Expr → m Bool) : m Unit 
goal: m Unit

full_name: Lean.Expr.forEach
code: @[inline] def Expr.forEach (e : Expr) (f : Expr → m Unit) : m Unit 
goal: m Unit
File: .lake/packages/lean4/src/lean/Lean/Util/FindLevelMVar.lean

full_name: Lean.FindLevelMVar.Visitor
code: abbrev Visitor 
goal: Type

full_name: Lean.Expr.findLevelMVar?
code: @[inline] def Expr.findLevelMVar? (e : Expr) (p : LMVarId → Bool) : Option LMVarId 
goal: Option Lean.LMVarId