Packages

p

zio

package zio

Linear Supertypes
DurationModule, VersionSpecific, IntersectionTypeCompat, FunctionToServiceBuilderOps, EitherCompat, BuildFromCompat, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. zio
  2. DurationModule
  3. VersionSpecific
  4. IntersectionTypeCompat
  5. FunctionToServiceBuilderOps
  6. EitherCompat
  7. BuildFromCompat
  8. AnyRef
  9. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Package Members

  1. package concurrent
  2. package internal
  3. package metrics
  4. package stm
  5. package stream
  6. 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
    import Assertion.isGreaterThan
    
    object MyTest extends DefaultRunnableSpec {
      def spec = suite("clock")(
        test("time is non-zero") {
          for {
            time <- Live.live(nanoTime)
          } yield assertTrue(time >= 0)
        }
      )
    }

Type Members

  1. type &[+A, +B] = A with B
    Definition Classes
    IntersectionTypeCompat
  2. abstract class =!=[A, B] extends Serializable

    Evidence type A is not equal to type B.

    Evidence type A is not equal to type B.

    Based on https://github.com/milessabin/shapeless.

  3. 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 call Companion(_.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[Has[FooService], Nothing, Unit] =
      for {
        int  <- FooService(_.magicNumber)
        bool <- FooService(_.castSpell("Oogabooga!"))
      } yield ()
  4. type BuildFrom[-From, -A, +C] = scala.collection.BuildFrom[From, A, C]
    Definition Classes
    BuildFromCompat
  5. sealed abstract class CanFail[-E] extends AnyRef

    A value of type CanFail[E] provides implicit evidence that an effect with error type E can fail, that is, that E is not equal to Nothing.

  6. abstract class CancelableFuture[+A] extends Future[A] with FutureTransformCompat[A]
  7. type Canceler[-R] = ZIO[R, Nothing, Any]
  8. sealed abstract class Cause[+E] extends Product with Serializable
  9. sealed abstract class Chunk[+A] extends ChunkLike[A] with Serializable

    A Chunk[A] represents a chunk of values of type A.

    A Chunk[A] represents a chunk of values of type A. 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.

  10. sealed abstract class ChunkBuilder[A] extends Builder[A, Chunk[A]]

    A ChunkBuilder[A] can build a Chunk[A] given elements of type A.

    A ChunkBuilder[A] can build a Chunk[A] given elements of type A. ChunkBuilder is a mutable data structure that is implemented to efficiently build chunks of unboxed primitives and for compatibility with the Scala collection library.

  11. 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 a Chunk to extend Scala's collection library.

    ChunkLike represents the capability for a Chunk 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 in Chunk 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 extends IndexedSeq to provide interoperability with Scala's collection library but users should avoid these methods whenever possible.

  12. trait Clock extends Serializable
  13. trait ComposeLowPriorityImplicits extends AnyRef
  14. trait Console extends Serializable
  15. type Dequeue[+A] = ZQueue[Nothing, Any, Any, Nothing, Nothing, A]
  16. type Duration = java.time.Duration
    Definition Classes
    DurationModule
  17. trait DurationModule extends AnyRef
  18. final class DurationOps extends AnyVal
  19. final class DurationSyntax extends AnyVal
  20. type ERef[+E, A] = ZRef[Any, Any, E, E, A, A]
  21. type Enqueue[-A] = ZQueue[Any, Nothing, Nothing, Any, A, Any]
  22. 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, and ParallelN.

  23. 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.

  24. trait ExecutorPlatformSpecific extends AnyRef
  25. sealed abstract class Exit[+E, +A] extends Product with Serializable

    An Exit[E, A] describes the result of executing an IO value.

    An Exit[E, A] describes the result of executing an IO value. The result is either succeeded with a value A, or failed with a Cause[E].

  26. final case class ExitCode(code: Int) extends Product with Serializable
  27. 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)
  28. 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.

  29. 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.

  30. type FiberRef[A] = ZFiberRef[Nothing, Nothing, A, A]
  31. final class FiberRefs extends AnyRef

    FiberRefs is a data type that represents a collection of FiberRef values.

    FiberRefs is a data type that represents a collection of FiberRef values. This allows safely propagating FiberRef values across fiber boundaries, for example between an asynchronous producer and consumer.

  32. trait FunctionToServiceBuilderOps extends AnyRef
  33. implicit final class Function0ToServiceBuilderSyntax[A] extends AnyRef
    Definition Classes
    FunctionToServiceBuilderOps
  34. implicit final class Function10ToServiceBuilderSyntax[A, B, C, D, E, F, G, H, I, J, K] extends AnyRef
    Definition Classes
    FunctionToServiceBuilderOps
  35. implicit final class Function11ToServiceBuilderSyntax[A, B, C, D, E, F, G, H, I, J, K, L] extends AnyRef
    Definition Classes
    FunctionToServiceBuilderOps
  36. implicit final class Function12ToServiceBuilderSyntax[A, B, C, D, E, F, G, H, I, J, K, L, M] extends AnyRef
    Definition Classes
    FunctionToServiceBuilderOps
  37. implicit final class Function13ToServiceBuilderSyntax[A, B, C, D, E, F, G, H, I, J, K, L, M, N] extends AnyRef
    Definition Classes
    FunctionToServiceBuilderOps
  38. implicit final class Function14ToServiceBuilderSyntax[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] extends AnyRef
    Definition Classes
    FunctionToServiceBuilderOps
  39. implicit final class Function15ToServiceBuilderSyntax[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] extends AnyRef
    Definition Classes
    FunctionToServiceBuilderOps
  40. implicit final class Function16ToServiceBuilderSyntax[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] extends AnyRef
    Definition Classes
    FunctionToServiceBuilderOps
  41. implicit final class Function17ToServiceBuilderSyntax[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] extends AnyRef
    Definition Classes
    FunctionToServiceBuilderOps
  42. implicit final class Function18ToServiceBuilderSyntax[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] extends AnyRef
    Definition Classes
    FunctionToServiceBuilderOps
  43. implicit final class Function19ToServiceBuilderSyntax[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] extends AnyRef
    Definition Classes
    FunctionToServiceBuilderOps
  44. implicit final class Function1ToServiceBuilderSyntax[A, B] extends AnyRef
    Definition Classes
    FunctionToServiceBuilderOps
  45. implicit final class Function20ToServiceBuilderSyntax[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
    FunctionToServiceBuilderOps
  46. implicit final class Function21ToServiceBuilderSyntax[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
    FunctionToServiceBuilderOps
  47. implicit final class Function2ToServiceBuilderSyntax[A, B, C] extends AnyRef
    Definition Classes
    FunctionToServiceBuilderOps
  48. implicit final class Function3ToServiceBuilderSyntax[A, B, C, D] extends AnyRef
    Definition Classes
    FunctionToServiceBuilderOps
  49. implicit final class Function4ToServiceBuilderSyntax[A, B, C, D, E] extends AnyRef
    Definition Classes
    FunctionToServiceBuilderOps
  50. implicit final class Function5ToServiceBuilderSyntax[A, B, C, D, E, F] extends AnyRef
    Definition Classes
    FunctionToServiceBuilderOps
  51. implicit final class Function6ToServiceBuilderSyntax[A, B, C, D, E, F, G] extends AnyRef
    Definition Classes
    FunctionToServiceBuilderOps
  52. implicit final class Function7ToServiceBuilderSyntax[A, B, C, D, E, F, G, H] extends AnyRef
    Definition Classes
    FunctionToServiceBuilderOps
  53. implicit final class Function8ToServiceBuilderSyntax[A, B, C, D, E, F, G, H, I] extends AnyRef
    Definition Classes
    FunctionToServiceBuilderOps
  54. implicit final class Function9ToServiceBuilderSyntax[A, B, C, D, E, F, G, H, I, J] extends AnyRef
    Definition Classes
    FunctionToServiceBuilderOps
  55. 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 type A.

    The trait Has[A] is used with ZIO environment to express an effect's dependency on a service of type A. For example, RIO[Has[Console], Unit] is an effect that requires a Console service.

    Services parameterized on path dependent types are not supported.

  56. type HasMany[K, A] = Has[Map[K, A]]
  57. type Hub[A] = ZHub[Any, Any, Nothing, Nothing, A, A]
  58. type IO[+E, +A] = ZIO[Any, E, A]
  59. 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.

  60. sealed abstract class IsSubtypeOfError[-A, +B] extends (A) => B with Serializable
    Annotations
    @implicitNotFound()
  61. sealed abstract class IsSubtypeOfOutput[-A, +B] extends (A) => B with Serializable
    Annotations
    @implicitNotFound()
  62. type LightTypeTag = izumi.reflect.macrortti.LightTypeTag
    Definition Classes
    VersionSpecific
  63. 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
  64. final case class LogSpan(label: String, startTime: Long) extends Product with Serializable
  65. type Managed[+E, +A] = ZManaged[Any, E, A]
  66. 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.

  67. sealed abstract class NeedsEnv[+R] extends Serializable

    A value of type NeedsEnv[R] provides implicit evidence that an effect with environment type R needs an environment, that is, that R is not equal to Any.

  68. final class NonEmptyChunk[+A] extends AnyRef

    A NonEmptyChunk is a Chunk that is guaranteed to contain at least one element.

    A NonEmptyChunk is a Chunk that is guaranteed to contain at least one element. As a result, operations which would not be safe when performed on Chunk, such as head or reduce, are safe when performed on NonEmptyChunk. Operations on NonEmptyChunk which could potentially return an empty chunk will return a Chunk instead.

  69. 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
  70. type Queue[A] = ZQueue[Any, Any, Nothing, Nothing, A, A]
  71. type RIO[-R, +A] = ZIO[R, Throwable, A]
  72. type RManaged[-R, +A] = ZManaged[R, Throwable, A]
  73. type RServiceBuilder[-RIn, +ROut] = ZServiceBuilder[RIn, Throwable, ROut]
  74. trait Random extends Serializable
  75. type Ref[A] = ZRef[Any, Any, Nothing, Nothing, A, A]
  76. 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.

  77. trait Runtime[+R] extends AnyRef

    A Runtime[R] is capable of executing tasks within an environment R.

  78. final case class RuntimeConfig(blockingExecutor: Executor, executor: Executor, fatal: (Throwable) => Boolean, reportFatal: (Throwable) => Nothing, supervisor: Supervisor[Any], logger: ZLogger[Any], runtimeConfigFlags: RuntimeConfigFlags) extends Product with Serializable

    A RuntimeConfig provides the minimum capabilities necessary to bootstrap execution of ZIO tasks.

  79. final case class RuntimeConfigAspect(customize: (RuntimeConfig) => RuntimeConfig) extends (RuntimeConfig) => RuntimeConfig with Product with Serializable
  80. sealed trait RuntimeConfigFlag extends AnyRef
  81. final case class RuntimeConfigFlags(flags: Set[RuntimeConfigFlag]) extends Product with Serializable
  82. trait Schedule[-Env, -In, +Out] extends Serializable

    A Schedule[Env, In, Out] defines a recurring schedule, which consumes values of type In, and which returns values of type Out.

    A Schedule[Env, In, Out] defines a recurring schedule, which consumes values of type In, and which returns values of type Out.

    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.

  83. abstract class Scheduler extends AnyRef
  84. type Semaphore = TSemaphore
  85. type ServiceBuilder[+E, +ROut] = ZServiceBuilder[Any, E, ROut]
  86. abstract class Supervisor[+A] extends AnyRef

    A Supervisor[A] is allowed to supervise the launching and termination of fibers, producing some visible value of type A from the supervision.

  87. trait System extends Serializable
  88. type Tag[A] = izumi.reflect.Tag[A]
    Definition Classes
    VersionSpecific
  89. type TagK[F[_]] = HKTag[AnyRef { type Arg[A] = F[A] }]
    Definition Classes
    VersionSpecific
  90. 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
  91. 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
  92. 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
  93. 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
  94. 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
  95. 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
  96. 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
  97. 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
  98. 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
  99. 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
  100. 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
  101. 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
  102. 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
  103. type TagK3[F[_, _, _]] = HKTag[AnyRef { type Arg[A, B, C] = F[A,B,C] }]
    Definition Classes
    VersionSpecific
  104. type TagK4[F[_, _, _, _]] = HKTag[AnyRef { type Arg[A0, A1, A2, A3] = F[A0,A1,A2,A3] }]
    Definition Classes
    VersionSpecific
  105. type TagK5[F[_, _, _, _, _]] = HKTag[AnyRef { type Arg[A0, A1, A2, A3, A4] = F[A0,A1,A2,A3,A4] }]
    Definition Classes
    VersionSpecific
  106. type TagK6[F[_, _, _, _, _, _]] = HKTag[AnyRef { type Arg[A0, A1, A2, A3, A4, A5] = F[A0,A1,A2,A3,A4,A5] }]
    Definition Classes
    VersionSpecific
  107. 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
  108. 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
  109. 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
  110. type TagKK[F[_, _]] = HKTag[AnyRef { type Arg[A, B] = F[A,B] }]
    Definition Classes
    VersionSpecific
  111. type Task[+A] = ZIO[Any, Throwable, A]
  112. type TaskManaged[+A] = ZManaged[Any, Throwable, A]
  113. type TaskServiceBuilder[+ROut] = ZServiceBuilder[Any, Throwable, ROut]
  114. type UIO[+A] = ZIO[Any, Nothing, A]
  115. type UManaged[+A] = ZManaged[Any, Nothing, A]
  116. type URIO[-R, +A] = ZIO[R, Nothing, A]
  117. type URManaged[-R, +A] = ZManaged[R, Nothing, A]
  118. type URServiceBuilder[-RIn, +ROut] = ZServiceBuilder[RIn, Nothing, ROut]
  119. type UServiceBuilder[+ROut] = ZServiceBuilder[Any, Nothing, ROut]
  120. trait Unzippable[A, B] extends AnyRef
  121. trait UnzippableLowPriority1 extends UnzippableLowPriority2
  122. trait UnzippableLowPriority2 extends UnzippableLowPriority3
  123. trait UnzippableLowPriority3 extends AnyRef
  124. trait ZCompose[+LeftLower, -LeftUpper, LeftOut[In], +RightLower, -RightUpper, RightOut[In]] extends AnyRef
  125. type ZDequeue[-R, +E, +A] = ZQueue[Nothing, R, Any, E, Nothing, A]

    A queue that can only be dequeued.

  126. type ZEnqueue[-R, +E, -A] = ZQueue[R, Nothing, E, Any, A, Any]

    A queue that can only be enqueued.

  127. type ZEnv = Has[Clock] with Has[Console] with Has[System] with Has[Random]
  128. sealed abstract class ZFiberRef[+EA, +EB, -A, +B] extends Serializable

    A FiberRef is ZIO's equivalent of Java's ThreadLocal.

    A FiberRef is ZIO's equivalent of Java's ThreadLocal. The value of a FiberRef 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 specified max as our combining function.

  129. 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 type A to the hub and subscribers can subscribe to take messages of type B from the hub. Publishing messages can require an environment of type RA and fail with an error of type EA. Taking messages can require an environment of type RB and fail with an error of type EB.

  130. 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 environment R, and may fail with an error of type E, or succeed with a value of type A.

    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.

  131. trait ZIOApp extends ZIOAppPlatformSpecific

    An entry point for a ZIO application that allows sharing service builders between applications.

    An entry point for a ZIO application that allows sharing service builders between applications. For a simpler version that uses the default ZIO environment see ZIOAppDefault.

  132. final case class ZIOAppArgs(getArgs: Chunk[String]) extends Product with Serializable

    A service that contains command-line arguments of an application.

  133. 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 ()
    }
  134. trait ZIOAppPlatformSpecific extends AnyRef
  135. trait ZIOAspect[+LowerR, -UpperR, +LowerE, -UpperE, +LowerA, -UpperA] extends AnyRef
  136. sealed trait ZIOMetric[-A] extends ZIOAspect[Nothing, Any, Nothing, Any, Nothing, A]

    A ZIOMetric is able to add collection of metrics to a ZIO effect without changing its environment or error types.

    A ZIOMetric is able to add collection of metrics to a ZIO effect without changing its environment or error types. Aspects are the idiomatic way of adding collection of metrics to effects.

  137. abstract class ZInputStream extends AnyRef
  138. trait ZLogger[+A] extends AnyRef
  139. sealed abstract class ZManaged[-R, +E, +A] extends ZManagedVersionSpecific[R, E, A] with Serializable

    A ZManaged[R, E, A] is a managed resource of type A, which may be used by invoking the use method of the resource.

    A ZManaged[R, E, A] is a managed resource of type A, which may be used by invoking the use 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 from use, 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.

  140. trait ZManagedAspect[+LowerR, -UpperR, +LowerE, -UpperE, +LowerA, -UpperA] extends AnyRef
  141. abstract class ZOutputStream extends AnyRef
  142. trait ZPool[+Error, Item] extends AnyRef

    A ZPool[E, A] is a pool of items of type A, each of which may be associated with the acquisition and release of resources.

    A ZPool[E, A] is a pool of items of type A, each of which may be associated with the acquisition and release of resources. An attempt to get an item A from a pool may fail with an error of type E.

  143. 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 type A can be enqueued and of which elements of type B can be dequeued.

    A ZQueue[RA, RB, EA, EB, A, B] is a lightweight, asynchronous queue into which values of type A can be enqueued and of which elements of type B can be dequeued. The queue's enqueueing operations may utilize an environment of type RA and may fail with errors of type EA. The dequeueing operations may utilize an environment of type RB and may fail with errors of type EB.

  144. 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 a ZRef are set and get. set takes a value of type A and sets the reference to a new value, requiring an environment of type RA and potentially failing with an error of type EA. get gets the current value of the reference and returns a value of type B, requiring an environment of type RB and potentially failing with an error of type EB.

    When the error and value types of the ZRef are unified, that is, it is a ZRef[R, R, E, E, A, A], the ZRef also supports atomic modify and update 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 a ZRef.Synchronized, a specialized type of ZRef 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 multiple ZRef.Synchronized values together to form a single ZRef.Synchronized value that can be atomically updated using the zip 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 the ZRef 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 value ZRef.Synchronized will guarantee that access to the value is properly synchronized.

  145. sealed abstract class ZScope[+A] extends AnyRef

    A ZScope[A] is a value that allows adding finalizers identified by a key.

    A ZScope[A] is a value that allows adding finalizers identified by a key. Scopes are closed with a value of type A, which is provided to all the finalizers when the scope is released.

    For safety reasons, this interface has no method to close a scope. Rather, an open scope may be required with ZScope.make, which returns a function that can close a scope. This allows scopes to be safely passed around without fear they will be accidentally closed.

  146. sealed abstract class ZServiceBuilder[-RIn, +E, +ROut] extends AnyRef

    A ZServiceBuilder[E, A, B] describes how to build one or more services in your application.

    A ZServiceBuilder[E, A, B] describes how to build one or more services in your application. Services can be injected into effects via ZIO#inject. Effects can require services via ZIO.service."

    ServiceBuilder 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 service builders are shared, meaning that if the same servicebuilder is used twice the service builder will only be allocated a single time.

    Because of their excellent composition properties, service builders are the idiomatic way in ZIO to create services that depend on other services.

  147. sealed trait ZState[S] extends AnyRef

    ZState[S] models a value of type S that can be read from and written to during the execution of an effect.

    ZState[S] models a value of type S that can be read from and written to during the execution of an effect. The idiomatic way to work with ZState is as part of the environment using operators defined on ZIO. 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 type S such as MyState above rather than using a type such as Int 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 use toServiceBuilder to convert it into a service builder that you can provide along with your application's other services.

  148. final case class ZTrace(fiberId: FiberId, stackTrace: Chunk[ZTraceElement]) extends Product with Serializable
  149. type ZTraceElement = Type with Traced
  150. trait Zippable[-A, -B] extends AnyRef
  151. trait ZippableLowPriority1 extends ZippableLowPriority2
  152. trait ZippableLowPriority2 extends ZippableLowPriority3
  153. trait ZippableLowPriority3 extends AnyRef

Deprecated Type Members

  1. trait App extends ZApp[ZEnv] with BootstrapRuntime

    The entry point for a purely-functional application on the JVM.

    The entry point for a purely-functional application on the JVM.

    import zio.App
    import zio.Console._
    
    object MyApp extends App {
    
      final def run(args: List[String]) =
        myAppLogic.exitCode
    
      val myAppLogic =
        for {
          _ <- printLine("Hello! What is your name?")
          n <- readLine
          _ <- printLine("Hello, " + n + ", good to meet you!")
        } yield ()
    }
    Annotations
    @deprecated
    Deprecated

    (Since version Use zio.ZIOAppDefault) 2.0.0

  2. trait BootstrapRuntime extends ZBootstrapRuntime[ZEnv]
    Annotations
    @deprecated
    Deprecated

    (Since version Use zio.Runtime) 2.0.0

  3. type ERefM[+E, A] = Synchronized[Any, Any, E, E, A, A]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use ERef.Synchronized

  4. type Layer[+E, +ROut] = ZServiceBuilder[Any, E, ROut]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use ServiceBuilder

  5. trait ManagedApp extends BootstrapRuntime
    Annotations
    @deprecated
    Deprecated

    (Since version Use zio.ZIOApp and use the managed inside run) 2.0.0

  6. type RLayer[-RIn, +ROut] = ZServiceBuilder[RIn, Throwable, ROut]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use RServiceBuilder

  7. type RefM[A] = Synchronized[Any, Any, Nothing, Nothing, A, A]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use Ref.Synchronized

  8. type TaskLayer[+ROut] = ZServiceBuilder[Any, Throwable, ROut]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use TaskServiceBuilder

  9. type ULayer[+ROut] = ZServiceBuilder[Any, Nothing, ROut]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use UServiceBuilder

  10. type URLayer[-RIn, +ROut] = ZServiceBuilder[RIn, Nothing, ROut]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use URServiceBuilder

  11. trait ZApp[R] extends ZBootstrapRuntime[R]

    The entry point for a purely-functional application on the JVM.

    The entry point for a purely-functional application on the JVM.

    import zio.ZApp
    import zio.Console._
    
    object MyApp extends ZApp[Has[Console]] {
    
      def environment: Has[Console] = Has(ConsoleLive)
    
      final def run(args: List[String]) =
        myAppLogic.exitCode
    
      def myAppLogic =
        for {
          _ <- printLine("Hello! What is your name?")
          n <- readLine
          _ <- printLine("Hello, " + n + ", good to meet you!")
        } yield ()
    }
    Annotations
    @deprecated
    Deprecated

    (Since version Use zio.ZIOApp) 2.0.0

  12. trait ZBootstrapRuntime[R] extends Runtime[R]
    Annotations
    @deprecated
    Deprecated

    (Since version Use Runtime) 2.0.0

  13. type ZLayer[-RIn, +E, +ROut] = ZServiceBuilder[RIn, E, ROut]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use ZServiceBuilder

  14. 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

  1. val ERef: ZRef.type
  2. val FiberRef: ZFiberRef.type
  3. val Hub: ZHub.type
  4. val Managed: ZManaged.type
  5. val Queue: ZQueue.type
  6. lazy val Tag: izumi.reflect.Tag.type
    Definition Classes
    VersionSpecific
  7. lazy val TagK: izumi.reflect.TagK.type
    Definition Classes
    VersionSpecific
  8. lazy val TagK3: izumi.reflect.TagK3.type
    Definition Classes
    VersionSpecific
  9. lazy val TagKK: izumi.reflect.TagKK.type
    Definition Classes
    VersionSpecific
  10. implicit def buildFromNothing[A, Collection[+Element] <: Iterable[Element] with IterableOps[A, Collection, _]]: BuildFrom[Collection[A], Nothing, Collection[Nothing]]
    Definition Classes
    BuildFromCompat
  11. implicit def duration2DurationOps(duration: Duration): DurationOps
    Definition Classes
    DurationModule
  12. implicit def durationInt(n: Int): DurationSyntax
    Definition Classes
    DurationModule
  13. implicit def durationLong(n: Long): DurationSyntax
    Definition Classes
    DurationModule
  14. implicit val durationOrdering: Ordering[Duration]
    Definition Classes
    DurationModule
  15. object =!= extends Serializable
  16. object Accessible
  17. case object BuildInfo extends Product with Serializable

    This object was generated by sbt-buildinfo.

  18. object CanFail extends CanFail[Any]
  19. object Cause extends Serializable
  20. object Chunk extends ChunkFactory with ChunkPlatformSpecific with Serializable
  21. object ChunkBuilder
  22. object ChunkLike extends SeqFactory[Chunk]
  23. object Clock extends ClockPlatformSpecific with Serializable
  24. object Console extends Serializable
  25. object Duration
  26. object ExecutionStrategy
  27. object Executor extends DefaultExecutors with Serializable
  28. object Exit extends Serializable
  29. object ExitCode extends Serializable
  30. object Fiber extends FiberPlatformSpecific
  31. object FiberId extends Serializable
  32. object FiberRefs
  33. object Has extends Serializable
  34. object IO
  35. object InterruptStatus extends Serializable
  36. object IsSubtypeOfError extends Serializable
  37. object IsSubtypeOfOutput extends Serializable
  38. object LogLevel extends Serializable
  39. object NeedsEnv extends NeedsEnv[Nothing]
  40. object NonEmptyChunk
  41. object Promise extends Serializable
  42. object RIO
  43. object Random extends Serializable
  44. object Ref extends Serializable
  45. object Runtime
  46. object RuntimeConfig extends RuntimeConfigPlatformSpecific with Serializable
  47. object RuntimeConfigAspect extends ((RuntimeConfig) => RuntimeConfig) => RuntimeConfigAspect with Serializable
  48. object RuntimeConfigFlag
  49. object RuntimeConfigFlags extends Serializable
  50. object Schedule extends Serializable
  51. object Scheduler
  52. object Semaphore
  53. object Supervisor
  54. object System extends Serializable
  55. object Task extends TaskPlatformSpecific
  56. object UIO
  57. object URIO
  58. object Unzippable extends UnzippableLowPriority1
  59. object ZCompose extends ComposeLowPriorityImplicits
  60. object ZEnv
  61. object ZFiberRef extends Serializable
  62. object ZHub extends Serializable
  63. object ZIO extends ZIOCompanionPlatformSpecific with Serializable
  64. object ZIOApp
  65. object ZIOAppArgs extends Serializable
  66. object ZIOAppDefault
  67. object ZIOAspect
  68. object ZIOMetric
  69. object ZInputStream
  70. object ZLogger
  71. object ZManaged extends ZManagedPlatformSpecific with Serializable
  72. object ZOutputStream
  73. object ZPool
  74. object ZQueue extends Serializable
  75. object ZRef extends Serializable
  76. object ZScope
  77. object ZServiceBuilder extends ZServiceBuilderCompanionVersionSpecific
  78. object ZState
  79. object ZTrace extends Serializable
  80. object ZTraceElement
  81. object Zippable extends ZippableLowPriority1

Deprecated Value Members

  1. val ZLayer: ZServiceBuilder.type
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use ZServiceBuilder

  2. def buildFromAny[Element, Collection[+Element] <: Iterable[Element] with IterableOps[Any, Collection, Any]]: BuildFrom[Collection[Any], Element, Collection[Element]]
    Definition Classes
    BuildFromCompat
    Annotations
    @deprecated
    Deprecated

    (Since version 1.0.6) Use BuildFrom.buildFromIterableOps or buildFromNothing instead

  3. object RefM
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use Ref.Synchronized

  4. object ZRefM
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use ZRef.Synchronized

Inherited from DurationModule

Inherited from VersionSpecific

Inherited from IntersectionTypeCompat

Inherited from EitherCompat

Inherited from BuildFromCompat

Inherited from AnyRef

Inherited from Any

Ungrouped