Lake.Config.LeanConfig

source

inductive Lake.BuildType :

Type

Lake equivalent of CMake's CMAKE_BUILD_TYPE.

debug : BuildType
Debug optimization, asserts enabled, custom debug code enabled, and debug info included in executable (so you can step through the code with a debugger and have address to source-file:line-number translation). For example, passes -Og -g when compiling C code.
relWithDebInfo : BuildType
Optimized, with debug info, but no debug code or asserts (e.g., passes -O3 -g -DNDEBUG when compiling C code).
minSizeRel : BuildType
Same as release but optimizing for size rather than speed (e.g., passes -Os -DNDEBUG when compiling C code).
release : BuildType
High optimization level and no debug info, code, or asserts (e.g., passes -O3 -DNDEBUG when compiling C code).

Instances For

source

instance Lake.instInhabitedBuildType :

Inhabited BuildType

Equations

Lake.instInhabitedBuildType = { default := Lake.BuildType.debug }

source

instance Lake.instReprBuildType :

Repr BuildType

Equations

Lake.instReprBuildType = { reprPrec := Lake.reprBuildType✝ }

source

instance Lake.instDecidableEqBuildType :

DecidableEq BuildType

Equations

Lake.instDecidableEqBuildType x✝ y✝ = if h : x✝.toCtorIdx = y✝.toCtorIdx then isTrue ⋯ else isFalse ⋯

source

instance Lake.instOrdBuildType :

Ord BuildType

Equations

Lake.instOrdBuildType = { compare := Lake.ordBuildType✝ }

source

instance Lake.instLTBuildType :

LT BuildType

Ordering on build types. The ordering is used to determine the minimum build version that is necessary for a build.

Equations

Lake.instLTBuildType = ltOfOrd

source

instance Lake.instLEBuildType :

LE BuildType

Equations

Lake.instLEBuildType = leOfOrd

source

instance Lake.instMinBuildType :

Min BuildType

Equations

Lake.instMinBuildType = minOfLe

source

instance Lake.instMaxBuildType :

Max BuildType

Equations

Lake.instMaxBuildType = maxOfLe

source

inductive Lake.Backend :

Type

Compiler backend with which to compile Lean.

c : Backend
Force the C backend.
llvm : Backend
Force the LLVM backend.
default : Backend
Use the default backend. Can be overridden by more specific configuration.

Instances For

source

instance Lake.instReprBackend :

Repr Backend

Equations

Lake.instReprBackend = { reprPrec := Lake.reprBackend✝ }

source

instance Lake.instDecidableEqBackend :

DecidableEq Backend

Equations

Lake.instDecidableEqBackend x✝ y✝ = if h : x✝.toCtorIdx = y✝.toCtorIdx then isTrue ⋯ else isFalse ⋯

source

instance Lake.instInhabitedBackend :

Inhabited Backend

Equations

Lake.instInhabitedBackend = { default := Lake.Backend.default }

source

def Lake.Backend.ofString? (s : String) :

Option Backend

Equations

Lake.Backend.ofString? "c" = some Lake.Backend.c
Lake.Backend.ofString? "llvm" = some Lake.Backend.llvm
Lake.Backend.ofString? "default" = some Lake.Backend.default
Lake.Backend.ofString? s = none

source

def Lake.Backend.toString (bt : Backend) :

String

Equations

Lake.Backend.c.toString = "c"
Lake.Backend.llvm.toString = "llvm"
Lake.Backend.default.toString = "default"

source

instance Lake.instToStringBackend :

ToString Backend

Equations

Lake.instToStringBackend = { toString := Lake.Backend.toString }

source

def Lake.Backend.orPreferLeft :

Backend → Backend → Backend

If the left backend is default, choose the right one. Otherwise, keep the left one. This is used to implement preferential choice of backends, where the library config can refine the package config. Formally, a left absorbing monoid on {C, LLVM} with Default as the unit.

Equations

Lake.Backend.default.orPreferLeft x✝ = x✝
x✝¹.orPreferLeft x✝ = x✝¹

source

def Lake.BuildType.leancArgs :

BuildType → Array String

The arguments to pass to leanc based on the build type.

Equations

Lake.BuildType.debug.leancArgs = #["-Og", "-g"]
Lake.BuildType.relWithDebInfo.leancArgs = #["-O3", "-g", "-DNDEBUG"]
Lake.BuildType.minSizeRel.leancArgs = #["-Os", "-DNDEBUG"]
Lake.BuildType.release.leancArgs = #["-O3", "-DNDEBUG"]

source

def Lake.BuildType.ofString? (s : String) :

Option BuildType

Equations

Lake.BuildType.ofString? "debug" = some Lake.BuildType.debug
Lake.BuildType.ofString? "relWithDebInfo" = some Lake.BuildType.relWithDebInfo
Lake.BuildType.ofString? "minSizeRel" = some Lake.BuildType.minSizeRel
Lake.BuildType.ofString? "release" = some Lake.BuildType.release
Lake.BuildType.ofString? s = none

source

def Lake.BuildType.toString (bt : BuildType) :

String

Equations

Lake.BuildType.debug.toString = "debug"
Lake.BuildType.relWithDebInfo.toString = "relWithDebInfo"
Lake.BuildType.minSizeRel.toString = "minSizeRel"
Lake.BuildType.release.toString = "release"

source

instance Lake.instToStringBuildType :

ToString BuildType

Equations

Lake.instToStringBuildType = { toString := Lake.BuildType.toString }

source

structure Lake.LeanOption :

Type

An option that is used by Lean as if it was passed using -D.

name : Lean.Name
The option's name.
value : Lean.LeanOptionValue
The option's value.

Instances For

source

instance Lake.instInhabitedLeanOption :

Inhabited LeanOption

Equations

Lake.instInhabitedLeanOption = { default := { name := default, value := default } }

source

instance Lake.instReprLeanOption :

Repr LeanOption

Equations

Lake.instReprLeanOption = { reprPrec := Lake.reprLeanOption✝ }

source

def Lake.LeanOption.asCliArg (o : LeanOption) :

String

Formats the lean option as a CLI argument using the -D flag.

Equations

o.asCliArg = toString "-D" ++ toString o.name ++ toString "=" ++ toString o.value.asCliFlagValue ++ toString ""

source

structure Lake.LeanConfig :

Type

Configuration options common to targets that build modules.

buildType : BuildType
The mode in which the modules should be built (e.g., debug, release). Defaults to release.
leanOptions : Array LeanOption
An Array of additional options to pass to both the Lean language server (i.e., lean --server) launched by lake serve and to lean when compiling a module's Lean source files.
moreLeanArgs : Array String
Additional arguments to pass to lean when compiling a module's Lean source files.
weakLeanArgs : Array String
Additional arguments to pass to lean when compiling a module's Lean source files.
Unlike moreLeanArgs, these arguments do not affect the trace of the build result, so they can be changed without triggering a rebuild. They come before moreLeanArgs.
moreLeancArgs : Array String
Additional arguments to pass to leanc when compiling a module's C source files generated by lean.
Lake already passes some flags based on the buildType, but you can change this by, for example, adding -O0 and -UNDEBUG.
moreServerOptions : Array LeanOption
Additional options to pass to the Lean language server (i.e., lean --server) launched by lake serve.
weakLeancArgs : Array String
Additional arguments to pass to leanc when compiling a module's C source files generated by lean.
Unlike moreLeancArgs, these arguments do not affect the trace of the build result, so they can be changed without triggering a rebuild. They come before moreLeancArgs.
moreLinkObjs : TargetArray System.FilePath
Additional target objects to use when linking (both static and shared). These will come after the paths of native facets.
moreLinkLibs : TargetArray Dynlib
Additional target libraries to pass to leanc when linking (e.g., for shared libraries or binary executables). These will come after the paths of other link objects.
moreLinkArgs : Array String
Additional arguments to pass to leanc when linking (e.g., for shared libraries or binary executables). These will come after the paths of the linked objects.
weakLinkArgs : Array String
Additional arguments to pass to leanc when linking (e.g., for shared libraries or binary executables). These will come after the paths of the linked objects.
Unlike moreLinkArgs, these arguments do not affect the trace of the build result, so they can be changed without triggering a rebuild. They come before moreLinkArgs.
backend : Backend
Compiler backend that modules should be built using (e.g., C, LLVM). Defaults to C.
platformIndependent : Option Bool
Asserts whether Lake should assume Lean modules are platform-independent.
- If false, Lake will add System.Platform.target to the module traces within the code unit (e.g., package or library). This will force Lean code to be re-elaborated on different platforms.
- If true, Lake will exclude platform-dependent elements (e.g., precompiled modules, external libraries) from a module's trace, preventing re-elaboration on different platforms. Note that this will not effect modules outside the code unit in question. For example, a platform-independent package which depends on a platform-dependent library will still be platform-dependent.
- If none, Lake will construct traces as natural. That is, it will include platform-dependent artifacts in the trace if they module depends on them, but otherwise not force modules to be platform-dependent.
There is no check for correctness here, so a configuration can lie and Lake will not catch it. Defaults to none.
dynlibs : TargetArray Dynlib
plugins : TargetArray Dynlib