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

full_name: Lake.LeanExe.config
code: /-- A Lean executable -- its package plus its configuration. -/
structure LeanExe where
  /-- The package the executable belongs to. -/
  pkg : Package
   /-- The executable's user-defined configuration. -/
  config : LeanExeConfig
goal: Lake.LeanExeConfig

full_name: Lake.LeanExe
code: /-- A Lean executable -- its package plus its configuration. -/
structure LeanExe where
  /-- The package the executable belongs to. -/
  pkg : Package
   /-- The executable's user-defined configuration. -/
  config : LeanExeConfig
goal: Type

full_name: Lake.LeanExe.pkg
code: /-- A Lean executable -- its package plus its configuration. -/
structure LeanExe where
  /-- The package the executable belongs to. -/
  pkg : Package
   /-- The executable's user-defined configuration. -/
  config : LeanExeConfig
goal: Lake.Package

full_name: Lake.Package.leanExes
code: /-- The Lean executables of the package (as an Array). -/
@[inline] def Package.leanExes (self : Package) : Array LeanExe 
goal: Array Lake.LeanExe

full_name: Lake.Package.findLeanExe?
code: /-- Try to find a Lean executable in the package with the given name. -/
@[inline] def Package.findLeanExe? (name : Name) (self : Package) : Option LeanExe 
goal: Option Lake.LeanExe

full_name: Lake.LeanExeConfig.toLeanLibConfig
code: /--
Converts the executable configuration into a library
with a single module (the root).
-/
def LeanExeConfig.toLeanLibConfig (self : LeanExeConfig) : LeanLibConfig 
goal: Lake.LeanLibConfig

full_name: Lake.LeanExe.name
code: /-- The executable's well-formed name. -/
@[inline] def name (self : LeanExe) : Name 
goal: Lake.Name

full_name: Lake.LeanExe.toLeanLib
code: /-- Converts the executable into a library with a single module (the root). -/
@[inline] def toLeanLib (self : LeanExe) : LeanLib 
goal: Lake.LeanLib

full_name: Lake.LeanExe.root
code: /-- The executable's root module. -/
@[inline] def root (self : LeanExe) : Module 
goal: Lake.Module

full_name: Lake.LeanExe.isRoot?
code: /-- Return the the root module if the name matches, otherwise return none. -/
def isRoot? (name : Name) (self : LeanExe) : Option Module 
goal: Option Lake.Module

full_name: Lake.LeanExe.fileName
code: /--
The file name of binary executable
(i.e., `exeName` plus the platform's `exeExtension`).
-/
@[inline] def fileName (self : LeanExe) : FilePath 
goal: Lake.FilePath

full_name: Lake.LeanExe.file
code: /-- The path to the executable in the package's `binDir`. -/
@[inline] def file (self : LeanExe) : FilePath 
goal: Lake.FilePath

full_name: Lake.LeanExe.supportInterpreter
code: /-- The executable's `supportInterpreter` configuration. -/
@[inline] def supportInterpreter (self : LeanExe) : Bool 
goal: Bool

full_name: Lake.LeanExe.linkArgs
code: /--
The arguments to pass to `leanc` when linking the binary executable.
By default, the package's plus the executable's `moreLinkArgs`.

If `supportInterpreter := true`, Lake links directly to the Lean shared
libraries on Windows by prepending `-leanshared` and adds `-rdynamic` on
other systems.
-/
def linkArgs (self : LeanExe) : Array String 
goal: Array String

full_name: Lake.LeanExe.weakLinkArgs
code: /--
The arguments to weakly pass to `leanc` when linking the binary executable.
That is, the package's `weakLinkArgs` plus the executable's  `weakLinkArgs`.
-/
@[inline] def weakLinkArgs (self : LeanExe) : Array String 
goal: Array String

full_name: Lake.Package.findTargetModule?
code: /-- Locate the named, buildable, but not necessarily importable, module in the package. -/
def Package.findTargetModule? (mod : Name) (self : Package) : Option Module 
goal: Option Lake.Module