Packages

  • package root
    Definition Classes
    root
  • package h8io
    Definition Classes
    root
  • package stages
    Definition Classes
    h8io
  • package cats
    Definition Classes
    stages
  • object Validated

    Stage projections for cats.data.Validated.

    Stage projections for cats.data.Validated.

    cats.data.Validated[L, R] is a right-biased validation type where Invalid(l) holds an error value and Valid(r) holds a success value. The two projections here allow a pipeline to route values based on which side is present, producing h8io.stages.Yield.Some for the expected side and h8io.stages.Yield.None otherwise. In both cases the status is h8io.stages.Status.Success.

    Example:

    import h8io.stages.cats.Validated

val validStage   = Validated.Valid[String]    // Stage[cats.data.Validated[Any, String], String, Nothing]
val invalidStage = Validated.Invalid[String]  // Stage[cats.data.Validated[String, Any], String, Nothing]
    Definition Classes
    cats
  • Invalid
  • Valid

object Valid extends RightProjection[Validated]

Extracts the Valid (right/success) value, yielding nothing for Invalid values.

Use Validated.Valid[T] to get a typed Projection[Validated[Any, T], T].

Linear Supertypes
RightProjection[Validated], Projection[Validated[Any, Any], Any], StaticStage[Validated[Any, Any], Any, Nothing], SAMStage[Validated[Any, Any], Any, Nothing], Stagnation[Validated[Any, Any], Any, Nothing], Evolution[Validated[Any, Any], Any, Nothing], Stage[Validated[Any, Any], Any, Nothing], (Validated[Any, Any]) ⇒ Yield[Validated[Any, Any], Any, Nothing], AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Valid
  2. RightProjection
  3. Projection
  4. StaticStage
  5. SAMStage
  6. Stagnation
  7. Evolution
  8. Stage
  9. Function1
  10. AnyRef
  11. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. def andThen[A](g: (Yield[Validated[Any, Any], Any, Nothing]) ⇒ A): (Validated[Any, Any]) ⇒ A
    Definition Classes
    Function1
    Annotations
    @unspecialized()
  5. final def apply[T]: Projection[Validated[Any, T], T]

    Returns a typed view of this projection for right-side values of type T.

    Returns a typed view of this projection for right-side values of type T.

    T

    the concrete right-side type

    returns

    this projection typed as Projection[C[Any, T], T]

    Definition Classes
    RightProjection
  6. final def apply(in: Validated[Any, Any]): Yield[Validated[Any, Any], Any, Nothing]

    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.

    Definition Classes
    StaticStage → Stage → Function1
  7. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  8. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native() @IntrinsicCandidate()
  9. final def compose[_O, _E >: Nothing](that: Evolution[Any, _O, _E]): Evolution[Validated[Any, Any], _O, _E]

    Composes this evolution with the one downstream of it, so that for every status

    Composes this evolution with the one downstream of it, so that for every status

    composed(s) == self(s) ~> that(s)

    This is how Yield composition carries both continuations of a pipeline forward; application code rarely calls it directly.

    Definition Classes
    Evolution
    Annotations
    @inline()
  10. def compose[A](g: (A) ⇒ Validated[Any, Any]): (A) ⇒ Yield[Validated[Any, Any], Any, Nothing]
    Definition Classes
    Function1
    Annotations
    @unspecialized()
  11. def dispose(): Unit

    Releases everything held by the Stage that produced this evolution.

    Releases everything held by the Stage that produced this evolution. That stage is permanently unusable afterwards — neither applied nor skipped again — and this is the only place its resources are released.

    Whoever terminates a pipeline is responsible for disposing the evolution of the final Yield, so that the continuation is released at once instead of being carried around. The reference terminal driver is the execute extension method of h8io.stages.base in the lib module.

    dispose() stays valid after evolve has been called on the same instance, and must then release everything still alive, including whatever building the continuation acquired. evolve hands over no ownership: this evolution remains the cleanup point for its lineage until the continuation has run and produced an evolution of its own, which takes the role over from that moment.

    Exceptions are not part of this contract: a stage whose apply throws produces no yield and therefore no evolution, so there is nothing to dispose — it must clean up after itself (see the Lifecycle section in Stage).

    A no-op is a fine implementation for a stage holding nothing external.

    Definition Classes
    Stagnation → Evolution
  12. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  13. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  14. final def evolve(status: Status[_]): Stage[Validated[Any, Any], Any, Nothing]

    The next stage, for the given status.

    The next stage, for the given status.

    May release what belongs to this generation alone — anything the returned stage and its own evolution will not reuse.

    evolve and dispose are not mutually exclusive. Usually only one of them is called on an instance: a terminal driver disposes, a continuing pipeline evolves and drops the previous evolution. But a caller may do both, and operators owning their inner stage (Loop, Repeat and the rest of h8io.stages.cycles in the lib module) do exactly that — they evolve eagerly and keep the inner dispose as the cleanup handle of the generation they just built.

    Definition Classes
    Stagnation → Evolution
  15. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @IntrinsicCandidate()
  16. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @IntrinsicCandidate()
  17. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  18. final def map[_I, _O, _E](f: (Stage[Validated[Any, Any], Any, Nothing]) ⇒ Stage[_I, _O, _E]): Evolution[_I, _O, _E]

    Applies f to every stage this evolution would return, leaving disposal delegated to it unchanged.

    Applies f to every stage this evolution would return, leaving disposal delegated to it unchanged.

    The way an operator keeps its wrapping in place across generations: the continuation comes back wrapped the same way the current stage is.

    Definition Classes
    Evolution
    Annotations
    @inline()
  19. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  20. val none: None[Nothing]

    A pre-built h8io.stages.Yield.None used when the container holds no value for this projection.

    A pre-built h8io.stages.Yield.None used when the container holds no value for this projection.

    Attributes
    protected
    Definition Classes
    Projection
  21. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @IntrinsicCandidate()
  22. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @IntrinsicCandidate()
  23. def process(in: Validated[Any, Any]): StaticYield[Any, Nothing]

    The processing logic for this stage.

    The processing logic for this stage.

    in

    the input value

    returns

    a h8io.stages.base.StaticYield describing whether an output was produced and the resulting h8io.stages.Status

    Definition Classes
    Valid → StaticStage
  24. final def skip(): Evolution[Validated[Any, Any], Any, Nothing]

    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.

    Definition Classes
    SAMStage → Stage
  25. def some(out: Any): Some[Any, Nothing]

    Creates a successful h8io.stages.Yield.Some carrying out.

    Creates a successful h8io.stages.Yield.Some carrying out.

    Attributes
    protected
    Definition Classes
    Projection
  26. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  27. def toString(): String
    Definition Classes
    Function1 → AnyRef → Any
  28. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  29. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  30. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  31. final def ~>[_O, _E >: Nothing](that: Stage[Any, _O, _E]): Stage[Validated[Any, Any], _O, _E]

    Composes this stage with that, feeding this stage's output into it.

    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.

    Definition Classes
    Stage
    Annotations
    @inline()

Deprecated Value Members

  1. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] ) @Deprecated
    Deprecated

Inherited from RightProjection[Validated]

Inherited from Projection[Validated[Any, Any], Any]

Inherited from StaticStage[Validated[Any, Any], Any, Nothing]

Inherited from SAMStage[Validated[Any, Any], Any, Nothing]

Inherited from Stagnation[Validated[Any, Any], Any, Nothing]

Inherited from Evolution[Validated[Any, Any], Any, Nothing]

Inherited from Stage[Validated[Any, Any], Any, Nothing]

Inherited from (Validated[Any, Any]) ⇒ Yield[Validated[Any, Any], Any, Nothing]

Inherited from AnyRef

Inherited from Any

Ungrouped