h8io.stages.base
Type aliases used throughout the lib module for describing stage transformations.
// A decorator is a stage itself: it wraps a Stage[I, O, E] and is one:
val myDecorator: Decorator[String, Int, Nothing] = CompleteIfNone(stage)
// A decoration is the function building it; an alteration is the same with the types free to change:
val myDecoration: Decoration[String, Int, Nothing] = CompleteIfNone(_)
val myAlteration: Alteration[Stage[String, Int, Nothing], Stage[String, Option[Int], Nothing]] = Lift(_)
Attributes
Members list
Type members
Classlikes
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).
Type parameters
- E
-
the error type (covariant)
- I
-
the input type (contravariant)
- O
-
the output type (covariant)
- S
-
the concrete type of the wrapped stage (covariant)
Attributes
- Supertypes
- Known subtypes
Companion object for BaseBinaryOperator.
Companion object for BaseBinaryOperator.
Attributes
- Supertypes
-
class Objecttrait Matchableclass Any
- Self type
-
BaseBinaryOperator.type
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.
Type parameters
- E
-
the error type (covariant)
- I
-
the shared input type (contravariant)
- LS
-
the type of the left sub-stage (covariant, must accept input
I) - O
-
the combined output type (covariant)
- RS
-
the type of the right sub-stage (covariant, must accept input
I)
Attributes
- Supertypes
- Known subtypes
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.
Type parameters
- E
-
the error type (covariant)
- I
-
the input type (contravariant)
- O
-
the output type (covariant)
Value parameters
- _dispose
-
the thunk
disposedelegates to; a no-op when built by the single-argumentConstEvolution.apply - stage
-
the stage returned by every branch
Attributes
- Companion
- object
- Supertypes
-
trait Serializabletrait Producttrait Equalsclass Objecttrait Matchableclass AnyShow all
Companion object for ConstEvolution.
Companion object for ConstEvolution.
Attributes
- Companion
- class
- Supertypes
-
trait Producttrait Mirrorclass Objecttrait Matchableclass Any
- Self type
-
ConstEvolution.type
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
}
Type parameters
- I
-
the input type (contravariant)
- O
-
the output type (covariant)
Attributes
- Companion
- object
- Supertypes
- Known subtypes
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.
Type parameters
- E
-
the error type (covariant)
- I
-
the input type (contravariant)
- O
-
the output type (covariant)
Attributes
- Companion
- object
- Supertypes
- Known subtypes
Companion object for FruitfulStaticStage.
Companion object for FruitfulStaticStage.
Attributes
- Companion
- trait
- Supertypes
-
class Objecttrait Matchableclass Any
- Self type
-
FruitfulStaticStage.type
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.
Type parameters
- E
-
the error type (covariant)
- I
-
the input type (contravariant)
- O
-
the output type (covariant)
Attributes
- Companion
- object
- Supertypes
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.
Type parameters
- C
-
the binary type constructor (must be covariant in both type parameters)
Attributes
- Supertypes
-
class Objecttrait Matchableclass AnyShow all
- Known subtypes
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.
Type parameters
- E
-
the error type (covariant)
- O
-
the output type (covariant)
Attributes
- Companion
- object
- Supertypes
-
class Objecttrait Matchableclass Any
- Known subtypes
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.
Type parameters
- I
-
the container input type (contravariant)
- O
-
the extracted value type
Attributes
- Supertypes
-
class Objecttrait Matchableclass AnyShow all
- Known subtypes
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.
Type parameters
- C
-
the binary type constructor (must be covariant in both type parameters)
Attributes
- Supertypes
-
class Objecttrait Matchableclass AnyShow all
- Known subtypes
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).
Type parameters
- E
-
the error type (covariant)
- I
-
the input type (contravariant)
- O
-
the output type (covariant)
Attributes
- Companion
- object
- Supertypes
-
class Objecttrait Matchableclass AnyShow all
- Known subtypes
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).
Type parameters
- E
-
the error type (covariant)
- I
-
the input type (contravariant)
- O
-
the output type (covariant)
Attributes
- Supertypes
- Known subtypes
-
Extension methods for Stage.
Extension methods for Stage.
Attributes
- Supertypes
-
class AnyValtrait Matchableclass Any
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.
Type parameters
- E
-
the error type (covariant)
- I
-
the input type (contravariant)
- O
-
the output type (covariant)
Attributes
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.
Type parameters
- E
-
the error type (covariant)
- I
-
the input type (contravariant)
- O
-
the output type (covariant)
Attributes
Companion object for StaticStage.
Companion object for StaticStage.
Attributes
- Companion
- trait
- Supertypes
-
class Objecttrait Matchableclass Any
- Self type
-
StaticStage.type
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.
Type parameters
- E
-
the error type (covariant)
- O
-
the output type (covariant)
Attributes
- Companion
- object
- Supertypes
-
class Objecttrait Matchableclass Any
- Known subtypes
Companion object for StaticYield.
Companion object for StaticYield.
Attributes
- Companion
- trait
- Supertypes
-
trait Sumtrait Mirrorclass Objecttrait Matchableclass Any
- Self type
-
StaticYield.type
Types
A function that transforms one stage type into another.
A function that transforms one stage type into another.
Type parameters
- IS
-
the input stage type (contravariant)
- OS
-
the output stage type (covariant)
Attributes
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).
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).
Type parameters
- E
-
the shared error type (covariant)
- I
-
the shared input type (contravariant)
- LO
-
the left output type (covariant)
- O
-
the combined output type (covariant)
- RO
-
the right output type (covariant)
Attributes
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.
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.
Attributes
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).
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).