Job Monad

This module contains additional definitions for Lake Job. In particular, it defines JobM, which uses BuildContext, which contains OpaqueJobs, hence the module split.

@[reducible, inline]

abbrev Lake.JobM (α : Type) : Type

The monad of asynchronous Lake jobs.

While this can be lifted into FetchM, job action should generally be wrapped into an asynchronous job (e.g., via Job.async) instead of being run directly in FetchM.

@[inline]

def Lake.JobM.ofFn {α : Type} (f : IndexBuildFn RecBuildM → Option Package → CallStack BuildKey → IO.Ref BuildStore → BuildContext → JobState → BaseIO (EResult Log.Pos JobState α)) : JobM α

Construct a FetchM monad from its full functional representation.

@[inline]

def Lake.JobM.toFn {α : Type} (self : JobM α) : IndexBuildFn RecBuildM → Option Package → CallStack BuildKey → IO.Ref BuildStore → BuildContext → JobState → BaseIO (EResult Log.Pos JobState α)

Convert a JobM monad to its full functional representation.

@[implicit_reducible, instance 10000]

instance Lake.instMonadStateOfJobStateJobM : MonadStateOf JobState JobM

@[implicit_reducible]

instance Lake.instMonadStateOfLogJobM : MonadStateOf Log JobM

@[implicit_reducible]

instance Lake.instMonadLogJobM : MonadLog JobM

@[implicit_reducible]

instance Lake.instMonadErrorJobM : MonadError JobM

@[implicit_reducible]

instance Lake.instAlternativeJobM : Alternative JobM

@[implicit_reducible]

instance Lake.instMonadLiftLogIOJobM : MonadLift LogIO JobM

@[inline]

def Lake.updateAction (action : JobAction) : JobM PUnit

Record that this job is trying to perform some action.

@[inline]

def Lake.getTrace : JobM BuildTrace

Returns the current job's build trace.

@[inline]

def Lake.setTrace (trace : BuildTrace) : JobM PUnit

Sets the current job's build trace.

@[inline]

def Lake.newTrace (caption : String := "<nil>") : JobM PUnit

Replace the job's build trace with a new empty trace.

@[inline]

def Lake.modifyTrace (f : BuildTrace → BuildTrace) : JobM PUnit

Mutates the job's trace, applying f to it.

@[inline]

def Lake.setTraceCaption (caption : String) : JobM PUnit

Set the caption of the job's build trace.

@[inline]

def Lake.takeTrace : JobM BuildTrace

Returns the current job's build trace and removes it from the state.

@[inline]

def Lake.swapTrace (trace : BuildTrace) : JobM BuildTrace

Sets the current job's trace and returns the previous one.

@[inline]

def Lake.addTrace (trace : BuildTrace) : JobM PUnit

Mix a trace into the current job's build trace.

@[inline]

def Lake.addSubTrace {α : Type} (caption : String) (x : JobM α) : JobM α

Runs x with a new trace and then mixes it into the original trace.

@[reducible, inline]

abbrev Lake.SpawnM (α : Type) : Type

The monad used to spawn asynchronous Lake build jobs. Lifts into FetchM.

@[inline]

def Lake.SpawnM.ofFn {α : Type} (f : IndexBuildFn RecBuildM → Option Package → CallStack BuildKey → IO.Ref BuildStore → BuildContext → BuildTrace → BaseIO α) : SpawnM α

Construct a SpawnM monad from its full functional representation.

@[inline]

def Lake.SpawnM.toFn {α : Type} (self : SpawnM α) : IndexBuildFn RecBuildM → Option Package → CallStack BuildKey → IO.Ref BuildStore → BuildContext → BuildTrace → BaseIO α

Convert a SpawnM monad to its full functional representation.

@[inline]

def Lake.JobM.runSpawnM {α : Type} (x : SpawnM α) : JobM α

@[implicit_reducible]

instance Lake.instMonadLiftSpawnMJobM : MonadLift SpawnM JobM

@[inline]

def Lake.FetchM.runJobM {α : Type} (x : JobM α) : FetchM α

Run a JobM action in FetchM.

Generally, this should not be done, and instead a job action should be run asynchronously in a Job (e.g., via Job.async).

@[implicit_reducible]

instance Lake.instMonadLiftJobMFetchM : MonadLift JobM FetchM

@[inline]

def Lake.JobM.runFetchM {α : Type} (x : FetchM α) : JobM α

Run a FetchM action in JobM.

@[implicit_reducible]

instance Lake.instMonadLiftFetchMJobM : MonadLift FetchM JobM

@[inline]

def Lake.Job.bindTask {m : Type u_1 → Type u_2} {β : Type u_1} {α : Type u_3} [Monad m] [OptDataKind β] (f : JobTask α → m (JobTask β)) (self : Job α) : m (Job β)

def Lake.Job.sync {α : Type} [OptDataKind α] (act : JobM α) (caption : String := "") : SpawnM (Job α)

Returns a job that has synchronously performed act.

def Lake.Job.async {α : Type} [OptDataKind α] (act : JobM α) (prio : Task.Priority := Task.Priority.default) (caption : String := "") : SpawnM (Job α)

Spawn a job that asynchronously performs act.

@[inline]

def Lake.Job.wait {α : Type} (self : Job α) : BaseIO (JobResult α)

Wait for a job to complete and return the result.

@[inline]

def Lake.Job.wait? {α : Type} (self : Job α) : BaseIO (Option α)

Wait for a job to complete and return the produced value. If an error occurred, return none and discarded any logs produced.

def Lake.Job.await {α : Type} (self : Job α) : LogIO α

Wait for a job to complete and return the produced value. Logs the job's log and throws if there was an error.

def Lake.Job.mapM {β : Type} {α : Type u_1} [kind : OptDataKind β] (self : Job α) (f : α → JobM β) (prio : Task.Priority := Task.Priority.default) (sync : Bool := false) : SpawnM (Job β)

Apply f asynchronously to the job's output.

def Lake.Job.bindM {β : Type} {α : Type u_1} [kind : OptDataKind β] (self : Job α) (f : α → JobM (Job β)) (prio : Task.Priority := Task.Priority.default) (sync : Bool := false) : SpawnM (Job β)

Apply f asynchronously to the job's output and asynchronously await the resulting job.

@[inline]

def Lake.Job.zipResultWith {γ : Type u_1} {α : Type u_2} {β : Type u_3} [OptDataKind γ] (f : JobResult α → JobResult β → JobResult γ) (self : Job α) (other : Job β) (prio : Task.Priority := Task.Priority.default) (sync : Bool := false) : Job γ

a.zipWith f b produces a new job c that applies f to the results of a and b. The job c errors if either a or b error.

@[inline]

def Lake.Job.zipWith {γ : Type u_1} {α : Type u_2} {β : Type u_3} [OptDataKind γ] (f : α → β → γ) (self : Job α) (other : Job β) (prio : Task.Priority := Task.Priority.default) (sync : Bool := false) : Job γ

a.zipWith f b produces a new job c that applies f to the results of a and b. The job c errors if either a or b error.

def Lake.Job.add {α : Type u_1} {β : Type u_2} (self : Job α) (other : Job β) : Job α

Merges this job with another, discarding its output and trace.

def Lake.Job.mix {α : Type u_1} {β : Type u_2} (self : Job α) (other : Job β) : Job Unit

Merges this job with another, discarding both outputs.

def Lake.Job.mixList {α : Type u_1} (jobs : List (Job α)) (traceCaption : String := "<collection>") : Job Unit

Merge a List of jobs into one, discarding their outputs.

def Lake.Job.mixArray {α : Type u_1} (jobs : Array (Job α)) (traceCaption : String := "<collection>") : Job Unit

Merge an Array of jobs into one, discarding their outputs.

def Lake.Job.collectList {α : Type u_1} (jobs : List (Job α)) (traceCaption : String := "<collection>") : Job (List α)

Merge a List of jobs into one, collecting their outputs into a List.

def Lake.Job.collectArray {α : Type u_1} (jobs : Array (Job α)) (traceCaption : String := "<collection>") : Job (Array α)

Merge an Array of jobs into one, collecting their outputs into an Array.

def Lake.Job.collectVector {n : Nat} {α : Type u} [Nonempty α] (jobs : Vector (Job α) n) (traceCaption : String := "<collection>") : Job (Vector α n)

Merge an Vector of jobs into one, collecting their outputs into an Array.