File: .lake/packages/lean4/src/lean/lake/Lake/Config/LeanConfig.lean

full_name: Lake.instDecidableEqBuildType
code: /--
Lake equivalent of CMake's
[`CMAKE_BUILD_TYPE`](https://stackoverflow.com/a/59314670).
-/
inductive 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.
  -/
  | debug
  /--
  Optimized, *with* debug info, but no debug code or asserts
  (e.g., passes `-O3 -g -DNDEBUG` when compiling C code).
  -/
  | relWithDebInfo
  /--
  Same as `release` but optimizing for size rather than speed
  (e.g., passes `-Os -DNDEBUG` when compiling C code).
  -/
  | minSizeRel
  /--
  High optimization level and no debug info, code, or asserts
  (e.g., passes `-O3 -DNDEBUG` when compiling C code).
  -/
  | release
deriving Inhabited, Repr, DecidableEq, Ord
goal: DecidableEq Lake.BuildType

full_name: Lake.instInhabitedBuildType
code: /--
Lake equivalent of CMake's
[`CMAKE_BUILD_TYPE`](https://stackoverflow.com/a/59314670).
-/
inductive 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.
  -/
  | debug
  /--
  Optimized, *with* debug info, but no debug code or asserts
  (e.g., passes `-O3 -g -DNDEBUG` when compiling C code).
  -/
  | relWithDebInfo
  /--
  Same as `release` but optimizing for size rather than speed
  (e.g., passes `-Os -DNDEBUG` when compiling C code).
  -/
  | minSizeRel
  /--
  High optimization level and no debug info, code, or asserts
  (e.g., passes `-O3 -DNDEBUG` when compiling C code).
  -/
  | release
deriving Inhabited, Repr, DecidableEq, Ord
goal: Inhabited Lake.BuildType

full_name: Lake.BuildType
code: /--
Lake equivalent of CMake's
[`CMAKE_BUILD_TYPE`](https://stackoverflow.com/a/59314670).
-/
inductive 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.
  -/
  | debug
  /--
  Optimized, *with* debug info, but no debug code or asserts
  (e.g., passes `-O3 -g -DNDEBUG` when compiling C code).
  -/
  | relWithDebInfo
  /--
  Same as `release` but optimizing for size rather than speed
  (e.g., passes `-Os -DNDEBUG` when compiling C code).
  -/
  | minSizeRel
  /--
  High optimization level and no debug info, code, or asserts
  (e.g., passes `-O3 -DNDEBUG` when compiling C code).
  -/
  | release
deriving Inhabited, Repr, DecidableEq, Ord
goal: Type

full_name: Lake.BuildType.minSizeRel
code: /--
Lake equivalent of CMake's
[`CMAKE_BUILD_TYPE`](https://stackoverflow.com/a/59314670).
-/
inductive 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.
  -/
  | debug
  /--
  Optimized, *with* debug info, but no debug code or asserts
  (e.g., passes `-O3 -g -DNDEBUG` when compiling C code).
  -/
  | relWithDebInfo
  /--
  Same as `release` but optimizing for size rather than speed
  (e.g., passes `-Os -DNDEBUG` when compiling C code).
  -/
  | minSizeRel
  /--
  High optimization level and no debug info, code, or asserts
  (e.g., passes `-O3 -DNDEBUG` when compiling C code).
  -/
  | release
deriving Inhabited, Repr, DecidableEq, Ord
goal: Lake.BuildType

full_name: Lake.BuildType.relWithDebInfo
code: /--
Lake equivalent of CMake's
[`CMAKE_BUILD_TYPE`](https://stackoverflow.com/a/59314670).
-/
inductive 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.
  -/
  | debug
  /--
  Optimized, *with* debug info, but no debug code or asserts
  (e.g., passes `-O3 -g -DNDEBUG` when compiling C code).
  -/
  | relWithDebInfo
  /--
  Same as `release` but optimizing for size rather than speed
  (e.g., passes `-Os -DNDEBUG` when compiling C code).
  -/
  | minSizeRel
  /--
  High optimization level and no debug info, code, or asserts
  (e.g., passes `-O3 -DNDEBUG` when compiling C code).
  -/
  | release
deriving Inhabited, Repr, DecidableEq, Ord
goal: Lake.BuildType

full_name: Lake.BuildType.debug
code: /--
Lake equivalent of CMake's
[`CMAKE_BUILD_TYPE`](https://stackoverflow.com/a/59314670).
-/
inductive 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.
  -/
  | debug
  /--
  Optimized, *with* debug info, but no debug code or asserts
  (e.g., passes `-O3 -g -DNDEBUG` when compiling C code).
  -/
  | relWithDebInfo
  /--
  Same as `release` but optimizing for size rather than speed
  (e.g., passes `-Os -DNDEBUG` when compiling C code).
  -/
  | minSizeRel
  /--
  High optimization level and no debug info, code, or asserts
  (e.g., passes `-O3 -DNDEBUG` when compiling C code).
  -/
  | release
deriving Inhabited, Repr, DecidableEq, Ord
goal: Lake.BuildType

full_name: Lake.instReprBuildType
code: /--
Lake equivalent of CMake's
[`CMAKE_BUILD_TYPE`](https://stackoverflow.com/a/59314670).
-/
inductive 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.
  -/
  | debug
  /--
  Optimized, *with* debug info, but no debug code or asserts
  (e.g., passes `-O3 -g -DNDEBUG` when compiling C code).
  -/
  | relWithDebInfo
  /--
  Same as `release` but optimizing for size rather than speed
  (e.g., passes `-Os -DNDEBUG` when compiling C code).
  -/
  | minSizeRel
  /--
  High optimization level and no debug info, code, or asserts
  (e.g., passes `-O3 -DNDEBUG` when compiling C code).
  -/
  | release
deriving Inhabited, Repr, DecidableEq, Ord
goal: Repr Lake.BuildType

full_name: Lake.instOrdBuildType
code: /--
Lake equivalent of CMake's
[`CMAKE_BUILD_TYPE`](https://stackoverflow.com/a/59314670).
-/
inductive 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.
  -/
  | debug
  /--
  Optimized, *with* debug info, but no debug code or asserts
  (e.g., passes `-O3 -g -DNDEBUG` when compiling C code).
  -/
  | relWithDebInfo
  /--
  Same as `release` but optimizing for size rather than speed
  (e.g., passes `-Os -DNDEBUG` when compiling C code).
  -/
  | minSizeRel
  /--
  High optimization level and no debug info, code, or asserts
  (e.g., passes `-O3 -DNDEBUG` when compiling C code).
  -/
  | release
deriving Inhabited, Repr, DecidableEq, Ord
goal: Ord Lake.BuildType

full_name: Lake.BuildType.release
code: /--
Lake equivalent of CMake's
[`CMAKE_BUILD_TYPE`](https://stackoverflow.com/a/59314670).
-/
inductive 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.
  -/
  | debug
  /--
  Optimized, *with* debug info, but no debug code or asserts
  (e.g., passes `-O3 -g -DNDEBUG` when compiling C code).
  -/
  | relWithDebInfo
  /--
  Same as `release` but optimizing for size rather than speed
  (e.g., passes `-Os -DNDEBUG` when compiling C code).
  -/
  | minSizeRel
  /--
  High optimization level and no debug info, code, or asserts
  (e.g., passes `-O3 -DNDEBUG` when compiling C code).
  -/
  | release
deriving Inhabited, Repr, DecidableEq, Ord
goal: Lake.BuildType

full_name: Lake.instLTBuildType
code: /--
Ordering on build types. The ordering is used to determine
the *minimum* build version that is necessary for a build.
-/
instance : LT BuildType 
goal: LT Lake.BuildType

full_name: Lake.instLEBuildType
code: instance : LE BuildType 
goal: LE Lake.BuildType

full_name: Lake.instMinBuildType
code: instance : Min BuildType 
goal: Min Lake.BuildType

full_name: Lake.instMaxBuildType
code: instance : Max BuildType 
goal: Max Lake.BuildType

full_name: Lake.Backend.default
code: /--
Compiler backend with which to compile Lean.
-/
inductive Backend
  /--
  Force the C backend.
  -/
  | c
  /--
  Force the LLVM backend.
  -/
  | llvm
  /--
  Use the default backend. Can be overridden by more specific configuration.
  -/
  | default
deriving Repr, DecidableEq
goal: Lake.Backend

full_name: Lake.Backend.llvm
code: /--
Compiler backend with which to compile Lean.
-/
inductive Backend
  /--
  Force the C backend.
  -/
  | c
  /--
  Force the LLVM backend.
  -/
  | llvm
  /--
  Use the default backend. Can be overridden by more specific configuration.
  -/
  | default
deriving Repr, DecidableEq
goal: Lake.Backend

full_name: Lake.Backend.c
code: /--
Compiler backend with which to compile Lean.
-/
inductive Backend
  /--
  Force the C backend.
  -/
  | c
  /--
  Force the LLVM backend.
  -/
  | llvm
  /--
  Use the default backend. Can be overridden by more specific configuration.
  -/
  | default
deriving Repr, DecidableEq
goal: Lake.Backend

full_name: Lake.instDecidableEqBackend
code: /--
Compiler backend with which to compile Lean.
-/
inductive Backend
  /--
  Force the C backend.
  -/
  | c
  /--
  Force the LLVM backend.
  -/
  | llvm
  /--
  Use the default backend. Can be overridden by more specific configuration.
  -/
  | default
deriving Repr, DecidableEq
goal: DecidableEq Lake.Backend

full_name: Lake.instReprBackend
code: /--
Compiler backend with which to compile Lean.
-/
inductive Backend
  /--
  Force the C backend.
  -/
  | c
  /--
  Force the LLVM backend.
  -/
  | llvm
  /--
  Use the default backend. Can be overridden by more specific configuration.
  -/
  | default
deriving Repr, DecidableEq
goal: Repr Lake.Backend

full_name: Lake.Backend
code: /--
Compiler backend with which to compile Lean.
-/
inductive Backend
  /--
  Force the C backend.
  -/
  | c
  /--
  Force the LLVM backend.
  -/
  | llvm
  /--
  Use the default backend. Can be overridden by more specific configuration.
  -/
  | default
deriving Repr, DecidableEq
goal: Type

full_name: Lake.instInhabitedBackend
code: instance : Inhabited Backend 
goal: Inhabited Lake.Backend

full_name: Lake.Backend.ofString?
code: def Backend.ofString? (s : String) : Option Backend 
goal: Option Lake.Backend

full_name: Lake.Backend.toString
code: protected def Backend.toString (bt : Backend) : String 
goal: String

full_name: Lake.instToStringBackend
code: instance : ToString Backend 
goal: ToString Lake.Backend

full_name: Lake.Backend.orPreferLeft
code: /--
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.
-/
def Backend.orPreferLeft : Backend → Backend → Backend

goal: Lake.Backend → Lake.Backend → Lake.Backend

full_name: Lake.BuildType.leancArgs
code: /-- The arguments to pass to `leanc` based on the build type. -/
def BuildType.leancArgs : BuildType → Array String

goal: Lake.BuildType → Array String

full_name: Lake.BuildType.ofString?
code: def BuildType.ofString? (s : String) : Option BuildType 
goal: Option Lake.BuildType

full_name: Lake.BuildType.toString
code: protected def BuildType.toString (bt : BuildType) : String 
goal: String

full_name: Lake.instToStringBuildType
code: instance : ToString BuildType 
goal: ToString Lake.BuildType

full_name: Lake.instReprLeanOption
code: /-- Option that is used by Lean as if it was passed using `-D`. -/
structure LeanOption where
  name  : Lean.Name
  value : Lean.LeanOptionValue
  deriving Inhabited, Repr
goal: Repr Lake.LeanOption

full_name: Lake.LeanOption.value
code: /-- Option that is used by Lean as if it was passed using `-D`. -/
structure LeanOption where
  name  : Lean.Name
  value : Lean.LeanOptionValue
  deriving Inhabited, Repr
goal: Lean.LeanOptionValue

full_name: Lake.LeanOption.name
code: /-- Option that is used by Lean as if it was passed using `-D`. -/
structure LeanOption where
  name  : Lean.Name
  value : Lean.LeanOptionValue
  deriving Inhabited, Repr
goal: Lean.Name

full_name: Lake.instInhabitedLeanOption
code: /-- Option that is used by Lean as if it was passed using `-D`. -/
structure LeanOption where
  name  : Lean.Name
  value : Lean.LeanOptionValue
  deriving Inhabited, Repr
goal: Inhabited Lake.LeanOption

full_name: Lake.LeanOption
code: /-- Option that is used by Lean as if it was passed using `-D`. -/
structure LeanOption where
  name  : Lean.Name
  value : Lean.LeanOptionValue
  deriving Inhabited, Repr
goal: Type

full_name: Lake.LeanOption.asCliArg
code: /-- Formats the lean option as a CLI argument using the `-D` flag. -/
def LeanOption.asCliArg (o : LeanOption) : String 
goal: String

full_name: Lake.LeanConfig.moreLinkArgs
code: /-- Configuration options common to targets that build modules. -/
structure LeanConfig where
  /--
  The mode in which the modules should be built (e.g., `debug`, `release`).
  Defaults to `release`.
  -/
  buildType : BuildType := .release
  /--
  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.
  -/
  leanOptions : Array LeanOption := #[]
  /--
  Additional arguments to pass 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.

  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`.
  -/
  weakLeanArgs : 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`.
  -/
  moreLeancArgs : Array String := #[]
  /--
  Additional options to pass to the Lean language server
  (i.e., `lean --server`) launched by `lake serve`.
  -/
  moreServerOptions : Array LeanOption := #[]
  /--
  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`.
  -/
  weakLeancArgs : 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
  external libraries.
  -/
  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
  external libraries.

  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`.
  -/
  weakLinkArgs : Array String := #[]
  /--
  Compiler backend that modules should be built using (e.g., `C`, `LLVM`).
  Defaults to `C`.
  -/
  backend : Backend := .default
  /--
  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`.
  -/
  platformIndependent : Option Bool := none
deriving Inhabited, Repr
goal: Array String

full_name: Lake.LeanConfig.moreServerOptions
code: /-- Configuration options common to targets that build modules. -/
structure LeanConfig where
  /--
  The mode in which the modules should be built (e.g., `debug`, `release`).
  Defaults to `release`.
  -/
  buildType : BuildType := .release
  /--
  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.
  -/
  leanOptions : Array LeanOption := #[]
  /--
  Additional arguments to pass 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.

  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`.
  -/
  weakLeanArgs : 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`.
  -/
  moreLeancArgs : Array String := #[]
  /--
  Additional options to pass to the Lean language server
  (i.e., `lean --server`) launched by `lake serve`.
  -/
  moreServerOptions : Array LeanOption := #[]
  /--
  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`.
  -/
  weakLeancArgs : 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
  external libraries.
  -/
  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
  external libraries.

  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`.
  -/
  weakLinkArgs : Array String := #[]
  /--
  Compiler backend that modules should be built using (e.g., `C`, `LLVM`).
  Defaults to `C`.
  -/
  backend : Backend := .default
  /--
  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`.
  -/
  platformIndependent : Option Bool := none
deriving Inhabited, Repr
goal: Array Lake.LeanOption

full_name: Lake.LeanConfig.weakLeanArgs
code: /-- Configuration options common to targets that build modules. -/
structure LeanConfig where
  /--
  The mode in which the modules should be built (e.g., `debug`, `release`).
  Defaults to `release`.
  -/
  buildType : BuildType := .release
  /--
  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.
  -/
  leanOptions : Array LeanOption := #[]
  /--
  Additional arguments to pass 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.

  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`.
  -/
  weakLeanArgs : 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`.
  -/
  moreLeancArgs : Array String := #[]
  /--
  Additional options to pass to the Lean language server
  (i.e., `lean --server`) launched by `lake serve`.
  -/
  moreServerOptions : Array LeanOption := #[]
  /--
  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`.
  -/
  weakLeancArgs : 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
  external libraries.
  -/
  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
  external libraries.

  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`.
  -/
  weakLinkArgs : Array String := #[]
  /--
  Compiler backend that modules should be built using (e.g., `C`, `LLVM`).
  Defaults to `C`.
  -/
  backend : Backend := .default
  /--
  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`.
  -/
  platformIndependent : Option Bool := none
deriving Inhabited, Repr
goal: Array String

full_name: Lake.LeanConfig
code: /-- Configuration options common to targets that build modules. -/
structure LeanConfig where
  /--
  The mode in which the modules should be built (e.g., `debug`, `release`).
  Defaults to `release`.
  -/
  buildType : BuildType := .release
  /--
  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.
  -/
  leanOptions : Array LeanOption := #[]
  /--
  Additional arguments to pass 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.

  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`.
  -/
  weakLeanArgs : 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`.
  -/
  moreLeancArgs : Array String := #[]
  /--
  Additional options to pass to the Lean language server
  (i.e., `lean --server`) launched by `lake serve`.
  -/
  moreServerOptions : Array LeanOption := #[]
  /--
  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`.
  -/
  weakLeancArgs : 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
  external libraries.
  -/
  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
  external libraries.

  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`.
  -/
  weakLinkArgs : Array String := #[]
  /--
  Compiler backend that modules should be built using (e.g., `C`, `LLVM`).
  Defaults to `C`.
  -/
  backend : Backend := .default
  /--
  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`.
  -/
  platformIndependent : Option Bool := none
deriving Inhabited, Repr
goal: Type

full_name: Lake.LeanConfig.buildType
code: /-- Configuration options common to targets that build modules. -/
structure LeanConfig where
  /--
  The mode in which the modules should be built (e.g., `debug`, `release`).
  Defaults to `release`.
  -/
  buildType : BuildType := .release
  /--
  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.
  -/
  leanOptions : Array LeanOption := #[]
  /--
  Additional arguments to pass 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.

  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`.
  -/
  weakLeanArgs : 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`.
  -/
  moreLeancArgs : Array String := #[]
  /--
  Additional options to pass to the Lean language server
  (i.e., `lean --server`) launched by `lake serve`.
  -/
  moreServerOptions : Array LeanOption := #[]
  /--
  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`.
  -/
  weakLeancArgs : 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
  external libraries.
  -/
  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
  external libraries.

  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`.
  -/
  weakLinkArgs : Array String := #[]
  /--
  Compiler backend that modules should be built using (e.g., `C`, `LLVM`).
  Defaults to `C`.
  -/
  backend : Backend := .default
  /--
  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`.
  -/
  platformIndependent : Option Bool := none
deriving Inhabited, Repr
goal: Lake.BuildType

full_name: Lake.LeanConfig.moreLeancArgs
code: /-- Configuration options common to targets that build modules. -/
structure LeanConfig where
  /--
  The mode in which the modules should be built (e.g., `debug`, `release`).
  Defaults to `release`.
  -/
  buildType : BuildType := .release
  /--
  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.
  -/
  leanOptions : Array LeanOption := #[]
  /--
  Additional arguments to pass 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.

  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`.
  -/
  weakLeanArgs : 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`.
  -/
  moreLeancArgs : Array String := #[]
  /--
  Additional options to pass to the Lean language server
  (i.e., `lean --server`) launched by `lake serve`.
  -/
  moreServerOptions : Array LeanOption := #[]
  /--
  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`.
  -/
  weakLeancArgs : 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
  external libraries.
  -/
  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
  external libraries.

  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`.
  -/
  weakLinkArgs : Array String := #[]
  /--
  Compiler backend that modules should be built using (e.g., `C`, `LLVM`).
  Defaults to `C`.
  -/
  backend : Backend := .default
  /--
  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`.
  -/
  platformIndependent : Option Bool := none
deriving Inhabited, Repr
goal: Array String

full_name: Lake.instInhabitedLeanConfig
code: /-- Configuration options common to targets that build modules. -/
structure LeanConfig where
  /--
  The mode in which the modules should be built (e.g., `debug`, `release`).
  Defaults to `release`.
  -/
  buildType : BuildType := .release
  /--
  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.
  -/
  leanOptions : Array LeanOption := #[]
  /--
  Additional arguments to pass 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.

  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`.
  -/
  weakLeanArgs : 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`.
  -/
  moreLeancArgs : Array String := #[]
  /--
  Additional options to pass to the Lean language server
  (i.e., `lean --server`) launched by `lake serve`.
  -/
  moreServerOptions : Array LeanOption := #[]
  /--
  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`.
  -/
  weakLeancArgs : 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
  external libraries.
  -/
  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
  external libraries.

  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`.
  -/
  weakLinkArgs : Array String := #[]
  /--
  Compiler backend that modules should be built using (e.g., `C`, `LLVM`).
  Defaults to `C`.
  -/
  backend : Backend := .default
  /--
  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`.
  -/
  platformIndependent : Option Bool := none
deriving Inhabited, Repr
goal: Inhabited Lake.LeanConfig

full_name: Lake.LeanConfig.leanOptions
code: /-- Configuration options common to targets that build modules. -/
structure LeanConfig where
  /--
  The mode in which the modules should be built (e.g., `debug`, `release`).
  Defaults to `release`.
  -/
  buildType : BuildType := .release
  /--
  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.
  -/
  leanOptions : Array LeanOption := #[]
  /--
  Additional arguments to pass 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.

  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`.
  -/
  weakLeanArgs : 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`.
  -/
  moreLeancArgs : Array String := #[]
  /--
  Additional options to pass to the Lean language server
  (i.e., `lean --server`) launched by `lake serve`.
  -/
  moreServerOptions : Array LeanOption := #[]
  /--
  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`.
  -/
  weakLeancArgs : 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
  external libraries.
  -/
  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
  external libraries.

  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`.
  -/
  weakLinkArgs : Array String := #[]
  /--
  Compiler backend that modules should be built using (e.g., `C`, `LLVM`).
  Defaults to `C`.
  -/
  backend : Backend := .default
  /--
  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`.
  -/
  platformIndependent : Option Bool := none
deriving Inhabited, Repr
goal: Array Lake.LeanOption

full_name: Lake.LeanConfig.weakLeancArgs
code: /-- Configuration options common to targets that build modules. -/
structure LeanConfig where
  /--
  The mode in which the modules should be built (e.g., `debug`, `release`).
  Defaults to `release`.
  -/
  buildType : BuildType := .release
  /--
  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.
  -/
  leanOptions : Array LeanOption := #[]
  /--
  Additional arguments to pass 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.

  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`.
  -/
  weakLeanArgs : 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`.
  -/
  moreLeancArgs : Array String := #[]
  /--
  Additional options to pass to the Lean language server
  (i.e., `lean --server`) launched by `lake serve`.
  -/
  moreServerOptions : Array LeanOption := #[]
  /--
  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`.
  -/
  weakLeancArgs : 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
  external libraries.
  -/
  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
  external libraries.

  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`.
  -/
  weakLinkArgs : Array String := #[]
  /--
  Compiler backend that modules should be built using (e.g., `C`, `LLVM`).
  Defaults to `C`.
  -/
  backend : Backend := .default
  /--
  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`.
  -/
  platformIndependent : Option Bool := none
deriving Inhabited, Repr
goal: Array String

full_name: Lake.LeanConfig.weakLinkArgs
code: /-- Configuration options common to targets that build modules. -/
structure LeanConfig where
  /--
  The mode in which the modules should be built (e.g., `debug`, `release`).
  Defaults to `release`.
  -/
  buildType : BuildType := .release
  /--
  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.
  -/
  leanOptions : Array LeanOption := #[]
  /--
  Additional arguments to pass 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.

  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`.
  -/
  weakLeanArgs : 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`.
  -/
  moreLeancArgs : Array String := #[]
  /--
  Additional options to pass to the Lean language server
  (i.e., `lean --server`) launched by `lake serve`.
  -/
  moreServerOptions : Array LeanOption := #[]
  /--
  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`.
  -/
  weakLeancArgs : 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
  external libraries.
  -/
  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
  external libraries.

  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`.
  -/
  weakLinkArgs : Array String := #[]
  /--
  Compiler backend that modules should be built using (e.g., `C`, `LLVM`).
  Defaults to `C`.
  -/
  backend : Backend := .default
  /--
  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`.
  -/
  platformIndependent : Option Bool := none
deriving Inhabited, Repr
goal: Array String

full_name: Lake.LeanConfig.backend
code: /-- Configuration options common to targets that build modules. -/
structure LeanConfig where
  /--
  The mode in which the modules should be built (e.g., `debug`, `release`).
  Defaults to `release`.
  -/
  buildType : BuildType := .release
  /--
  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.
  -/
  leanOptions : Array LeanOption := #[]
  /--
  Additional arguments to pass 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.

  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`.
  -/
  weakLeanArgs : 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`.
  -/
  moreLeancArgs : Array String := #[]
  /--
  Additional options to pass to the Lean language server
  (i.e., `lean --server`) launched by `lake serve`.
  -/
  moreServerOptions : Array LeanOption := #[]
  /--
  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`.
  -/
  weakLeancArgs : 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
  external libraries.
  -/
  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
  external libraries.

  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`.
  -/
  weakLinkArgs : Array String := #[]
  /--
  Compiler backend that modules should be built using (e.g., `C`, `LLVM`).
  Defaults to `C`.
  -/
  backend : Backend := .default
  /--
  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`.
  -/
  platformIndependent : Option Bool := none
deriving Inhabited, Repr
goal: Lake.Backend

full_name: Lake.LeanConfig.platformIndependent
code: /-- Configuration options common to targets that build modules. -/
structure LeanConfig where
  /--
  The mode in which the modules should be built (e.g., `debug`, `release`).
  Defaults to `release`.
  -/
  buildType : BuildType := .release
  /--
  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.
  -/
  leanOptions : Array LeanOption := #[]
  /--
  Additional arguments to pass 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.

  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`.
  -/
  weakLeanArgs : 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`.
  -/
  moreLeancArgs : Array String := #[]
  /--
  Additional options to pass to the Lean language server
  (i.e., `lean --server`) launched by `lake serve`.
  -/
  moreServerOptions : Array LeanOption := #[]
  /--
  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`.
  -/
  weakLeancArgs : 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
  external libraries.
  -/
  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
  external libraries.

  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`.
  -/
  weakLinkArgs : Array String := #[]
  /--
  Compiler backend that modules should be built using (e.g., `C`, `LLVM`).
  Defaults to `C`.
  -/
  backend : Backend := .default
  /--
  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`.
  -/
  platformIndependent : Option Bool := none
deriving Inhabited, Repr
goal: Option Bool

full_name: Lake.LeanConfig.moreLeanArgs
code: /-- Configuration options common to targets that build modules. -/
structure LeanConfig where
  /--
  The mode in which the modules should be built (e.g., `debug`, `release`).
  Defaults to `release`.
  -/
  buildType : BuildType := .release
  /--
  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.
  -/
  leanOptions : Array LeanOption := #[]
  /--
  Additional arguments to pass 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.

  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`.
  -/
  weakLeanArgs : 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`.
  -/
  moreLeancArgs : Array String := #[]
  /--
  Additional options to pass to the Lean language server
  (i.e., `lean --server`) launched by `lake serve`.
  -/
  moreServerOptions : Array LeanOption := #[]
  /--
  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`.
  -/
  weakLeancArgs : 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
  external libraries.
  -/
  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
  external libraries.

  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`.
  -/
  weakLinkArgs : Array String := #[]
  /--
  Compiler backend that modules should be built using (e.g., `C`, `LLVM`).
  Defaults to `C`.
  -/
  backend : Backend := .default
  /--
  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`.
  -/
  platformIndependent : Option Bool := none
deriving Inhabited, Repr
goal: Array String

full_name: Lake.instReprLeanConfig
code: /-- Configuration options common to targets that build modules. -/
structure LeanConfig where
  /--
  The mode in which the modules should be built (e.g., `debug`, `release`).
  Defaults to `release`.
  -/
  buildType : BuildType := .release
  /--
  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.
  -/
  leanOptions : Array LeanOption := #[]
  /--
  Additional arguments to pass 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.

  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`.
  -/
  weakLeanArgs : 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`.
  -/
  moreLeancArgs : Array String := #[]
  /--
  Additional options to pass to the Lean language server
  (i.e., `lean --server`) launched by `lake serve`.
  -/
  moreServerOptions : Array LeanOption := #[]
  /--
  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`.
  -/
  weakLeancArgs : 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
  external libraries.
  -/
  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
  external libraries.

  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`.
  -/
  weakLinkArgs : Array String := #[]
  /--
  Compiler backend that modules should be built using (e.g., `C`, `LLVM`).
  Defaults to `C`.
  -/
  backend : Backend := .default
  /--
  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`.
  -/
  platformIndependent : Option Bool := none
deriving Inhabited, Repr
goal: Repr Lake.LeanConfig