Lake Configuration Monads

Definitions and helpers for interacting with the Lake configuration monads.

@[inline, reducible]

abbrev Lake.MonadLakeEnv (m : Type → Type u) : Type u

A monad equipped with a (read-only) detected environment for Lake.

Equations

• Lake.MonadLakeEnv m = MonadReaderOf Lake.Env m

@[inline, reducible]

abbrev Lake.MonadWorkspace (m : Type → Type u) : Type u

A monad equipped with a (read-only) Lake Workspace.

Equations

• Lake.MonadWorkspace m = MonadReaderOf Lake.Workspace m

@[inline, reducible]

abbrev Lake.MonadLake (m : Type → Type u) : Type u

A monad equipped with a (read-only) Lake context.

Equations

• Lake.MonadLake m = MonadReaderOf Lake.Context m

@[inline]

def Lake.mkLakeContext (ws : Lake.Workspace) : Lake.Context

Make a Lake.Context from a Workspace.

Equations

• Lake.mkLakeContext ws = { opaqueWs := Lake.OpaqueWorkspace.mk ws }

instance Lake.instMonadLake {m : Type → Type u_1} [Lake.MonadWorkspace m] [Functor m] : Lake.MonadLake m

Equations

• Lake.instMonadLake = { read := (fun x => Lake.mkLakeContext x) <$> read }

@[inline]

def Lake.Context.workspace (self : Lake.Context) : Lake.Workspace

Equations

• Lake.Context.workspace self = Lake.OpaqueWorkspace.get self.opaqueWs

instance Lake.instMonadWorkspace {m : Type → Type u_1} [Lake.MonadLake m] [Functor m] : Lake.MonadWorkspace m

Equations

• Lake.instMonadWorkspace = { read := (fun x => Lake.Context.workspace x) <$> read }

instance Lake.instMonadLakeEnv {m : Type → Type u_1} [Lake.MonadWorkspace m] [Functor m] : Lake.MonadLakeEnv m

Equations

• Lake.instMonadLakeEnv = { read := (fun x => x.lakeEnv) <$> read }

Workspace Helpers

@[inline]

def Lake.getWorkspace {m : Type → Type u_1} [Lake.MonadWorkspace m] : m Lake.Workspace

Get the workspace of the context.

Equations

• Lake.getWorkspace = read

@[inline]

def Lake.getRootPackage {m : Type → Type u_1} [Lake.MonadWorkspace m] [Functor m] : m Lake.Package

Get the root package of the context's workspace.

Equations

• Lake.getRootPackage = (fun x => x.root) <$> read

@[inline]

def Lake.findPackage? {m : Type → Type u_1} [Lake.MonadWorkspace m] [Functor m] (name : Lake.Name) : m (Option (Lake.NPackage name))

Try to find a package within the workspace with the given name.

Equations

• Lake.findPackage? name = (fun x => Lake.Workspace.findPackage? name x) <$> Lake.getWorkspace

@[inline]

def Lake.findModule? {m : Type → Type u_1} [Lake.MonadWorkspace m] [Functor m] (name : Lake.Name) : m (Option Lake.Module)

Locate the named module in the workspace (if it is local to it).

Equations

• Lake.findModule? name = (fun x => Lake.Workspace.findModule? name x) <$> Lake.getWorkspace

@[inline]

def Lake.findLeanExe? {m : Type → Type u_1} [Lake.MonadWorkspace m] [Functor m] (name : Lake.Name) : m (Option Lake.LeanExe)

Try to find a Lean executable in the workspace with the given name.

Equations

• Lake.findLeanExe? name = (fun x => Lake.Workspace.findLeanExe? name x) <$> Lake.getWorkspace

@[inline]

def Lake.findLeanLib? {m : Type → Type u_1} [Lake.MonadWorkspace m] [Functor m] (name : Lake.Name) : m (Option Lake.LeanLib)

Try to find a Lean library in the workspace with the given name.

Equations

• Lake.findLeanLib? name = (fun x => Lake.Workspace.findLeanLib? name x) <$> Lake.getWorkspace

@[inline]

def Lake.findExternLib? {m : Type → Type u_1} [Lake.MonadWorkspace m] [Functor m] (name : Lake.Name) : m (Option Lake.ExternLib)

Try to find an external library in the workspace with the given name.

Equations

• Lake.findExternLib? name = (fun x => Lake.Workspace.findExternLib? name x) <$> Lake.getWorkspace

@[inline]

def Lake.getLeanPath {m : Type → Type u_1} [Lake.MonadWorkspace m] [Functor m] : m Lake.SearchPath

Get the paths added to LEAN_PATH by the context's workspace.

Equations

• Lake.getLeanPath = (fun x => Lake.Workspace.leanPath x) <$> Lake.getWorkspace

@[inline]

def Lake.getLeanSrcPath {m : Type → Type u_1} [Lake.MonadWorkspace m] [Functor m] : m Lake.SearchPath

Get the paths added to LEAN_SRC_PATH by the context's workspace.

Equations

• Lake.getLeanSrcPath = (fun x => Lake.Workspace.leanSrcPath x) <$> Lake.getWorkspace

@[inline]

def Lake.getSharedLibPath {m : Type → Type u_1} [Lake.MonadWorkspace m] [Functor m] : m Lake.SearchPath

Get the paths added to the shared library path by the context's workspace.

Equations

• Lake.getSharedLibPath = (fun x => Lake.Workspace.sharedLibPath x) <$> Lake.getWorkspace

@[inline]

def Lake.getAugmentedLeanPath {m : Type → Type u_1} [Lake.MonadWorkspace m] [Functor m] : m Lake.SearchPath

Get the augmented LEAN_PATH set by the context's workspace.

Equations

• Lake.getAugmentedLeanPath = (fun x => Lake.Workspace.augmentedLeanPath x) <$> Lake.getWorkspace

@[inline]

def Lake.getAugmentedLeanSrcPath {m : Type → Type u_1} [Lake.MonadWorkspace m] [Functor m] : m Lake.SearchPath

Get the augmented LEAN_SRC_PATH set by the context's workspace.

Equations

• Lake.getAugmentedLeanSrcPath = (fun x => Lake.Workspace.augmentedLeanSrcPath x) <$> Lake.getWorkspace

@[inline]

def Lake.getAugmentedSharedLibPath {m : Type → Type u_1} [Lake.MonadWorkspace m] [Functor m] : m Lake.SearchPath

Get the augmented shared library path set by the context's workspace.

Equations

• Lake.getAugmentedSharedLibPath = (fun x => Lake.Workspace.augmentedSharedLibPath x) <$> Lake.getWorkspace

@[inline]

def Lake.getAugmentedEnv {m : Type → Type u_1} [Lake.MonadWorkspace m] [Functor m] : m (Array (String × Option String))

Get the augmented environment variables set by the context's workspace.

Equations

• Lake.getAugmentedEnv = (fun x => Lake.Workspace.augmentedEnvVars x) <$> Lake.getWorkspace

Environment Helpers

@[inline]

def Lake.getLakeEnv {m : Type → Type u_1} [Lake.MonadLakeEnv m] : m Lake.Env

Equations

• Lake.getLakeEnv = read

@[inline]

def Lake.getElanToolchain {m : Type → Type u_1} [Lake.MonadLakeEnv m] [Functor m] : m String

Get the name of Elan toolchain for the Lake environment. Empty if none.

Equations

• Lake.getElanToolchain = (fun x => Lake.Env.toolchain x) <$> Lake.getLakeEnv

Search Path Helpers

@[inline]

def Lake.getEnvLeanPath {m : Type → Type u_1} [Lake.MonadLakeEnv m] [Functor m] : m Lake.SearchPath

Get the detected LEAN_PATH value of the Lake environment.

Equations

• Lake.getEnvLeanPath = (fun x => Lake.Env.leanPath x) <$> Lake.getLakeEnv

@[inline]

def Lake.getEnvLeanSrcPath {m : Type → Type u_1} [Lake.MonadLakeEnv m] [Functor m] : m Lake.SearchPath

Get the detected LEAN_SRC_PATH value of the Lake environment.

Equations

• Lake.getEnvLeanSrcPath = (fun x => Lake.Env.leanSrcPath x) <$> Lake.getLakeEnv

@[inline]

def Lake.getEnvSharedLibPath {m : Type → Type u_1} [Lake.MonadLakeEnv m] [Functor m] : m Lake.SearchPath

Get the detected sharedLibPathEnvVar value of the Lake environment.

Equations

• Lake.getEnvSharedLibPath = (fun x => Lake.Env.sharedLibPath x) <$> Lake.getLakeEnv

Elan Install Helpers

@[inline]

def Lake.getElanInstall? {m : Type → Type u_1} [Lake.MonadLakeEnv m] [Functor m] : m (Option Lake.ElanInstall)

Get the detected Elan installation (if one).

Equations

• Lake.getElanInstall? = (fun x => x.elan?) <$> Lake.getLakeEnv

@[inline]

def Lake.getElanHome? {m : Type → Type u_1} [Lake.MonadLakeEnv m] [Functor m] : m (Option Lake.FilePath)

Get the root directory of the detected Elan installation (i.e., ELAN_HOME).

Equations

• Lake.getElanHome? = (fun x => Option.map (fun x => x.home) x) <$> Lake.getElanInstall?

@[inline]

def Lake.getElan? {m : Type → Type u_1} [Lake.MonadLakeEnv m] [Functor m] : m (Option Lake.FilePath)

Get the path of the elan binary in the detected Elan installation.

Equations

• Lake.getElan? = (fun x => Option.map (fun x => x.elan) x) <$> Lake.getElanInstall?

Lean Install Helpers

@[inline]

def Lake.getLeanInstall {m : Type → Type u_1} [Lake.MonadLakeEnv m] [Functor m] : m Lake.LeanInstall

Get the detected Lean installation.

Equations

• Lake.getLeanInstall = (fun x => x.lean) <$> Lake.getLakeEnv

@[inline]

def Lake.getLeanSysroot {m : Type → Type u_1} [Lake.MonadLakeEnv m] [Functor m] : m Lake.FilePath

Get the root directory of the detected Lean installation.

Equations

• Lake.getLeanSysroot = (fun x => x.sysroot) <$> Lake.getLeanInstall

@[inline]

def Lake.getLeanSrcDir {m : Type → Type u_1} [Lake.MonadLakeEnv m] [Functor m] : m Lake.FilePath

Get the Lean source directory of the detected Lean installation.

Equations

• Lake.getLeanSrcDir = (fun x => x.srcDir) <$> Lake.getLeanInstall

@[inline]

def Lake.getLeanLibDir {m : Type → Type u_1} [Lake.MonadLakeEnv m] [Functor m] : m Lake.FilePath

Get the Lean library directory of the detected Lean installation.

Equations

• Lake.getLeanLibDir = (fun x => x.leanLibDir) <$> Lake.getLeanInstall

@[inline]

def Lake.getLeanIncludeDir {m : Type → Type u_1} [Lake.MonadLakeEnv m] [Functor m] : m Lake.FilePath

Get the C include directory of the detected Lean installation.

Equations

• Lake.getLeanIncludeDir = (fun x => x.includeDir) <$> Lake.getLeanInstall

@[inline]

def Lake.getLeanSystemLibDir {m : Type → Type u_1} [Lake.MonadLakeEnv m] [Functor m] : m Lake.FilePath

Get the system library directory of the detected Lean installation.

Equations

• Lake.getLeanSystemLibDir = (fun x => x.systemLibDir) <$> Lake.getLeanInstall

@[inline]

def Lake.getLean {m : Type → Type u_1} [Lake.MonadLakeEnv m] [Functor m] : m Lake.FilePath

Get the path of the lean binary in the detected Lean installation.

Equations

• Lake.getLean = (fun x => x.lean) <$> Lake.getLeanInstall

@[inline]

def Lake.getLeanc {m : Type → Type u_1} [Lake.MonadLakeEnv m] [Functor m] : m Lake.FilePath

Get the path of the leanc binary in the detected Lean installation.

Equations

• Lake.getLeanc = (fun x => x.leanc) <$> Lake.getLeanInstall

@[inline]

def Lake.getLeanSharedLib {m : Type → Type u_1} [Lake.MonadLakeEnv m] [Functor m] : m Lake.FilePath

Get the path of the libleanshared library in the detected Lean installation.

Equations

• Lake.getLeanSharedLib = (fun x => x.sharedLib) <$> Lake.getLeanInstall

@[inline]

def Lake.getLeanAr {m : Type → Type u_1} [Lake.MonadLakeEnv m] [Functor m] : m Lake.FilePath

Get the path of the ar binary in the detected Lean installation.

Equations

• Lake.getLeanAr = (fun x => x.ar) <$> Lake.getLeanInstall

@[inline]

def Lake.getLeanCc {m : Type → Type u_1} [Lake.MonadLakeEnv m] [Functor m] : m Lake.FilePath

Get the path of C compiler in the detected Lean installation.

Equations

• Lake.getLeanCc = (fun x => x.cc) <$> Lake.getLeanInstall

@[inline]

def Lake.getLeanCc? {m : Type → Type u_1} [Lake.MonadLakeEnv m] [Functor m] : m (Option String)

Get the optional LEAN_CC compiler override of the detected Lean installation.

Equations

• Lake.getLeanCc? = (fun x => Lake.LeanInstall.leanCc? x) <$> Lake.getLeanInstall

Lake Install Helpers

@[inline]

def Lake.getLakeInstall {m : Type → Type u_1} [Lake.MonadLakeEnv m] [Functor m] : m Lake.LakeInstall

Get the detected Lake installation.

Equations

• Lake.getLakeInstall = (fun x => x.lake) <$> Lake.getLakeEnv

@[inline]

def Lake.getLakeHome {m : Type → Type u_1} [Lake.MonadLakeEnv m] [Functor m] : m Lake.FilePath

Get the root directory of the detected Lake installation (e.g., LAKE_HOME).

Equations

• Lake.getLakeHome = (fun x => x.home) <$> Lake.getLakeInstall

@[inline]

def Lake.getLakeSrcDir {m : Type → Type u_1} [Lake.MonadLakeEnv m] [Functor m] : m Lake.FilePath

Get the source directory of the detected Lake installation.

Equations

• Lake.getLakeSrcDir = (fun x => x.srcDir) <$> Lake.getLakeInstall

@[inline]

def Lake.getLakeLibDir {m : Type → Type u_1} [Lake.MonadLakeEnv m] [Functor m] : m Lake.FilePath

Get the Lean library directory of the detected Lake installation.

Equations

• Lake.getLakeLibDir = (fun x => x.libDir) <$> Lake.getLakeInstall

@[inline]

def Lake.getLake {m : Type → Type u_1} [Lake.MonadLakeEnv m] [Functor m] : m Lake.FilePath

Get the path of the lake binary in the detected Lake installation.

Equations

• Lake.getLake = (fun x => x.lake) <$> Lake.getLakeInstall