Type Members

1.  final case class AndThen[-I, OI, +O, +E](upstream: Evolution[OI, O, E], downstream: Evolution[I, OI, E]) extends Evolution[I, O, E] with Product with Serializable

   An Evolution composed of two sequential evolutions.

   An Evolution composed of two sequential evolutions.

   Parameter naming

   The field names are intentionally the reverse of Stage.AndThen. In Stage.AndThen, upstream processes I → OI and downstream processes OI → O. Here it is the other way around:

   • downstream: Evolution[I, OI, E] — holds the evolution of the pipeline's upstream stage (I → OI).
   • upstream: Evolution[OI, O, E] — holds the evolution of the pipeline's downstream stage (OI → O).

   The inversion follows from how <~ routes data: upstream(s) <~ downstream(s) feeds downstream's stage first, so the I → OI evolution occupies downstream and OI → O occupies upstream. compose stores its receiver as downstream and its argument as upstream:

   pipelineUpstream.skip().compose(pipelineDownstream.skip())
   // == Evolution.AndThen(upstream = pipelineDownstream.skip(),
   //                      downstream = pipelineUpstream.skip())

   Continuation composition

   For any status s:

   composed(s) == upstream(s) <~ downstream(s)
   // data flow: I → downstream's stage → OI → upstream's stage → O

   Disposal

   Both evolutions are disposed in the order upstream then downstream (i.e. pipeline-downstream first, then pipeline-upstream), matching the reverse-order convention used in Stage.AndThen before disposal was moved to Evolution.

   I

   input type of the composed pipeline

   OI

   intermediate type between the two stages

   O

   output type of the composed pipeline

   E

   error type

   upstream

   the evolution of the pipeline's downstream stage (OI → O)

   downstream

   the evolution of the pipeline's upstream stage (I → OI)

2.  type Any = Evolution[_, _, _]
3.  type Endo[T, +E] = Evolution[T, T, E]
4.  final case class Mapped[II, IO, IE, -OI, +OO, +OE](evolution: Evolution[II, IO, IE], f: (Stage[II, IO, IE]) => Stage[OI, OO, OE]) extends Evolution[OI, OO, OE] with Product with Serializable

   An Evolution whose continuations are produced by applying f to the corresponding continuations of evolution.

   An Evolution whose continuations are produced by applying f to the corresponding continuations of evolution.

   Created by Evolution#map. Disposal is delegated to the wrapped evolution.

   II

   input type of the inner stages

   IO

   output type of the inner stages

   IE

   error type of the inner stages

   OI

   input type of the resulting stages (contravariant)

   OO

   output type of the resulting stages (covariant)

   OE

   error type of the resulting stages (covariant)

   evolution

   the inner evolution whose continuations are transformed

   f

   the function applied to each continuation stage