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

full_name: _private.«.lake».packages.lean4.src.lean.lake.Lake.CLI.Translate.0.Lake.descopeSyntax
code: private partial def descopeSyntax : Syntax → Syntax

goal: Lean.Syntax → Lean.Syntax

full_name: _private.«.lake».packages.lean4.src.lean.lake.Lake.CLI.Translate.0.Lake.descopeTSyntax
code: private def descopeTSyntax (stx : TSyntax k) : TSyntax k 
goal: Lean.TSyntax k

full_name: Lake.Package.mkConfigString
code: def Package.mkConfigString (pkg : Package) (lang : ConfigLang) : LogIO String 
goal: Lake.LogIO String
File: .lake/packages/lean4/src/lean/lake/Lake/Main.lean

full_name: main
code: def main (args : List String) : IO UInt32 
goal: IO UInt32
File: .lake/packages/lean4/src/lean/lake/Lake/Version.lean

full_name: Lake.version.major
code: def version.major 
goal: Nat

full_name: Lake.version.minor
code: def version.minor 
goal: Nat

full_name: Lake.version.patch
code: def version.patch 
goal: Nat

full_name: Lake.version.isRelease
code: def version.isRelease 
goal: Bool

full_name: Lake.version.specialDesc
code: def version.specialDesc 
goal: String

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

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

full_name: Lake.uiVersionString
code: def uiVersionString 
goal: String
File: .lake/packages/lean4/src/lean/lake/Lake/Build/Store.lean

full_name: Lake.MonadBuildStore
code: /-- A monad equipped with a Lake build store. -/
abbrev MonadBuildStore (m) 
goal: Type u_1

full_name: Lake.BuildStore
code: /-- The type of the Lake build store. -/
abbrev BuildStore 
goal: Type

full_name: Lake.BuildStore.empty
code: @[inline] def BuildStore.empty : BuildStore 
goal: Lake.BuildStore

full_name: Lake.BuildStore.collectModuleFacetArray
code: /-- Derive an array of built module facets from the store. -/
def collectModuleFacetArray (self : BuildStore)
(facet : Name) [FamilyOut ModuleData facet α] : Array α 
goal: Array α

full_name: Lake.BuildStore.collectModuleFacetMap
code: /-- Derive a map of module names to built facets from the store. -/
def collectModuleFacetMap (self : BuildStore)
(facet : Name) [FamilyOut ModuleData facet α] : NameMap α 
goal: Lake.NameMap α

full_name: Lake.BuildStore.collectPackageFacetArray
code: /-- Derive an array of built package facets from the store. -/
def collectPackageFacetArray (self : BuildStore)
(facet : Name) [FamilyOut PackageData facet α] : Array α 
goal: Array α

full_name: Lake.BuildStore.collectTargetFacetArray
code: /-- Derive an array of built target facets from the store. -/
def collectTargetFacetArray (self : BuildStore)
(facet : Name) [FamilyOut TargetData facet α] : Array α 
goal: Array α

full_name: Lake.BuildStore.collectSharedExternLibs
code: /-- Derive an array of built external shared libraries from the store. -/
def collectSharedExternLibs (self : BuildStore)
[FamilyOut TargetData `externLib.shared α] : Array α 
goal: Array α
File: .lake/packages/lean4/src/lean/lake/Lake/Build/Index.lean

full_name: Lake.mkTargetFacetBuild
code: /--
Converts a conveniently-typed target facet build function into its
dynamically-typed equivalent.
-/
@[macro_inline] def mkTargetFacetBuild
  (facet : Name) (build : FetchM (BuildJob α))
  [h : FamilyOut TargetData facet (BuildJob α)]
: FetchM (TargetData facet) 
goal: Lake.FetchM (Lake.TargetData facet)

full_name: Lake.ExternLib.recBuildStatic
code: def ExternLib.recBuildStatic (lib : ExternLib) : FetchM (BuildJob FilePath) 
goal: Lake.FetchM (Lake.BuildJob Lake.FilePath)

full_name: Lake.ExternLib.recBuildShared
code: def ExternLib.recBuildShared (lib : ExternLib) : FetchM (BuildJob FilePath) 
goal: Lake.FetchM (Lake.BuildJob Lake.FilePath)

full_name: Lake.ExternLib.recComputeDynlib
code: def ExternLib.recComputeDynlib (lib : ExternLib) : FetchM (BuildJob Dynlib) 
goal: Lake.FetchM (Lake.BuildJob Lake.Dynlib)

full_name: Lake.recBuildWithIndex
code: /-- Recursive build function for anything in the Lake build index. -/
def recBuildWithIndex : (info : BuildInfo) → FetchM (BuildData info.key)

goal: Lake.FetchM (Lake.BuildData info.key)

full_name: Lake.FetchM.run
code: /--
Run a recursive Lake build using the Lake build index
and a topological / suspending scheduler.
-/
def FetchM.run (x : FetchM α) : RecBuildM α 
goal: Lake.RecBuildM α
File: .lake/packages/lean4/src/lean/lake/Lake/Build/Executable.lean

full_name: Lake.LeanExe.recBuildExe
code: def LeanExe.recBuildExe (self : LeanExe) : FetchM (BuildJob FilePath) 
goal: Lake.FetchM (Lake.BuildJob Lake.FilePath)
File: .lake/packages/lean4/src/lean/lake/Lake/Build/Topological.lean

full_name: Lake.DFetchFn
code: /--
A dependently typed monadic *fetch* function.

That is, a function within the monad `m` and takes an input `a : α`
describing what to fetch and and produces some output `b : β a` (dependently
typed) or `b : B` (not) describing what was fetched. All build functions are
fetch functions, but not all fetch functions need build something.
-/
abbrev DFetchFn (α : Type u) (β : α → Type v) (m : Type v → Type w) 
goal: Type (max u w)

full_name: Lake.DFetchT
code: /-- A transformer that equips a monad with a `DFetchFn`. -/
abbrev DFetchT (α : Type u) (β : α → Type v) (m : Type v → Type w) 
goal: Type v → Type (max (max w u) w)

full_name: Lake.FetchT
code: /-- A `DFetchT` that is not dependently typed. -/
abbrev FetchT (α : Type u) (β : Type v) (m : Type v → Type w) 
goal: Type v → Type (max (max w u) w)

full_name: Lake.DRecFetchFn
code: abbrev DRecFetchFn (α : Type u) (β : α → Type v) (m : Type v → Type w) 
goal: Type (max u w u)

full_name: Lake.RecFetchFn
code: /-- A `DRecFetchFn` that is not dependently typed. -/
abbrev RecFetchFn (α : Type u) (β : Type v) (m : Type v → Type w) 
goal: Type (max u w)

full_name: Lake.recFetch
code: /-- A `DFetchFn` that provides its base `DRecFetchFn` with itself. -/
@[specialize] partial def recFetch
[(α : Type u) → Nonempty (m α)] (fetch : DRecFetchFn α β m) : DFetchFn α β m 
goal: Lake.DFetchFn α β m

full_name: Lake.recFetchAcyclic
code: /--
A `recFetch` augmented by a `MonadCycle` to guard against recursive cycles.
If the set of visited keys is finite, this function should provably terminate.

We use `keyOf` to the derive the unique key of a fetch from its descriptor
`a : α`. We do this because descriptors may not be comparable and/or contain
more information than necessary to determine uniqueness.
-/
@[specialize] def recFetchAcyclic
  [BEq κ] [Monad m] [MonadCycle κ m]
  (keyOf : α → κ) (fetch : DRecFetchFn α β m)
: DFetchFn α β m 
goal: Lake.DFetchFn α β m

full_name: Lake.recFetchMemoize
code: /--
`recFetchAcyclic` augmented with a `MonadDStore` to
memoize fetch results and thus avoid computing the same result twice.
-/
@[specialize] def recFetchMemoize
  [BEq κ] [Monad m] [MonadCycle κ m] [MonadDStore κ β m]
  (keyOf : α → κ) (fetch : DRecFetchFn α (fun a => β (keyOf a)) m)
: DFetchFn α (fun a => β (keyOf a)) m 
goal: Lake.DFetchFn α (fun a => β (keyOf a)) m
File: .lake/packages/lean4/src/lean/lake/Lake/Build/Package.lean

full_name: Lake.Package.recComputeDeps
code: /-- Compute a topological ordering of the package's transitive dependencies. -/
def Package.recComputeDeps (self : Package) : FetchM (Array Package) 
goal: Lake.FetchM (Array Lake.Package)

full_name: Lake.Package.depsFacetConfig
code: /-- The `PackageFacetConfig` for the builtin `depsFacet`. -/
def Package.depsFacetConfig : PackageFacetConfig depsFacet 
goal: Lake.PackageFacetConfig Lake.Package.depsFacet

full_name: Lake.Package.recBuildExtraDepTargets
code: /--
Build the `extraDepTargets` for the package and its transitive dependencies.
Also fetch pre-built releases for the package's' dependencies.
-/
def Package.recBuildExtraDepTargets (self : Package) : FetchM (BuildJob Unit) 
goal: Lake.FetchM (Lake.BuildJob Unit)

full_name: Lake.Package.extraDepFacetConfig
code: /-- The `PackageFacetConfig` for the builtin `dynlibFacet`. -/
def Package.extraDepFacetConfig : PackageFacetConfig extraDepFacet 
goal: Lake.PackageFacetConfig Lake.Package.extraDepFacet

full_name: Lake.Package.fetchOptRelease
code: /-- Download and unpack the package's prebuilt release archive (from GitHub). -/
def Package.fetchOptRelease (self : Package) : FetchM (BuildJob Bool) 
goal: Lake.FetchM (Lake.BuildJob Bool)

full_name: Lake.Package.optReleaseFacetConfig
code: /-- The `PackageFacetConfig` for the builtin `optReleaseFacet`. -/
def Package.optReleaseFacetConfig : PackageFacetConfig optReleaseFacet 
goal: Lake.PackageFacetConfig Lake.Package.optReleaseFacet

full_name: Lake.Package.releaseFacetConfig
code: /-- The `PackageFacetConfig` for the builtin `releaseFacet`. -/
def Package.releaseFacetConfig : PackageFacetConfig releaseFacet 
goal: Lake.PackageFacetConfig Lake.Package.releaseFacet

full_name: Lake.Package.afterReleaseAsync
code: /-- Perform a build job after first checking for a cloud release for the package. -/
def Package.afterReleaseAsync (self : Package) (build : SpawnM (Job α)) : FetchM (Job α) 
goal: Lake.FetchM (Lake.Job α)

full_name: Lake.Package.afterReleaseSync
code: /-- Perform a build after first checking for a cloud release for the package. -/
def Package.afterReleaseSync (self : Package) (build : JobM α) : FetchM (Job α) 
goal: Lake.FetchM (Lake.Job α)

full_name: Lake.initPackageFacetConfigs
code: /--
A package facet name to build function map that contains builders for
the initial set of Lake package facets (e.g., `extraDep`).
-/
def initPackageFacetConfigs : DNameMap PackageFacetConfig 
goal: Lake.DNameMap Lake.PackageFacetConfig
File: .lake/packages/lean4/src/lean/lake/Lake/Build/Actions.lean

full_name: Lake.compileLeanModule
code: def compileLeanModule
  (leanFile : FilePath)
  (oleanFile? ileanFile? cFile? bcFile?: Option FilePath)
  (leanPath : SearchPath := []) (rootDir : FilePath := ".")
  (dynlibs : Array FilePath := #[]) (dynlibPath : SearchPath := {})
  (leanArgs : Array String := #[]) (lean : FilePath := "lean")
: LogIO Unit 
goal: Lake.LogIO Unit

full_name: Lake.compileO
code: def compileO
  (oFile srcFile : FilePath)
  (moreArgs : Array String := #[]) (compiler : FilePath := "cc")
: LogIO Unit 
goal: Lake.LogIO Unit

full_name: Lake.compileStaticLib
code: def compileStaticLib
  (libFile : FilePath) (oFiles : Array FilePath)
  (ar : FilePath := "ar")
: LogIO Unit 
goal: Lake.LogIO Unit

full_name: Lake.compileSharedLib
code: def compileSharedLib
  (libFile : FilePath) (linkArgs : Array String)
  (linker : FilePath := "cc")
: LogIO Unit 
goal: Lake.LogIO Unit

full_name: Lake.compileExe
code: def compileExe
  (binFile : FilePath) (linkFiles : Array FilePath)
  (linkArgs : Array String := #[]) (linker : FilePath := "cc")
: LogIO Unit 
goal: Lake.LogIO Unit

full_name: Lake.download
code: /-- Download a file using `curl`, clobbering any existing file. -/
def download  (url : String) (file : FilePath) : LogIO PUnit 
goal: Lake.LogIO PUnit

full_name: Lake.untar
code: /-- Unpack an archive `file` using `tar` into the directory `dir`. -/
def untar (file : FilePath) (dir : FilePath) (gzip := true) : LogIO PUnit 
goal: Lake.LogIO PUnit

full_name: Lake.tar
code: /-- Pack a directory `dir` using `tar` into the archive `file`. -/
def tar
  (dir : FilePath) (file : FilePath)
  (gzip := true) (excludePaths : Array FilePath := #[])
: LogIO PUnit 
goal: Lake.LogIO PUnit
File: .lake/packages/lean4/src/lean/lake/Lake/Build/Imports.lean

full_name: Lake.buildImportsAndDeps
code: /--
Builds an `Array` of module imports for a Lean file.
Used by `lake setup-file` to build modules for the Lean server and
by `lake lean` to build the imports of a file.
Returns the set of module dynlibs built (so they can be loaded by Lean).
-/
def buildImportsAndDeps (leanFile : FilePath) (imports : Array Module) : FetchM (BuildJob (Array FilePath)) 
goal: Lake.FetchM (Lake.BuildJob (Array Lake.FilePath))
File: .lake/packages/lean4/src/lean/lake/Lake/Toml/Load.lean

full_name: Lake.Toml.loadToml
code: /-- Load a TOML table from some input. -/
def loadToml (ictx : InputContext) : EIO MessageLog Table 
goal: EIO Lean.MessageLog Lake.Toml.Table
File: .lake/packages/lean4/src/lean/lake/Lake/Util/MainM.lean

full_name: Lake.MainM
code: /--
The monad in Lake for `main`-like functions.
Supports IO, logging, and `exit`.
-/
def MainM 
goal: Type → Type

full_name: Lake.instMonadMainM
code: instance : Monad MainM 
goal: Monad Lake.MainM

full_name: Lake.instMonadFinallyMainM
code: instance : MonadFinally MainM 
goal: MonadFinally Lake.MainM

full_name: Lake.instMonadLiftBaseIOMainM
code: instance : MonadLift BaseIO MainM 
goal: MonadLift BaseIO Lake.MainM

full_name: Lake.MainM.mk
code: @[inline] protected def mk (x : EIO ExitCode α) : MainM α 
goal: Lake.MainM α

full_name: Lake.MainM.toEIO
code: @[inline] protected def toEIO (self : MainM α) : EIO ExitCode α 
goal: EIO Lake.ExitCode α

full_name: Lake.MainM.toBaseIO
code: @[inline] protected def toBaseIO (self : MainM α) : BaseIO (Except ExitCode α) 
goal: BaseIO (Except Lake.ExitCode α)

full_name: Lake.MainM.run
code: @[inline] protected def run (self : MainM α) : BaseIO ExitCode 
goal: BaseIO Lake.ExitCode

full_name: Lake.MainM.exit
code: /-- Exit with given return code. -/
@[inline] protected def exit (rc : ExitCode) : MainM α 
goal: Lake.MainM α

full_name: Lake.MainM.instMonadExit
code: instance : MonadExit MainM 
goal: Lake.MonadExit Lake.MainM

full_name: Lake.MainM.tryCatchExit
code: /-- Try this and catch exits. -/
@[inline] protected def tryCatchExit (f : ExitCode → MainM α) (self : MainM α) : MainM α 
goal: Lake.MainM α

full_name: Lake.MainM.tryCatchError
code: /-- Try this and catch error codes (i.e., non-zero exits). -/
@[inline] protected def tryCatchError (f : ExitCode → MainM α) (self : MainM α) : MainM α 
goal: Lake.MainM α

full_name: Lake.MainM.failure
code: /-- Exit with a generic error code (i.e., 1). -/
@[inline] protected def failure : MainM α 
goal: Lake.MainM α

full_name: Lake.MainM.orElse
code: /-- If this exits with an error code (i.e., not 0), perform other. -/
@[inline] protected def orElse (self : MainM α) (other : Unit → MainM α) : MainM α 
goal: Lake.MainM α

full_name: Lake.MainM.instAlternative
code: instance : Alternative MainM 
goal: Alternative Lake.MainM

full_name: Lake.MainM.instMonadLog
code: instance : MonadLog MainM 
goal: Lake.MonadLog Lake.MainM

full_name: Lake.MainM.error
code: /-- Print out a error line with the given message and then exit with an error code. -/
@[inline] protected def error (msg : String) (rc : ExitCode := 1) : MainM α 
goal: Lake.MainM α

full_name: Lake.MainM.instMonadError
code: instance : MonadError MainM 
goal: Lake.MonadError Lake.MainM

full_name: Lake.MainM.instMonadLiftIO
code: instance : MonadLift IO MainM 
goal: MonadLift IO Lake.MainM

full_name: Lake.MainM.runLogIO.replay
code: @[inline] def runLogIO (x : LogIO α)
  (minLv := LogLevel.info) (ansiMode := AnsiMode.auto) (out := OutStream.stderr)
: MainM α 
goal: BaseIO Unit

full_name: Lake.MainM.runLogIO
code: @[inline] def runLogIO (x : LogIO α)
  (minLv := LogLevel.info) (ansiMode := AnsiMode.auto) (out := OutStream.stderr)
: MainM α 
goal: Lake.MainM α

full_name: Lake.MainM.instMonadLiftLogIO
code: instance (priority := low) : MonadLift LogIO MainM 
goal: MonadLift Lake.LogIO Lake.MainM
File: .lake/packages/lean4/src/lean/lake/Lake/Util/OrdHashSet.lean

full_name: Lake.OrdHashSet
code: /-- A `HashSet` that preserves insertion order. -/
structure OrdHashSet (α) [Hashable α] [BEq α] where
  toHashSet : HashSet α
  toArray : Array α
goal: Type u_1

full_name: Lake.OrdHashSet.toHashSet
code: /-- A `HashSet` that preserves insertion order. -/
structure OrdHashSet (α) [Hashable α] [BEq α] where
  toHashSet : HashSet α
  toArray : Array α
goal: Lean.HashSet α

full_name: Lake.OrdHashSet.toArray
code: /-- A `HashSet` that preserves insertion order. -/
structure OrdHashSet (α) [Hashable α] [BEq α] where
  toHashSet : HashSet α
  toArray : Array α
goal: Array α

full_name: Lake.OrdHashSet.instCoeHashSet
code: instance : Coe (OrdHashSet α) (HashSet α) 
goal: Coe (Lake.OrdHashSet α) (Lean.HashSet α)

full_name: Lake.OrdHashSet.empty
code: def empty : OrdHashSet α 
goal: Lake.OrdHashSet α

full_name: Lake.OrdHashSet.instEmptyCollection
code: instance : EmptyCollection (OrdHashSet α) 
goal: EmptyCollection (Lake.OrdHashSet α)

full_name: Lake.OrdHashSet.mkEmpty
code: def mkEmpty (size : Nat) : OrdHashSet α 
goal: Lake.OrdHashSet α

full_name: Lake.OrdHashSet.insert
code: def insert (self : OrdHashSet α) (a : α) : OrdHashSet α 
goal: Lake.OrdHashSet α

full_name: Lake.OrdHashSet.appendArray
code: def appendArray (self : OrdHashSet α) (arr : Array α) 
goal: Lake.OrdHashSet α

full_name: Lake.OrdHashSet.instHAppendArray
code: instance : HAppend (OrdHashSet α) (Array α) (OrdHashSet α) 
goal: HAppend (Lake.OrdHashSet α) (Array α) (Lake.OrdHashSet α)

full_name: Lake.OrdHashSet.append
code: protected def append (self other : OrdHashSet α) 
goal: Lake.OrdHashSet α

full_name: Lake.OrdHashSet.instAppend
code: instance : Append (OrdHashSet α) 
goal: Append (Lake.OrdHashSet α)

full_name: Lake.OrdHashSet.ofArray
code: def ofArray (arr : Array α) : OrdHashSet α 
goal: Lake.OrdHashSet α

full_name: Lake.OrdHashSet.all
code: @[inline] def all (f : α → Bool) (self : OrdHashSet α) : Bool  
goal: Bool

full_name: Lake.OrdHashSet.any
code: @[inline] def any (f : α → Bool) (self : OrdHashSet α) : Bool  
goal: Bool

full_name: Lake.OrdHashSet.foldl
code: @[inline] def foldl (f : β → α → β) (init : β) (self : OrdHashSet α) : β 
goal: β

full_name: Lake.OrdHashSet.foldlM
code: @[inline] def foldlM [Monad m] (f : β → α → m β) (init : β) (self : OrdHashSet α) : m β 
goal: m β

full_name: Lake.OrdHashSet.foldr
code: @[inline] def foldr (f : α → β → β) (init : β) (self : OrdHashSet α) : β 
goal: β

full_name: Lake.OrdHashSet.foldrM
code: @[inline] def foldrM [Monad m] (f : α → β → m β) (init : β) (self : OrdHashSet α) : m β 
goal: m β

full_name: Lake.OrdHashSet.forM
code: @[inline] def forM [Monad m] (f : α → m PUnit) (self : OrdHashSet α) : m PUnit 
goal: m PUnit

full_name: Lake.OrdHashSet.forIn
code: @[inline] protected def forIn [Monad m] (self : OrdHashSet α) (init : β) (f : α → β → m (ForInStep β)) : m β 
goal: m β

full_name: Lake.OrdHashSet.instForIn
code: instance : ForIn m (OrdHashSet α) α 
goal: ForIn m (Lake.OrdHashSet α) α
File: .lake/packages/lean4/src/lean/lake/Lake/Util/IO.lean

full_name: Lake.createParentDirs
code: /-- Creates any missing parent directories of `path`. -/
def createParentDirs (path : System.FilePath) : IO Unit 
goal: IO Unit
File: .lake/packages/lean4/src/lean/lake/Lake/Util/OrderedTagAttribute.lean

full_name: Lake.OrderedTagAttribute.ext
code: structure OrderedTagAttribute where
  attr : AttributeImpl
  ext  : PersistentEnvExtension Name Name (Array Name)
  deriving Inhabited
goal: Lean.PersistentEnvExtension Lean.Name Lean.Name (Array Lean.Name)

full_name: Lake.OrderedTagAttribute.attr
code: structure OrderedTagAttribute where
  attr : AttributeImpl
  ext  : PersistentEnvExtension Name Name (Array Name)
  deriving Inhabited
goal: Lean.AttributeImpl

full_name: Lake.instInhabitedOrderedTagAttribute
code: structure OrderedTagAttribute where
  attr : AttributeImpl
  ext  : PersistentEnvExtension Name Name (Array Name)
  deriving Inhabited
goal: Inhabited Lake.OrderedTagAttribute

full_name: Lake.OrderedTagAttribute
code: structure OrderedTagAttribute where
  attr : AttributeImpl
  ext  : PersistentEnvExtension Name Name (Array Name)
  deriving Inhabited
goal: Type

full_name: Lake.registerOrderedTagAttribute
code: def registerOrderedTagAttribute (name : Name) (descr : String)
    (validate : Name → AttrM Unit := fun _ => pure ()) (ref : Name := by exact decl_name%) : IO OrderedTagAttribute 
goal: IO Lake.OrderedTagAttribute

full_name: Lake.OrderedTagAttribute.hasTag
code: def OrderedTagAttribute.hasTag (attr : OrderedTagAttribute) (env : Environment) (decl : Name) : Bool 
goal: Bool

full_name: Lake.OrderedTagAttribute.getAllEntries
code: /-- Get all tagged declaration names, both those imported and those in the current module. -/
def OrderedTagAttribute.getAllEntries (attr : OrderedTagAttribute) (env : Environment) : Array Name 
goal: Array Lean.Name
File: .lake/packages/lean4/src/lean/lake/Lake/Util/Exit.lean

full_name: Lake.ExitCode
code: /-- A process exit / return code. -/
abbrev ExitCode 
goal: Type

full_name: Lake.MonadExit.exit
code: class MonadExit (m : Type u → Type v) where
  exit {α : Type u} : ExitCode → m α
goal: Lake.ExitCode → m α

full_name: Lake.MonadExit
code: class MonadExit (m : Type u → Type v) where
  exit {α : Type u} : ExitCode → m α
goal: Type (max (u + 1) v)

full_name: Lake.instMonadExitOfMonadLift
code: instance [MonadLift m n] [MonadExit m] : MonadExit n 
goal: Lake.MonadExit n

full_name: Lake.exitIfErrorCode
code: /-- Exit with `ExitCode` if it is not 0. Otherwise, continue. -/
@[inline] def exitIfErrorCode [Pure m] [MonadExit m]  (rc : ExitCode) : m Unit 
goal: m Unit
File: .lake/packages/lean4/src/lean/lake/Lake/Util/NativeLib.lean

full_name: Lake.sharedLibExt
code: /-- The shared library file extension for the `Platform`. -/
def sharedLibExt : String 
goal: String

full_name: Lake.nameToStaticLib
code: /-- Convert a library name into its static library file name for the `Platform`. -/
def nameToStaticLib (name : String) : String 
goal: String

full_name: Lake.nameToSharedLib
code: /-- Convert a library name into its shared library file name for the `Platform`. -/
def nameToSharedLib (name : String) : String 
goal: String

full_name: Lake.sharedLibPathEnvVar
code: /--
The environment variable that stores the search path
used to find shared libraries on the `Platform`.
-/
def sharedLibPathEnvVar 
goal: String

full_name: Lake.getSearchPath
code: /-- Gets a `SearchPath` from an environment variable. -/
def getSearchPath (envVar : String) : BaseIO SearchPath 
goal: BaseIO System.SearchPath
File: .lake/packages/lean4/src/lean/lake/Lake/Util/Proc.lean

full_name: Lake.mkCmdLog
code: def mkCmdLog (args : IO.Process.SpawnArgs) : String 
goal: String

full_name: Lake.logOutput
code: @[inline] def logOutput
  [Monad m] (out : IO.Process.Output) (log : String → m PUnit)
: m Unit 
goal: m Unit

full_name: Lake.rawProc
code: @[inline] def rawProc (args : IO.Process.SpawnArgs) (quiet := false) : LogIO IO.Process.Output 
goal: Lake.LogIO IO.Process.Output

full_name: Lake.proc
code: def proc (args : IO.Process.SpawnArgs) (quiet := false) : LogIO Unit 
goal: Lake.LogIO Unit

full_name: Lake.captureProc
code: def captureProc (args : IO.Process.SpawnArgs) : LogIO String 
goal: Lake.LogIO String

full_name: Lake.captureProc?
code: def captureProc? (args : IO.Process.SpawnArgs) : BaseIO (Option String) 
goal: BaseIO (Option String)

full_name: Lake.testProc
code: def testProc (args : IO.Process.SpawnArgs) : BaseIO Bool 
goal: BaseIO Bool
File: .lake/packages/lean4/src/lean/lake/Lake/Util/FilePath.lean

full_name: Lake.mkRelPathString
code: /--
Convert a relative file path to a platform-independent string.
Uses `/` as the path separator, even on Windows.
-/
def mkRelPathString (path : FilePath) : String 
goal: String

full_name: Lake.«instToJsonFilePath_.lake»
code: scoped instance : ToJson FilePath 
goal: Lean.ToJson System.FilePath

full_name: Lake.«instToExprFilePath_.lake»
code: scoped instance : ToExpr FilePath 
goal: Lean.ToExpr System.FilePath
File: .lake/packages/lean4/src/lean/lake/Lake/Util/Casing.lean

full_name: Lake.toUpperCamelCaseString
code: /-- Converts a snake case, kebab case, or lower camel case `String` to upper camel case. -/
def toUpperCamelCaseString (str : String) : String 
goal: String

full_name: Lake.toUpperCamelCase
code: /-- Converts a snake case, kebab case, or lower camel case `Name` to upper camel case. -/
def toUpperCamelCase (name : Name) : Name 
goal: Lean.Name
File: .lake/packages/lean4/src/lean/lake/Lake/Util/List.lean

full_name: Lake.List.squeeze
code: /-- Remove adjacent duplicates. -/
def List.squeeze [BEq α] : List α → List α

goal: List α → List α