Type Members

1.  final case class Const[+O](out: O) extends Fn[Any, O] with Product with Serializable

   A stage that always produces the same constant output, ignoring its input.

   A stage that always produces the same constant output, ignoring its input.

   Const wraps a fixed value out and returns it on every invocation, always succeeding (h8io.stages.Status.Success). Because it is a h8io.stages.base.Fn, it is stateless and can be reused freely.

   Example:

   val always42: Stage[Any, Int, Nothing] = Const(42)

   O

   the output type (covariant)

   out

   the constant value to produce on every invocation

2.  final case class Countdown[T](i: Long, n: Long) extends Endo[T, Nothing] with Endo[T, Nothing] with Product with Serializable

   An endomorphic stage that passes its input through for exactly n invocations and then signals pipeline completion.

   An endomorphic stage that passes its input through for exactly n invocations and then signals pipeline completion.

   On each of the first n − 1 calls the stage yields h8io.stages.Status.Success and decrements its counter. On the n-th call it yields h8io.stages.Status.Complete and resets to n. After any h8io.stages.Status.Complete the stage also resets to n, ready for reuse.

   Countdown is fully immutable: each state transition creates a new instance rather than mutating the current one.

   Preconditions (checked at construction via assume):

   • n > 0
   • 1 ≤ i ≤ n

   T

   the value type passed through unchanged

   i

   the remaining number of successful yields before completion (1 ≤ i ≤ n)

   n

   the total period length (must be positive)

3.  sealed case class DeadEnd(_dispose: () ⇒ Unit) extends StaticStage[Any, Nothing, Nothing] with Product with Serializable

   A terminal stage that never produces an output value.

   A terminal stage that never produces an output value.

   Every invocation of apply returns a h8io.stages.Yield.None with h8io.stages.Status.Complete, immediately signaling that the pipeline is finished.

   DeadEnd is the natural "end-of-stream" marker and is also returned by Countdown.apply when n ≤ 0 and by h8io.stages.operators.LocalSoftDeadline when the duration is non-positive.

   An optional _dispose hook can be supplied at construction to release resources when the stage is disposed; the companion object DeadEnd uses a no-op hook.

   _dispose

   a thunk invoked by h8io.stages.Evolution.dispose; defaults to a no-op in the companion object

4.  final class GlobalSoftDeadline[T] extends Endo[T, Nothing]

   An endomorphic stage that passes values through as long as a wall-clock deadline has not elapsed.

   An endomorphic stage that passes values through as long as a wall-clock deadline has not elapsed.

   The deadline is measured from the moment this instance is created: the timestamp ts is captured once at construction using now(). On each invocation, if the elapsed time (now() - ts) is less than duration (in nanoseconds), the stage yields h8io.stages.Status.Success; otherwise it yields h8io.stages.Status.Complete.

   The deadline is global in the sense that it is fixed at construction and never resets, unlike h8io.stages.operators.LocalSoftDeadline which restarts its window with each new unit of work.

   T

   the value type passed through unchanged

5.  final case class Scan[T, +E](op: Stage[(T, T), T, E]) extends Endo[T, E] with Product with Serializable

   An endomorphic stage that folds its own inputs into a running accumulator across pipeline runs, via the binary operation stage op — the running-total counterpart of h8io.stages.cycles.Reduce and h8io.stages.cycles.Fold.

   An endomorphic stage that folds its own inputs into a running accumulator across pipeline runs, via the binary operation stage op — the running-total counterpart of h8io.stages.cycles.Reduce and h8io.stages.cycles.Fold.

   Unlike the h8io.stages.cycles family, Scan has no inner stage and no cycle: it consumes one external input per outer run and threads its own accumulator from one run to the next. The first input becomes the accumulator unchanged, without invoking op (the classic seedless reduce, seeded from the pipeline's own input stream instead of a single seed value); each subsequent input is folded via op((accumulator, input)) and the result — the new running total — is emitted immediately, ready for the next run.

   When op is applied but itself yields no output — e.g. it filters some inputs out — the accumulator is left unchanged rather than discarded, exactly as in Reduce/Fold, and Scan itself yields nothing for that run.

   Since Scan has no separate alterand, the status of a run is simply the status op produced (or Success, for the seeding run in which op is skipped) — there is nothing else to combine it with. Whenever that status is h8io.stages.Status.Complete, the next generation resets to a fresh, unseeded Scan instead of continuing to accumulate — mirroring how h8io.stages.std.Countdown resets on any non-Success status: Complete marks one logical unit of work as finished, and the next external input starts a new one, seeding from scratch.

   T

   the accumulator and input type (invariant: threaded through as both input and output of op)

   E

   the error type (covariant)

   op

   the binary operation stage folding the accumulator and a new input into the next accumulator