Type Members

1.  final case class And[-I, +LO, +RO, +E](left: Stage[I, LO, E], right: Stage[I, RO, E]) extends BaseBinaryOperator[I, LO, RO, (LO, RO), E] with Product with Serializable

   A binary operator that applies left and right to the same input sequentially, producing a tuple of both outputs when both succeed.

   A binary operator that applies left and right to the same input sequentially, producing a tuple of both outputs when both succeed.

   The evaluation is short-circuit on the left side:

   • If left yields h8io.stages.Yield.Some, right is applied to the same input.
     • If right also yields Some, the result is Yield.Some((leftOut, rightOut), ...).
     • If right yields None, the result is Yield.None(mergedStatus, ...).
   • If left yields h8io.stages.Yield.None, right is **not** applied and the result is Yield.None(leftStatus, ...).

   Statuses from both sides are merged with combine.

   I

   the shared input type (contravariant)

   LO

   the left output type (covariant)

   RO

   the right output type (covariant)

   E

   the error type (covariant)

   left

   the first stage to apply

   right

   the second stage to apply when left succeeds

2.  final case class CompleteIfNone[I, O, E](alterand: Stage[I, O, E]) extends Decorator[I, O, E] with Product with Serializable

   A decorator that stops the pipeline when the inner stage produces no output.

   A decorator that stops the pipeline when the inner stage produces no output.

   When the inner stage yields h8io.stages.Yield.None with h8io.stages.Status.Success, CompleteIfNone upgrades the status to h8io.stages.Status.Complete, signaling that processing should not continue. All other h8io.stages.Yield variants are forwarded unchanged (with the evolution mapped to preserve the decorator).

   This is useful for stages that return None when their input stream is exhausted — wrapping them with CompleteIfNone turns the absence of output into a clean pipeline termination.

   I

   the input type

   O

   the output type

   E

   the error type

   alterand

   the inner stage to observe

3.  final case class IAnd[-I, +LO, +RO, +E](left: Stage[I, LO, E], right: Stage[I, RO, E]) extends BinaryOperator[Stage[I, LO, E], Stage[I, RO, E], I, (LO, RO), E] with Product with Serializable

   An independent binary operator that applies two stages to the same input and combines their outputs into a tuple.

   An independent binary operator that applies two stages to the same input and combines their outputs into a tuple.

   Both left and right are always applied — unlike And, which skips right if left produces no output.

   • If both stages yield h8io.stages.Yield.Some, the result is h8io.stages.Yield.Some((leftOut, rightOut), mergedStatus, ...).
   • If either stage yields h8io.stages.Yield.None, the result is h8io.stages.Yield.None(mergedStatus, ...).

   Statuses from both stages are merged with combine (i.e., leftStatus.combine(rightStatus)). The evolution pairs each branch's continuations symmetrically.

   I

   the shared input type (contravariant)

   LO

   the left output type (covariant)

   RO

   the right output type (covariant)

   E

   the error type (covariant)

   left

   the first stage

   right

   the second stage

4.  final case class Lift[I, O, E](alterand: Stage[I, O, E]) extends Alterator[Stage[I, O, E], I, Option[O], E] with Fruitful[I, Option[O], E] with Product with Serializable

   A decorator that wraps a stage's optional output into an Option, making the result always present.

   A decorator that wraps a stage's optional output into an Option, making the result always present.

   • If the inner stage yields h8io.stages.Yield.Some(v, ...), Lift produces h8io.stages.Yield.Some(Some(v), ...).
   • If the inner stage yields h8io.stages.Yield.None(...), Lift produces h8io.stages.Yield.Some(None, ...).

   Because Lift always emits a value, it extends h8io.stages.base.Fruitful. The evolution of the result is mapped so that every continuation stage is also wrapped in Lift, preserving the lifting semantics across the entire pipeline.

   Lift is the inverse of h8io.stages.projections.Unlift.

   I

   the input type

   O

   the inner output type; the outer output type becomes Option[O]

   E

   the error type

   alterand

   the inner stage whose output is optionally present

5.  final case class LocalSoftDeadline[-I, +O, +E](tsSupplier: () ⇒ Long, now: () ⇒ Long, duration: Long, alterand: Stage[I, O, E]) extends Decorator[I, O, E] with Product with Serializable

   A decorator that stops the pipeline when a time budget measured from the beginning of the current unit of work is exhausted.

   A decorator that stops the pipeline when a time budget measured from the beginning of the current unit of work is exhausted.

   Unlike h8io.stages.std.GlobalSoftDeadline, which measures time from the moment the stage is created and never resets, LocalSoftDeadline measures time from the apply call that started the current unit of work: the timestamp is captured at that call and preserved for as long as the evolution is invoked with h8io.stages.Status.Success. When the evolution is invoked with any other status, the clock is reset — the new window starts at the next apply call. The same reset happens after the deadline has been exceeded.

   The deadline is soft: it is checked after the inner stage has already been applied. If it is exceeded, a h8io.stages.Status.Success in the current h8io.stages.Yield is upgraded to an errorless h8io.stages.Status.Complete; any other status is left unchanged.

   If duration ≤ 0 the factory methods return h8io.stages.std.DeadEnd directly, ensuring the pipeline immediately terminates.

   I

   the input type (contravariant)

   O

   the output type (covariant)

   E

   the error type (covariant)

   tsSupplier

   a thunk that returns the timestamp of the start of the current deadline window

   now

   a supplier of the current time in nanoseconds

   duration

   the time budget in nanoseconds

   alterand

   the inner stage whose deadline is enforced

6.  final case class Or[-I, +LO, +RO, +E](left: Stage[I, LO, E], right: Stage[I, RO, E]) extends BinaryOperator[Stage[I, LO, E], Stage[I, RO, E], I, Either[LO, RO], E] with Product with Serializable

   A binary operator that tries left first; if left produces no output, it falls back to right, wrapping the result in scala.util.Either.

   A binary operator that tries left first; if left produces no output, it falls back to right, wrapping the result in scala.util.Either.

   Evaluation rules for a given input:

   • If left yields h8io.stages.Yield.Some, the result is Yield.Some(Left(leftOut), leftStatus, ...). right is **not** applied.
   • If left yields h8io.stages.Yield.None, right is applied:
     • right yields Some → Yield.Some(Right(rightOut), mergedStatus, ...).
     • right yields None → Yield.None(mergedStatus, ...).

   Statuses are merged with combine.

   I

   the shared input type (contravariant)

   LO

   the left output type (covariant)

   RO

   the right output type (covariant)

   E

   the error type (covariant)

   left

   the preferred stage; tried first

   right

   the fallback stage; tried only when left yields no output

7.  final case class Safe[-I, +O, +E](alterand: Stage[I, O, E]) extends Alterator[Stage[I, O, E], I, O, Either[Throwable, E]] with SafeStage[I, O, Either[Throwable, E]] with Product with Serializable

   A decorator that catches non-fatal exceptions thrown by the inner stage and converts them into h8io.stages.Status.Complete error values.

   A decorator that catches non-fatal exceptions thrown by the inner stage and converts them into h8io.stages.Status.Complete error values.

   The error type is widened from E to Either[Throwable, E]:

   • Errors already carried by the inner stage are wrapped as Right(e).
   • Exceptions caught during apply are reported as Left(throwable) in a Yield.None(Status.error(Left(e)), this).

   Only non-fatal exceptions (matched by scala.util.control.NonFatal) are caught; fatal errors such as OutOfMemoryError propagate normally.

   The evolution is mapped so that every continuation stage remains wrapped in Safe, maintaining exception safety across the entire pipeline.

   Safe is a crutch for the simplest cases — stateless stages. Per the Lifecycle contract in h8io.stages.Stage, a stage that throws from apply has already released its own resources, so the recovered continuation simply reuses the inner stage — retrying it on the next input — and carries a no-op dispose. A stage that owns resources should be made safe by itself instead of being wrapped: extend h8io.stages.base.SafeStage and supply a recover with the appropriate cleanup (the h8io.stages.base.ConstEvolution overload taking a dispose function exists for exactly this).

   I

   the input type (contravariant)

   O

   the output type (covariant)

   E

   the original error type of the inner stage (covariant)

   alterand

   the inner stage whose exceptions should be caught