File: .lake/packages/lean4/src/lean/lake/Lake/Build/Trace.lean

full_name: Lake.CheckExists.checkExists
code: class CheckExists.{u} (i : Type u) where
  /-- Check whether there already exists an artifact for the given target info. -/
  checkExists : i → BaseIO Bool
goal: i → BaseIO Bool

full_name: Lake.instCheckExistsFilePath
code: instance : CheckExists FilePath 
goal: Lake.CheckExists System.FilePath

full_name: Lake.ComputeTrace.computeTrace
code: class ComputeTrace.{u,v,w} (i : Type u) (m : outParam $ Type v → Type w) (t : Type v) where
  /--  Compute the trace of some target info using information from the monadic context. -/
  computeTrace : i → m t
goal: i → m t

full_name: Lake.computeTrace
code: @[inline] def computeTrace [ComputeTrace i m t] [MonadLiftT m n] (info : i) : n t 
goal: n t

full_name: Lake.NilTrace.nilTrace
code: class NilTrace.{u} (t : Type u) where
  /-- The nil trace. Should not unduly clash with a proper trace. -/
  nilTrace : t
goal: t

full_name: Lake.inhabitedOfNilTrace
code: instance inhabitedOfNilTrace [NilTrace t] : Inhabited t 
goal: Inhabited t

full_name: Lake.MixTrace.mixTrace
code: class MixTrace.{u} (t : Type u) where
  /-- Combine two traces. The result should be dirty if either of the inputs is dirty. -/
  mixTrace : t → t → t
goal: t → t → t

full_name: Lake.mixTraceList
code: def mixTraceList (traces : List t) : t 
goal: t

full_name: Lake.mixTraceArray
code: def mixTraceArray (traces : Array t) : t 
goal: t

full_name: Lake.computeListTrace
code: @[specialize] def computeListTrace [MonadLiftT m n] [Monad n] (artifacts : List i) : n t 
goal: n t

full_name: Lake.instComputeTraceListOfMonad
code: instance [Monad m] : ComputeTrace (List i) m t 
goal: Lake.ComputeTrace (List i) m t

full_name: Lake.computeArrayTrace
code: @[specialize] def computeArrayTrace [MonadLiftT m n] [Monad n] (artifacts : Array i) : n t 
goal: n t

full_name: Lake.instComputeTraceArrayOfMonad
code: instance [Monad m] : ComputeTrace (Array i) m t 
goal: Lake.ComputeTrace (Array i) m t

full_name: Lake.Hash.val
code: /--
A content hash.
TODO: Use a secure hash rather than the builtin Lean hash function.
-/
structure Hash where
  val : UInt64
  deriving BEq, DecidableEq, Repr
goal: UInt64

full_name: Lake.instBEqHash
code: /--
A content hash.
TODO: Use a secure hash rather than the builtin Lean hash function.
-/
structure Hash where
  val : UInt64
  deriving BEq, DecidableEq, Repr
goal: BEq Lake.Hash

full_name: Lake.instReprHash
code: /--
A content hash.
TODO: Use a secure hash rather than the builtin Lean hash function.
-/
structure Hash where
  val : UInt64
  deriving BEq, DecidableEq, Repr
goal: Repr Lake.Hash

full_name: Lake.Hash
code: /--
A content hash.
TODO: Use a secure hash rather than the builtin Lean hash function.
-/
structure Hash where
  val : UInt64
  deriving BEq, DecidableEq, Repr
goal: Type

full_name: Lake.Hash.ofNat
code: @[inline] def ofNat (n : Nat) 
goal: Lake.Hash

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

full_name: Lake.Hash.load?
code: def load? (hashFile : FilePath) : BaseIO (Option Hash) 
goal: BaseIO (Option Lake.Hash)

full_name: Lake.Hash.nil
code: def nil : Hash 
goal: Lake.Hash

full_name: Lake.Hash.instNilTrace
code: instance : NilTrace Hash 
goal: Lake.NilTrace Lake.Hash

full_name: Lake.Hash.mix
code: @[inline] def mix (h1 h2 : Hash) : Hash 
goal: Lake.Hash

full_name: Lake.Hash.instMixTrace
code: instance : MixTrace Hash 
goal: Lake.MixTrace Lake.Hash

full_name: Lake.Hash.toString
code: @[inline] protected def toString (self : Hash) : String 
goal: String

full_name: Lake.Hash.instToString
code: instance : ToString Hash 
goal: ToString Lake.Hash

full_name: Lake.Hash.ofString
code: @[inline] def ofString (str : String) 
goal: Lake.Hash

full_name: Lake.Hash.ofByteArray
code: @[inline] def ofByteArray (bytes : ByteArray) : Hash 
goal: Lake.Hash

full_name: Lake.Hash.toJson
code: @[inline] protected def toJson (self : Hash) : Json 
goal: Lean.Json

full_name: Lake.Hash.instToJson
code: instance : ToJson Hash 
goal: Lean.ToJson Lake.Hash

full_name: Lake.Hash.fromJson?
code: @[inline] protected def fromJson? (json : Json) : Except String Hash 
goal: Except String Lake.Hash

full_name: Lake.Hash.instFromJson
code: instance : FromJson Hash 
goal: Lean.FromJson Lake.Hash

full_name: Lake.ComputeHash
code: class ComputeHash (α : Type u) (m : outParam $ Type → Type v)  where
  computeHash : α → m Hash
goal: Type (max u v)

full_name: Lake.ComputeHash.computeHash
code: class ComputeHash (α : Type u) (m : outParam $ Type → Type v)  where
  computeHash : α → m Hash
goal: α → m Lake.Hash

full_name: Lake.instComputeTraceHashOfComputeHash
code: instance [ComputeHash α m] : ComputeTrace α m Hash 
goal: Lake.ComputeTrace α m Lake.Hash

full_name: Lake.pureHash
code: @[inline] def pureHash [ComputeHash α Id] (a : α) : Hash 
goal: Lake.Hash

full_name: Lake.computeHash
code: @[inline] def computeHash [ComputeHash α m] [MonadLiftT m n] (a : α) : n Hash 
goal: n Lake.Hash

full_name: Lake.instComputeHashStringId
code: instance : ComputeHash String Id 
goal: Lake.ComputeHash String Id

full_name: Lake.computeFileHash
code: def computeFileHash (file : FilePath) : IO Hash 
goal: IO Lake.Hash

full_name: Lake.instComputeHashFilePathIO
code: instance : ComputeHash FilePath IO 
goal: Lake.ComputeHash System.FilePath IO

full_name: Lake.computeTextFileHash
code: def computeTextFileHash (file : FilePath) : IO Hash 
goal: IO Lake.Hash

full_name: Lake.TextFilePath
code: /--
  A wrapper around `FilePath` that adjusts its `ComputeHash` implementation
  to normalize `\r\n` sequences to `\n` for cross-platform compatibility. -/
structure TextFilePath where
  path : FilePath
goal: Type

full_name: Lake.TextFilePath.path
code: /--
  A wrapper around `FilePath` that adjusts its `ComputeHash` implementation
  to normalize `\r\n` sequences to `\n` for cross-platform compatibility. -/
structure TextFilePath where
  path : FilePath
goal: System.FilePath

full_name: Lake.instCoeTextFilePathFilePath
code: instance : Coe TextFilePath FilePath 
goal: Coe Lake.TextFilePath System.FilePath

full_name: Lake.instComputeHashTextFilePathIO
code: instance : ComputeHash TextFilePath IO 
goal: Lake.ComputeHash Lake.TextFilePath IO

full_name: Lake.computeArrayHash
code: @[specialize] def computeArrayHash [ComputeHash α m] [Monad m] (xs : Array α) : m Hash 
goal: m Lake.Hash

full_name: Lake.instComputeHashArrayOfMonad
code: instance [ComputeHash α m] [Monad m] : ComputeHash (Array α) m 
goal: Lake.ComputeHash (Array α) m

full_name: Lake.MTime
code: /-- A modification time. -/
def MTime 
goal: Type

full_name: Lake.MTime.instOfNat
code: instance : OfNat MTime (nat_lit 0) 
goal: OfNat Lake.MTime 0

full_name: Lake.MTime.instBEq
code: instance : BEq MTime 
goal: BEq Lake.MTime

full_name: Lake.MTime.instRepr
code: instance : Repr MTime 
goal: Repr Lake.MTime

full_name: Lake.MTime.instOrd
code: instance : Ord MTime 
goal: Ord Lake.MTime

full_name: Lake.MTime.instLT
code: instance : LT MTime 
goal: LT Lake.MTime

full_name: Lake.MTime.instLE
code: instance : LE MTime 
goal: LE Lake.MTime

full_name: Lake.MTime.instMin
code: instance : Min MTime 
goal: Min Lake.MTime

full_name: Lake.MTime.instMax
code: instance : Max MTime 
goal: Max Lake.MTime

full_name: Lake.MTime.instNilTrace
code: instance : NilTrace MTime 
goal: Lake.NilTrace Lake.MTime

full_name: Lake.MTime.instMixTrace
code: instance : MixTrace MTime 
goal: Lake.MixTrace Lake.MTime

full_name: Lake.GetMTime.getMTime
code: class GetMTime (α) where
  getMTime : α → IO MTime
goal: α → IO Lake.MTime

full_name: Lake.GetMTime
code: class GetMTime (α) where
  getMTime : α → IO MTime
goal: Sort (max 1 u_1)

full_name: Lake.instComputeTraceIOMTimeOfGetMTime
code: instance [GetMTime α] : ComputeTrace α IO MTime 
goal: Lake.ComputeTrace α IO Lake.MTime

full_name: Lake.getFileMTime
code: @[inline] def getFileMTime (file : FilePath) : IO MTime 
goal: IO Lake.MTime

full_name: Lake.instGetMTimeFilePath
code: instance : GetMTime FilePath 
goal: Lake.GetMTime System.FilePath

full_name: Lake.instGetMTimeTextFilePath
code: instance : GetMTime TextFilePath 
goal: Lake.GetMTime Lake.TextFilePath

full_name: Lake.MTime.checkUpToDate
code: /--
Check if `info` is up-to-date using modification time.
That is, check if the info is newer than `self`.
-/
@[specialize] def MTime.checkUpToDate
  [GetMTime i] (info : i) (self : MTime)
: BaseIO Bool 
goal: BaseIO Bool

full_name: Lake.BuildTrace
code: /-- Trace used for common Lake targets. Combines `Hash` and `MTime`. -/
structure BuildTrace where
  hash : Hash
  mtime : MTime
  deriving Repr
goal: Type

full_name: Lake.instReprBuildTrace
code: /-- Trace used for common Lake targets. Combines `Hash` and `MTime`. -/
structure BuildTrace where
  hash : Hash
  mtime : MTime
  deriving Repr
goal: Repr Lake.BuildTrace

full_name: Lake.BuildTrace.hash
code: /-- Trace used for common Lake targets. Combines `Hash` and `MTime`. -/
structure BuildTrace where
  hash : Hash
  mtime : MTime
  deriving Repr
goal: Lake.Hash

full_name: Lake.BuildTrace.mtime
code: /-- Trace used for common Lake targets. Combines `Hash` and `MTime`. -/
structure BuildTrace where
  hash : Hash
  mtime : MTime
  deriving Repr
goal: Lake.MTime

full_name: Lake.BuildTrace.ofHash
code: @[inline] def ofHash (hash : Hash) : BuildTrace 
goal: Lake.BuildTrace

full_name: Lake.BuildTrace.instCoeHash
code: instance : Coe Hash BuildTrace 
goal: Coe Lake.Hash Lake.BuildTrace

full_name: Lake.BuildTrace.ofMTime
code: @[inline] def ofMTime (mtime : MTime) : BuildTrace 
goal: Lake.BuildTrace

full_name: Lake.BuildTrace.instCoeMTime
code: instance : Coe MTime BuildTrace 
goal: Coe Lake.MTime Lake.BuildTrace

full_name: Lake.BuildTrace.nil
code: def nil : BuildTrace 
goal: Lake.BuildTrace

full_name: Lake.BuildTrace.instNilTrace
code: instance : NilTrace BuildTrace 
goal: Lake.NilTrace Lake.BuildTrace

full_name: Lake.BuildTrace.compute
code: @[specialize] def compute [ComputeHash i m] [MonadLiftT m IO] [GetMTime i] (info : i) : IO BuildTrace 
goal: IO Lake.BuildTrace

full_name: Lake.BuildTrace.instComputeTraceIOOfComputeHashOfMonadLiftTOfGetMTime
code: instance [ComputeHash i m] [MonadLiftT m IO] [GetMTime i] : ComputeTrace i IO BuildTrace 
goal: Lake.ComputeTrace i IO Lake.BuildTrace

full_name: Lake.BuildTrace.mix
code: def mix (t1 t2 : BuildTrace) : BuildTrace 
goal: Lake.BuildTrace

full_name: Lake.BuildTrace.instMixTrace
code: instance : MixTrace BuildTrace 
goal: Lake.MixTrace Lake.BuildTrace

full_name: Lake.BuildTrace.checkAgainstHash
code: /--
Check if the info is up-to-date using a hash.
That is, check that info exists and its input hash matches this trace's hash.
-/
@[specialize] def checkAgainstHash [CheckExists i]
(info : i) (hash : Hash) (self : BuildTrace) : BaseIO Bool 
goal: BaseIO Bool

full_name: Lake.BuildTrace.checkAgainstTime
code: /--
Check if the info is up-to-date using modification time.
That is, check if the info is newer than this input trace's modification time.
-/
@[inline] def checkAgainstTime
  [GetMTime i] (info : i) (self : BuildTrace)
: BaseIO Bool 
goal: BaseIO Bool

full_name: Lake.BuildTrace.checkAgainstFile
code: /--
Check if the info is up-to-date using a trace file.
If the file exists, match its hash to this trace's hash.
If not, check if the info is newer than this trace's modification time.

**Deprecated:** Should not be done manually,
but as part of `buildUnlessUpToDate`.
-/
@[deprecated, specialize] def checkAgainstFile
  [CheckExists i] [GetMTime i]
  (info : i) (traceFile : FilePath) (self : BuildTrace)
: BaseIO Bool 
goal: BaseIO Bool

full_name: Lake.BuildTrace.writeToFile
code: /--
Write trace to a file.

**Deprecated:** Should not be done manually,
but as part of `buildUnlessUpToDate`.
-/
@[deprecated] def writeToFile (traceFile : FilePath) (self : BuildTrace) : IO PUnit 
goal: IO PUnit