Type Members

1.  type Alteration[-IS <: Any, +OS <: Any] = (IS) ⇒ OS

   A function that transforms one stage type into another.

2.  trait Alterator[+S <: Any, -I, +O, +E] extends Stage[I, O, E]

   A h8io.stages.Stage that wraps another stage (the alterand).

   A h8io.stages.Stage that wraps another stage (the alterand).

   Alterator is the base trait for all unary operators and decorators that modify the behavior of a single inner stage. Resource disposal is the responsibility of the h8io.stages.Evolution returned by apply or skip — concrete subclasses must ensure their evolution delegates dispose to alterand's evolution.

   Do not mix Alterator with traits that supply the stage's own continuation — its skip, evolve or dispose (e.g. SAMStage, Stagnation). An alterator's evolution has to be built from alterand's: a mixin that answers this instead — and both of those seal it that way — leaves alterand neither evolved nor disposed, with nothing to signal it.

   Traits that only shape apply are safe to mix in, since they leave the continuation to the alterator itself: SafeStage and Fruitful are both used that way here (see h8io.stages.operators.Safe and h8io.stages.operators.Lift).

   S

   the concrete type of the wrapped stage (covariant)

   I

   the input type (contravariant)

   O

   the output type (covariant)

   E

   the error type (covariant)

3.  type BaseBinaryOperator[-I, +LO, +RO, +O, +E] = BinaryOperator[Stage[I, LO, E], Stage[I, RO, E], I, O, E]

   A BinaryOperator over two plain stages sharing the input and error types — the shape every binary operator in the library has (h8io.stages.operators.And, h8io.stages.operators.Or, h8io.stages.operators.IAnd, h8io.stages.cats.IOr).

4.  trait BinaryOperator[+LS <: Stage[I, _, _], +RS <: Stage[I, _, _], -I, +O, +E] extends Stage[I, O, E]

   A h8io.stages.Stage that composes two sub-stages operating on the same input type.

   A h8io.stages.Stage that composes two sub-stages operating on the same input type.

   Exception-safe disposal of both sub-stage evolutions is provided by BaseBinaryOperator.Evolution (in the base package object), which delegates to h8io.stages.Evolution.dispose: right.dispose() is called first, then left.dispose(), and a failure of the former does not prevent the latter.

   Concrete subclasses (e.g. h8io.stages.operators.And, h8io.stages.operators.Or, h8io.stages.operators.IAnd) implement apply to define how the two sub-stages are combined.

   LS

   the type of the left sub-stage (covariant, must accept input I)

   RS

   the type of the right sub-stage (covariant, must accept input I)

   I

   the shared input type (contravariant)

   O

   the combined output type (covariant)

   E

   the error type (covariant)

5.  final case class ConstEvolution[-I, +O, +E](stage: Stage[I, O, E], _dispose: () ⇒ Unit) extends Evolution[I, O, E] with Product with Serializable

   An Evolution that returns the same constant Stage regardless of the status.

   An Evolution that returns the same constant Stage regardless of the status.

   Used by StageOps.toEvolution to lift a stage into an evolution. Being deaf to the status is the point wherever the status reaching this evolution is not the one the constant stage should be chosen by — that is what makes it the evolution the h8io.stages.cycles operators return outwards.

   Disposal is not tied to the constant stage: it runs whatever _dispose holds, so the caller decides what this evolution is the cleanup handle for.

   I

   the input type (contravariant)

   O

   the output type (covariant)

   E

   the error type (covariant)

   stage

   the stage returned by every branch

   _dispose

   the thunk dispose delegates to; a no-op when built by the single-argument ConstEvolution.apply

6.  type Decoration[I, O, E] = (Stage[I, O, E]) ⇒ Stage[I, O, E]

   An Alteration that transforms a Stage[I, O, E] into another Stage[I, O, E] of the same type — the standard function shape passed to h8io.stages.Evolution.map.

7.  type Decorator[-I, +O, +E] = Alterator[Stage[I, O, E], I, O, E]

   A UnaryOperator that wraps a Stage[I, O, E] and preserves its type — the standard shape for decorators (e.g.

   A UnaryOperator that wraps a Stage[I, O, E] and preserves its type — the standard shape for decorators (e.g. h8io.stages.operators.CompleteIfNone, h8io.stages.operators.KeepLastOutput).

8.  trait Fn[-I, +O] extends Fruitful[I, O, Nothing] with SAMStage[I, O, Nothing]

   The simplest way to create a Stage from a single pure function.

   The simplest way to create a Stage from a single pure function.

   Extend Fn and implement f; everything else — wrapping in Yield.Some, attaching Status.Success, wiring the evolution — is handled automatically. Fn always succeeds and returns this as the evolution (via Stagnation), making it stateless and reusable.

   Because apply is final, a Fn stage can never produce Yield.None or a non-Success status. When either of those is needed, use StaticStage instead.

   Example usage:

   object DoubleInt extends Fn[Int, Int] {
     def f(in: Int): Int = in * 2
   }

   I

   the input type (contravariant)

   O

   the output type (covariant)

9.  trait Fruitful[-I, +O, +E] extends Stage[I, O, E]

   A Stage that is guaranteed to always produce a h8io.stages.Yield.Some.

   A Stage that is guaranteed to always produce a h8io.stages.Yield.Some.

   Overriding apply to return Yield.Some (instead of the broader Yield) lets the compiler track this guarantee statically, making Fruitful stages safe to use wherever an output value is always expected.

   I

   the input type (contravariant)

   O

   the output type (covariant)

   E

   the error type (covariant)

10.  trait FruitfulStaticStage[-I, +O, +E] extends SAMStage[I, O, E] with Fruitful[I, O, E]

    A h8io.stages.Stage that is its own Evolution and is guaranteed to always produce an output value.

    A h8io.stages.Stage that is its own Evolution and is guaranteed to always produce an output value.

    The fruitful counterpart of StaticStage: apply and skip are sealed, and subclasses implement process, returning the output value paired with its h8io.stages.Status — no yield wrapping at all. apply carries the h8io.stages.Yield.Some return type required by Fruitful, so the always-an-output guarantee is statically tracked.

    See Fn for the further-constrained variant that, in addition, always succeeds.

    I

    the input type (contravariant)

    O

    the output type (covariant)

    E

    the error type (covariant)

11.  trait LeftProjection[C[+_, +_]] extends Projection[C[Any, Any], Any]

    A Projection for the left side of a covariant binary type constructor C[+_, +_].

    A Projection for the left side of a covariant binary type constructor C[+_, +_].

    Instances operate on the widened C[Any, Any] and can be safely cast to any specific Projection[C[T, Any], T] via the apply[T] method.

    C

    the binary type constructor (must be covariant in both type parameters)

12.  sealed trait Outcome[+O, +E] extends AnyRef

    The final result of executing a h8io.stages.Stage via the execute extension method (see StageOps).

    The final result of executing a h8io.stages.Stage via the execute extension method (see StageOps).

    Unlike h8io.stages.Yield, an Outcome does not carry an h8io.stages.Evolution; it is the terminal value returned to the caller after the pipeline has finished processing a single input. The h8io.stages.Status indicates whether execution succeeded (Status.Success) or completed (Status.Complete), with or without accumulated errors. If disposing the evolution fails, the exception is recorded in Outcome.disposeFailure without preventing the outcome from being returned.

    O

    the output type (covariant)

    E

    the error type (covariant)

13.  trait Projection[-I, O] extends StaticStage[I, O, Nothing]

    Base trait for stages that extract a value from a container type C.

    Base trait for stages that extract a value from a container type C.

    A Projection either succeeds (h8io.stages.Yield.Some) when the expected value is present, or produces a h8io.stages.Yield.None (with h8io.stages.Status.Success) when it is absent — preserving the overall pipeline status without signaling an error.

    The helper constructor some and the pre-built none carry Status.Success and are ready for use in StaticStage.process implementations of concrete projections.

    I

    the container input type (contravariant)

    O

    the extracted value type

14.  trait RightProjection[C[+_, +_]] extends Projection[C[Any, Any], Any]

    A Projection for the right side of a covariant binary type constructor C[+_, +_].

    A Projection for the right side of a covariant binary type constructor C[+_, +_].

    Mirror of LeftProjection for the right type parameter.

    C

    the binary type constructor (must be covariant in both type parameters)

15.  trait SAMStage[-I, +O, +E] extends Stage[I, O, E] with Stagnation[I, O, E]

    A Stage with a default implementation of skip.

    A Stage with a default implementation of skip.

    skip returns this, so every status branch of the evolution evaluates to this. A skipped SAMStage is therefore indistinguishable from an active one that evolves back to itself. This is appropriate for stateless or self-contained stages (e.g. h8io.stages.std.Complete, h8io.stages.std.GlobalSoftDeadline) that carry no external resources and always use the same instance as the next stage.

    dispose is a no-op by default. Override it when the stage holds external resources that must be released (see h8io.stages.std.DeadEnd for an example).

    I

    the input type (contravariant)

    O

    the output type (covariant)

    E

    the error type (covariant)

16.  trait SafeStage[-I, +O, +E] extends Stage[I, O, E]

    A h8io.stages.Stage that separates normal execution from exception recovery.

    A h8io.stages.Stage that separates normal execution from exception recovery.

    SafeStage seals apply and dispatches to body for the happy path. If body throws a non-fatal exception (anything matched by scala.util.control.NonFatal), recover is called instead. Fatal exceptions (e.g., OutOfMemoryError) are not caught and propagate normally.

    Concrete classes implement body for the normal case and recover to convert exceptions into an appropriate h8io.stages.Yield (typically a h8io.stages.Yield.None with an error status).

    I

    the input type (contravariant)

    O

    the output type (covariant)

    E

    the error type (covariant)

17.  implicit final class StageOps[I, O, E] extends AnyVal

    Extension methods for Stage.

18.  trait Stagnation[-I, +O, +E] extends Evolution[I, O, E]

    An h8io.stages.Evolution that always returns itself as the next stage.

    An h8io.stages.Evolution that always returns itself as the next stage.

    Mixing in Stagnation fixes evolve to unconditionally return this, regardless of the h8io.stages.Status passed in, and makes dispose a no-op. The stage is therefore stateless with respect to evolution: every pipeline run produces the same continuation.

    Appropriate for stages that hold no external resources and whose behavior does not depend on the outcome of previous runs. See SAMStage and StaticStage for concrete mixins built on top of Stagnation.

    I

    the input type (contravariant)

    O

    the output type (covariant)

    E

    the error type (covariant)

19.  trait StaticStage[-I, +O, +E] extends SAMStage[I, O, E]

    A h8io.stages.Stage that is its own Evolution.

    A h8io.stages.Stage that is its own Evolution.

    StaticStage seals apply and skip, delegating the actual processing logic to process. apply wraps the StaticYield returned by process into a full h8io.stages.Yield with this as the evolution; skip returns this directly.

    Mixing in StaticStage is appropriate when the stage does not change between runs and holds no external resources. See FruitfulStaticStage for the counterpart that always produces an output, and Fn for the further-constrained variant that always produces an output with h8io.stages.Status.Success.

    I

    the input type (contravariant)

    O

    the output type (covariant)

    E

    the error type (covariant)

20.  sealed trait StaticYield[+O, +E] extends AnyRef

    The result type returned by StaticStage.process.

    The result type returned by StaticStage.process.

    StaticYield mirrors h8io.stages.Yield but omits the Evolution field, since StaticStage always uses this as the continuation. apply in StaticStage wraps a StaticYield into a full h8io.stages.Yield by supplying the evolution automatically.

    O

    the output type (covariant)

    E

    the error type (covariant)

21.  type UnaryOperator[+S <: Stage[I, _, _], -I, +O, +E] = Alterator[S, I, O, E]

    An Alterator-based unary operator: a stage that wraps a single sub-stage S and potentially changes its input/output/error types.