Packages

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

Self Type
ZManaged[R, E, A]
Linear Supertypes
Serializable, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ZManaged
  2. Serializable
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def &&&[R1 <: R, E1 >: E, B](that: ZManaged[R1, E1, B]): ZManaged[R1, E1, (A, B)]

    Symbolic alias for zip.

  4. final def &>[R1 <: R, E1 >: E, A1](that: ZManaged[R1, E1, A1]): ZManaged[R1, E1, A1]

    Symbolic alias for zipParRight

  5. final def *>[R1 <: R, E1 >: E, A1](that: ZManaged[R1, E1, A1]): ZManaged[R1, E1, A1]

    Symbolic alias for zipRight

  6. final def +++[R1, B, E1 >: E](that: ZManaged[R1, E1, B]): ZManaged[Either[R, R1], E1, Either[A, B]]
  7. final def <&[R1 <: R, E1 >: E, A1](that: ZManaged[R1, E1, A1]): ZManaged[R1, E1, A]

    Symbolic alias for zipParLeft

  8. final def <&>[R1 <: R, E1 >: E, A1](that: ZManaged[R1, E1, A1]): ZManaged[R1, E1, (A, A1)]

    Symbolic alias for zipPar

  9. final def <*[R1 <: R, E1 >: E, A1](that: ZManaged[R1, E1, A1]): ZManaged[R1, E1, A]

    Symbolic alias for zipLeft.

  10. final def <*>[R1 <: R, E1 >: E, A1](that: ZManaged[R1, E1, A1]): ZManaged[R1, E1, (A, A1)]

    Symbolic alias for zip.

  11. final def <<<[R1, E1 >: E](that: ZManaged[R1, E1, R]): ZManaged[R1, E1, A]

    Symbolic alias for compose

  12. final def <>[R1 <: R, E2, A1 >: A](that: => ZManaged[R1, E2, A1])(implicit ev: CanFail[E]): ZManaged[R1, E2, A1]

    Operator alias for orElse.

  13. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  14. final def >>=[R1 <: R, E1 >: E, B](k: (A) => ZManaged[R1, E1, B]): ZManaged[R1, E1, B]

    Symbolic alias for flatMap

  15. final def >>>[R1 >: A, E1 >: E, B](that: ZManaged[R1, E1, B]): ZManaged[R, E1, B]

    Symbolic alias for andThen

  16. final def absolve[R1 <: R, E1, B](implicit ev: <:<[ZManaged[R, E, A], ZManaged[R1, E1, Either[E1, B]]]): ZManaged[R1, E1, B]

    Submerges the error case of an Either into the ZManaged.

    Submerges the error case of an Either into the ZManaged. The inverse operation of ZManaged.either.

  17. final def absorb(implicit ev: <:<[E, Throwable]): ZManaged[R, Throwable, A]

    Attempts to convert defects into a failure, throwing away all information about the cause of the failure.

  18. final def absorbWith(f: (E) => Throwable): ZManaged[R, Throwable, A]

    Attempts to convert defects into a failure, throwing away all information about the cause of the failure.

  19. final def andThen[R1 >: A, E1 >: E, B](that: ZManaged[R1, E1, B]): ZManaged[R, E1, B]

    Executes the this effect and then provides its output as an environment to the second effect

  20. final def as[B](b: => B): ZManaged[R, E, B]

    Maps this effect to the specified constant while preserving the effects of this effect.

  21. final def asError[E1](e1: E1): ZManaged[R, E1, A]

    Replaces the error value (if any) by the value provided.

  22. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  23. final def bimap[E1, A1](f: (E) => E1, g: (A) => A1)(implicit ev: CanFail[E]): ZManaged[R, E1, A1]

    Returns an effect whose failure and success channels have been mapped by the specified pair of functions, f and g.

  24. final def catchAll[R1 <: R, E2, A1 >: A](h: (E) => ZManaged[R1, E2, A1])(implicit ev: CanFail[E]): ZManaged[R1, E2, A1]

    Recovers from all errors.

  25. final def catchAllCause[R1 <: R, E2, A1 >: A](h: (Cause[E]) => ZManaged[R1, E2, A1]): ZManaged[R1, E2, A1]

    Recovers from all errors with provided Cause.

    Recovers from all errors with provided Cause.

    managed.catchAllCause(_ => ZManaged.succeed(defaultConfig))
    See also

    absorb, sandbox, mapErrorCause - other functions that can recover from defects

  26. final def catchSome[R1 <: R, E1 >: E, A1 >: A](pf: PartialFunction[E, ZManaged[R1, E1, A1]])(implicit ev: CanFail[E]): ZManaged[R1, E1, A1]

    Recovers from some or all of the error cases.

  27. final def catchSomeCause[R1 <: R, E1 >: E, A1 >: A](pf: PartialFunction[Cause[E], ZManaged[R1, E1, A1]]): ZManaged[R1, E1, A1]

    Recovers from some or all of the error Causes.

  28. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  29. final def collect[E1 >: E, B](e: E1)(pf: PartialFunction[A, B]): ZManaged[R, E1, B]

    Fail with e if the supplied PartialFunction does not match, otherwise succeed with the returned value.

  30. final def collectM[R1 <: R, E1 >: E, B](e: E1)(pf: PartialFunction[A, ZManaged[R1, E1, B]]): ZManaged[R1, E1, B]

    Fail with e if the supplied PartialFunction does not match, otherwise continue with the returned value.

  31. final def compose[R1, E1 >: E](that: ZManaged[R1, E1, R]): ZManaged[R1, E1, A]

    Executes the second effect and then provides its output as an environment to this effect

  32. final def either(implicit ev: CanFail[E]): ZManaged[R, Nothing, Either[E, A]]

    Returns an effect whose failure and success have been lifted into an Either.The resulting effect cannot fail

  33. final def ensuring[R1 <: R](f: ZIO[R1, Nothing, Any]): ZManaged[R1, E, A]

    Ensures that f is executed when this ZManaged is finalized, after the existing finalizer.

    Ensures that f is executed when this ZManaged is finalized, after the existing finalizer.

    For usecases that need access to the ZManaged's result, see ZManaged#onExit.

  34. final def ensuringFirst[R1 <: R](f: ZIO[R1, Nothing, Any]): ZManaged[R1, E, A]

    Ensures that f is executed when this ZManaged is finalized, before the existing finalizer.

    Ensures that f is executed when this ZManaged is finalized, before the existing finalizer.

    For usecases that need access to the ZManaged's result, see ZManaged#onExitFirst.

  35. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  36. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  37. final def eventually(implicit ev: CanFail[E]): ZManaged[R, Nothing, A]

    Returns a ZManaged that ignores errors raised by the acquire effect and runs it repeatedly until it eventually succeeds.

  38. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  39. final def first[R1 <: R, A1 >: A]: ZManaged[R1, E, (A1, R1)]

    Zips this effect with its environment

  40. final def flatMap[R1 <: R, E1 >: E, B](f0: (A) => ZManaged[R1, E1, B]): ZManaged[R1, E1, B]

    Returns an effect that models the execution of this effect, followed by the passing of its value to the specified continuation function k, followed by the effect that it returns.

  41. final def flatMapError[R1 <: R, E2](f: (E) => ZManaged[R1, Nothing, E2])(implicit ev: CanFail[E]): ZManaged[R1, E2, A]

    Effectfully map the error channel

  42. final def flatten[R1 <: R, E1 >: E, B](implicit ev: <:<[A, ZManaged[R1, E1, B]]): ZManaged[R1, E1, B]

    Returns an effect that performs the outer effect first, followed by the inner effect, yielding the value of the inner effect.

    Returns an effect that performs the outer effect first, followed by the inner effect, yielding the value of the inner effect.

    This method can be used to "flatten" nested effects.

  43. final def flip: ZManaged[R, A, E]

    Flip the error and result

  44. final def flipWith[R1, A1, E1](f: (ZManaged[R, A, E]) => ZManaged[R1, A1, E1]): ZManaged[R1, E1, A1]

    Flip the error and result, then apply an effectful function to the effect

  45. final def fold[B](failure: (E) => B, success: (A) => B)(implicit ev: CanFail[E]): ZManaged[R, Nothing, B]

    Folds over the failure value or the success value to yield an effect that does not fail, but succeeds with the value returned by the left or right function passed to fold.

  46. final def foldCauseM[R1 <: R, E1, A1](failure: (Cause[E]) => ZManaged[R1, E1, A1], success: (A) => ZManaged[R1, E1, A1]): ZManaged[R1, E1, A1]

    A more powerful version of foldM that allows recovering from any kind of failure except interruptions.

  47. final def foldM[R1 <: R, E2, B](failure: (E) => ZManaged[R1, E2, B], success: (A) => ZManaged[R1, E2, B])(implicit ev: CanFail[E]): ZManaged[R1, E2, B]

    Recovers from errors by accepting one effect to execute for the case of an error, and one effect to execute for the case of success.

  48. final def fork: ZManaged[R, Nothing, Fiber[E, A]]

    Creates a ZManaged value that acquires the original resource in a fiber, and provides that fiber.

    Creates a ZManaged value that acquires the original resource in a fiber, and provides that fiber. The finalizer for this value will interrupt the fiber and run the original finalizer.

  49. final def get[E1 >: E, B](implicit ev1: =:=[E1, Nothing], ev2: <:<[A, Option[B]]): ZManaged[R, Unit, B]

    Unwraps the optional success of this effect, but can fail with unit value.

  50. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  51. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  52. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  53. final def join[R1, E1 >: E, A1 >: A](that: ZManaged[R1, E1, A1]): ZManaged[Either[R, R1], E1, A1]

    Depending on the environment execute this or the other effect

  54. final def left[R1 <: R, C]: ZManaged[Either[R1, C], E, Either[A, C]]
  55. final def map[B](f0: (A) => B): ZManaged[R, E, B]

    Returns an effect whose success is mapped by the specified f function.

  56. final def mapError[E1](f: (E) => E1)(implicit ev: CanFail[E]): ZManaged[R, E1, A]

    Returns an effect whose failure is mapped by the specified f function.

  57. final def mapErrorCause[E1](f: (Cause[E]) => Cause[E1]): ZManaged[R, E1, A]

    Returns an effect whose full failure is mapped by the specified f function.

  58. final def mapM[R1 <: R, E1 >: E, B](f: (A) => ZIO[R1, E1, B]): ZManaged[R1, E1, B]

    Effectfully maps the resource acquired by this value.

  59. def memoize: ZManaged[R, E, ZManaged[R, E, A]]
  60. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  61. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  62. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  63. final def onExit[R1 <: R](cleanup: (Exit[E, A]) => ZIO[R1, Nothing, Any]): ZManaged[R1, E, A]

    Ensures that a cleanup function runs when this ZManaged is finalized, after the existing finalizers.

  64. final def onExitFirst[R1 <: R](cleanup: (Exit[E, A]) => ZIO[R1, Nothing, Any]): ZManaged[R1, E, A]

    Ensures that a cleanup function runs when this ZManaged is finalized, before the existing finalizers.

  65. final def option(implicit ev: CanFail[E]): ZManaged[R, Nothing, Option[A]]

    Executes this effect, skipping the error but returning optionally the success.

  66. final def orDie(implicit ev1: <:<[E, Throwable], ev2: CanFail[E]): ZManaged[R, Nothing, A]

    Translates effect failure into death of the fiber, making all failures unchecked and not a part of the type of the effect.

  67. final def orDieWith(f: (E) => Throwable)(implicit ev: CanFail[E]): ZManaged[R, Nothing, A]

    Keeps none of the errors, and terminates the fiber with them, using the specified function to convert the E into a Throwable.

  68. final def orElse[R1 <: R, E2, A1 >: A](that: => ZManaged[R1, E2, A1])(implicit ev: CanFail[E]): ZManaged[R1, E2, A1]

    Executes this effect and returns its value, if it succeeds, but otherwise executes the specified effect.

  69. final def orElseEither[R1 <: R, E2, B](that: => ZManaged[R1, E2, B])(implicit ev: CanFail[E]): ZManaged[R1, E2, Either[A, B]]

    Returns an effect that will produce the value of this effect, unless it fails, in which case, it will produce the value of the specified effect.

  70. final def preallocate: ZIO[R, E, Managed[Nothing, A]]

    Preallocates the managed resource, resulting in a ZManaged that reserves and acquires immediately and cannot fail.

  71. final def provide(r: R)(implicit ev: NeedsEnv[R]): ZManaged[Any, E, A]

    Provides the ZManaged effect with its required environment, which eliminates its dependency on R.

  72. final def provideSome[R0](f: (R0) => R)(implicit ev: NeedsEnv[R]): ZManaged[R0, E, A]

    Provides some of the environment required to run this effect, leaving the remainder R0.

  73. final def refineOrDie[E1](pf: PartialFunction[E, E1])(implicit ev1: <:<[E, Throwable], ev2: CanFail[E]): ZManaged[R, E1, A]

    Keeps some of the errors, and terminates the fiber with the rest.

  74. final def refineOrDieWith[E1](pf: PartialFunction[E, E1])(f: (E) => Throwable)(implicit ev: CanFail[E]): ZManaged[R, E1, A]

    Keeps some of the errors, and terminates the fiber with the rest, using the specified function to convert the E into a Throwable.

  75. final def refineToOrDie[E1](implicit arg0: ClassTag[E1], ev1: <:<[E, Throwable], ev2: CanFail[E]): ZManaged[R, E1, A]

    Keeps some of the errors, and terminates the fiber with the rest.

  76. final def reserve: ZIO[R, E, Reservation[R, E, A]]

    Gives access to wrapped Reservation.

  77. final def retry[R1 <: R, E1 >: E, S](policy: Schedule[R1, E1, S])(implicit ev: CanFail[E]): ZManaged[R1, E1, A]

    Retries with the specified retry policy.

    Retries with the specified retry policy. Retries are done following the failure of the original io (up to a fixed maximum with once or recurs for example), so that that io.retry(Schedule.once) means "execute io and in case of failure, try again once".

  78. final def right[R1 <: R, C]: ZManaged[Either[C, R1], E, Either[C, A]]
  79. final def run: ZManaged[R, Nothing, Exit[E, A]]

    Returns an effect that semantically runs the effect on a fiber, producing an zio.Exit for the completion value of the fiber.

  80. final def sandbox: ZManaged[R, Cause[E], A]

    Exposes the full cause of failure of this effect.

  81. final def sandboxWith[R1 <: R, E2, B](f: (ZManaged[R1, Cause[E], A]) => ZManaged[R1, Cause[E2], B]): ZManaged[R1, E2, B]

    Companion helper to sandbox.

    Companion helper to sandbox. Allows recovery, and partial recovery, from errors and defects alike.

  82. final def second[R1 <: R, A1 >: A]: ZManaged[R1, E, (R1, A1)]

    Zips this effect with its environment

  83. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  84. final def tap[R1 <: R, E1 >: E](f: (A) => ZManaged[R1, E1, Any]): ZManaged[R1, E1, A]

    Returns an effect that effectfully peeks at the acquired resource.

  85. final def tapM[R1 <: R, E1 >: E](f: (A) => ZIO[R1, E1, Any]): ZManaged[R1, E1, A]

    Like ZManaged#tap, but uses a function that returns a ZIO value rather than a ZManaged value.

  86. final def timed: ZManaged[R with Clock, E, (Duration, A)]

    Returns a new effect that executes this one and times the acquisition of the resource.

  87. final def timeout(d: Duration): ZManaged[R with Clock, E, Option[A]]

    Returns an effect that will timeout this resource, returning None if the timeout elapses before the resource was reserved and acquired.

    Returns an effect that will timeout this resource, returning None if the timeout elapses before the resource was reserved and acquired. If the reservation completes successfully (even after the timeout) the release action will be run on a new fiber. Some will be returned if acquisition and reservation complete in time

  88. def toString(): String
    Definition Classes
    AnyRef → Any
  89. final lazy val unit: ZManaged[R, E, Unit]

    Return unit while running the effect

  90. final def unsandbox[E1](implicit ev: <:<[E, Cause[E1]]): ZManaged[R, E1, A]

    The inverse operation ZManaged.sandboxed

  91. final def use[R1 <: R, E1 >: E, B](f: (A) => ZIO[R1, E1, B]): ZIO[R1, E1, B]

    Run an effect while acquiring the resource before and releasing it after

  92. final val useForever: ZIO[R, E, Nothing]

    Use the resource until interruption.

    Use the resource until interruption. Useful for resources that you want to acquire and use as long as the application is running, like a HTTP server.

  93. final def use_[R1 <: R, E1 >: E, B](f: ZIO[R1, E1, B]): ZIO[R1, E1, B]

    Run an effect while acquiring the resource before and releasing it after.

    Run an effect while acquiring the resource before and releasing it after. This does not provide the resource to the function

  94. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  95. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  96. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  97. final def when(b: Boolean): ZManaged[R, E, Unit]

    The moral equivalent of if (p) exp

  98. final def whenM[R1 <: R, E1 >: E](b: ZManaged[R1, E1, Boolean]): ZManaged[R1, E1, Unit]

    The moral equivalent of if (p) exp when p has side-effects

  99. final def withEarlyRelease: ZManaged[R, E, (URIO[R, Any], A)]

    Modifies this ZManaged to provide a canceler that can be used to eagerly execute the finalizer of this ZManaged.

    Modifies this ZManaged to provide a canceler that can be used to eagerly execute the finalizer of this ZManaged. The canceler will run uninterruptibly with an exit value indicating that the effect was interrupted, and if completed will cause the regular finalizer to not run.

  100. final def withEarlyReleaseExit(exit: Exit[Any, Any]): ZManaged[R, E, (URIO[R, Any], A)]

    A more powerful version of withEarlyRelease that allows specifying an exit value in the event of early release.

  101. final def zip[R1 <: R, E1 >: E, A1](that: ZManaged[R1, E1, A1]): ZManaged[R1, E1, (A, A1)]

    Named alias for <*>.

  102. final def zipLeft[R1 <: R, E1 >: E, A1](that: ZManaged[R1, E1, A1]): ZManaged[R1, E1, A]

    Named alias for <*.

  103. final def zipPar[R1 <: R, E1 >: E, A1](that: ZManaged[R1, E1, A1]): ZManaged[R1, E1, (A, A1)]

    Named alias for <&>.

  104. final def zipParLeft[R1 <: R, E1 >: E, A1](that: ZManaged[R1, E1, A1]): ZManaged[R1, E1, A]

    Named alias for <&.

  105. final def zipParRight[R1 <: R, E1 >: E, A1](that: ZManaged[R1, E1, A1]): ZManaged[R1, E1, A1]

    Named alias for &>.

  106. final def zipRight[R1 <: R, E1 >: E, A1](that: ZManaged[R1, E1, A1]): ZManaged[R1, E1, A1]

    Named alias for *>.

  107. final def zipWith[R1 <: R, E1 >: E, A1, A2](that: ZManaged[R1, E1, A1])(f: (A, A1) => A2): ZManaged[R1, E1, A2]

    Returns an effect that executes both this effect and the specified effect, in sequence, combining their results with the specified f function.

  108. final def zipWithPar[R1 <: R, E1 >: E, A1, A2](that: ZManaged[R1, E1, A1])(f0: (A, A1) => A2): ZManaged[R1, E1, A2]

    Returns an effect that executes both this effect and the specified effect, in parallel, combining their results with the specified f function.

    Returns an effect that executes both this effect and the specified effect, in parallel, combining their results with the specified f function. If either side fails, then the other side will be interrupted.

  109. final def |||[R1, E1 >: E, A1 >: A](that: ZManaged[R1, E1, A1]): ZManaged[Either[R, R1], E1, A1]

    Symbolic alias for join

Deprecated Value Members

  1. final def const[B](b: => B): ZManaged[R, E, B]
    Annotations
    @deprecated
    Deprecated

    (Since version 1.0.0) use as

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped