Utilities

class Lake.CheckExists (i : Type u) : Type u

• checkExists : i → BaseIO Bool

  Check whether there already exists an artifact for the given target info.

instance Lake.instCheckExistsFilePath : Lake.CheckExists Lake.FilePath

Trace Abstraction

class Lake.ComputeTrace (i : Type u) (m : outParam (Type v → Type w)) (t : Type v) : Type (max u w)

• computeTrace : i → m t

  Compute the trace of some target info using information from the monadic context.

def Lake.computeTrace {i : Type u_1} {m : Type u_2 → Type u_3} {t : Type u_2} {n : Type u_2 → Type u_4} [Lake.ComputeTrace i m t] [MonadLiftT m n] (info : i) : n t

class Lake.NilTrace (t : Type u) : Type u

• nilTrace : t

  The nil trace. Should not unduly clash with a proper trace.

instance Lake.instInhabited {t : Type u_1} [Lake.NilTrace t] : Inhabited t

class Lake.MixTrace (t : Type u) : Type u

• mixTrace : t → t → t

  Combine two traces. The result should be dirty if either of the inputs is dirty.

def Lake.mixTraceM {t : Type u_1} {m : Type u_1 → Type u_2} [Lake.MixTrace t] [Pure m] (t1 : t) (t2 : t) : m t

def Lake.mixTraceList {t : Type u_1} [Lake.MixTrace t] [Lake.NilTrace t] (traces : List t) : t

def Lake.mixTraceArray {t : Type u_1} [Lake.MixTrace t] [Lake.NilTrace t] (traces : Array t) : t

def Lake.computeListTrace {t : Type u_1} {i : Type u_2} {m : Type u_1 → Type u_3} [Lake.MixTrace t] [Lake.NilTrace t] [Lake.ComputeTrace i m t] {n : Type u_1 → Type u_4} [MonadLiftT m n] [Monad n] (artifacts : List i) : n t

instance Lake.instComputeTraceList {t : Type u_1} {i : Type u_2} {m : Type u_1 → Type u_3} [Lake.MixTrace t] [Lake.NilTrace t] [Lake.ComputeTrace i m t] [Monad m] : Lake.ComputeTrace (List i) m t

def Lake.computeArrayTrace {t : Type u_1} {i : Type u_2} {m : Type u_1 → Type u_3} [Lake.MixTrace t] [Lake.NilTrace t] [Lake.ComputeTrace i m t] {n : Type u_1 → Type u_4} [MonadLiftT m n] [Monad n] (artifacts : Array i) : n t

instance Lake.instComputeTraceArray {t : Type u_1} {i : Type u_2} {m : Type u_1 → Type u_3} [Lake.MixTrace t] [Lake.NilTrace t] [Lake.ComputeTrace i m t] [Monad m] : Lake.ComputeTrace (Array i) m t

Hash Trace

structure Lake.Hash : Type

• val : UInt64

A content hash. TODO: Use a secure hash rather than the builtin Lean hash function.

instance Lake.instBEqHash : BEq Lake.Hash

instance Lake.instDecidableEqHash : DecidableEq Lake.Hash

instance Lake.instReprHash : Repr Lake.Hash

def Lake.Hash.ofNat (n : Nat) : Lake.Hash

def Lake.Hash.loadFromFile (hashFile : Lake.FilePath) : IO (Option Lake.Hash)

def Lake.Hash.nil : Lake.Hash

instance Lake.Hash.instNilTraceHash : Lake.NilTrace Lake.Hash

def Lake.Hash.mix (h1 : Lake.Hash) (h2 : Lake.Hash) : Lake.Hash

instance Lake.Hash.instMixTraceHash : Lake.MixTrace Lake.Hash

def Lake.Hash.toString (self : Lake.Hash) : String

instance Lake.Hash.instToStringHash : ToString Lake.Hash

def Lake.Hash.ofString (str : String) : Lake.Hash

def Lake.Hash.ofByteArray (bytes : ByteArray) : Lake.Hash

class Lake.ComputeHash (α : Type u) (m : outParam (Type → Type v)) : Type (max u v)

• computeHash : α → m Lake.Hash

instance Lake.instComputeTraceHash {α : Type u_1} {m : Type → Type u_2} [Lake.ComputeHash α m] : Lake.ComputeTrace α m Lake.Hash

def Lake.pureHash {α : Type u_1} [Lake.ComputeHash α Id] (a : α) : Lake.Hash

def Lake.computeHash {α : Type u_1} {m : Type → Type u_2} {n : Type → Type u_3} [Lake.ComputeHash α m] [MonadLiftT m n] (a : α) : n Lake.Hash

instance Lake.instComputeHashStringId : Lake.ComputeHash String Id

def Lake.computeFileHash (file : Lake.FilePath) : IO Lake.Hash

instance Lake.instComputeHashFilePathIO : Lake.ComputeHash Lake.FilePath IO

structure Lake.TextFilePath : Type

• path : Lake.FilePath

A wrapper around FilePath that adjusts its ComputeHash implementation to normalize \r\n sequences to \n for cross-platform compatibility.

def Lake.crlf2lf (text : String) : String

This is the same as String.replace text "\r\n" "\n", but more efficient.

partial def Lake.crlf2lf.go (text : String) (acc : String) (accStop : String.Pos) (pos : String.Pos) : String

instance Lake.instComputeHashTextFilePathIO : Lake.ComputeHash Lake.TextFilePath IO

instance Lake.instComputeHashArray {α : Type u_1} {m : Type → Type u_2} [Lake.ComputeHash α m] [Monad m] : Lake.ComputeHash (Array α) m

Modification Time (MTime) Trace

def Lake.MTime : Type

A modification time.

instance Lake.MTime.instOfNatMTime : OfNat Lake.MTime 0

instance Lake.MTime.instBEqMTime : BEq Lake.MTime

instance Lake.MTime.instReprMTime : Repr Lake.MTime

instance Lake.MTime.instOrdMTime : Ord Lake.MTime

instance Lake.MTime.instLTMTime : LT Lake.MTime

instance Lake.MTime.instLEMTime : LE Lake.MTime

instance Lake.MTime.instMinMTime : Min Lake.MTime

instance Lake.MTime.instMaxMTime : Max Lake.MTime

instance Lake.MTime.instNilTraceMTime : Lake.NilTrace Lake.MTime

instance Lake.MTime.instMixTraceMTime : Lake.MixTrace Lake.MTime

class Lake.GetMTime (α : Sort u_1) : Sort (max 1 u_1)

• getMTime : α → IO Lake.MTime

instance Lake.instComputeTraceIOMTime {α : Type u_1} [Lake.GetMTime α] : Lake.ComputeTrace α IO Lake.MTime

def Lake.getFileMTime (file : Lake.FilePath) : IO Lake.MTime

instance Lake.instGetMTimeFilePath : Lake.GetMTime Lake.FilePath

instance Lake.instGetMTimeTextFilePath : Lake.GetMTime Lake.TextFilePath

def Lake.checkIfNewer {i : Sort u_1} [Lake.GetMTime i] (info : i) (depMTime : Lake.MTime) : BaseIO Bool

Check if the info's MTIme is at least depMTime.

Lake Build Trace (Hash + MTIme)

structure Lake.BuildTrace : Type

• hash : Lake.Hash
• mtime : Lake.MTime

Trace used for common Lake targets. Combines Hash and MTime.

instance Lake.instReprBuildTrace : Repr Lake.BuildTrace

def Lake.BuildTrace.withHash (hash : Lake.Hash) (self : Lake.BuildTrace) : Lake.BuildTrace

def Lake.BuildTrace.withoutHash (self : Lake.BuildTrace) : Lake.BuildTrace

def Lake.BuildTrace.withMTime (mtime : Lake.MTime) (self : Lake.BuildTrace) : Lake.BuildTrace

def Lake.BuildTrace.withoutMTime (self : Lake.BuildTrace) : Lake.BuildTrace

def Lake.BuildTrace.fromHash (hash : Lake.Hash) : Lake.BuildTrace

instance Lake.BuildTrace.instCoeHashBuildTrace : Coe Lake.Hash Lake.BuildTrace

def Lake.BuildTrace.fromMTime (mtime : Lake.MTime) : Lake.BuildTrace

instance Lake.BuildTrace.instCoeMTimeBuildTrace : Coe Lake.MTime Lake.BuildTrace

def Lake.BuildTrace.nil : Lake.BuildTrace

instance Lake.BuildTrace.instNilTraceBuildTrace : Lake.NilTrace Lake.BuildTrace

def Lake.BuildTrace.compute {i : Type u_1} {m : Type → Type u_2} [Lake.ComputeHash i m] [MonadLiftT m IO] [Lake.GetMTime i] (info : i) : IO Lake.BuildTrace

instance Lake.BuildTrace.instComputeTraceIOBuildTrace {i : Type u_1} {m : Type → Type u_2} [Lake.ComputeHash i m] [MonadLiftT m IO] [Lake.GetMTime i] : Lake.ComputeTrace i IO Lake.BuildTrace

def Lake.BuildTrace.mix (t1 : Lake.BuildTrace) (t2 : Lake.BuildTrace) : Lake.BuildTrace

instance Lake.BuildTrace.instMixTraceBuildTrace : Lake.MixTrace Lake.BuildTrace

def Lake.BuildTrace.checkAgainstHash {i : Type u_1} [Lake.CheckExists i] (info : i) (hash : Lake.Hash) (self : Lake.BuildTrace) : BaseIO Bool

Check the build trace against the given target info and hash to see if the target is up-to-date.

def Lake.BuildTrace.checkAgainstTime {i : Type u_1} [Lake.CheckExists i] [Lake.GetMTime i] (info : i) (self : Lake.BuildTrace) : BaseIO Bool

Check the build trace against the given target info and its modification time to see if the target is up-to-date.

def Lake.BuildTrace.checkAgainstFile {i : Type u_1} [Lake.CheckExists i] [Lake.GetMTime i] (info : i) (traceFile : Lake.FilePath) (self : Lake.BuildTrace) : BaseIO Bool

Check the build trace against the given target info and its trace file to see if the target is up-to-date.

def Lake.BuildTrace.writeToFile (traceFile : Lake.FilePath) (self : Lake.BuildTrace) : IO PUnit