ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: .lake/packages/lean4/src/lean/Init/Data/BitVec/Folds.lean

full_name: BitVec.iunfoldr
code: /--
iunfoldr is an iterative operation that applies a function `f` repeatedly.

It produces a sequence of state values `[s_0, s_1 .. s_w]` and a bitvector
`v` where `f i s_i = (s_{i+1}, b_i)` and `b_i` is bit `i`th least-significant bit
in `v` (e.g., `getLsb v i = b_i`).

Theorems involving `iunfoldr` can be eliminated using `iunfoldr_replace` below.
-/
def iunfoldr (f : Fin w -> α → α × Bool) (s : α) : α × BitVec w 
goal: α × BitVec w

full_name: BitVec.iunfoldr.fst_eq
code: theorem iunfoldr.fst_eq
    {f : Fin w → α → α × Bool} (state : Nat → α) (s : α)
    (init : s = state 0)
    (ind : ∀(i : Fin w), (f i (state i.val)).fst = state (i.val+1)) :
    (iunfoldr f s).fst = state w 
goal: (BitVec.iunfoldr f s).fst = state w

full_name: _private.«.lake».packages.lean4.src.lean.Init.Data.BitVec.Folds.0.BitVec.iunfoldr.eq_test
code: private theorem iunfoldr.eq_test
    {f : Fin w → α → α × Bool} (state : Nat → α) (value : BitVec w) (a : α)
    (init : state 0 = a)
    (step : ∀(i : Fin w), f i (state i.val) = (state (i.val+1), value.getLsb i.val)) :
    iunfoldr f a = (state w, BitVec.truncate w value) 
goal: BitVec.iunfoldr f a = (state w, BitVec.truncate w value)

full_name: BitVec.iunfoldr_getLsb'
code: theorem iunfoldr_getLsb' {f : Fin w → α → α × Bool} (state : Nat → α)
    (ind : ∀(i : Fin w), (f i (state i.val)).fst = state (i.val+1)) :
  (∀ i : Fin w, getLsb (iunfoldr f (state 0)).snd i.val = (f i (state i.val)).snd)
  ∧ (iunfoldr f (state 0)).fst = state w 
goal: (∀ (i : Fin w), (BitVec.iunfoldr f (state 0)).snd.getLsb ↑i = (f i (state ↑i)).snd) ∧
  (BitVec.iunfoldr f (state 0)).fst = state w

full_name: BitVec.iunfoldr_getLsb
code: theorem iunfoldr_getLsb {f : Fin w → α → α × Bool} (state : Nat → α) (i : Fin w)
    (ind : ∀(i : Fin w), (f i (state i.val)).fst = state (i.val+1)) :
  getLsb (iunfoldr f (state 0)).snd i.val = (f i (state i.val)).snd 
goal: (BitVec.iunfoldr f (state 0)).snd.getLsb ↑i = (f i (state ↑i)).snd

full_name: BitVec.iunfoldr_replace
code: /--
Correctness theorem for `iunfoldr`.
-/
theorem iunfoldr_replace
    {f : Fin w → α → α × Bool} (state : Nat → α) (value : BitVec w) (a : α)
    (init : state 0 = a)
    (step : ∀(i : Fin w), f i (state i.val) = (state (i.val+1), value.getLsb i.val)) :
    iunfoldr f a = (state w, value) 
goal: BitVec.iunfoldr f a = (state w, value)

full_name: BitVec.iunfoldr_replace_snd
code: theorem iunfoldr_replace_snd
  {f : Fin w → α → α × Bool} (state : Nat → α) (value : BitVec w) (a : α)
    (init : state 0 = a)
    (step : ∀(i : Fin w), f i (state i.val) = (state (i.val+1), value.getLsb i.val)) :
    (iunfoldr f a).snd = value 
goal: (BitVec.iunfoldr f a).snd = value
File: .lake/packages/lean4/src/lean/lake/Lake/Config/WorkspaceConfig.lean

full_name: Lake.WorkspaceConfig
code: /-- A `Workspace`'s declarative configuration. -/
structure WorkspaceConfig where
  /--
  The directory to which Lake should download remote dependencies.
  Defaults to `defaultPackagesDir` (i.e., `.lake/packages`).
  -/
  packagesDir : FilePath := defaultPackagesDir
  deriving Inhabited, Repr
goal: Type

full_name: Lake.WorkspaceConfig.packagesDir
code: /-- A `Workspace`'s declarative configuration. -/
structure WorkspaceConfig where
  /--
  The directory to which Lake should download remote dependencies.
  Defaults to `defaultPackagesDir` (i.e., `.lake/packages`).
  -/
  packagesDir : FilePath := defaultPackagesDir
  deriving Inhabited, Repr
goal: System.FilePath

full_name: Lake.instInhabitedWorkspaceConfig
code: /-- A `Workspace`'s declarative configuration. -/
structure WorkspaceConfig where
  /--
  The directory to which Lake should download remote dependencies.
  Defaults to `defaultPackagesDir` (i.e., `.lake/packages`).
  -/
  packagesDir : FilePath := defaultPackagesDir
  deriving Inhabited, Repr
goal: Inhabited Lake.WorkspaceConfig

full_name: Lake.instReprWorkspaceConfig
code: /-- A `Workspace`'s declarative configuration. -/
structure WorkspaceConfig where
  /--
  The directory to which Lake should download remote dependencies.
  Defaults to `defaultPackagesDir` (i.e., `.lake/packages`).
  -/
  packagesDir : FilePath := defaultPackagesDir
  deriving Inhabited, Repr
goal: Repr Lake.WorkspaceConfig
File: .lake/packages/lean4/src/lean/lake/Lake/Config/Context.lean

full_name: Lake.Context.opaqueWs
code: /-- A Lake configuration. -/
structure Context where
  opaqueWs : OpaqueWorkspace
goal: Lake.OpaqueWorkspace

full_name: Lake.Context
code: /-- A Lake configuration. -/
structure Context where
  opaqueWs : OpaqueWorkspace
goal: Type

full_name: Lake.LakeT
code: /-- A transformer to equip a monad with a `Lake.Context`. -/
abbrev LakeT 
goal: Type u_1

full_name: Lake.LakeT.run
code: @[inline] def LakeT.run (ctx : Context) (self : LakeT m α) : m α 
goal: m α

full_name: Lake.LakeM
code: /-- A monad equipped with a `Lake.Context`. -/
abbrev LakeM 
goal: Type

full_name: Lake.LakeM.run
code: @[inline] def LakeM.run (ctx : Context) (self : LakeM α) : α 
goal: α
File: .lake/packages/lean4/src/lean/lake/Lake/Config/ExternLib.lean

full_name: Lake.ExternLib.name
code: /-- An external library -- its package plus its configuration. -/
structure ExternLib where
  /-- The package the library belongs to. -/
  pkg : Package
  /-- The external library's name. -/
  name : Name
  /-- The library's user-defined configuration. -/
  config : ExternLibConfig pkg.name name
goal: Lake.Name

full_name: Lake.ExternLib.pkg
code: /-- An external library -- its package plus its configuration. -/
structure ExternLib where
  /-- The package the library belongs to. -/
  pkg : Package
  /-- The external library's name. -/
  name : Name
  /-- The library's user-defined configuration. -/
  config : ExternLibConfig pkg.name name
goal: Lake.Package

full_name: Lake.ExternLib
code: /-- An external library -- its package plus its configuration. -/
structure ExternLib where
  /-- The package the library belongs to. -/
  pkg : Package
  /-- The external library's name. -/
  name : Name
  /-- The library's user-defined configuration. -/
  config : ExternLibConfig pkg.name name
goal: Type

full_name: Lake.ExternLib.config
code: /-- An external library -- its package plus its configuration. -/
structure ExternLib where
  /-- The package the library belongs to. -/
  pkg : Package
  /-- The external library's name. -/
  name : Name
  /-- The library's user-defined configuration. -/
  config : ExternLibConfig pkg.name name
goal: Lake.ExternLibConfig self.pkg.name self.name

full_name: Lake.Package.externLibs
code: /-- The external libraries of the package (as an Array). -/
@[inline] def Package.externLibs (self : Package) : Array ExternLib 
goal: Array Lake.ExternLib

full_name: Lake.Package.findExternLib?
code: /-- Try to find a external library in the package with the given name. -/
@[inline] def Package.findExternLib? (name : Name) (self : Package) : Option ExternLib 
goal: Option Lake.ExternLib

full_name: Lake.ExternLib.linkArgs
code: /--
The arguments to pass to `leanc` when linking the external library.
That is, the package's `moreLinkArgs`.
-/
@[inline] def linkArgs (self : ExternLib) : Array String 
goal: Array String

full_name: Lake.ExternLib.staticTargetName
code: /-- The name of the package target used to build the external library's static binary. -/
@[inline] def staticTargetName (self : ExternLib) : Name 
goal: Lake.Name
File: .lake/packages/lean4/src/lean/lake/Lake/Config/Defaults.lean

full_name: Lake.defaultLakeDir
code: /--
The default directory to output Lake-related files
(e.g., build artifacts, packages, caches, etc.).
Currently not configurable.
-/
def defaultLakeDir : FilePath 
goal: System.FilePath

full_name: Lake.defaultPackagesDir
code: /-- The default setting for a `WorkspaceConfig`'s `packagesDir` option. -/
def defaultPackagesDir 
goal: System.FilePath

full_name: Lake.defaultConfigFile
code: /-- The default name of the Lake configuration file (i.e., `lakefile`). -/
def defaultConfigFile : FilePath 
goal: System.FilePath

full_name: Lake.defaultLeanConfigFile
code: /-- The default name of the Lean Lake configuration file (i.e., `lakefile.lean`). -/
def defaultLeanConfigFile : FilePath 
goal: System.FilePath

full_name: Lake.defaultTomlConfigFile
code: /-- The default name of the TOML Lake configuration file (i.e., `lakefile.toml`). -/
def defaultTomlConfigFile : FilePath 
goal: System.FilePath

full_name: Lake.defaultManifestFile
code: /-- The default name of the Lake manifest file (i.e., `lake-manifest.json`). -/
def defaultManifestFile : FilePath 
goal: System.FilePath

full_name: Lake.defaultBuildDir
code: /-- The default build directory for packages (i.e., `.lake/build`). -/
def defaultBuildDir : FilePath 
goal: System.FilePath

full_name: Lake.defaultLeanLibDir
code: /-- The default Lean library directory for packages. -/
def defaultLeanLibDir : FilePath 
goal: System.FilePath

full_name: Lake.defaultNativeLibDir
code: /-- The default native library directory for packages. -/
def defaultNativeLibDir : FilePath 
goal: System.FilePath

full_name: Lake.defaultBinDir
code: /-- The default binary directory for packages. -/
def defaultBinDir : FilePath 
goal: System.FilePath

full_name: Lake.defaultIrDir
code: /-- The default IR directory for packages. -/
def defaultIrDir : FilePath 
goal: System.FilePath
File: .lake/packages/lean4/src/lean/lake/Lake/Config/ExternLibConfig.lean

full_name: Lake.ExternLibConfig
code: /-- A external library's declarative configuration. -/
structure ExternLibConfig (pkgName name : Name) where
  /-- The library's build data. -/
  getJob : CustomData (pkgName, .str name "static") → BuildJob FilePath
  deriving Inhabited
goal: Type

full_name: Lake.ExternLibConfig.getJob
code: /-- A external library's declarative configuration. -/
structure ExternLibConfig (pkgName name : Name) where
  /-- The library's build data. -/
  getJob : CustomData (pkgName, .str name "static") → BuildJob FilePath
  deriving Inhabited
goal: Lake.CustomData (pkgName, name.str "static") → Lake.BuildJob System.FilePath

full_name: Lake.instInhabitedExternLibConfig
code: /-- A external library's declarative configuration. -/
structure ExternLibConfig (pkgName name : Name) where
  /-- The library's build data. -/
  getJob : CustomData (pkgName, .str name "static") → BuildJob FilePath
  deriving Inhabited
goal: {a a_1 : Lake.Name} → Inhabited (Lake.ExternLibConfig a a_1)

full_name: Lake.ExternLibDecl.pkg
code: /-- A dependently typed configuration based on its registered package and name. -/
structure ExternLibDecl where
  pkg : Name
  name : Name
  config : ExternLibConfig pkg name
goal: Lake.Name

full_name: Lake.ExternLibDecl.name
code: /-- A dependently typed configuration based on its registered package and name. -/
structure ExternLibDecl where
  pkg : Name
  name : Name
  config : ExternLibConfig pkg name
goal: Lake.Name

full_name: Lake.ExternLibDecl
code: /-- A dependently typed configuration based on its registered package and name. -/
structure ExternLibDecl where
  pkg : Name
  name : Name
  config : ExternLibConfig pkg name
goal: Type

full_name: Lake.ExternLibDecl.config
code: /-- A dependently typed configuration based on its registered package and name. -/
structure ExternLibDecl where
  pkg : Name
  name : Name
  config : ExternLibConfig pkg name
goal: Lake.ExternLibConfig self.pkg self.name
File: .lake/packages/lean4/src/lean/lake/Lake/Config/Opaque.lean

full_name: Lake.instNonemptyOpaquePackage
code: /-- Opaque reference to a `Package` used for forward declaration. -/
declare_opaque_type OpaquePackage
goal: Nonempty Lake.OpaquePackage

full_name: Lake.OpaquePackage.nonemptyType
code: /-- Opaque reference to a `Package` used for forward declaration. -/
declare_opaque_type OpaquePackage
goal: NonemptyType

full_name: Lake.OpaquePackage
code: /-- Opaque reference to a `Package` used for forward declaration. -/
declare_opaque_type OpaquePackage
goal: Type

full_name: Lake.instNonemptyOpaqueWorkspace
code: /-- Opaque reference to a `Workspace` used for forward declaration. -/
declare_opaque_type OpaqueWorkspace
goal: Nonempty Lake.OpaqueWorkspace

full_name: Lake.OpaqueWorkspace.nonemptyType
code: /-- Opaque reference to a `Workspace` used for forward declaration. -/
declare_opaque_type OpaqueWorkspace
goal: NonemptyType

full_name: Lake.OpaqueWorkspace
code: /-- Opaque reference to a `Workspace` used for forward declaration. -/
declare_opaque_type OpaqueWorkspace
goal: Type

full_name: Lake.OpaqueTargetConfig.nonemptyType
code: /-- Opaque reference to a `TargetConfig` used for forward declaration. -/
declare_opaque_type OpaqueTargetConfig (pkgName name : Name)
goal: NonemptyType

full_name: Lake.OpaqueTargetConfig
code: /-- Opaque reference to a `TargetConfig` used for forward declaration. -/
declare_opaque_type OpaqueTargetConfig (pkgName name : Name)
goal: Type

full_name: Lake.instNonemptyOpaqueTargetConfig
code: /-- Opaque reference to a `TargetConfig` used for forward declaration. -/
declare_opaque_type OpaqueTargetConfig (pkgName name : Name)
goal: Nonempty (Lake.OpaqueTargetConfig pkgName name)
File: .lake/packages/lean4/src/lean/lake/Lake/Config/Script.lean

full_name: Lake.ScriptM
code: /--
The type of a `Script`'s monad.
`IO` equipped information about the Lake configuration.
-/
abbrev ScriptM 
goal: Type

full_name: Lake.ScriptFn
code: /--
The type of a `Script`'s function.
Similar to the `main` function's signature, except that its monad is
also equipped with information about the Lake configuration.
-/
abbrev ScriptFn 
goal: Type

full_name: Lake.Script
code: /--
A package `Script` is a `ScriptFn` definition that is
indexed by a `String` key and can be be run by `lake run <key> [-- <args>]`.
-/
structure Script where
  /-- The full name of the `Script` (e.g., `pkg/script`). -/
  name : String
  fn : ScriptFn
  doc? : Option String
  deriving Inhabited
goal: Type

full_name: Lake.Script.name
code: /--
A package `Script` is a `ScriptFn` definition that is
indexed by a `String` key and can be be run by `lake run <key> [-- <args>]`.
-/
structure Script where
  /-- The full name of the `Script` (e.g., `pkg/script`). -/
  name : String
  fn : ScriptFn
  doc? : Option String
  deriving Inhabited
goal: String

full_name: Lake.instInhabitedScript
code: /--
A package `Script` is a `ScriptFn` definition that is
indexed by a `String` key and can be be run by `lake run <key> [-- <args>]`.
-/
structure Script where
  /-- The full name of the `Script` (e.g., `pkg/script`). -/
  name : String
  fn : ScriptFn
  doc? : Option String
  deriving Inhabited
goal: Inhabited Lake.Script

full_name: Lake.Script.doc?
code: /--
A package `Script` is a `ScriptFn` definition that is
indexed by a `String` key and can be be run by `lake run <key> [-- <args>]`.
-/
structure Script where
  /-- The full name of the `Script` (e.g., `pkg/script`). -/
  name : String
  fn : ScriptFn
  doc? : Option String
  deriving Inhabited
goal: Option String

full_name: Lake.Script.fn
code: /--
A package `Script` is a `ScriptFn` definition that is
indexed by a `String` key and can be be run by `lake run <key> [-- <args>]`.
-/
structure Script where
  /-- The full name of the `Script` (e.g., `pkg/script`). -/
  name : String
  fn : ScriptFn
  doc? : Option String
  deriving Inhabited
goal: Lake.ScriptFn

full_name: Lake.Script.run
code: def Script.run (args : List String) (self : Script) : ScriptM ExitCode 
goal: Lake.ScriptM Lake.ExitCode
File: .lake/packages/lean4/src/lean/lake/Lake/Config/Lang.lean

full_name: Lake.instReprConfigLang
code: /-- Lake configuration language identifier. -/
inductive ConfigLang
| lean | toml
deriving Repr, DecidableEq
goal: Repr Lake.ConfigLang

full_name: Lake.ConfigLang
code: /-- Lake configuration language identifier. -/
inductive ConfigLang
| lean | toml
deriving Repr, DecidableEq
goal: Type

full_name: Lake.ConfigLang.lean
code: /-- Lake configuration language identifier. -/
inductive ConfigLang
| lean | toml
deriving Repr, DecidableEq
goal: Lake.ConfigLang

full_name: Lake.instDecidableEqConfigLang
code: /-- Lake configuration language identifier. -/
inductive ConfigLang
| lean | toml
deriving Repr, DecidableEq
goal: DecidableEq Lake.ConfigLang

full_name: Lake.ConfigLang.toml
code: /-- Lake configuration language identifier. -/
inductive ConfigLang
| lean | toml
deriving Repr, DecidableEq
goal: Lake.ConfigLang

full_name: Lake.instInhabitedConfigLang
code: instance : Inhabited ConfigLang 
goal: Inhabited Lake.ConfigLang

full_name: Lake.ConfigLang.ofString?
code: def ConfigLang.ofString? : String → Option ConfigLang

goal: String → Option Lake.ConfigLang

full_name: Lake.ConfigLang.fileExtension
code: def ConfigLang.fileExtension : ConfigLang → String

goal: Lake.ConfigLang → String

full_name: Lake.instToStringConfigLang
code: instance : ToString ConfigLang 
goal: ToString Lake.ConfigLang
File: .lake/packages/lean4/src/lean/lake/Lake/CLI/Serve.lean

full_name: Lake.noConfigFileCode
code: /-- Exit code to return if `setup-file` cannot find the config file. -/
def noConfigFileCode : ExitCode 
goal: Lake.ExitCode

full_name: Lake.invalidConfigEnvVar
code: /--
Environment variable that is set when `lake serve` cannot parse the Lake configuration file
and falls back to plain `lean --server`.
-/
def invalidConfigEnvVar 
goal: String

full_name: Lake.setupFile
code: /--
Build a list of imports of a file and print the `.olean` and source directories
of every used package, as well as the server options for the file.
If no configuration file exists, exit silently with `noConfigFileCode` (i.e, 2).

The `setup-file` command is used internally by the Lean 4 server.
-/
def setupFile
  (loadConfig : LoadConfig) (path : FilePath) (imports : List String := [])
  (buildConfig : BuildConfig := {})
: MainM PUnit 
goal: Lake.MainM PUnit

full_name: Lake.serve
code: /--
Start the Lean LSP for the `Workspace` loaded from `config`
with the given additional `args`.
-/
def serve (config : LoadConfig) (args : Array String) : IO UInt32 
goal: IO UInt32
File: .lake/packages/lean4/src/lean/lake/Lake/CLI/Help.lean

full_name: Lake.usage
code: def usage 
goal: String

full_name: Lake.templateHelp
code: def templateHelp 
goal: String

full_name: Lake.helpNew
code: def helpNew 
goal: String

full_name: Lake.helpInit
code: def helpInit 
goal: String

full_name: Lake.helpBuild
code: def helpBuild 
goal: String

full_name: Lake.helpUpdate
code: def helpUpdate 
goal: String

full_name: Lake.helpTest
code: def helpTest 
goal: String

full_name: Lake.helpCheckTest
code: def helpCheckTest 
goal: String

full_name: Lake.helpLint
code: def helpLint 
goal: String

full_name: Lake.helpCheckLint
code: def helpCheckLint 
goal: String

full_name: Lake.helpPack
code: def helpPack 
goal: String

full_name: Lake.helpUnpack
code: def helpUnpack 
goal: String

full_name: Lake.helpUpload
code: def helpUpload 
goal: String

full_name: Lake.helpClean
code: def helpClean 
goal: String

full_name: Lake.helpScriptCli
code: def helpScriptCli 
goal: String

full_name: Lake.helpScriptList
code: def helpScriptList 
goal: String

full_name: Lake.helpScriptRun
code: def helpScriptRun 
goal: String

full_name: Lake.helpScriptDoc
code: def helpScriptDoc 
goal: String

full_name: Lake.helpServe
code: def helpServe 
goal: String

full_name: Lake.helpEnv
code: def helpEnv 
goal: String

full_name: Lake.helpExe
code: def helpExe 
goal: String

full_name: Lake.helpLean
code: def helpLean 
goal: String

full_name: Lake.helpTranslateConfig
code: def helpTranslateConfig 
goal: String

full_name: Lake.helpScript
code: def helpScript : (cmd : String) → String

goal: String

full_name: Lake.help
code: def help : (cmd : String) → String

goal: String
File: .lake/packages/lean4/src/lean/lake/Lake/CLI/Translate/Toml.lean

full_name: _private.«.lake».packages.lean4.src.lean.lake.Lake.CLI.Translate.Toml.0.Lake.«instBEqFilePath_.lake»
code: private local instance : BEq FilePath 
goal: BEq Lake.FilePath

full_name: Lake.«instToTomlBackend_.lake»
code: instance : ToToml Backend 
goal: Lake.ToToml Lake.Backend

full_name: Lake.«instSmartInsertBackend_.lake»
code: instance : SmartInsert Backend 
goal: Lake.SmartInsert Lake.Backend

full_name: Lake.«instToTomlBuildType_.lake»
code: instance : ToToml BuildType 
goal: Lake.ToToml Lake.BuildType

full_name: Lake.Toml.encodeLeanOptionValue
code: def Toml.encodeLeanOptionValue (v : LeanOptionValue) : Value 
goal: Lake.Toml.Value

full_name: Lake.«instToTomlLeanOptionValue_.lake»
code: instance : ToToml LeanOptionValue 
goal: Lake.ToToml Lean.LeanOptionValue

full_name: Lake.Toml.encodeLeanOptions
code: def Toml.encodeLeanOptions (opts : Array LeanOption) : Table 
goal: Lake.Toml.Table

full_name: Lake.Toml.leanOptionsEncoder
code: def Toml.leanOptionsEncoder : ToToml (Array LeanOption) 
goal: Lake.ToToml (Array Lake.LeanOption)

full_name: Lake.WorkspaceConfig.toToml
code: protected def WorkspaceConfig.toToml (cfg : WorkspaceConfig) (t : Table := {}) : Table 
goal: Lake.Toml.Table

full_name: Lake.«instToTomlWorkspaceConfig_.lake»
code: instance : ToToml WorkspaceConfig 
goal: Lake.ToToml Lake.WorkspaceConfig

full_name: Lake.LeanConfig.toToml
code: def LeanConfig.toToml (cfg : LeanConfig) (t : Table := {}) : Table 
goal: Lake.Toml.Table

full_name: Lake.«instToTomlLeanConfig_.lake»
code: instance : ToToml LeanConfig 
goal: Lake.ToToml Lake.LeanConfig

full_name: Lake.PackageConfig.toToml
code: protected def PackageConfig.toToml (cfg : PackageConfig) (t : Table := {}) : Table 
goal: Lake.Toml.Table

full_name: Lake.«instToTomlPackageConfig_.lake»
code: instance : ToToml PackageConfig 
goal: Lake.ToToml Lake.PackageConfig

full_name: Lake.«instToTomlGlob_.lake»
code: instance : ToToml Glob 
goal: Lake.ToToml Lake.Glob

full_name: Lake.LeanLibConfig.toToml
code: protected def LeanLibConfig.toToml (cfg : LeanLibConfig) (t : Table := {}) : Table 
goal: Lake.Toml.Table

full_name: Lake.«instToTomlLeanLibConfig_.lake»
code: instance : ToToml LeanLibConfig 
goal: Lake.ToToml Lake.LeanLibConfig

full_name: Lake.LeanExeConfig.toToml
code: protected def LeanExeConfig.toToml (cfg : LeanExeConfig) (t : Table  := {}) : Table 
goal: Lake.Toml.Table

full_name: Lake.«instToTomlLeanExeConfig_.lake»
code: instance : ToToml LeanExeConfig 
goal: Lake.ToToml Lake.LeanExeConfig

full_name: Lake.Dependency.toToml
code: protected def Dependency.toToml (dep : Dependency) (t : Table  := {}) : Table 
goal: Lake.Toml.Table

full_name: Lake.«instToTomlDependency_.lake»
code: instance : ToToml Dependency 
goal: Lake.ToToml Lake.Dependency

full_name: Lake.Package.mkTomlConfig
code: /-- Create a TOML table that encodes the declarative configuration of the package. -/
def Package.mkTomlConfig (pkg : Package) (t : Table := {}) : Table 
goal: Lake.Toml.Table
File: .lake/packages/lean4/src/lean/lake/Lake/CLI/Actions.lean

full_name: Lake.env
code: def env (cmd : String) (args : Array String := #[]) : LakeT IO UInt32 
goal: Lake.LakeT IO UInt32

full_name: Lake.exe
code: def exe (name : Name) (args  : Array String := #[]) (buildConfig : BuildConfig := {}) : LakeT IO UInt32 
goal: Lake.LakeT IO UInt32

full_name: Lake.Package.pack
code: def Package.pack (pkg : Package) (file : FilePath := pkg.buildArchiveFile) : LogIO Unit 
goal: Lake.LogIO Unit

full_name: Lake.Package.unpack
code: def Package.unpack (pkg : Package) (file : FilePath := pkg.buildArchiveFile) : LogIO Unit 
goal: Lake.LogIO Unit

full_name: Lake.Package.uploadRelease
code: def Package.uploadRelease (pkg : Package) (tag : String) : LogIO Unit 
goal: Lake.LogIO Unit

full_name: Lake.Package.resolveDriver
code: def Package.resolveDriver
  (pkg : Package) (kind : String) (driver : String)
: LakeT IO (Package × String) 
goal: Lake.LakeT IO (Lake.Package × String)

full_name: Lake.Package.test
code: def Package.test (pkg : Package) (args : List String := []) (buildConfig : BuildConfig := {}) : LakeT IO UInt32 
goal: Lake.LakeT IO UInt32

full_name: Lake.Package.lint
code: def Package.lint (pkg : Package) (args : List String := []) (buildConfig : BuildConfig := {}) : LakeT IO UInt32 
goal: Lake.LakeT IO UInt32