zio
package zio
- Alphabetic
- By Inheritance
- zio
- VersionSpecific
- PlatformSpecific
- EitherCompat
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Package Members
Type Members
- trait =!=[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 App extends BootstrapRuntime
- trait BootstrapRuntime extends Runtime[ZEnv]
- sealed trait 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 trait Cause[+E] extends Product with Serializable
- sealed trait Chunk[+A] extends ChunkLike[A]
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.NOTE: For performance reasons
Chunk
does not box primitive types. As a result, it is not safe to construct chunks from heteregenous primitive types. - 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.11 / 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. - type Dequeue[+A] = ZQueue[Nothing, Any, Any, Nothing, Nothing, A]
A queue that can only be dequeued.
- type ERef[+E, A] = ZRef[E, E, A, A]
- type ERefM[+E, A] = ZRefM[Any, Any, E, E, A, A]
- sealed trait 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
. - sealed trait 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]
. - sealed trait 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.
- final class FiberRef[A] extends Serializable
Fiber's counterpart for Java's
ThreadLocal
.Fiber's counterpart for Java's
ThreadLocal
. Value is automatically propagated to child on fork and merged back in after joining child.for { fiberRef <- FiberRef.make("Hello world!") child <- fiberRef.set("Hi!).fork result <- child.join } yield result
result
will be equal to "Hi!" as changes done by child were merged on join.FiberRef#make also allows specifying how the values will be combined when joining. By default this will use the value of the joined fiber. for { fiberRef <- FiberRef.make(0, math.max) child <- fiberRef.update(_ + 1).fork _ <- fiberRef.update(_ + 2) _ <- child.join value <- fiberRef.get } yield value }}}
value
will be 2 as the value in the joined fiber is lower and we specifiedmax
as our combine function. - final class Has[A] extends Serializable
The trait
Has[A]
is used with ZIO environment to express an effect's dependency on a service of typeA
.The trait
Has[A]
is used with ZIO environment to express an effect's dependency on a service of typeA
. For example,RIO[Has[Console.Service], Unit]
is an effect that requires aConsole.Service
service. Inside the ZIO library, type aliases are provided as shorthands for common services, e.g.:type Console = Has[ConsoleService]
Services parameterized on path dependent types are not supported.
- 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. - type Layer[+E, +ROut] = ZLayer[Any, E, ROut]
- type LightTypeTag = izumi.reflect.macrortti.LightTypeTag
- Definition Classes
- VersionSpecific
- type Managed[+E, +A] = ZManaged[Any, E, A]
- trait ManagedApp extends BootstrapRuntime
- sealed trait NeedsEnv[+R] extends AnyRef
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]
- type Ref[A] = ZRef[Nothing, Nothing, A, A]
- type RefM[A] = ZRefM[Any, Any, Nothing, Nothing, A, A]
- final case class Reservation[-R, +E, +A](acquire: ZIO[R, E, A], release: (Exit[Any, Any]) => ZIO[R, Nothing, 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
. - trait Schedule[-R, -A, +B] extends Serializable
Defines a stateful, possibly effectful, recurring schedule of actions.
Defines a stateful, possibly effectful, recurring schedule of actions.
A
Schedule[R, A, B]
consumesA
values, and based on the inputs and the internal state, decides whether to continue or halt. Every decision is accompanied by a (possibly zero) delay, and an output value of typeB
.Schedules compose in each of the following ways:
1. Intersection, using the
&&
operator, which requires that both schedules continue, using the longer of the two durations. 2. Union, using the||
operator, which requires that only one schedule continues, using the shorter of the two durations. 3. Sequence, using the<||>
operator, which runs the first schedule until it ends, and then switches over to the second schedule.Schedule[R, A, B]
forms a profunctor on[A, B]
, an applicative functor onB
, and a monoid, allowing rich composition of different schedules. - final class 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.
- type Tag[A] = izumi.reflect.Tag[A]
- Definition Classes
- VersionSpecific
- 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
- type Task[+A] = ZIO[Any, Throwable, A]
- type TaskLayer[+ROut] = ZLayer[Any, Throwable, ROut]
- type TaskManaged[+A] = ZManaged[Any, Throwable, A]
- sealed abstract class TracingStatus extends Serializable with Product
Whether ZIO Tracing is enabled for the current fiber in the current region.
- 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]
- type ZEnv = Clock with Console with System with Random
- Definition Classes
- PlatformSpecific
- sealed trait ZIO[-R, +E, +A] extends Serializable with ZIOPlatformSpecific[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. - sealed trait ZLayer[-RIn, +E, +ROut] extends AnyRef
A
ZLayer[A, E, B]
describes a layer of an application: every layer in an application requires some services (the input) and produces some services (the output).A
ZLayer[A, E, B]
describes a layer of an application: every layer in an application requires some services (the input) and produces some services (the output).Layers can be thought of as recipes for producing bundles of services, given their dependencies (other services).
Construction of layers 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.
- final class ZManaged[-R, +E, +A] extends 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 ZQueue[-RA, -RB, +EA, +EB, -A, +B] extends Serializable
A
ZQueue[RA, EA, RB, 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, EA, RB, 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 trait ZRef[+EA, +EB, -A, +B] extends Serializable
A
ZRef[EA, EB, A, B]
is a polymorphic, purely functional description of a mutable reference.A
ZRef[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, potentially failing with an error of typeEA
.get
gets the current value of the reference and returns a value of typeB
, potentially failing with an error of typeEB
.When the error and value types of the
ZRef
are unified, that is, it is aZRef[E, E, A, A]
, theZRef
also supports atomicmodify
andupdate
operations. All operations are guaranteed to be safe for concurrent access.NOTE: While
ZRef
provides the functional equivalent of a mutable reference, the value inside theZRef
should be immutable. For performance reasonsZRef
is implemented in terms of compare and swap operations rather than synchronization. These operations are not safe for mutable values that do not support concurrent access. - sealed trait ZRefM[-RA, -RB, +EA, +EB, -A, +B] extends AnyRef
A
ZRefM[RA, RB, EA, EB, A, B]
is a polymorphic, purely functional description of a mutable reference.A
ZRefM[RA, RB, EA, EB, A, B]
is a polymorphic, purely functional description of a mutable reference. The fundamental operations of aZRefM
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
ZRefM
are unified, that is, it is aZRefM[E, E, A, A]
, theZRefM
also supports atomicmodify
andupdate
operations.Unlike
ZRef
,ZRefM
allows performing effects within update operations, at some cost to performance. Writes will semantically block other writers, while multiple readers can read simultaneously. - final case class ZTrace(fiberId: Id, executionTrace: List[ZTraceElement], stackTrace: List[ZTraceElement], parentTrace: Option[ZTrace]) extends Product with Serializable
Deprecated Type Members
- type Tagged[A] = izumi.reflect.Tag[A]
- Definition Classes
- VersionSpecific
- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) use Tag
- type TaggedF[F[_]] = HKTag[AnyRef { type Arg[A] = F[A] }]
- Definition Classes
- VersionSpecific
- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) use TagK
- type TaggedF10[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
- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) use TagK10
- type TaggedF11[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
- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) use TagK11
- type TaggedF12[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
- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) use TagK12
- type TaggedF13[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
- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) use TagK13
- type TaggedF14[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
- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) use TagK14
- type TaggedF15[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
- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) use TagK15
- type TaggedF16[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
- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) use TagK16
- type TaggedF17[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
- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) use TagK17
- type TaggedF18[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
- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) use TagK18
- type TaggedF19[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
- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) use TagK19
- type TaggedF2[F[_, _]] = HKTag[AnyRef { type Arg[A, B] = F[A,B] }]
- Definition Classes
- VersionSpecific
- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) use TagKK
- type TaggedF20[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
- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) use TagK20
- type TaggedF21[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
- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) use TagK21
- type TaggedF22[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
- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) use TagK22
- type TaggedF3[F[_, _, _]] = HKTag[AnyRef { type Arg[A, B, C] = F[A,B,C] }]
- Definition Classes
- VersionSpecific
- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) use TagK3
- type TaggedF4[F[_, _, _, _]] = HKTag[AnyRef { type Arg[A0, A1, A2, A3] = F[A0,A1,A2,A3] }]
- Definition Classes
- VersionSpecific
- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) use TagK4
- type TaggedF5[F[_, _, _, _, _]] = HKTag[AnyRef { type Arg[A0, A1, A2, A3, A4] = F[A0,A1,A2,A3,A4] }]
- Definition Classes
- VersionSpecific
- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) use TagK5
- type TaggedF6[F[_, _, _, _, _, _]] = HKTag[AnyRef { type Arg[A0, A1, A2, A3, A4, A5] = F[A0,A1,A2,A3,A4,A5] }]
- Definition Classes
- VersionSpecific
- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) use TagK6
- type TaggedF7[F[_, _, _, _, _, _, _]] = HKTag[AnyRef { type Arg[A0, A1, A2, A3, A4, A5, A6] = F[A0,A1,A2,A3,A4,A5,A6] }]
- Definition Classes
- VersionSpecific
- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) use TagK7
- type TaggedF8[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
- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) use TagK8
- type TaggedF9[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
- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) use TagK9
- type TypeTag = izumi.reflect.macrortti.LightTypeTag
- Definition Classes
- VersionSpecific
- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) use LightTypeTag
Value Members
- val Managed: ZManaged.type
- lazy val Tag: 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
- object <*>
- 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
- object ChunkLike extends SeqFactory[Chunk]
- object ExecutionStrategy
- object Exit extends Serializable
- object Fiber extends FiberPlatformSpecific
- object FiberRef extends Serializable
- object Has extends Serializable
- object IO
- object InterruptStatus extends Serializable
- object NeedsEnv extends NeedsEnv[Nothing]
- object NonEmptyChunk
- object Promise extends Serializable
- object Queue
- object RIO
- object Ref extends Serializable
- object RefM
- object Runtime
- object Schedule extends Serializable
- object Semaphore extends Serializable
- object Task extends TaskPlatformSpecific
- object TracingStatus extends Serializable
- object UIO
- object URIO
- object ZEnv
- Definition Classes
- PlatformSpecific
- object ZIO extends ZIOCompanionPlatformSpecific with Serializable
- object ZLayer
- object ZManaged extends Serializable
- object ZQueue extends Serializable
- object ZRef extends Serializable
- object ZRefM
- object ZTrace extends Serializable