Enum Next 

#[non_exhaustive]
pub enum Next {
    Continue,
    Goto {
        job: JobId,
        feedback: Option<String>,
    },
    Stop,
}

What happens after a job succeeds.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Continue

Ordinary progress: dependents run once their deps are satisfied. This is what every job does without a router.

Goto

Re-enter the graph at job, which runs again — along with everything downstream of it that had already finished. The cycle.

feedback is what the job is told on the way back in. Measured on a real run without it: a revise job re-entered five times produced 33, 33, 33, 31, 33 characters against a limit of 26 — it saw the same draft each lap and no word of why it had been rejected, so it wrote the same thing. A loop that cannot see its own last attempt repeats; it does not refine.

Fields

job: JobId

feedback: Option<String>

Stop

End the run here and report success, leaving the rest of the graph unrun. The early exit an iterative loop needs when it converges before its budget: the answer is good enough, so stop paying for more.

Implementations

impl Next

pub fn back_to(job: impl Into<JobId>) -> Self

Next::Goto, named for how it reads at a call site: back_to("revise").

Prefer back_to_with — a job told only “again” tends to answer the same way.

pub fn back_to_with(job: impl Into<JobId>, feedback: impl Into<String>) -> Self

Go back, and say why. The feedback reaches the job as the first thing it reads, above its own previous attempt.

Trait Implementations

impl Clone for Next

fn clone(&self) -> Next

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Next

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Next

impl PartialEq for Next

fn eq(&self, other: &Next) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Next