object ZFlow
- Alphabetic
- By Inheritance
- ZFlow
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Type Members
- final case class Await[E, A](exFlow: Remote[ExecutingFlow[E, A]]) extends ZFlow[Any, ActivityError, Either[E, A]] with Product with Serializable
- final case class Ensuring[R, E, A](flow: ZFlow[R, E, A], finalizer: ZFlow[Any, ZNothing, Unit]) extends ZFlow[R, E, A] with Product with Serializable
- final case class Fail[E](error: Remote[E]) extends ZFlow[Any, E, Nothing] with Product with Serializable
- final case class Fold[R, E, E2, A, B](value: ZFlow[R, E, A], errorCase: Option[UnboundRemoteFunction[E, ZFlow[R, E2, B]]], successCase: Option[UnboundRemoteFunction[A, ZFlow[R, E2, B]]]) extends ZFlow[R, E2, B] with Product with Serializable
- final case class Fork[R, E, A](flow: ZFlow[R, E, A]) extends ZFlow[R, Nothing, ExecutingFlow[E, A]] with Product with Serializable
- final case class Input[R]() extends ZFlow[R, Nothing, R] with Product with Serializable
- final case class Interrupt[E, A](exFlow: Remote[ExecutingFlow[E, A]]) extends ZFlow[Any, ActivityError, Unit] with Product with Serializable
- final case class Iterate[R, E, A](initial: Remote[A], step: UnboundRemoteFunction[A, ZFlow[R, E, A]], predicate: UnboundRemoteFunction[A, Boolean]) extends ZFlow[R, E, A] with Product with Serializable
- final case class Log(message: Remote[String]) extends ZFlow[Any, Nothing, Unit] with Product with Serializable
- final case class Modify[A, B](svar: Remote[RemoteVariableReference[A]], f: UnboundRemoteFunction[A, (B, A)]) extends ZFlow[Any, Nothing, B] with Product with Serializable
- final case class NewVar[A](name: String, initial: Remote[A], appendTempCounter: Boolean) extends ZFlow[Any, Nothing, RemoteVariableReference[A]] with Product with Serializable
- final case class OrTry[R, E, A](left: ZFlow[R, E, A], right: ZFlow[R, E, A]) extends ZFlow[R, E, A] with Product with Serializable
- final case class Provide[R, E, A](value: Remote[R], flow: ZFlow[R, E, A]) extends ZFlow[Any, E, A] with Product with Serializable
- final case class Read[A](svar: Remote[RemoteVariableReference[A]]) extends ZFlow[Any, Nothing, A] with Product with Serializable
- final case class Return[A](value: Remote[A]) extends ZFlow[Any, Nothing, A] with Product with Serializable
- final case class RunActivity[R, A](input: Remote[R], activity: Activity[R, A]) extends ZFlow[Any, ActivityError, A] with Product with Serializable
- final case class Timeout[R, E, A](flow: ZFlow[R, E, A], duration: Remote[zio.Duration]) extends ZFlow[R, E, Option[A]] with Product with Serializable
- final case class Transaction[R, E, A](workflow: ZFlow[R, E, A]) extends ZFlow[R, E, A] with Product with Serializable
- final case class Unwrap[R, E, A](remote: Remote[ZFlow[R, E, A]]) extends ZFlow[R, E, A] with Product with Serializable
- final case class UnwrapRemote[A](remote: Remote[Remote[A]]) extends ZFlow[Any, Nothing, A] with Product with Serializable
- final case class WaitTill(time: Remote[flow.Instant]) extends ZFlow[Any, Nothing, Unit] with Product with Serializable
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def apply[A](remote: Remote[A]): ZFlow[Any, ZNothing, A]
Creates a flow that returns the given remote value
- def apply[A](a: A)(implicit arg0: Schema[A]): ZFlow[Any, ZNothing, A]
Creates a flow that returns the given value.
Creates a flow that returns the given value.
The value's type must have a Schema to be able to persist it in a Remote value.
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def fail[E](error: Remote[E]): ZFlow[Any, E, ZNothing]
Creates a flow that fails with the given remote value
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def foreach[R, E, A, B](values: Remote[List[A]])(body: (Remote[A]) => ZFlow[R, E, B])(implicit arg0: Schema[B]): ZFlow[R, E, List[B]]
Creates a flow that executes the flow returned by the body function for each element of the given values.
Creates a flow that executes the flow returned by the body function for each element of the given values.
The result of the flow is the list of each flow's result, in the same order as the input values are.
- def foreachPar[R, A, B](values: Remote[List[A]])(body: (Remote[A]) => ZFlow[R, ActivityError, B])(implicit arg0: Schema[B]): ZFlow[R, ActivityError, List[B]]
Creates a flow that executes the flow returned by the body function for each element of the given values.
Creates a flow that executes the flow returned by the body function for each element of the given values. The sub-flows are all executed in parallel.
The result of the flow is the list of each flow's result, in the same order as the input values are.
- def fromEither[E, A](either: Remote[Either[E, A]]): ZFlow[Any, E, A]
Creates a flow from a remote either value that either fails or succeeds corresponding to the either value.
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def ifThenElse[R, E, A](p: Remote[Boolean])(ifTrue: ZFlow[R, E, A], ifFalse: ZFlow[R, E, A]): ZFlow[R, E, A]
Creates a flow that executes either the ifTrue flow or the ifFalse flow based on the given remote boolean's value
- def input[R]: ZFlow[R, ZNothing, R]
Creates a flow that returns the flow's input
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def iterate[R, E, A](initial: Remote[A], step: (Remote[A]) => Remote[ZFlow[R, E, A]], predicate: (Remote[A]) => Remote[Boolean]): Iterate[R, E, A]
Creates a flow that iterates a sub-flow starting from an initial value until a given predicate evaluates to true.
- def log(remoteMessage: Remote[String]): ZFlow[Any, ZNothing, Unit]
Creates a flow that logs a remote string
- def log(message: String): ZFlow[Any, ZNothing, Unit]
Creates a flow that logs a string
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def newTempVar[A](prefix: String, initial: Remote[A]): ZFlow[Any, ZNothing, RemoteVariableReference[A]]
- def newVar[A](name: String, initial: Remote[A]): ZFlow[Any, ZNothing, RemoteVariableReference[A]]
Creates a flow that defines a new remote variable of type A, with a given name and initial value.
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def now: ZFlow[Any, ZNothing, flow.Instant]
Creates a flow that returns the current time
- def random: ZFlow[Any, ZNothing, Double]
Generates a random floating point number between 0 and 1
Generates a random floating point number between 0 and 1
For generating random values for different data types use the zio.flow.Random API.
- def randomUUID: ZFlow[Any, ZNothing, UUID]
Generates a random UUID
Generates a random UUID
For generating random values for different data types use the zio.flow.Random API.
- def recurse[R, E, A, B](initial: Remote[A])(body: (Remote[A], (Remote[A]) => ZFlow[R, E, B]) => ZFlow[R, E, B]): ZFlow[R, E, B]
Creates a flow that allows it's body run recursively
Creates a flow that allows it's body run recursively
- initial
The initial value passed to the body
- body
A function that gets the current value and a function that can be used to recurse
- def recurseSimple[R, E, A](initial: Remote[A])(body: (Remote[A], (Remote[A]) => ZFlow[R, E, A]) => ZFlow[R, E, A]): ZFlow[R, E, A]
Creates a flow that allows it's body run recursively
Creates a flow that allows it's body run recursively
- initial
The initial value passed to the body
- body
A function that gets the current value and a function that can be used to recurse
- def repeatUntil[R, E](flow: ZFlow[R, E, Boolean]): ZFlow[R, E, Boolean]
Creates a flow that repeats the given flow and stops when it evaluates to true.
- def repeatWhile[R, E](flow: ZFlow[R, E, Boolean]): ZFlow[R, E, Boolean]
Creates a flow that repeats the given flow and stops when it evaluates to false.
- implicit def schema[R, E, A]: Schema[ZFlow[R, E, A]]
- lazy val schemaAny: Schema[ZFlow[Any, Any, Any]]
- def sleep(duration: Remote[zio.Duration]): ZFlow[Any, ZNothing, Unit]
Creates a flow that waits for the given duration
- def succeed[A](value: Remote[A]): ZFlow[Any, ZNothing, A]
Creates a flow that returns the given remote value
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- def transaction[R, E, A](make: (ZFlowTransaction) => ZFlow[R, E, A]): ZFlow[R, E, A]
Creates a transactional flow.
Creates a transactional flow.
Within a transaction each accessed remote variable is tracked and in case they got modified from another flow before the transaction finishes, the whole transaction is going to be retried.
Activities executed within a transaction gets reverted in case of failure.
- val unit: ZFlow[Any, ZNothing, Unit]
A flow that returns the unit value
- def unwrap[R, E, A](remote: Remote[ZFlow[R, E, A]]): ZFlow[R, E, A]
Creates a flow that unwraps a remote flow value and executes it
- def unwrapRemote[A](remote: Remote[Remote[A]]): ZFlow[Any, ZNothing, A]
Creates a flow that unwraps a nested remote value
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- def waitTill(instant: Remote[flow.Instant]): ZFlow[Any, ZNothing, Unit]
Creates a flow that suspends execution until a given point in time
- def when[R, E, A](predicate: Remote[Boolean])(flow: ZFlow[R, E, A]): ZFlow[R, E, Unit]
Creates a flow that only runs the given flow if the given predicate is true
- object Await extends Serializable
- case object Die extends ZFlow[Any, Nothing, Nothing] with Product with Serializable
- object Ensuring extends Serializable
- object Fail extends Serializable
- object Fold extends Serializable
- object Fork extends Serializable
- object Input extends Serializable
- object Interrupt extends Serializable
- object Iterate extends Serializable
- object Log extends Serializable
- object Modify extends Serializable
- object NewVar extends Serializable
- case object Now extends ZFlow[Any, Nothing, flow.Instant] with Product with Serializable
- object OrTry extends Serializable
- object Provide extends Serializable
- case object Random extends ZFlow[Any, Nothing, Double] with Product with Serializable
- case object RandomUUID extends ZFlow[Any, Nothing, UUID] with Product with Serializable
- object Read extends Serializable
- case object RetryUntil extends ZFlow[Any, Nothing, Nothing] with Product with Serializable
- object Return extends Serializable
- object RunActivity extends Serializable
- object Timeout extends Serializable
- object Transaction extends Serializable
- object Unwrap extends Serializable
- object UnwrapRemote extends Serializable
- object WaitTill extends Serializable