zio
package zio
- Alphabetic
- By Inheritance
- zio
- DurationModule
- VersionSpecific
- IntersectionTypeCompat
- FunctionToLayerSyntax
- EitherCompat
- BuildFromCompat
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
-
type
&[+A, +B] = A with B
- Definition Classes
- IntersectionTypeCompat
-
abstract
class
=!=[A, B] extends Serializable
Evidence type
A
is not equal to typeB
.Evidence type
A
is not equal to typeB
.Based on https://github.com/milessabin/shapeless.
-
trait
Accessible[R] extends AnyRef
A simple, macro-less means of creating accessors from Services.
A simple, macro-less means of creating accessors from Services. Extend the companion object with
Accessible[ServiceName]
, then simply callCompanion(_.someMethod)
, to return a ZIO effect that requires the Service in its environment.Example:
trait FooService { def magicNumber: UIO[Int] def castSpell(chant: String): UIO[Boolean] } object FooService extends Accessible[FooService] val example: ZIO[FooService, Nothing, Unit] = for { int <- FooService(_.magicNumber) bool <- FooService(_.castSpell("Oogabooga!")) } yield ()
-
type
BuildFrom[-From, -A, +C] = CanBuildFrom[From, A, C]
- Definition Classes
- BuildFromCompat
-
implicit
class
BuildFromOps[From, A, C] extends AnyRef
- Definition Classes
- BuildFromCompat
-
sealed abstract
class
CanFail[-E] extends AnyRef
A value of type
CanFail[E]
provides implicit evidence that an effect with error typeE
can fail, that is, thatE
is not equal toNothing
. - abstract class CancelableFuture[+A] extends Future[A] with FutureTransformCompat[A]
- type Canceler[-R] = ZIO[R, Nothing, Any]
- sealed abstract class Cause[+E] extends Product with Serializable
-
sealed abstract
class
Chunk[+A] extends ChunkLike[A] with Serializable
A
Chunk[A]
represents a chunk of values of typeA
.A
Chunk[A]
represents a chunk of values of typeA
. Chunks are designed are usually backed by arrays, but expose a purely functional, safe interface to the underlying elements, and they become lazy on operations that would be costly with arrays, such as repeated concatenation.The implementation of balanced concatenation is based on the one for Conc-Trees in "Conc-Trees for Functional and Parallel Programming" by Aleksandar Prokopec and Martin Odersky. http://aleksandar-prokopec.com/resources/docs/lcpc-conc-trees.pdf
NOTE: For performance reasons
Chunk
does not box primitive types. As a result, it is not safe to construct chunks from heterogeneous primitive types. -
sealed abstract
class
ChunkBuilder[A] extends Builder[A, Chunk[A]]
A
ChunkBuilder[A]
can build aChunk[A]
given elements of typeA
.A
ChunkBuilder[A]
can build aChunk[A]
given elements of typeA
.ChunkBuilder
is a mutable data structure that is implemented to efficiently build chunks of unboxed primitives and for compatibility with the Scala collection library. -
sealed abstract
class
ChunkCanBuildFrom[A] extends CanBuildFrom[Chunk[Any], A, Chunk[A]]
ChunkCanBuildFrom
provides implicit evidence that a collection of typeChunk[A]
can be built from elements of typeA
.ChunkCanBuildFrom
provides implicit evidence that a collection of typeChunk[A]
can be built from elements of typeA
. Since aChunk[A]
can be built from elements of typeA
for any typeA
, this implicit evidence always exists. It is used primarily to provide proof that the target type of a collection operation is aChunk
to support high performance implementations of transformation operations for chunks. - trait Clock extends Serializable
- trait Console extends Serializable
- type Dequeue[+A] = ZQueue[Nothing, Any, Any, Nothing, Nothing, A]
-
type
Duration = java.time.Duration
- Definition Classes
- DurationModule
- trait DurationModule extends AnyRef
- final class DurationOps extends AnyVal
- final class DurationSyntax extends AnyVal
- type ERef[+E, A] = ZRef[Any, Any, E, E, A, A]
- type Enqueue[-A] = ZQueue[Any, Nothing, Nothing, Any, A, Any]
-
type
EnvironmentTag[A] = izumi.reflect.Tag[A]
- Definition Classes
- VersionSpecific
-
sealed abstract
class
ExecutionStrategy extends AnyRef
Describes a strategy for evaluating multiple effects, potentially in parallel.
Describes a strategy for evaluating multiple effects, potentially in parallel. There are three possible execution strategies:
Sequential
,Parallel
, andParallelN
. -
abstract
class
Executor extends ExecutorPlatformSpecific
An executor is responsible for executing actions.
An executor is responsible for executing actions. Each action is guaranteed to begin execution on a fresh stack frame.
- trait ExecutorPlatformSpecific extends AnyRef
-
sealed abstract
class
Exit[+E, +A] extends Product with Serializable
An
Exit[E, A]
describes the result of executing anIO
value.An
Exit[E, A]
describes the result of executing anIO
value. The result is either succeeded with a valueA
, or failed with aCause[E]
. - final case class ExitCode(code: Int) extends Product with Serializable
-
sealed abstract
class
Fiber[+E, +A] extends AnyRef
A fiber is a lightweight thread of execution that never consumes more than a whole thread (but may consume much less, depending on contention and asynchronicity).
A fiber is a lightweight thread of execution that never consumes more than a whole thread (but may consume much less, depending on contention and asynchronicity). Fibers are spawned by forking ZIO effects, which run concurrently with the parent effect.
Fibers can be joined, yielding their result to other fibers, or interrupted, which terminates the fiber, safely releasing all resources.
def parallel[A, B](io1: Task[A], io2: Task[B]): Task[(A, B)] = for { fiber1 <- io1.fork fiber2 <- io2.fork a <- fiber1.join b <- fiber2.join } yield (a, b)
-
final
case class
FiberFailure(cause: Cause[Any]) extends Throwable with Product with Serializable
Represents a failure in a fiber.
Represents a failure in a fiber. This could be caused by some non- recoverable error, such as a defect or system error, by some typed error, or by interruption (or combinations of all of the above).
This class is used to wrap ZIO failures into something that can be thrown, to better integrate with Scala exception handling.
-
sealed
trait
FiberId extends Serializable
The identity of a Fiber, described by the time it began life, and a monotonically increasing sequence number generated from an atomic counter.
- type FiberRef[A] = ZFiberRef[Nothing, Nothing, A, A]
-
final
class
FiberRefs extends AnyRef
FiberRefs
is a data type that represents a collection ofFiberRef
values.FiberRefs
is a data type that represents a collection ofFiberRef
values. This allows safely propagatingFiberRef
values across fiber boundaries, for example between an asynchronous producer and consumer. - trait FunctionToLayerSyntax extends AnyRef
-
implicit final
class
Function0ToLayerOps[A] extends AnyRef
- Definition Classes
- FunctionToLayerSyntax
-
implicit final
class
Function10ToLayerOps[A, B, C, D, E, F, G, H, I, J, K] extends AnyRef
- Definition Classes
- FunctionToLayerSyntax
-
implicit final
class
Function11ToLayerOps[A, B, C, D, E, F, G, H, I, J, K, L] extends AnyRef
- Definition Classes
- FunctionToLayerSyntax
-
implicit final
class
Function12ToLayerOps[A, B, C, D, E, F, G, H, I, J, K, L, M] extends AnyRef
- Definition Classes
- FunctionToLayerSyntax
-
implicit final
class
Function13ToLayerOps[A, B, C, D, E, F, G, H, I, J, K, L, M, N] extends AnyRef
- Definition Classes
- FunctionToLayerSyntax
-
implicit final
class
Function14ToLayerOps[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] extends AnyRef
- Definition Classes
- FunctionToLayerSyntax
-
implicit final
class
Function15ToLayerOps[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] extends AnyRef
- Definition Classes
- FunctionToLayerSyntax
-
implicit final
class
Function16ToLayerOps[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] extends AnyRef
- Definition Classes
- FunctionToLayerSyntax
-
implicit final
class
Function17ToLayerOps[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] extends AnyRef
- Definition Classes
- FunctionToLayerSyntax
-
implicit final
class
Function18ToLayerOps[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] extends AnyRef
- Definition Classes
- FunctionToLayerSyntax
-
implicit final
class
Function19ToLayerOps[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] extends AnyRef
- Definition Classes
- FunctionToLayerSyntax
-
implicit final
class
Function1ToLayerOps[A, B] extends AnyRef
- Definition Classes
- FunctionToLayerSyntax
-
implicit final
class
Function20ToLayerOps[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] extends AnyRef
- Definition Classes
- FunctionToLayerSyntax
-
implicit final
class
Function21ToLayerOps[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] extends AnyRef
- Definition Classes
- FunctionToLayerSyntax
-
implicit final
class
Function2ToLayerOps[A, B, C] extends AnyRef
- Definition Classes
- FunctionToLayerSyntax
-
implicit final
class
Function3ToLayerOps[A, B, C, D] extends AnyRef
- Definition Classes
- FunctionToLayerSyntax
-
implicit final
class
Function4ToLayerOps[A, B, C, D, E] extends AnyRef
- Definition Classes
- FunctionToLayerSyntax
-
implicit final
class
Function5ToLayerOps[A, B, C, D, E, F] extends AnyRef
- Definition Classes
- FunctionToLayerSyntax
-
implicit final
class
Function6ToLayerOps[A, B, C, D, E, F, G] extends AnyRef
- Definition Classes
- FunctionToLayerSyntax
-
implicit final
class
Function7ToLayerOps[A, B, C, D, E, F, G, H] extends AnyRef
- Definition Classes
- FunctionToLayerSyntax
-
implicit final
class
Function8ToLayerOps[A, B, C, D, E, F, G, H, I] extends AnyRef
- Definition Classes
- FunctionToLayerSyntax
-
implicit final
class
Function9ToLayerOps[A, B, C, D, E, F, G, H, I, J] extends AnyRef
- Definition Classes
- FunctionToLayerSyntax
- type Hub[A] = ZHub[Any, Any, Nothing, Nothing, A, A]
- type IO[+E, +A] = ZIO[Any, E, A]
-
sealed abstract
class
InterruptStatus extends Serializable with Product
The
InterruptStatus
of a fiber determines whether or not it can be interrupted.The
InterruptStatus
of a fiber determines whether or not it can be interrupted. The status can change over time in different regions. - trait IsNotIntersection[A] extends Serializable
- trait IsNotIntersectionVersionSpecific extends AnyRef
-
sealed abstract
class
IsSubtypeOfError[-A, +B] extends (A) ⇒ B with Serializable
- Annotations
- @implicitNotFound( ... )
-
sealed abstract
class
IsSubtypeOfOutput[-A, +B] extends (A) ⇒ B with Serializable
- Annotations
- @implicitNotFound( ... )
- type Layer[+E, +ROut] = ZLayer[Any, E, ROut]
-
type
LightTypeTag = izumi.reflect.macrortti.LightTypeTag
- Definition Classes
- VersionSpecific
-
final
case class
LogLevel(ordinal: Int, label: String, syslog: Int) extends ZIOAspect[Nothing, Any, Nothing, Any, Nothing, Any] with Product with Serializable
LogLevel represents the log level associated with an individual logging operation.
LogLevel represents the log level associated with an individual logging operation. Log levels are used both to describe the granularity (or importance) of individual log statements, as well as to enable tuning verbosity of log output.
- ordinal
The priority of the log message. Larger values indicate higher priority.
- label
A label associated with the log level.
- syslog
The syslog severity level of the log level. LogLevel values are ZIO aspects, and therefore can be used with aspect syntax.
myEffect @@ LogLevel.Info
- final case class LogSpan(label: String, startTime: Long) extends Product with Serializable
- type Managed[+E, +A] = ZManaged[Any, E, A]
-
final
case class
MetricLabel(key: String, value: String) extends Product with Serializable
A
MetricLabel
represents a key value pair that allows analyzing metrics at an additional level of granularity.A
MetricLabel
represents a key value pair that allows analyzing metrics at an additional level of granularity. For example if a metric tracks the response time of a service labels could be used to create separate versions that track response times for different clients. -
sealed abstract
class
NeedsEnv[+R] extends Serializable
A value of type
NeedsEnv[R]
provides implicit evidence that an effect with environment typeR
needs an environment, that is, thatR
is not equal toAny
. -
final
class
NonEmptyChunk[+A] extends AnyRef
A
NonEmptyChunk
is aChunk
that is guaranteed to contain at least one element.A
NonEmptyChunk
is aChunk
that is guaranteed to contain at least one element. As a result, operations which would not be safe when performed onChunk
, such ashead
orreduce
, are safe when performed onNonEmptyChunk
. Operations onNonEmptyChunk
which could potentially return an empty chunk will return aChunk
instead. -
final
class
Promise[E, A] extends Serializable
A promise represents an asynchronous variable, of zio.IO type, that can be set exactly once, with the ability for an arbitrary number of fibers to suspend (by calling
await
) and automatically resume when the variable is set.A promise represents an asynchronous variable, of zio.IO type, that can be set exactly once, with the ability for an arbitrary number of fibers to suspend (by calling
await
) and automatically resume when the variable is set.Promises can be used for building primitive actions whose completions require the coordinated action of multiple fibers, and for building higher-level concurrent or asynchronous structures.
for { promise <- Promise.make[Nothing, Int] _ <- promise.succeed(42).delay(1.second).fork value <- promise.await // Resumes when forked fiber completes promise } yield value
- type Queue[A] = ZQueue[Any, Any, Nothing, Nothing, A, A]
- type RIO[-R, +A] = ZIO[R, Throwable, A]
- type RLayer[-RIn, +ROut] = ZLayer[RIn, Throwable, ROut]
- type RManaged[-R, +A] = ZManaged[R, Throwable, A]
- trait Random extends Serializable
- type Ref[A] = ZRef[Any, Any, Nothing, Nothing, A, A]
-
final
case class
Reservation[-R, +E, +A](acquire: ZIO[R, E, A], release: (Exit[Any, Any]) ⇒ URIO[R, Any]) extends Product with Serializable
A
Reservation[-R, +E, +A]
encapsulates resource acquisition and disposal without specifying when or how that resource might be used.A
Reservation[-R, +E, +A]
encapsulates resource acquisition and disposal without specifying when or how that resource might be used.See ZManaged#reserve and ZIO#reserve for details of usage.
-
trait
Runtime[+R] extends AnyRef
A
Runtime[R]
is capable of executing tasks within an environmentR
. -
final
case class
RuntimeConfig(blockingExecutor: Executor, executor: Executor, fatal: (Throwable) ⇒ Boolean, reportFatal: (Throwable) ⇒ Nothing, supervisor: Supervisor[Any], loggers: Set[zio.&[String, Cause[Any]], Any], flags: RuntimeConfigFlags) extends Product with Serializable
A
RuntimeConfig
provides the minimum capabilities necessary to bootstrap execution ofZIO
tasks. - final case class RuntimeConfigAspect(customize: (RuntimeConfig) ⇒ RuntimeConfig) extends (RuntimeConfig) ⇒ RuntimeConfig with Product with Serializable
- sealed trait RuntimeConfigFlag extends AnyRef
- final case class RuntimeConfigFlags(flags: Set[RuntimeConfigFlag]) extends Product with Serializable
-
trait
Schedule[-Env, -In, +Out] extends Serializable
A
Schedule[Env, In, Out]
defines a recurring schedule, which consumes values of typeIn
, and which returns values of typeOut
.A
Schedule[Env, In, Out]
defines a recurring schedule, which consumes values of typeIn
, and which returns values of typeOut
.Schedules are defined as a possibly infinite set of intervals spread out over time. Each interval defines a window in which recurrence is possible.
When schedules are used to repeat or retry effects, the starting boundary of each interval produced by a schedule is used as the moment when the effect will be executed again.
Schedules compose in the following primary ways:
* Union. This performs the union of the intervals of two schedules. * Intersection. This performs the intersection of the intervals of two schedules. * Sequence. This concatenates the intervals of one schedule onto another.
In addition, schedule inputs and outputs can be transformed, filtered (to terminate a schedule early in response to some input or output), and so forth.
A variety of other operators exist for transforming and combining schedules, and the companion object for
Schedule
contains all common types of schedules, both for performing retrying, as well as performing repetition. - abstract class Scheduler extends AnyRef
- type Semaphore = TSemaphore
-
abstract
class
Supervisor[+A] extends AnyRef
A
Supervisor[A]
is allowed to supervise the launching and termination of fibers, producing some visible value of typeA
from the supervision. - trait System extends Serializable
- trait Tag[A] extends EnvironmentTag[A]
-
type
TagK[F[_]] = HKTag[AnyRef { type Arg[A] = F[A] }]
- Definition Classes
- VersionSpecific
-
type
TagK10[F[_, _, _, _, _, _, _, _, _, _]] = HKTag[AnyRef { type Arg[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9] = F[A0,A1,A2,A3,A4,A5,A6,A7,A8,A9] }]
- Definition Classes
- VersionSpecific
-
type
TagK11[F[_, _, _, _, _, _, _, _, _, _, _]] = HKTag[AnyRef { type Arg[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10] = F[A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10] }]
- Definition Classes
- VersionSpecific
-
type
TagK12[F[_, _, _, _, _, _, _, _, _, _, _, _]] = HKTag[AnyRef { type Arg[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11] = F[A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11] }]
- Definition Classes
- VersionSpecific
-
type
TagK13[F[_, _, _, _, _, _, _, _, _, _, _, _, _]] = HKTag[AnyRef { type Arg[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12] = F[A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12] }]
- Definition Classes
- VersionSpecific
-
type
TagK14[F[_, _, _, _, _, _, _, _, _, _, _, _, _, _]] = HKTag[AnyRef { type Arg[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13] = F[A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13] }]
- Definition Classes
- VersionSpecific
-
type
TagK15[F[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _]] = HKTag[AnyRef { type Arg[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14] = F[A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14] }]
- Definition Classes
- VersionSpecific
-
type
TagK16[F[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]] = HKTag[AnyRef { type Arg[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15] = F[A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15] }]
- Definition Classes
- VersionSpecific
-
type
TagK17[F[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]] = HKTag[AnyRef { type Arg[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16] = F[A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16] }]
- Definition Classes
- VersionSpecific
-
type
TagK18[F[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]] = HKTag[AnyRef { type Arg[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17] = F[A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17] }]
- Definition Classes
- VersionSpecific
-
type
TagK19[F[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]] = HKTag[AnyRef { type Arg[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18] = F[A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18] }]
- Definition Classes
- VersionSpecific
-
type
TagK20[F[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]] = HKTag[AnyRef { type Arg[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19] = F[A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18,A19] }]
- Definition Classes
- VersionSpecific
-
type
TagK21[F[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]] = HKTag[AnyRef { type Arg[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20] = F[A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18,A19,A20] }]
- Definition Classes
- VersionSpecific
-
type
TagK22[F[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]] = HKTag[AnyRef { type Arg[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21] = F[A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18,A19,A20,A21] }]
- Definition Classes
- VersionSpecific
-
type
TagK3[F[_, _, _]] = HKTag[AnyRef { type Arg[A, B, C] = F[A,B,C] }]
- Definition Classes
- VersionSpecific
-
type
TagK4[F[_, _, _, _]] = HKTag[AnyRef { type Arg[A0, A1, A2, A3] = F[A0,A1,A2,A3] }]
- Definition Classes
- VersionSpecific
-
type
TagK5[F[_, _, _, _, _]] = HKTag[AnyRef { type Arg[A0, A1, A2, A3, A4] = F[A0,A1,A2,A3,A4] }]
- Definition Classes
- VersionSpecific
-
type
TagK6[F[_, _, _, _, _, _]] = HKTag[AnyRef { type Arg[A0, A1, A2, A3, A4, A5] = F[A0,A1,A2,A3,A4,A5] }]
- Definition Classes
- VersionSpecific
-
type
TagK7[F[_, _, _, _, _, _, _]] = HKTag[AnyRef { type Arg[A0, A1, A2, A3, A4, A5, A6] = F[A0,A1,A2,A3,A4,A5,A6] }]
- Definition Classes
- VersionSpecific
-
type
TagK8[F[_, _, _, _, _, _, _, _]] = HKTag[AnyRef { type Arg[A0, A1, A2, A3, A4, A5, A6, A7] = F[A0,A1,A2,A3,A4,A5,A6,A7] }]
- Definition Classes
- VersionSpecific
-
type
TagK9[F[_, _, _, _, _, _, _, _, _]] = HKTag[AnyRef { type Arg[A0, A1, A2, A3, A4, A5, A6, A7, A8] = F[A0,A1,A2,A3,A4,A5,A6,A7,A8] }]
- Definition Classes
- VersionSpecific
-
type
TagKK[F[_, _]] = HKTag[AnyRef { type Arg[A, B] = F[A,B] }]
- Definition Classes
- VersionSpecific
- trait TagVersionSpecific extends AnyRef
- type Task[+A] = ZIO[Any, Throwable, A]
- type TaskLayer[+ROut] = ZLayer[Any, Throwable, ROut]
- type TaskManaged[+A] = ZManaged[Any, Throwable, A]
- type UIO[+A] = ZIO[Any, Nothing, A]
- type ULayer[+ROut] = ZLayer[Any, Nothing, ROut]
- type UManaged[+A] = ZManaged[Any, Nothing, A]
- type URIO[-R, +A] = ZIO[R, Nothing, A]
- type URLayer[-RIn, +ROut] = ZLayer[RIn, Nothing, ROut]
- type URManaged[-R, +A] = ZManaged[R, Nothing, A]
- trait Unzippable[A, B] extends AnyRef
- trait UnzippableLowPriority1 extends UnzippableLowPriority2
- trait UnzippableLowPriority2 extends UnzippableLowPriority3
- trait UnzippableLowPriority3 extends AnyRef
-
type
ZDequeue[-R, +E, +A] = ZQueue[Nothing, R, Any, E, Nothing, A]
A queue that can only be dequeued.
-
type
ZEnqueue[-R, +E, -A] = ZQueue[R, Nothing, E, Any, A, Any]
A queue that can only be enqueued.
- type ZEnv = Clock with Console with System with Random
- final class ZEnvironment[+R] extends Serializable
-
sealed abstract
class
ZFiberRef[+EA, +EB, -A, +B] extends Serializable
A
FiberRef
is ZIO's equivalent of Java'sThreadLocal
.A
FiberRef
is ZIO's equivalent of Java'sThreadLocal
. The value of aFiberRef
is automatically propagated to child fibers when they are forked and merged back in to the value of the parent fiber after they are joined.for { fiberRef <- FiberRef.make("Hello world!") child <- fiberRef.set("Hi!).fork result <- child.join } yield result
Here
result
will be equal to "Hi!" since changed made by a child fiber are merged back in to the value of the parent fiber on join.By default the value of the child fiber will replace the value of the parent fiber on join but you can specify your own logic for how values should be merged.
for { fiberRef <- FiberRef.make(0, math.max) child <- fiberRef.update(_ + 1).fork _ <- fiberRef.update(_ + 2) _ <- child.join value <- fiberRef.get } yield value
Here
value
will be 2 as the value in the joined fiber is lower and we specifiedmax
as our combining function. -
sealed abstract
class
ZHub[-RA, -RB, +EA, +EB, -A, +B] extends Serializable
A
ZHub[RA, RB, EA, EB, A, B]
is an asynchronous message hub.A
ZHub[RA, RB, EA, EB, A, B]
is an asynchronous message hub. Publishers can publish messages of typeA
to the hub and subscribers can subscribe to take messages of typeB
from the hub. Publishing messages can require an environment of typeRA
and fail with an error of typeEA
. Taking messages can require an environment of typeRB
and fail with an error of typeEB
. -
sealed
trait
ZIO[-R, +E, +A] extends Serializable with ZIOPlatformSpecific[R, E, A] with ZIOVersionSpecific[R, E, A]
A
ZIO[R, E, A]
value is an immutable value that lazily describes a workflow or job.A
ZIO[R, E, A]
value is an immutable value that lazily describes a workflow or job. The workflow requires some environmentR
, and may fail with an error of typeE
, or succeed with a value of typeA
.These lazy workflows, referred to as _effects_, can be informally thought of as functions in the form:
R => Either[E, A]
ZIO effects model resourceful interaction with the outside world, including synchronous, asynchronous, concurrent, and parallel interaction.
ZIO effects use a fiber-based concurrency model, with built-in support for scheduling, fine-grained interruption, structured concurrency, and high scalability.
To run an effect, you need a
Runtime
, which is capable of executing effects. Runtimes bundle a thread pool together with the environment that effects need. -
trait
ZIOApp extends ZIOAppPlatformSpecific with ZIOAppVersionSpecific
An entry point for a ZIO application that allows sharing layers between applications.
An entry point for a ZIO application that allows sharing layers between applications. For a simpler version that uses the default ZIO environment see
ZIOAppDefault
. -
final
case class
ZIOAppArgs(getArgs: Chunk[String]) extends Product with Serializable
A service that contains command-line arguments of an application.
-
trait
ZIOAppDefault extends ZIOApp
The entry point for a ZIO application.
The entry point for a ZIO application.
import zio.ZIOAppDefault import zio.Console._ object MyApp extends ZIOAppDefault { def run = for { _ <- printLine("Hello! What is your name?") n <- readLine _ <- printLine("Hello, " + n + ", good to meet you!") } yield () }
- trait ZIOAppPlatformSpecific extends AnyRef
- trait ZIOAppVersionSpecific extends AnyRef
- trait ZIOAspect[+LowerR, -UpperR, +LowerE, -UpperE, +LowerA, -UpperA] extends AnyRef
-
sealed
trait
ZIOMetric[-A] extends ZIOAspect[Nothing, Any, Nothing, Any, Nothing, A]
A
ZIOMetric
is able to add collection of metrics to aZIO
effect without changing its environment or error types.A
ZIOMetric
is able to add collection of metrics to aZIO
effect without changing its environment or error types. Aspects are the idiomatic way of adding collection of metrics to effects. -
sealed abstract
class
ZLayer[-RIn, +E, +ROut] extends AnyRef
A
ZLayer[E, A, B]
describes how to build one or more services in your application.A
ZLayer[E, A, B]
describes how to build one or more services in your application. Services can be injected into effects via ZIO#provide. Effects can require services via ZIO.service."Layer can be thought of as recipes for producing bundles of services, given their dependencies (other services).
Construction of services can be effectful and utilize resources that must be acquired and safely released when the services are done being utilized.
By default layers are shared, meaning that if the same layer is used twice the layer will only be allocated a single time.
Because of their excellent composition properties, layers are the idiomatic way in ZIO to create services that depend on other services.
- trait ZLogger[-Message, +Output] extends AnyRef
-
sealed abstract
class
ZManaged[-R, +E, +A] extends ZManagedVersionSpecific[R, E, A] with Serializable
A
ZManaged[R, E, A]
is a managed resource of typeA
, which may be used by invoking theuse
method of the resource.A
ZManaged[R, E, A]
is a managed resource of typeA
, which may be used by invoking theuse
method of the resource. The resource will be automatically acquired before the resource is used, and automatically released after the resource is used.Resources do not survive the scope of
use
, meaning that if you attempt to capture the resource, leak it fromuse
, and then use it after the resource has been consumed, the resource will not be valid anymore and may fail with some checked error, as per the type of the functions provided by the resource. - trait ZManagedAspect[+LowerR, -UpperR, +LowerE, -UpperE, +LowerA, -UpperA] extends AnyRef
-
trait
ZPool[+Error, Item] extends AnyRef
A
ZPool[E, A]
is a pool of items of typeA
, each of which may be associated with the acquisition and release of resources.A
ZPool[E, A]
is a pool of items of typeA
, each of which may be associated with the acquisition and release of resources. An attempt to get an itemA
from a pool may fail with an error of typeE
. -
abstract
class
ZQueue[-RA, -RB, +EA, +EB, -A, +B] extends Serializable
A
ZQueue[RA, RB, EA, EB, A, B]
is a lightweight, asynchronous queue into which values of typeA
can be enqueued and of which elements of typeB
can be dequeued.A
ZQueue[RA, RB, EA, EB, A, B]
is a lightweight, asynchronous queue into which values of typeA
can be enqueued and of which elements of typeB
can be dequeued. The queue's enqueueing operations may utilize an environment of typeRA
and may fail with errors of typeEA
. The dequeueing operations may utilize an environment of typeRB
and may fail with errors of typeEB
. -
sealed abstract
class
ZRef[-RA, -RB, +EA, +EB, -A, +B] extends Serializable
A
ZRef[RA, RB, EA, EB, A, B]
is a polymorphic, purely functional description of a mutable reference.A
ZRef[RA, RB, EA, EB, A, B]
is a polymorphic, purely functional description of a mutable reference. The fundamental operations of aZRef
areset
andget
.set
takes a value of typeA
and sets the reference to a new value, requiring an environment of typeRA
and potentially failing with an error of typeEA
.get
gets the current value of the reference and returns a value of typeB
, requiring an environment of typeRB
and potentially failing with an error of typeEB
.When the error and value types of the
ZRef
are unified, that is, it is aZRef[R, R, E, E, A, A]
, theZRef
also supports atomicmodify
andupdate
operations. All operations are guaranteed to be safe for concurrent access.By default,
ZRef
is implemented in terms of compare and swap operations for maximum performance and does not support performing effects within update operations. If you need to perform effects within update operations you can create aZRef.Synchronized
, a specialized type ofZRef
that supports performing effects within update operations at some cost to performance. In this case writes will semantically block other writers, while multiple readers can read simultaneously.ZRef.Synchronized
also supports composing multipleZRef.Synchronized
values together to form a singleZRef.Synchronized
value that can be atomically updated using thezip
operator. In this case reads and writes will semantically block other readers and writers.NOTE: While
ZRef
provides the functional equivalent of a mutable reference, the value inside theZRef
should normally be immutable since compare and swap operations are not safe for mutable values that do not support concurrent access. If you do need to use a mutable valueZRef.Synchronized
will guarantee that access to the value is properly synchronized. -
sealed
trait
ZScope extends AnyRef
A
ZScope
represents the scope of a fiber lifetime.A
ZScope
represents the scope of a fiber lifetime. The scope of a fiber can be retrieved using ZIO.scope, and when forking fibers, you can specify a custom scope to fork them on by using the ZIO#forkIn. -
sealed
trait
ZState[S] extends AnyRef
ZState[S]
models a value of typeS
that can be read from and written to during the execution of an effect.ZState[S]
models a value of typeS
that can be read from and written to during the execution of an effect. The idiomatic way to work withZState
is as part of the environment using operators defined onZIO
. For example:final case class MyState(counter: Int) for { _ <- ZIO.updateState[MyState](state => state.copy(counter = state.counter + 1)) count <- ZIO.getStateWith[MyState](_.counter) } yield count
Because
ZState
is typically used as part of the environment, it is recommended to define your own state typeS
such asMyState
above rather than using a type such asInt
to avoid the risk of ambiguity.To run an effect that depends on some state, create the initial state with the
make
constructor and then usetoLayer
to convert it into a service builder that you can provide along with your application's other services. - final case class ZTrace(fiberId: FiberId, stackTrace: Chunk[ZTraceElement]) extends Product with Serializable
- type ZTraceElement = Type with Traced
- trait Zippable[-A, -B] extends AnyRef
- trait ZippableLowPriority1 extends ZippableLowPriority2
- trait ZippableLowPriority2 extends ZippableLowPriority3
- trait ZippableLowPriority3 extends AnyRef
-
trait
App extends ZApp[ZEnv] with BootstrapRuntime
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) Use zio.ZIOAppDefault
-
trait
BootstrapRuntime extends ZBootstrapRuntime[ZEnv]
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) Use zio.Runtime
-
type
ERefM[+E, A] = Synchronized[Any, Any, E, E, A, A]
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use ERef.Synchronized
-
trait
ManagedApp extends BootstrapRuntime
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) Use zio.ZIOApp and use the managed inside
run
-
type
RefM[A] = Synchronized[Any, Any, Nothing, Nothing, A, A]
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use Ref.Synchronized
-
trait
ZApp[R] extends Runtime[R]
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) Use zio.ZIOApp
-
trait
ZBootstrapRuntime[R] extends Runtime[R]
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) Use Runtime
-
type
ZRefM[-RA, -RB, +EA, +EB, -A, +B] = Synchronized[RA, RB, EA, EB, A, B]
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use ZRef.Synchronized
Value Members
- val ERef: ZRef.type
-
lazy val
EnvironmentTag: izumi.reflect.Tag.type
- Definition Classes
- VersionSpecific
- val FiberRef: ZFiberRef.type
- val Hub: ZHub.type
- val Managed: ZManaged.type
- val Queue: ZQueue.type
-
lazy val
TagK: izumi.reflect.TagK.type
- Definition Classes
- VersionSpecific
-
lazy val
TagK3: izumi.reflect.TagK3.type
- Definition Classes
- VersionSpecific
-
lazy val
TagKK: izumi.reflect.TagKK.type
- Definition Classes
- VersionSpecific
-
implicit
def
duration2DurationOps(duration: Duration): DurationOps
- Definition Classes
- DurationModule
-
implicit
def
durationInt(n: Int): DurationSyntax
- Definition Classes
- DurationModule
-
implicit
def
durationLong(n: Long): DurationSyntax
- Definition Classes
- DurationModule
-
implicit
val
durationOrdering: Ordering[Duration]
- Definition Classes
- DurationModule
- object =!= extends Serializable
-
object
BuildInfo extends Product with Serializable
This object was generated by sbt-buildinfo.
- object CanFail extends CanFail[Any]
- object Cause extends Serializable
- object Chunk extends IndexedSeqFactory[Chunk] with ChunkFactory with ChunkPlatformSpecific with Serializable
- object ChunkBuilder
- object ChunkCanBuildFrom
- object ChunkLike
- object Clock extends ClockPlatformSpecific with Serializable
- object Console extends Serializable
- object Duration
- object ExecutionStrategy
- object Executor extends DefaultExecutors with Serializable
- object Exit extends Serializable
- object ExitCode extends Serializable
- object Fiber extends FiberPlatformSpecific
- object FiberId extends Serializable
- object FiberRefs
- object IO
- object InterruptStatus extends Serializable
- object IsNotIntersection extends IsNotIntersectionVersionSpecific with Serializable
- object IsSubtypeOfError extends Serializable
- object IsSubtypeOfOutput extends Serializable
- object LogLevel extends Serializable
- object NeedsEnv extends NeedsEnv[Nothing]
- object NonEmptyChunk
- object Promise extends Serializable
- object RIO
- object Random extends Serializable
- object Ref extends Serializable
- object Runtime
- object RuntimeConfig extends RuntimeConfigPlatformSpecific with Serializable
- object RuntimeConfigAspect extends ((RuntimeConfig) ⇒ RuntimeConfig) ⇒ RuntimeConfigAspect with Serializable
- object RuntimeConfigFlag
- object RuntimeConfigFlags extends Serializable
- object Schedule extends Serializable
- object Scheduler
- object Semaphore
- object Supervisor
- object System extends Serializable
- object Tag extends TagVersionSpecific
- object Task extends TaskPlatformSpecific
- object UIO
- object URIO
- object Unzippable extends UnzippableLowPriority1
- object ZEnv
- object ZEnvironment extends Serializable
- object ZFiberRef extends Serializable
- object ZHub extends Serializable
- object ZIO extends ZIOCompanionPlatformSpecific with Serializable
- object ZIOApp
- object ZIOAppArgs extends Serializable
- object ZIOAppDefault
- object ZIOAspect
- object ZIOMetric
- object ZLayer extends ZLayerCompanionVersionSpecific
- object ZLogger
- object ZManaged extends ZManagedPlatformSpecific with Serializable
- object ZPool
- object ZQueue extends Serializable
- object ZRef extends Serializable
- object ZScope
- object ZState
- object ZTrace extends Serializable
- object ZTraceElement
- object Zippable extends ZippableLowPriority1