Packages

p

zio

package zio

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

Package Members

  1. package blocking
  2. package clock
  3. package console
  4. package duration
  5. package internal
  6. package random
  7. package stm
  8. package stream
  9. package system
  10. 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.test.environment.Live
    import zio.clock.nanoTime
    import Assertion.isGreaterThan
    
    object MyTest extends DefaultRunnableSpec {
      def spec = suite("clock")(
        testM("time is non-zero") {
          assertM(Live.live(nanoTime))(isGreaterThan(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. trait App extends 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
    
      def myAppLogic =
        for {
          _ <- putStrLn("Hello! What is your name?")
          n <- getStrLn
          _ <- putStrLn("Hello, " + n + ", good to meet you!")
        } yield ()
    }
  5. trait BootstrapRuntime extends Runtime[ZEnv]
  6. type BuildFrom[-From, -A, +C] = scala.collection.BuildFrom[From, A, C]
    Definition Classes
    BuildFromCompat
  7. 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.

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

    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.

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

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

  14. type Dequeue[+A] = ZQueue[Nothing, Any, Any, Nothing, Nothing, A]
  15. class DurationSyntax extends AnyRef
  16. type ERef[+E, A] = ZRef[E, E, A, A]
  17. type ERefM[+E, A] = ZRefM[Any, Any, E, E, A, A]
  18. type Enqueue[-A] = ZQueue[Any, Nothing, Nothing, Any, A, Any]
  19. 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.

  20. 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].

  21. final case class ExitCode(code: Int) extends Product with Serializable
  22. 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)
  23. 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.

  24. 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 specified max as our combine function.

  25. trait FunctionToLayerOps extends AnyRef
  26. implicit final class Function0ToLayerSyntax[A] extends AnyRef
    Definition Classes
    FunctionToLayerOps
  27. implicit final class Function10ToLayerSyntax[A, B, C, D, E, F, G, H, I, J, K] extends AnyRef
    Definition Classes
    FunctionToLayerOps
  28. implicit final class Function11ToLayerSyntax[A, B, C, D, E, F, G, H, I, J, K, L] extends AnyRef
    Definition Classes
    FunctionToLayerOps
  29. implicit final class Function12ToLayerSyntax[A, B, C, D, E, F, G, H, I, J, K, L, M] extends AnyRef
    Definition Classes
    FunctionToLayerOps
  30. implicit final class Function13ToLayerSyntax[A, B, C, D, E, F, G, H, I, J, K, L, M, N] extends AnyRef
    Definition Classes
    FunctionToLayerOps
  31. implicit final class Function14ToLayerSyntax[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] extends AnyRef
    Definition Classes
    FunctionToLayerOps
  32. implicit final class Function15ToLayerSyntax[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] extends AnyRef
    Definition Classes
    FunctionToLayerOps
  33. implicit final class Function16ToLayerSyntax[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] extends AnyRef
    Definition Classes
    FunctionToLayerOps
  34. implicit final class Function17ToLayerSyntax[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] extends AnyRef
    Definition Classes
    FunctionToLayerOps
  35. implicit final class Function18ToLayerSyntax[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] extends AnyRef
    Definition Classes
    FunctionToLayerOps
  36. implicit final class Function19ToLayerSyntax[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] extends AnyRef
    Definition Classes
    FunctionToLayerOps
  37. implicit final class Function1ToLayerSyntax[A, B] extends AnyRef
    Definition Classes
    FunctionToLayerOps
  38. implicit final class Function20ToLayerSyntax[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
    FunctionToLayerOps
  39. implicit final class Function21ToLayerSyntax[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
    FunctionToLayerOps
  40. implicit final class Function2ToLayerSyntax[A, B, C] extends AnyRef
    Definition Classes
    FunctionToLayerOps
  41. implicit final class Function3ToLayerSyntax[A, B, C, D] extends AnyRef
    Definition Classes
    FunctionToLayerOps
  42. implicit final class Function4ToLayerSyntax[A, B, C, D, E] extends AnyRef
    Definition Classes
    FunctionToLayerOps
  43. implicit final class Function5ToLayerSyntax[A, B, C, D, E, F] extends AnyRef
    Definition Classes
    FunctionToLayerOps
  44. implicit final class Function6ToLayerSyntax[A, B, C, D, E, F, G] extends AnyRef
    Definition Classes
    FunctionToLayerOps
  45. implicit final class Function7ToLayerSyntax[A, B, C, D, E, F, G, H] extends AnyRef
    Definition Classes
    FunctionToLayerOps
  46. implicit final class Function8ToLayerSyntax[A, B, C, D, E, F, G, H, I] extends AnyRef
    Definition Classes
    FunctionToLayerOps
  47. implicit final class Function9ToLayerSyntax[A, B, C, D, E, F, G, H, I, J] extends AnyRef
    Definition Classes
    FunctionToLayerOps
  48. 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.Service], Unit] is an effect that requires a Console.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.

  49. type Hub[A] = ZHub[Any, Any, Nothing, Nothing, A, A]
  50. type IO[+E, +A] = ZIO[Any, E, A]
  51. 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.

  52. type Layer[+E, +ROut] = ZLayer[Any, E, ROut]
  53. type LightTypeTag = izumi.reflect.macrortti.LightTypeTag
    Definition Classes
    VersionSpecific
  54. type Managed[+E, +A] = ZManaged[Any, E, A]
  55. trait ManagedApp extends BootstrapRuntime
  56. 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.

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

  58. 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
  59. type Queue[A] = ZQueue[Any, Any, Nothing, Nothing, A, A]
  60. type RIO[-R, +A] = ZIO[R, Throwable, A]
  61. type RLayer[-RIn, +ROut] = ZLayer[RIn, Throwable, ROut]
  62. type RManaged[-R, +A] = ZManaged[R, Throwable, A]
  63. type Ref[A] = ZRef[Nothing, Nothing, A, A]
  64. type RefM[A] = ZRefM[Any, Any, Nothing, Nothing, A, A]
  65. 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.

  66. trait Runtime[+R] extends AnyRef

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

  67. sealed abstract class 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.

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

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

  70. type Tag[A] = izumi.reflect.Tag[A]
    Definition Classes
    VersionSpecific
  71. type TagK[F[_]] = HKTag[AnyRef { type Arg[A] = F[A] }]
    Definition Classes
    VersionSpecific
  72. 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
  73. 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
  74. 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
  75. 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
  76. 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
  77. 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
  78. 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
  79. 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
  80. 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
  81. 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
  82. 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
  83. 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
  84. 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
  85. type TagK3[F[_, _, _]] = HKTag[AnyRef { type Arg[A, B, C] = F[A,B,C] }]
    Definition Classes
    VersionSpecific
  86. type TagK4[F[_, _, _, _]] = HKTag[AnyRef { type Arg[A0, A1, A2, A3] = F[A0,A1,A2,A3] }]
    Definition Classes
    VersionSpecific
  87. type TagK5[F[_, _, _, _, _]] = HKTag[AnyRef { type Arg[A0, A1, A2, A3, A4] = F[A0,A1,A2,A3,A4] }]
    Definition Classes
    VersionSpecific
  88. type TagK6[F[_, _, _, _, _, _]] = HKTag[AnyRef { type Arg[A0, A1, A2, A3, A4, A5] = F[A0,A1,A2,A3,A4,A5] }]
    Definition Classes
    VersionSpecific
  89. 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
  90. 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
  91. 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
  92. type TagKK[F[_, _]] = HKTag[AnyRef { type Arg[A, B] = F[A,B] }]
    Definition Classes
    VersionSpecific
  93. type Task[+A] = ZIO[Any, Throwable, A]
  94. type TaskLayer[+ROut] = ZLayer[Any, Throwable, ROut]
  95. type TaskManaged[+A] = ZManaged[Any, Throwable, A]
  96. sealed abstract class TracingStatus extends Serializable with Product

    Whether ZIO Tracing is enabled for the current fiber in the current region.

  97. type UIO[+A] = ZIO[Any, Nothing, A]
  98. type ULayer[+ROut] = ZLayer[Any, Nothing, ROut]
  99. type UManaged[+A] = ZManaged[Any, Nothing, A]
  100. type URIO[-R, +A] = ZIO[R, Nothing, A]
  101. type URLayer[-RIn, +ROut] = ZLayer[RIn, Nothing, ROut]
  102. type URManaged[-R, +A] = ZManaged[R, Nothing, A]
  103. trait Unzippable[A, B] extends AnyRef
  104. trait UnzippableLowPriority1 extends UnzippableLowPriority2
  105. trait UnzippableLowPriority2 extends UnzippableLowPriority3
  106. trait UnzippableLowPriority3 extends AnyRef
  107. type ZDequeue[-R, +E, +A] = ZQueue[Nothing, R, Any, E, Nothing, A]

    A queue that can only be dequeued.

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

    A queue that can only be enqueued.

  109. type ZEnv = Clock with Console with System with Random with Blocking
    Definition Classes
    PlatformSpecific
  110. 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.

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

  112. abstract class ZInputStream extends AnyRef
  113. sealed abstract class 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.

  114. sealed abstract class ZManaged[-R, +E, +A] extends 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.

  115. abstract class ZOutputStream extends AnyRef
  116. 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.

  117. sealed abstract class 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 a ZRef are set and get. set takes a value of type A and sets the reference to a new value, potentially failing with an error of type EA. get gets the current value of the reference and returns a value of type B, 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[E, E, A, A], the ZRef also supports atomic modify and update 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 the ZRef should be immutable. For performance reasons ZRef 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.

  118. sealed abstract class 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 a ZRefM 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 ZRefM are unified, that is, it is a ZRefM[E, E, A, A], the ZRefM also supports atomic modify and update 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.

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

  120. final case class ZTrace(fiberId: Id, executionTrace: List[ZTraceElement], stackTrace: List[ZTraceElement], parentTrace: Option[ZTrace]) extends Product with Serializable
  121. trait Zippable[-A, -B] extends AnyRef
  122. trait ZippableLowPriority1 extends ZippableLowPriority2
  123. trait ZippableLowPriority2 extends ZippableLowPriority3
  124. trait ZippableLowPriority3 extends AnyRef

Deprecated Type Members

  1. type Tagged[A] = izumi.reflect.Tag[A]
    Definition Classes
    VersionSpecific
    Annotations
    @deprecated
    Deprecated

    (Since version 1.0.0) use Tag

  2. type TaggedF[F[_]] = HKTag[AnyRef { type Arg[A] = F[A] }]
    Definition Classes
    VersionSpecific
    Annotations
    @deprecated
    Deprecated

    (Since version 1.0.0) use TagK

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  24. type TypeTag = izumi.reflect.macrortti.LightTypeTag
    Definition Classes
    VersionSpecific
    Annotations
    @deprecated
    Deprecated

    (Since version 1.0.0) use LightTypeTag

Value Members

  1. val Hub: ZHub.type
  2. val Managed: ZManaged.type
  3. lazy val Tag: izumi.reflect.Tag.type
    Definition Classes
    VersionSpecific
  4. lazy val TagK: izumi.reflect.TagK.type
    Definition Classes
    VersionSpecific
  5. lazy val TagK3: izumi.reflect.TagK3.type
    Definition Classes
    VersionSpecific
  6. lazy val TagKK: izumi.reflect.TagKK.type
    Definition Classes
    VersionSpecific
  7. implicit def buildFromNothing[A, Collection[+Element] <: Iterable[Element] with IterableOps[A, Collection, _]]: BuildFrom[Collection[A], Nothing, Collection[Nothing]]
    Definition Classes
    BuildFromCompat
  8. object <*>
  9. object =!= extends Serializable
  10. object Accessible
  11. case object BuildInfo extends Product with Serializable

    This object was generated by sbt-buildinfo.

  12. object CanFail extends CanFail[Any]
  13. object Cause extends Serializable
  14. object Chunk extends ChunkFactory with ChunkPlatformSpecific
  15. object ChunkBuilder
  16. object ChunkLike extends SeqFactory[Chunk]
  17. object ExecutionStrategy
  18. object Exit extends Serializable
  19. object ExitCode extends Serializable
  20. object Fiber extends FiberPlatformSpecific
  21. object FiberRef extends Serializable
  22. object Has extends Serializable
  23. object IO
  24. object InterruptStatus extends Serializable
  25. object NeedsEnv extends NeedsEnv[Nothing]
  26. object NonEmptyChunk
  27. object Promise extends Serializable
  28. object Queue
  29. object RIO
  30. object Ref extends Serializable
  31. object RefM
  32. object Runtime
  33. object Schedule extends Serializable
  34. object Semaphore extends Serializable
  35. object Supervisor
  36. object Task extends TaskPlatformSpecific
  37. object TracingStatus extends Serializable
  38. object UIO
  39. object URIO
  40. object Unzippable extends UnzippableLowPriority1
  41. object ZEnv
    Definition Classes
    PlatformSpecific
  42. object ZHub extends Serializable
  43. object ZIO extends ZIOCompanionPlatformSpecific with Serializable
  44. object ZInputStream
  45. object ZLayer
  46. object ZManaged extends ZManagedPlatformSpecific with Serializable
  47. object ZOutputStream
  48. object ZQueue extends Serializable
  49. object ZRef extends Serializable
  50. object ZRefM
  51. object ZScope
  52. object ZTrace extends Serializable
  53. object Zippable extends ZippableLowPriority1

Deprecated Value Members

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

Inherited from VersionSpecific

Inherited from PlatformSpecific

Inherited from IntersectionTypeCompat

Inherited from FunctionToLayerOps

Inherited from EitherCompat

Inherited from BuildFromCompat

Inherited from AnyRef

Inherited from Any

Ungrouped