zio
package zio
- Alphabetic
- By Inheritance
- zio
- DurationModule
- VersionSpecific
- IntersectionTypeCompat
- EitherCompat
- BuildFromCompat
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Package Members
- package internal
- package metrics
- package stm
- package stream
- package test
_ZIO Test_ is a featherweight testing library for effectful programs.
_ZIO Test_ is a featherweight testing library for effectful programs.
The library imagines every spec as an ordinary immutable value, providing tremendous potential for composition. Thanks to tight integration with ZIO, specs can use resources (including those requiring disposal), have well- defined linear and parallel semantics, and can benefit from a host of ZIO combinators.
import zio.test._ import zio.Clock.nanoTime object MyTest extends ZIOSpecDefault { def spec = suite("clock")( test("time is non-zero") { for { time <- Live.live(nanoTime) } yield assertTrue(time >= 0L) } ) }
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.
- type BuildFrom[-From, -A, +C] = scala.collection.BuildFrom[From, A, C]
- Definition Classes
- BuildFromCompat
- trait Cached[+Error, +Resource] extends AnyRef
A Cached is a possibly resourceful value that is loaded into memory, and which can be refreshed either manually or automatically.
- 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]
- 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. - trait ChunkLike[+A] extends IndexedSeq[A] with IndexedSeqOps[A, Chunk, Chunk[A]] with StrictOptimizedSeqOps[A, Chunk, Chunk[A]] with IterableFactoryDefaults[A, Chunk]
ChunkLike
represents the capability for aChunk
to extend Scala's collection library.ChunkLike
represents the capability for aChunk
to extend Scala's collection library. Because of changes to Scala's collection library in 2.13, separate versions of this trait are implemented for 2.12 and 2.13 / Dotty. This allows code inChunk
to be written without concern for the implementation details of Scala's collection library to the maximum extent possible.Note that
IndexedSeq
is not a referentially transparent interface in that it exposes methods that are partial (e.g.apply
), allocate mutable state (e.g.iterator
), or are purely side effecting (e.g.foreach
).Chunk
extendsIndexedSeq
to provide interoperability with Scala's collection library but users should avoid these methods whenever possible. - trait Clock extends Serializable
- sealed trait Config[+A] extends AnyRef
A zio.Config describes the structure of some configuration data.
- trait ConfigProvider extends AnyRef
A ConfigProvider is a service that provides configuration given a description of the structure of that configuration.
- trait Console extends Serializable
- trait Dequeue[+A] extends Serializable
A queue that can only be dequeued.
- trait Differ[Value, Patch] extends Serializable
A
Differ[Value, Patch]
knows how to compare an old value and new value of typeValue
to produce a patch of typePatch
that describes the differences between those values.A
Differ[Value, Patch]
knows how to compare an old value and new value of typeValue
to produce a patch of typePatch
that describes the differences between those values. ADiffer
also knows how to apply a patch to an old value to produce a new value that represents the old value updated with the changes described by the patch.A
Differ
can be used to construct aFiberRef
supporting compositional updates using theFiberRef.makePatch
constructor.The
Differ
companion object contains constructors forDiffer
values for common data types such asChunk
,Map
, andSet
. In addition,
Differvalues can be transformed using the
transformoperator and combined using the
orElseEitherand
zipoperators. This allows creating
Differvalues for arbitrarily complex data types compositionally.
- type Duration = java.time.Duration
- Definition Classes
- DurationModule
- trait DurationModule extends AnyRef
- final class DurationOps extends AnyVal
- final class DurationSyntax extends AnyVal
- trait Enqueue[-A] extends Serializable
A queue that can only be enqueued.
- 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.
- sealed trait Exit[+E, +A] extends ZIO[Any, E, A]
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
- 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.
- trait FiberRef[A] 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 _ <- child.join result <- fiberRef.get } yield result
Here
result
will be equal to "Hi!" since changes 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, identity[Int], 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. - 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. - abstract class Hub[A] extends Enqueue[A]
A
Hub
is an asynchronous message hub.A
Hub
is an asynchronous message hub. Publishers can offer messages to the hub and subscribers can subscribe to take messages from the hub. - 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.
If a fiber is interruptible but in wind-down mode, then it cannot be interrupted no matter what. The InterruptStatus of a fiber reflects only whether it is within an interruptible or uninterruptible region, regardless of wind-down mode.
- trait IsReloadable[Service] extends AnyRef
IsReloadable[Service]
provides evidence that we know enough about the structure of a service to create a reloadable version of it.IsReloadable[Service]
provides evidence that we know enough about the structure of a service to create a reloadable version of it.The
reloadable
function creates a reloadable instance of the service that forwards every ZIO method call to the underlying service, wrapped in a zio.ScopedRef. The reloadable servservice allows the service to change its behavior at runtime.- Annotations
- @implicitNotFound()
trait MyService { def foo: UIO[String] } val service1: MyService = new MyService { def foo = ZIO.succeed("zio1") } val service2: MyService = new MyService { def foo = ZIO.succeed("zio2") } for { ref <- ScopedRef.make(service1) reloadable = IsReloadable[MyService].reloadable(ref) res1 <- reloadable.foo _ <- ref.set(ZIO.succeed(service2)) res2 <- reloadable.foo } yield assertTrue(res1 == "zio1" && res2 == "zio2")
- Note
In order to successfully generate a reloadable service, the type
Service
must meet the following requirements:Service
should be either a trait or a class with a primary constructor without any term parameters.Service
should contain only ZIO methods or vals.Service
should not have any abstract type members.
Example: - trait IsReloadableVersionSpecific 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 LogAnnotation(key: String, value: String) extends Product with Serializable
A
LogAnnotation
represents a key value pair that allows annotating logs with additional information. - 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
- final class MakePartiallyApplied[R] extends AnyVal
- final class MakeSomePartiallyApplied[R0, R] extends AnyVal
- final class NonEmptyChunk[+A] extends Serializable
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.ZIO 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.ZIO 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
- final class ProvideSomeLayerPartiallyApplied[R0, -R, +E, +A] extends AnyVal
- abstract class Queue[A] extends Dequeue[A] with Enqueue[A]
A
Queue
is a lightweight, asynchronous queue into which values can be enqueued and of which elements can be dequeued. - type RIO[-R, +A] = ZIO[R, Throwable, A]
- type RLayer[-RIn, +ROut] = ZLayer[RIn, Throwable, ROut]
- trait Random extends Serializable
- abstract class Ref[A] extends Serializable
A
Ref
is a purely functional description of a mutable reference.A
Ref
is a purely functional description of a mutable reference. The fundamental operations of aRef
areset
andget
.set
sets the reference to a new value.get
gets the current value of the reference.By default,
Ref
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 aRef.Synchronized
, a specialized type ofRef
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.NOTE: While
Ref
provides the functional equivalent of a mutable reference, the value inside theRef
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 valueRef.Synchronized
will guarantee that access to the value is properly synchronized. - final case class Reloadable[Service](scopedRef: ScopedRef[Service], reload: IO[Any, Unit]) extends Product with Serializable
A Reloadable is an implementation of some service that can be dynamically reloaded, or swapped out for another implementation on-the-fly.
- trait Runtime[+R] extends AnyRef
A
Runtime[R]
is capable of executing tasks within an environmentR
. - sealed trait RuntimeFlag extends AnyRef
A RuntimeFlag is a flag that can be set to enable or disable a particular feature of the ZIO runtime.
- type RuntimeFlags = Int
- 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
- trait Scope extends Serializable
A
Scope
is the foundation of safe, composable resource management in ZIO.A
Scope
is the foundation of safe, composable resource management in ZIO. A scope has two fundamental operators,addFinalizer
, which adds a finalizer to the scope, andclose
, which closes a scope and runs all finalizers that have been added to the scope. - trait ScopedRef[A] extends AnyRef
A ScopedRef is a reference whose value is associated with resources, which must be released properly.
A ScopedRef is a reference whose value is associated with resources, which must be released properly. You can both get the current value of any ScopedRef, as well as set it to a new value (which may require new resources). The reference itself takes care of properly releasing resources for the old value whenever a new value is obtained.
- sealed trait Semaphore extends Serializable
An asynchronous semaphore, which is a generalization of a mutex.
An asynchronous semaphore, which is a generalization of a mutex. Semaphores have a certain number of permits, which can be held and released concurrently by different parties. Attempts to acquire more permits than available result in the acquiring fiber being suspended until the specified number of permits become available.
If you need functionality that
Semaphore
doesnt' provide, use a TSemaphore and define it in a zio.stm.ZSTM transaction. - final case class StackTrace(fiberId: FiberId, stackTrace: Chunk[Trace]) extends Product with Serializable
- 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]
- trait ThreadLocalBridge extends AnyRef
- type Trace = Type with Traced
- type UIO[+A] = ZIO[Any, Nothing, A]
- type ULayer[+ROut] = ZLayer[Any, Nothing, ROut]
- type URIO[-R, +A] = ZIO[R, Nothing, A]
- type URLayer[-RIn, +ROut] = ZLayer[RIn, Nothing, ROut]
- sealed trait Unsafe extends Serializable
A marker interface used to indicate that a method is side-effecting, partial, or potentially type unsafe, such that it might throw a ClassCastException if used improperly.
A marker interface used to indicate that a method is side-effecting, partial, or potentially type unsafe, such that it might throw a ClassCastException if used improperly. This marker interface is useful for certain low-level ZIO methods, to differentiate them from the higher-level methods, which are always pure, total, and type-safe.
import Unsafe.unsafe unsafe { ... }
- trait Unzippable[A, B] extends AnyRef
- trait UnzippableLowPriority1 extends UnzippableLowPriority2
- trait UnzippableLowPriority2 extends UnzippableLowPriority3
- trait UnzippableLowPriority3 extends AnyRef
- abstract type ZAny >: Any
- final class ZEnvironment[+R] extends Serializable
- sealed trait ZIO[-R, +E, +A] extends Product with Serializable with ZIOPlatformSpecific[R, E, A] with ZIOVersionSpecific[R, E, A]
A
ZIO[R, E, A]
value is an immutable value (called an "effect") that describes an async, concurrent workflow.A
ZIO[R, E, A]
value is an immutable value (called an "effect") that describes an async, concurrent workflow. In order to be executed, the workflow requires a value of typeZEnvironment[R]
, and when executed, the workflow will either produce a failure of typeE
, or a success of typeA
.ZIO effects may informally be thought of as functions of the following form:
ZEnvironment[R] => Either[E, A]
ZIO effects model resourceful interaction with the outside world, including synchronous, asynchronous, concurrent, and parallel interaction.
The async and concurrent operations of ZIO effects are powered by fibers, which are lightweight, green threads that enable 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 ZIOAppVersionSpecific extends AnyRef
- trait ZIOAspect[+LowerR, -UpperR, +LowerE, -UpperE, +LowerA, -UpperA] extends AnyRef
- trait ZIOCompanionVersionSpecific extends AnyRef
- trait ZInputStream extends AnyRef
- trait ZKeyedPool[+Err, -Key, Item] extends AnyRef
- 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 ZLayerAspect[+LowerRIn, -UpperRIn, +LowerE, -UpperE, +LowerROut, -UpperROut] extends AnyRef
- trait ZLogger[-Message, +Output] extends AnyRef
- abstract type ZNothing <: Nothing
- trait ZOutputStream 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
. - 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 a stateful workflow, use the
ZIO.stateful
operator to allocate the initial state. - trait Zippable[-A, -B] extends AnyRef
- trait ZippableLowPriority1 extends ZippableLowPriority2
- trait ZippableLowPriority2 extends ZippableLowPriority3
- trait ZippableLowPriority3 extends AnyRef
Value Members
- lazy val EnvironmentTag: izumi.reflect.Tag.type
- Definition Classes
- VersionSpecific
- 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 buildFromNothing[Collection[+Element] <: Iterable[Element] with IterableOps[Any, Collection, _]]: BuildFrom[Collection[Any], Nothing, Collection[Nothing]]
- Definition Classes
- BuildFromCompat
- 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
- case object BuildInfo extends Product with Serializable
This object was generated by sbt-buildinfo.
- object Cached
- object CanFail extends CanFail[Any]
- object Cause extends Serializable
- object Chunk extends ChunkFactory with ChunkPlatformSpecific
- object ChunkBuilder
- object Clock extends ClockPlatformSpecific with Serializable
- object Config
- object ConfigProvider
- object Console extends Serializable
- object DefaultServices
- object Differ 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 FiberRef extends Serializable
- object FiberRefs
- object Hub extends Serializable
- object InterruptStatus extends Serializable
- object IsReloadable extends IsReloadableVersionSpecific
- object IsSubtypeOfError extends Serializable
- object IsSubtypeOfOutput extends Serializable
- object LogLevel extends Serializable
- object NonEmptyChunk extends Serializable
- object Promise extends Serializable
- object Queue extends QueuePlatformSpecific with Serializable
- object Random extends Serializable
- object Ref extends Serializable
- object Reloadable extends Serializable
- object Runtime extends RuntimePlatformSpecific
- object RuntimeFlag
- object RuntimeFlags
Maintains a set of runtime flags.
Maintains a set of runtime flags. Runtime flags affect the operation of the ZIO runtime system. They are exposed to application-level code because they affect the behavior and performance of application code.
For more information on individual flags, see zio.RuntimeFlag.
- object Schedule extends Serializable
- object Scheduler
- object Scope extends Serializable
- object ScopedRef
- object Semaphore extends Serializable
- object StackTrace extends Serializable
- object Supervisor
- object System extends Serializable
- object Tag extends TagVersionSpecific with Serializable
- object ThreadLocalBridge
- object Trace
- object Unsafe extends Unsafe with UnsafeVersionSpecific
- object Unzippable extends UnzippableLowPriority1
- object ZEnvironment extends Serializable
- object ZIO extends ZIOCompanionPlatformSpecific with ZIOCompanionVersionSpecific with Serializable
- object ZIOApp
- object ZIOAppArgs extends Serializable
- object ZIOAppDefault
- object ZIOAspect
- object ZInputStream
- object ZKeyedPool
- object ZLayer extends ZLayerCompanionVersionSpecific
- object ZLayerAspect
- object ZLogger
- object ZOutputStream
- object ZPool
- object ZState
- object Zippable extends ZippableLowPriority1
- object ZippableLowPriority1