Packages

sealed trait ZFlow[-R, +E, +A] extends AnyRef

ZFlow is a serializable executable workflow.

Values (including functions) used in ZFlows must be Remote values which guarantees that they can be persisted.

R

The type of the input that can be provided for the workflow

E

The type this workflow can fail with

A

The result type this workflow returns with in case it succeeds

Self Type
ZFlow[R, E, A]
Linear Supertypes
AnyRef, Any
Known Subclasses
Await, Die, Ensuring, Fail, Fold, Fork, Input, Interrupt, Iterate, Log, Modify, NewVar, Now, OrTry, Provide, Random, RandomUUID, Read, RetryUntil, Return, RunActivity, Timeout, Transaction, Unwrap, UnwrapRemote, WaitTill
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ZFlow
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Abstract Value Members

  1. abstract def substituteRec[B](f: Substitutions): ZFlow[R, E, A]
    Attributes
    protected

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. final def *>[R1 <: R, E1 >: E, A1 >: A, B](that: ZFlow[R1, E1, B]): ZFlow[R1, E1, B]

    Executes this flow and then that flow, keeping only the result of the second.

    Executes this flow and then that flow, keeping only the result of the second.

    An alias for zipRight.

  4. final def <*[R1 <: R, E1 >: E, A1 >: A, B](that: ZFlow[R1, E1, B]): ZFlow[R1, E1, A1]

    Executes this flow and then that flow, keeping only the result of the first.

    Executes this flow and then that flow, keeping only the result of the first.

    An alias for zipLeft

  5. final def <*>[R1 <: R, E1 >: E, A1 >: A, B](that: ZFlow[R1, E1, B]): ZFlow[R1, E1, (A1, B)]

    Executes this flow and then that flow keeping the result of both zipped together

    Executes this flow and then that flow keeping the result of both zipped together

    An alias for zip

  6. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  7. final def as[B](b: => Remote[B]): ZFlow[R, E, B]

    Replace the flow's result value with the provided value

  8. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  9. final def catchAll[R1 <: R, E1 >: E, A1 >: A, E2](f: (Remote[E1]) => ZFlow[R1, E2, A1]): ZFlow[R1, E2, A1]

    Recover from any failure of this flow by executing the given function

  10. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  11. final def ensuring[E1 >: E, A1 >: A](flow: ZFlow[Any, ZNothing, Any]): ZFlow[R, E1, A1]

    Ensure that the given flow is executed after this flow, regardless of success or failure

  12. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  13. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  14. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  15. final def flatMap[R1 <: R, E1 >: E, B](f: (Remote[A]) => ZFlow[R1, E1, B]): ZFlow[R1, E1, B]

    Executes this flow and then calls the given function with the flow's result to determine the next steps.

  16. final def foldFlow[R1 <: R, E2, B](onError: (Remote[E]) => ZFlow[R1, E2, B], onSuccess: (Remote[A]) => ZFlow[R1, E2, B]): ZFlow[R1, E2, B]

    Executes this flow and then calls either the onError or the onSuccess functions to determine the next steps.

  17. final def fork: ZFlow[R, ZNothing, ExecutingFlow[E, A]]

    Execute this flow in the background.

    Execute this flow in the background.

    The returned value (of type ExecutingFlow) can be used to await or interrupt the running flow.

  18. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  19. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  20. final def ifThenElse[R1 <: R, E1 >: E, B](ifTrue: ZFlow[R1, E1, B], ifFalse: ZFlow[R1, E1, B])(implicit ev: <:<[A, Boolean]): ZFlow[R1, E1, B]

    Executes this flow and based on its boolean result determines the next steps by either calling ifTrue or ifFalse

  21. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  22. final def iterate[R1 <: R, E1 >: E, A1 >: A](step: (Remote[A1]) => ZFlow[R1, E1, A1])(predicate: (Remote[A1]) => Remote[Boolean]): ZFlow[R1, E1, A1]

    Repeatedly executes a flow until a given predicate becomes true.

    Repeatedly executes a flow until a given predicate becomes true.

    The initial value is the result of this flow. The step function is called with this value to produce the next flow to execute. The iteration stops when the predicate function returns true for the last step's result.

  23. final def map[B](f: (Remote[A]) => Remote[B]): ZFlow[R, E, B]

    Maps the result of this flow with the given function

  24. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  25. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  26. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  27. final def orDie[R1 <: R, E1 >: E, A1 >: A]: ZFlow[R1, ZNothing, A1]

    Converts this flow's failure to a fatal flow failure

  28. final def orElse[R1 <: R, E1 >: E, E2, A1 >: A](that: ZFlow[R1, E2, A1]): ZFlow[R1, E2, A1]

    Executes this flow and if it fails executes that flow.

    Executes this flow and if it fails executes that flow.

    The flow and the fallback flow must have compatible result types. If they don't, use orElseEither.

  29. final def orElseEither[R1 <: R, A1 >: A, E2, B](that: ZFlow[R1, E2, B]): ZFlow[R1, E2, Either[A1, B]]

    Executes this flow and if it fails executes that flow.

    Executes this flow and if it fails executes that flow. The two flows can have different result types which will be captured in an Either value.

  30. final def orTry[R1 <: R, E1 >: E, A1 >: A](that: ZFlow[R1, E1, A1]): ZFlow[R1, E1, A1]

    Attempts to execute this flow, but then, if this flow is suspended due to performing a retry operation inside a transaction (because conditions necessary for executing this flow are not yet ready), then will switch over to the specified flow.

    Attempts to execute this flow, but then, if this flow is suspended due to performing a retry operation inside a transaction (because conditions necessary for executing this flow are not yet ready), then will switch over to the specified flow.

    If this flow never suspends, then it will always execute to success or failure, and the specified flow will never be executed.

  31. final def provide(value: Remote[R]): ZFlow[Any, E, A]

    Provide a value as this flow's input

  32. final def repeat[Ctx](schedule: ZFlowSchedule[Ctx]): ZFlow[R, E, List[A]]

    Runs this workflow and then repeats it according to the given schedule.

    Runs this workflow and then repeats it according to the given schedule. The result is the list of all the results collected from the repeated flow.

  33. final def replicate(n: Remote[Int]): ZFlow[R, E, Chunk[A]]

    Repeats this flow n times and collect all the results

  34. def schedule[Ctx](schedule: ZFlowSchedule[Ctx]): ZFlow[R, E, Option[A]]

    Delays the execution of this flow according to the given schedule.

  35. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  36. final def timeout(duration: Remote[zio.Duration]): ZFlow[R, E, Option[A]]

    Try to execute this flow but timeout after the given duration.

    Try to execute this flow but timeout after the given duration.

    If the flow finished running within the time limits, the result is wrapped in Some, otherwise if it timed out the result is None.

  37. def toString(): String
    Definition Classes
    AnyRef → Any
  38. final def unit: ZFlow[R, E, Unit]

    Ignores the successful result of this flow and return with unit instead

  39. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  40. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  41. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  42. final def widen[A0](implicit ev: <:<[A, A0]): ZFlow[R, E, A0]

    Widen the result type of the flow

  43. final def zip[R1 <: R, E1 >: E, A1 >: A, B](that: ZFlow[R1, E1, B]): ZFlow[R1, E1, (A1, B)]

    Executes this flow and then that flow keeping the result of both zipped together

    Executes this flow and then that flow keeping the result of both zipped together

    Has a symbolic alias <*>

  44. final def zipLeft[R1 <: R, E1 >: E, A1 >: A, B](that: ZFlow[R1, E1, B]): ZFlow[R1, E1, A1]

    Executes this flow and then that flow, keeping only the result of the first.

    Executes this flow and then that flow, keeping only the result of the first.

    Has a symbolic alias <*

  45. final def zipRight[R1 <: R, E1 >: E, A1 >: A, B](that: ZFlow[R1, E1, B]): ZFlow[R1, E1, B]

    Executes this flow and then that flow, keeping only the result of the second.

    Executes this flow and then that flow, keeping only the result of the second.

    Has a symbolic alias *>.

Inherited from AnyRef

Inherited from Any

Ungrouped