ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: .lake/packages/lean4/src/lean/lake/Lake/DSL/Meta.lean

full_name: Lake.DSL.evalTerm
code: @[implemented_by Term.evalTerm]
opaque evalTerm (α) (type : Expr) (value : Syntax) (safety := DefinitionSafety.safe) : TermElabM α
goal: Lean.Elab.TermElabM α

full_name: Lake.DSL.cmdDo
code: /--
The `do` command syntax groups multiple similarly indented commands together.
The group can then be passed to another command that usually only accepts a
single command (e.g., `meta if`).
-/
syntax cmdDo := ("do" many1Indent(command)) <|> command
goal: Lean.ParserDescr

full_name: Lake.DSL.expandCmdDo
code: def expandCmdDo : TSyntax ``cmdDo → Array Command

goal: Lean.TSyntax `Lake.DSL.cmdDo → Array Lean.Command

full_name: Lake.DSL.metaIf
code: /--
The `meta if` command has two forms:

```lean
meta if <c:term> then <a:command>
meta if <c:term> then <a:command> else <b:command>
```

It expands to the command `a` if the term `c` evaluates to true
(at elaboration time). Otherwise, it expands to command `b` (if an `else`
clause is provided).

One can use this command to specify, for example, external library targets
only available on specific platforms:

```lean
meta if System.Platform.isWindows then
extern_lib winOnlyLib := ...
else meta if System.Platform.isOSX then
extern_lib macOnlyLib := ...
else
extern_lib linuxOnlyLib := ...
```
-/
scoped syntax (name := metaIf)
"meta " "if " term " then " cmdDo (" else " cmdDo)? : command
goal: Lean.ParserDescr

full_name: Lake.DSL.«_aux_.lake_packages_lean4_src_lean_lake_Lake_DSL_Meta___elabRules_Lake_DSL_metaIf_1»
code: elab_rules : command | `(meta if $c then $t $[else $e?]?) => do
  if (← withRef c <| runTermElabM fun _ => evalTerm Bool (toTypeExpr Bool) c .unsafe) then
    let cmd := mkNullNode (expandCmdDo t)
    withMacroExpansion (← getRef) cmd <| elabCommand cmd
  else if let some e := e? then
    let cmd := mkNullNode (expandCmdDo e)
    withMacroExpansion (← getRef) cmd <| elabCommand cmd
goal: Lean.Elab.Command.CommandElab

full_name: Lake.DSL.evalExpr
code: @[implemented_by Meta.evalExpr]
opaque evalExpr (α) (expectedType : Expr) (value : Expr) (safety := DefinitionSafety.safe) : MetaM α
goal: Lean.MetaM α

full_name: Lake.DSL.toExprIO
code: def toExprIO [ToExpr α] (x : IO α) : IO Expr 
goal: IO Lean.Expr

full_name: Lake.DSL.runIO
code: /--
Executes a term of type `IO α` at elaboration-time
and produces an expression corresponding to the result via `ToExpr α`.
-/
scoped syntax:lead (name := runIO) "run_io " doSeq : term
goal: Lean.ParserDescr

full_name: Lake.DSL.elabRunIO
code: @[term_elab runIO]
def elabRunIO : TermElab 
goal: Lean.Elab.Term.TermElab
File: .lake/packages/lean4/src/lean/Lean/Modifiers.lean

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

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.Modifiers._hyg.4
code: builtin_initialize protectedExt : TagDeclarationExtension ← mkTagDeclarationExtension
goal: IO Lean.TagDeclarationExtension

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

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

full_name: Lean.privateHeader
code: def privateHeader : Name 
goal: Lean.Name

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

full_name: Lean.isPrivateName
code: def isPrivateName : Name → Bool
  
goal: Lean.Name → Bool

full_name: Lean.isPrivateNameExport
code: @[export lean_is_private_name]
def isPrivateNameExport (n : Name) : Bool 
goal: Bool

full_name: Lean.isPrivatePrefix
code: /--
Return `true` if `n` is of the form `_private.<module_name>.0`
See comment above.
-/
def isPrivatePrefix (n : Name) : Bool 
goal: Bool

full_name: Lean.isPrivatePrefix.go
code: /--
Return `true` if `n` is of the form `_private.<module_name>.0`
See comment above.
-/
def isPrivatePrefix (n : Name) : Bool 
goal: Bool

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Modifiers.0.Lean.privateToUserNameAux
code: private def privateToUserNameAux (n : Name) : Name 
goal: Lean.Name

full_name: Lean.privateToUserName?
code: @[export lean_private_to_user_name]
def privateToUserName? (n : Name) : Option Name 
goal: Option Lean.Name

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

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Modifiers.0.Lean.privatePrefixAux
code: private def privatePrefixAux : Name → Name
  
goal: Lean.Name → Lean.Name

full_name: Lean.privatePrefix?
code: @[export lean_private_prefix]
def privatePrefix? (n : Name) : Option Name 
goal: Option Lean.Name
File: .lake/packages/lean4/src/lean/lake/Lake/DSL/Require.lean

full_name: Lake.DSL.fromPath
code: syntax fromPath :=
  term
goal: Lean.ParserDescr

full_name: Lake.DSL.fromGit
code: syntax fromGit :=
  &"git " term:max ("@" term:max)? ("/" term)?
goal: Lean.ParserDescr

full_name: Lake.DSL.fromSource
code: syntax fromSource :=
  fromGit <|> fromPath
goal: Lean.ParserDescr

full_name: Lake.DSL.fromClause
code: /--
Specifies a specific source from which to draw the package dependency.
Dependencies that are downloaded from a remote source will be placed
into the workspace's `packagesDir`.

**Path Dependencies**

```
from <path>
```

Lake loads the package located a fixed `path` relative to the
requiring package's directory.

**Git Dependencies**

```
from git <url> [@ <rev>] [/ <subDir>]
```

Lake clones the Git repository available at the specified fixed Git `url`,
and checks out the specified revision `rev`. The revision can be a commit hash,
branch, or tag. If none is provided, Lake defaults to `master`. After checkout,
Lake loads the package located in `subDir` (or the repository root if no
subdirectory is specified).
-/
syntax fromClause :=
  " from " fromSource
goal: Lean.ParserDescr

full_name: Lake.DSL.withClause
code: syntax withClause :=
  " with " term
goal: Lean.ParserDescr

full_name: Lake.DSL.verSpec
code: syntax verSpec :=
  &"git "? term:max
goal: Lean.ParserDescr

full_name: Lake.DSL.verClause
code: /--
The version of the package to require.
To specify a Git revision, use the syntax `@ git <rev>`.
-/
syntax verClause :=
  " @ " verSpec
goal: Lean.ParserDescr

full_name: Lake.DSL.depName
code: syntax depName :=
  atomic(str " / ")? identOrStr
goal: Lean.ParserDescr

full_name: Lake.DSL.depSpec
code: syntax depSpec :=
  depName (verClause)? (fromClause)? (withClause)?
goal: Lean.ParserDescr

full_name: _private.«.lake».packages.lean4.src.lean.lake.Lake.DSL.Require.0.Lake.DSL.quoteOptTerm
code: @[inline] private def quoteOptTerm [Monad m] [MonadQuotation m] (term? : Option Term) : m Term 
goal: m Lean.Term

full_name: Lake.DSL.expandDepSpec
code: def expandDepSpec (stx : TSyntax ``depSpec) (doc? : Option DocComment) : MacroM Command 
goal: Lean.MacroM Lean.Command

full_name: Lake.DSL.requireDecl
code: macro (name := requireDecl)
doc?:(docComment)? kw:"require " spec:depSpec : command => withRef kw do
  expandDepSpec spec doc?
goal: Lean.ParserDescr

full_name: Lake.DSL.«_aux_.lake_packages_lean4_src_lean_lake_Lake_DSL_Require___macroRules_Lake_DSL_requireDecl_1»
code: macro (name := requireDecl)
doc?:(docComment)? kw:"require " spec:depSpec : command => withRef kw do
  expandDepSpec spec doc?
goal: Lean.Macro

full_name: Lake.DSL.RequireDecl
code: @[inherit_doc requireDecl] abbrev RequireDecl 
goal: Type

full_name: Lake.DSL.instCoeRequireDeclCommand
code: instance : Coe RequireDecl Command 
goal: Coe Lake.DSL.RequireDecl Lean.Command
File: .lake/packages/lean4/src/lean/lake/Lake/DSL/DeclUtil.lean

full_name: Lake.DSL.DocComment
code: abbrev DocComment 
goal: Type

full_name: Lake.DSL.Attributes
code: abbrev Attributes 
goal: Type

full_name: Lake.DSL.AttrInstance
code: abbrev AttrInstance 
goal: Type

full_name: Lake.DSL.WhereDecls
code: abbrev WhereDecls 
goal: Type

full_name: Lake.DSL.expandAttrs
code: def expandAttrs (attrs? : Option Attributes) : Array AttrInstance 
goal: Array Lake.DSL.AttrInstance

full_name: Lake.DSL.identOrStr
code: syntax identOrStr :=
  ident <|> str
goal: Lean.ParserDescr

full_name: Lake.DSL.IdentOrStr
code: abbrev IdentOrStr 
goal: Type

full_name: Lake.DSL.expandIdentOrStrAsIdent
code: def expandIdentOrStrAsIdent (stx : IdentOrStr) : Ident 
goal: Lean.Ident

full_name: Lake.DSL.declField
code: /-- A field assignment in a declarative configuration. -/
syntax declField :=
  ident " := " term
goal: Lean.ParserDescr

full_name: Lake.DSL.DeclField
code: @[inherit_doc declField] abbrev DeclField 
goal: Type

full_name: Lake.DSL.structVal
code: syntax structVal :=
  "{" manyIndent(group(declField ", "?)) "}"
goal: Lean.ParserDescr

full_name: Lake.DSL.declValDo
code: syntax declValDo :=
  ppSpace Term.do (Term.whereDecls)?
goal: Lean.ParserDescr

full_name: Lake.DSL.declValStruct
code: syntax declValStruct :=
  ppSpace structVal (Term.whereDecls)?
goal: Lean.ParserDescr

full_name: Lake.DSL.declValWhere
code: syntax declValWhere :=
  " where " sepByIndentSemicolon(declField) (Term.whereDecls)?
goal: Lean.ParserDescr

full_name: Lake.DSL.simpleDeclSig
code: syntax simpleDeclSig :=
  ident Term.typeSpec declValSimple
goal: Lean.ParserDescr

full_name: Lake.DSL.structDeclSig
code: syntax structDeclSig :=
  ((identOrStr)? (declValWhere <|> declValStruct)?) <|> identOrStr
goal: Lean.ParserDescr

full_name: Lake.DSL.bracketedSimpleBinder
code: syntax bracketedSimpleBinder :=
  "(" ident (" : " term)? ")"
goal: Lean.ParserDescr

full_name: Lake.DSL.simpleBinder
code: syntax simpleBinder :=
  ident <|> bracketedSimpleBinder
goal: Lean.ParserDescr

full_name: Lake.DSL.SimpleBinder
code: abbrev SimpleBinder 
goal: Type

full_name: Lake.DSL.expandOptSimpleBinder
code: def expandOptSimpleBinder (stx? : Option SimpleBinder) : MacroM FunBinder 
goal: Lean.MacroM Lake.FunBinder

full_name: Lake.DSL.Field
code: structure Field where
  ref : Syntax
  val : Term
goal: Type

full_name: Lake.DSL.Field.ref
code: structure Field where
  ref : Syntax
  val : Term
goal: Lean.Syntax

full_name: Lake.DSL.Field.val
code: structure Field where
  ref : Syntax
  val : Term
goal: Lean.Term

full_name: Lake.DSL.elabConfigDecl
code: def elabConfigDecl
  (tyName : Name)
  (sig : TSyntax ``structDeclSig)
  (doc? : Option DocComment) (attrs : Array AttrInstance)
  (name? : Option Name := none)
: CommandElabM PUnit 
goal: Lean.Elab.Command.CommandElabM PUnit
File: .lake/packages/lean4/src/lean/Lean/AddDecl.lean

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.AddDecl._hyg.6
code: register_builtin_option debug.skipKernelTC : Bool := {
  defValue := false
  group    := "debug"
  descr    := "skip kernel type checker. WARNING: setting this option to true may compromise soundness because your proofs will not be checked by the Lean kernel"
}
goal: IO (Lean.Option Bool)

full_name: Lean.debug.skipKernelTC
code: register_builtin_option debug.skipKernelTC : Bool := {
  defValue := false
  group    := "debug"
  descr    := "skip kernel type checker. WARNING: setting this option to true may compromise soundness because your proofs will not be checked by the Lean kernel"
}
goal: Lean.Option Bool

full_name: Lean.Environment.addDecl
code: def Environment.addDecl (env : Environment) (opts : Options) (decl : Declaration)
    (cancelTk? : Option IO.CancelToken := none) : Except KernelException Environment 
goal: Except Lean.KernelException Lean.Environment

full_name: Lean.Environment.addAndCompile
code: def Environment.addAndCompile (env : Environment) (opts : Options) (decl : Declaration)
    (cancelTk? : Option IO.CancelToken := none) : Except KernelException Environment 
goal: Except Lean.KernelException Lean.Environment

full_name: Lean.addDecl
code: def addDecl (decl : Declaration) : CoreM Unit 
goal: Lean.CoreM Unit

full_name: Lean.addAndCompile
code: def addAndCompile (decl : Declaration) : CoreM Unit 
goal: Lean.CoreM Unit
File: .lake/packages/lean4/src/lean/Lean/Compiler/Old.lean

full_name: Lean.Compiler.mkEagerLambdaLiftingName
code: @[export lean_mk_eager_lambda_lifting_name]
def mkEagerLambdaLiftingName (n : Name) (idx : Nat) : Name 
goal: Lean.Name

full_name: Lean.Compiler.isEagerLambdaLiftingName
code: @[export lean_is_eager_lambda_lifting_name]
def isEagerLambdaLiftingName : Name → Bool
  
goal: Lean.Name → Bool

full_name: Lean.Compiler.getDeclNamesForCodeGen
code: /-- Return the name of new definitions in the a given declaration.
    Here we consider only declarations we generate code for.
    We use this definition to implement `add_and_compile`. -/
def getDeclNamesForCodeGen : Declaration → List Name
  
goal: Lean.Declaration → List Lean.Name

full_name: Lean.Compiler.checkIsDefinition
code: def checkIsDefinition (env : Environment) (n : Name) : Except String Unit 
goal: Except String Unit

full_name: Lean.Compiler.mkUnsafeRecName
code: /--
  We generate auxiliary unsafe definitions for regular recursive definitions.
  The auxiliary unsafe definition has a clear runtime cost execution model.
  This function returns the auxiliary unsafe definition name for the given name. -/
@[export lean_mk_unsafe_rec_name]
def mkUnsafeRecName (declName : Name) : Name 
goal: Lean.Name

full_name: Lean.Compiler.isUnsafeRecName?
code: /-- Return `some _` if the given name was created using `mkUnsafeRecName` -/
@[export lean_is_unsafe_rec_name]
def isUnsafeRecName? : Name → Option Name
  
goal: Lean.Name → Option Lean.Name

full_name: Lean.Environment.compileDecls
code: /--
Compile the given block of mutual declarations.
Assumes the declarations have already been added to the environment using `addDecl`.
-/
@[extern "lean_compile_decls"]
opaque compileDecls (env : Environment) (opt : @& Options) (decls : @& List Name) : Except KernelException Environment
goal: Except Lean.KernelException Lean.Environment

full_name: Lean.Environment.compileDecl
code: /-- Compile the given declaration, it assumes the declaration has already been added to the environment using `addDecl`. -/
def compileDecl (env : Environment) (opt : @& Options) (decl : @& Declaration) : Except KernelException Environment 
goal: Except Lean.KernelException Lean.Environment
File: .lake/packages/lean4/src/lean/Lean/Compiler/ExportAttr.lean

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.ExportAttr.0.Lean.isValidCppId
code: private def isValidCppId (id : String) : Bool 
goal: Bool

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.ExportAttr.0.Lean.isValidCppName
code: private def isValidCppName : Name → Bool
  
goal: Lean.Name → Bool

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.Compiler.ExportAttr._hyg.95
code: builtin_initialize exportAttr : ParametricAttribute Name ←
  registerParametricAttribute {
    name := `export,
    descr := "name to be used by code generators",
    getParam := fun _ stx => do
      let exportName ← Attribute.Builtin.getId stx
      unless isValidCppName exportName do
        throwError "invalid 'export' function name, is not a valid C++ identifier"
      return exportName
  }
goal: IO (Lean.ParametricAttribute Lean.Name)

full_name: Lean.exportAttr
code: builtin_initialize exportAttr : ParametricAttribute Name ←
  registerParametricAttribute {
    name := `export,
    descr := "name to be used by code generators",
    getParam := fun _ stx => do
      let exportName ← Attribute.Builtin.getId stx
      unless isValidCppName exportName do
        throwError "invalid 'export' function name, is not a valid C++ identifier"
      return exportName
  }
goal: Lean.ParametricAttribute Lean.Name

full_name: Lean.getExportNameFor?
code: @[export lean_get_export_name_for]
def getExportNameFor? (env : Environment) (n : Name) : Option Name 
goal: Option Lean.Name

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

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

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.Compiler.NoncomputableAttr._hyg.4
code: builtin_initialize noncomputableExt : TagDeclarationExtension ← mkTagDeclarationExtension
goal: IO Lean.TagDeclarationExtension

full_name: Lean.addNoncomputable
code: /-- Mark in the environment extension that the given declaration has been declared by the user as `noncomputable`. -/
def addNoncomputable (env : Environment) (declName : Name) : Environment 
goal: Lean.Environment

full_name: Lean.isNoncomputable
code: /--
  Return true iff the user has declared the given declaration as `noncomputable`.
  Remark: we use this function only for introspection. It is currently not used by the code generator.
-/
def isNoncomputable (env : Environment) (declName : Name) : Bool 
goal: Bool
File: .lake/packages/lean4/src/lean/Lean/Compiler/NameMangling.lean

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.NameMangling.0.String.mangleAux
code: private def mangleAux : Nat → String.Iterator → String → String
  
goal: Nat → String.Iterator → String → String

full_name: String.mangle
code: def mangle (s : String) : String 
goal: String

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Compiler.NameMangling.0.Lean.Name.mangleAux
code: private def Name.mangleAux : Name → String
  
goal: Lean.Name → String

full_name: Lean.Name.mangle
code: @[export lean_name_mangle]
def Name.mangle (n : Name) (pre : String := "l_") : String 
goal: String

full_name: Lean.mkModuleInitializationFunctionName
code: @[export lean_mk_module_initialization_function_name]
def mkModuleInitializationFunctionName (moduleName : Name) : String 
goal: String
File: .lake/packages/lean4/src/lean/Lean/Compiler/ImplementedByAttr.lean

full_name: Lean.Compiler.initFn._@..lake.packages.lean4.src.lean.Lean.Compiler.ImplementedByAttr._hyg.4
code: builtin_initialize implementedByAttr : ParametricAttribute Name ← registerParametricAttribute {
  name := `implemented_by
  descr := "name of the Lean (probably unsafe) function that implements opaque constant"
  getParam := fun declName stx => do
    let decl ← getConstInfo declName
    let fnNameStx ← Attribute.Builtin.getIdent stx
    let fnName ← Elab.realizeGlobalConstNoOverloadWithInfo fnNameStx
    let fnDecl ← getConstInfo fnName
    unless decl.levelParams.length == fnDecl.levelParams.length do
      throwError "invalid 'implemented_by' argument '{fnName}', '{fnName}' has {fnDecl.levelParams.length} universe level parameter(s), but '{declName}' has {decl.levelParams.length}"
    let declType := decl.type
    let fnType ← Core.instantiateTypeLevelParams fnDecl (decl.levelParams.map mkLevelParam)
    unless declType == fnType do
      throwError "invalid 'implemented_by' argument '{fnName}', '{fnName}' has type{indentExpr fnType}\nbut '{declName}' has type{indentExpr declType}"
    if decl.name == fnDecl.name then
      throwError "invalid 'implemented_by' argument '{fnName}', function cannot be implemented by itself"
    return fnName
}
goal: IO (Lean.ParametricAttribute Lean.Name)

full_name: Lean.Compiler.implementedByAttr
code: builtin_initialize implementedByAttr : ParametricAttribute Name ← registerParametricAttribute {
  name := `implemented_by
  descr := "name of the Lean (probably unsafe) function that implements opaque constant"
  getParam := fun declName stx => do
    let decl ← getConstInfo declName
    let fnNameStx ← Attribute.Builtin.getIdent stx
    let fnName ← Elab.realizeGlobalConstNoOverloadWithInfo fnNameStx
    let fnDecl ← getConstInfo fnName
    unless decl.levelParams.length == fnDecl.levelParams.length do
      throwError "invalid 'implemented_by' argument '{fnName}', '{fnName}' has {fnDecl.levelParams.length} universe level parameter(s), but '{declName}' has {decl.levelParams.length}"
    let declType := decl.type
    let fnType ← Core.instantiateTypeLevelParams fnDecl (decl.levelParams.map mkLevelParam)
    unless declType == fnType do
      throwError "invalid 'implemented_by' argument '{fnName}', '{fnName}' has type{indentExpr fnType}\nbut '{declName}' has type{indentExpr declType}"
    if decl.name == fnDecl.name then
      throwError "invalid 'implemented_by' argument '{fnName}', function cannot be implemented by itself"
    return fnName
}
goal: Lean.ParametricAttribute Lean.Name

full_name: Lean.Compiler.getImplementedBy?
code: @[export lean_get_implemented_by]
def getImplementedBy? (env : Environment) (declName : Name) : Option Name 
goal: Option Lean.Name

full_name: Lean.Compiler.setImplementedBy
code: def setImplementedBy (env : Environment) (declName : Name) (impName : Name) : Except String Environment 
goal: Except String Lean.Environment

full_name: Lean.setImplementedBy
code: def setImplementedBy {m} [Monad m] [MonadEnv m] [MonadError m] (declName : Name) (impName : Name) : m Unit 
goal: m Unit
File: .lake/packages/lean4/src/lean/Lean/Compiler/LCNF/DeclHash.lean

full_name: Lean.Compiler.LCNF.«instHashableParam_.lake»
code: instance : Hashable Param 
goal: Hashable Lean.Compiler.LCNF.Param

full_name: Lean.Compiler.LCNF.hashParams
code: def hashParams (ps : Array Param) : UInt64 
goal: UInt64

full_name: Lean.Compiler.LCNF.«instHashableCode_.lake»
code: instance : Hashable Code 
goal: Hashable Lean.Compiler.LCNF.Code

full_name: Lean.Compiler.LCNF.«instHashableDecl_.lake»
code: Hashable
goal: Hashable Lean.Compiler.LCNF.Decl
File: .lake/packages/lean4/src/lean/Lean/Compiler/LCNF/Simp.lean

full_name: Lean.Compiler.LCNF.Decl.simp?
code: def Decl.simp? (decl : Decl) : SimpM (Option Decl) 
goal: Lean.Compiler.LCNF.Simp.SimpM (Option Lean.Compiler.LCNF.Decl)

full_name: Lean.Compiler.LCNF.Decl.simp.go
code: partial def Decl.simp (decl : Decl) (config : Config) : CompilerM Decl 
goal: Lean.Compiler.LCNF.CompilerM Lean.Compiler.LCNF.Decl

full_name: Lean.Compiler.LCNF.Decl.simp
code: partial def Decl.simp (decl : Decl) (config : Config) : CompilerM Decl 
goal: Lean.Compiler.LCNF.CompilerM Lean.Compiler.LCNF.Decl

full_name: Lean.Compiler.LCNF.simp
code: def simp (config : Config := {}) (occurrence : Nat := 0) (phase := Phase.base) : Pass 
goal: Lean.Compiler.LCNF.Pass

full_name: Lean.Compiler.LCNF.initFn._@..lake.packages.lean4.src.lean.Lean.Compiler.LCNF.Simp._hyg.837
code: builtin_initialize
  registerTraceClass `Compiler.simp (inherited := true)
  registerTraceClass `Compiler.simp.stat
  registerTraceClass `Compiler.simp.step
  registerTraceClass `Compiler.simp.step.new
goal: IO Unit
File: .lake/packages/lean4/src/lean/Lean/Compiler/LCNF/OtherDecl.lean

full_name: Lean.Compiler.LCNF.getOtherDeclType
code: /--
Return the LCNF type for constructors, inductive types, and foreign functions.
-/
def getOtherDeclType (declName : Name) (us : List Level := []) : CompilerM Expr 
goal: Lean.Compiler.LCNF.CompilerM Lean.Expr