Stage

h8io.stages.Stage
See theStage companion object
trait Stage[-I, +O, +E] extends I => Yield[I, O, E]

A single processing unit of a pipeline: a function from an input value to a Yield — an optional output, a Status, and an Evolution that decides what the pipeline looks like for the next run.

==Lifecycle==

Every stage instance takes exactly one of three paths per pipeline run:

  • '''applied''' — apply receives an input value and returns a Yield. It may perform side effects and produce any output, status and evolution it likes.
  • '''skipped''' — skip returns the evolution the stage would have returned had it run, without consuming an input. Any stage that takes part in a run but does not process the current input takes this path.
  • '''failed''' — apply throws. No Yield, and therefore no Evolution, reaches the caller.

Resource cleanup belongs to the Evolution returned by either of the first two: Evolution.dispose is the exclusive release point, and the stage is permanently unusable afterwards. The failed path is the one case where nobody outside can release anything — there is no evolution to dispose — so a stage that throws must release its own resources before letting the exception escape. The core takes no other part in exception handling; the lib module offers h8io.stages.operators.Safe as a crutch for the simplest, stateless cases. Fatal exceptions are outside this contract.

==Composition==

~> builds a pipeline out of two stages. When the upstream yields an output, it becomes the downstream's input and the two yields are merged; when it yields nothing, the downstream is not applied for this input — it is skipped and its evolution composed in, so it still evolves in step with the rest of the pipeline.

Type parameters

E

the error type (covariant)

I

the input type (contravariant)

O

the output type (covariant)

Attributes

Companion
object
Graph
Supertypes
trait I => Yield[I, O, E]
class Object
trait Matchable
class Any
Known subtypes
trait Alterator[S, I, O, E]
class Fold[R, I, O, E]
class Lift[I, O, E]
class Safe[I, O, E]
trait BinaryOperator[LS, RS, I, O, E]
class IOr[I, LO, RO, E]
class IAnd[I, LO, RO, E]
class Or[I, LO, RO, E]
trait Fruitful[I, O, E]
trait Fn[I, O]
object Coalesce
class Const[O]
object Swap
trait FruitfulStaticStage[I, O, E]
trait SAMStage[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
trait SafeStage[I, O, E]
Show all

Members list

Value members

Abstract methods

def apply(in: I): Yield[I, O, E]

Processes in and returns the Yield carrying the optional output, the status and the continuation.

Processes in and returns the Yield carrying the optional output, the status and the continuation.

A stage that throws from here must have released its own resources first — see the ''Lifecycle'' section above.

Attributes

def skip(): Evolution[I, O, E]

Returns this stage's Evolution without consuming an input.

Returns this stage's Evolution without consuming an input.

Called instead of apply whenever the stage takes part in a run but has nothing to process: the upstream yielded no output, or a binary operator excluded this branch. The evolution must be the one the stage would have returned had it run. Like apply, skip() may perform side effects — a decorator, for instance, may advance or release the inner stage it owns.

Attributes

Concrete methods

final def ~>[_O, _E >: E](that: Stage[O, _O, _E]): Stage[I, _O, _E]

Composes this stage with that, feeding this stage's output into it. See the ''Composition'' section above for what happens when there is no output to feed.

Composes this stage with that, feeding this stage's output into it. See the ''Composition'' section above for what happens when there is no output to feed.

Attributes

Inherited methods

def andThen[A](g: Yield[I, O, E] => A): I => A

Composes two instances of Function1 in a new Function1, with this function applied first.

Composes two instances of Function1 in a new Function1, with this function applied first.

Type parameters

A

the result type of function g

Value parameters

g

a function R => A

Attributes

Returns

a new function f such that f(x) == g(apply(x))

Inherited from:
Function1
def compose[A](g: A => I): A => Yield[I, O, E]

Composes two instances of Function1 in a new Function1, with this function applied last.

Composes two instances of Function1 in a new Function1, with this function applied last.

Type parameters

A

the type to which function g can be applied

Value parameters

g

a function A => T1

Attributes

Returns

a new function f such that f(x) == apply(g(x))

Inherited from:
Function1
override def toString(): String

Returns a string representation of the object.

Returns a string representation of the object.

The default representation is platform dependent.

Attributes

Returns

a string representation of the object.

Definition Classes
Function1 -> Any
Inherited from:
Function1