Evolution

h8io.stages.Evolution

See theEvolution companion object

trait Evolution[-I, +O, +E]

The continuation of a Stage: which stage handles the next input, chosen by the Status of the run that just finished. This is what makes a pipeline able to change as it runs — every Yield carries one.

An Evolution is also the exclusive owner of cleanup for the stage that produced it: see dispose.

The status to select on is the one carried alongside the evolution in the same yield, which is why callers normally go through Yield.evolve rather than dispatching on a status themselves. In a composed pipeline that status is the combined one of the whole run, never a single stage's own.

Type parameters

E: the error type (covariant)
I: the input type of the stages returned (contravariant)
O: their output type (covariant)

Attributes

Companion: object
Graph
Supertypes: class Object

trait Matchable

class Any
Known subtypes: trait Evolution[I, LO, RO, O, E]

class ConstEvolution[I, O, E]

trait Stagnation[I, O, E]

trait SAMStage[I, O, E]

trait Fn[I, O]

object Coalesce

class Const[O]

object Swap

trait FruitfulStaticStage[I, O, E]

trait StaticStage[I, O, E]

trait Projection[I, O]

trait LeftProjection[C]

object Left

object Invalid

object Left

object Left

trait RightProjection[C]

object Right

object Valid

object Right

object Right

object Unlift

class DeadEnd

object DeadEnd
Show all

Members list

Value members

Abstract methods

Releases everything held by the Stage that produced this evolution. That stage is permanently unusable afterwards — neither applied nor skipped again — and this is the only place its resources are released.

Whoever terminates a pipeline is responsible for disposing the evolution of the final Yield, so that the continuation is released at once instead of being carried around. The reference terminal driver is the execute extension method of h8io.stages.base in the lib module.

dispose() stays valid after evolve has been called on the same instance, and must then release everything still alive, including whatever building the continuation acquired. evolve hands over no ownership: this evolution remains the cleanup point for its lineage until the continuation has run and produced an evolution of its own, which takes the role over from that moment.

Exceptions are not part of this contract: a stage whose apply throws produces no yield and therefore no evolution, so there is nothing to dispose — it must clean up after itself (see the ''Lifecycle'' section in Stage).

A no-op is a fine implementation for a stage holding nothing external.

Attributes

The next stage, for the given status.

May release what belongs to this generation alone — anything the returned stage and its own evolution will not reuse.

evolve and dispose are not mutually exclusive. Usually only one of them is called on an instance: a terminal driver disposes, a continuing pipeline evolves and drops the previous evolution. But a caller may do both, and operators owning their inner stage (Loop, Repeat and the rest of h8io.stages.cycles in the lib module) do exactly that — they evolve eagerly and keep the inner dispose as the cleanup handle of the generation they just built.

Attributes

Concrete methods

Composes this evolution with the one downstream of it, so that for every status

 composed(s) == self(s) ~> that(s)

This is how Yield composition carries both continuations of a pipeline forward; application code rarely calls it directly.

Attributes

Applies f to every stage this evolution would return, leaving disposal delegated to it unchanged.

The way an operator keeps its wrapping in place across generations: the continuation comes back wrapped the same way the current stage is.

Attributes

In this article

Generated with