object ZFlow
- Alphabetic
- By Inheritance
- ZFlow
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
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( ... ) @native()
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): 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[_]
- 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( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @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
- 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
- object Now extends ZFlow[Any, Nothing, flow.Instant] with Product with Serializable
- object OrTry extends Serializable
- object Provide extends Serializable
- object Random extends ZFlow[Any, Nothing, Double] with Product with Serializable
- object RandomUUID extends ZFlow[Any, Nothing, UUID] with Product with Serializable
- object Read extends Serializable
- 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