Value Members

1.  final def !=(arg0: Any): Boolean

   Definition Classes

   AnyRef → Any

2.  final def ##(): Int

   Definition Classes

   AnyRef → Any

3.  def &&&[R1 <: R, E1 >: E, B](that: ZManaged[R1, E1, B]): ZManaged[R1, E1, (A, B)]

   Symbolic alias for zip.

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

   Symbolic alias for zipParRight

5.  def ***[R1, E1 >: E, B](that: ZManaged[R1, E1, B]): ZManaged[(R, R1), E1, (A, B)]

   Splits the environment, providing the first part to this effect and the second part to that effect.

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

   Symbolic alias for zipRight

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

   Symbolic alias for zipParLeft

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

   Symbolic alias for zipPar

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

    Symbolic alias for zipLeft.

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

    Symbolic alias for zip.

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

    Symbolic alias for compose

13.  def <>[R1 <: R, E2, A1 >: A](that: ⇒ ZManaged[R1, E2, A1])(implicit ev: CanFail[E]): ZManaged[R1, E2, A1]

    Operator alias for orElse.

14.  final def ==(arg0: Any): Boolean

    Definition Classes

    AnyRef → Any

15.  def >>=[R1 <: R, E1 >: E, B](k: (A) ⇒ ZManaged[R1, E1, B]): ZManaged[R1, E1, B]

    Symbolic alias for flatMap

16.  def >>>[E1 >: E, B](that: ZManaged[A, E1, B]): ZManaged[R, E1, B]

    Symbolic alias for andThen

17.  def absolve[E1 >: E, B](implicit ev: <:<[A, Either[E1, B]]): ZManaged[R, 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.

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

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

20.  def andThen[E1 >: E, B](that: ZManaged[A, E1, B]): ZManaged[R, E1, B]

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

21.  def as[B](b: ⇒ B): ZManaged[R, E, B]

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

22.  final def asInstanceOf[T0]: T0

    Definition Classes

    Any

23.  def asService[A1 >: A](implicit arg0: zio.Tag[A1]): ZManaged[R, E, Has[A1]]

    Maps the success value of this effect to a service.

24.  final def asSome: ZManaged[R, E, Option[A]]

    Maps the success value of this effect to an optional value.

25.  final def asSomeError: ZManaged[R, Option[E], A]

    Maps the error value of this effect to an optional value.

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

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

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

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

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

31.  def clone(): AnyRef

    Attributes

    protected[lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( ... ) @native()

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

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

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

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

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

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

38.  final def eq(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

39.  def equals(arg0: Any): Boolean

    Definition Classes

    AnyRef → Any

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

41.  def finalize(): Unit

    Attributes

    protected[lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( classOf[java.lang.Throwable] )

42.  def first[R1 <: R, A1 >: A]: ZManaged[R1, E, (A1, R1)]

    Zips this effect with its environment

43.  def flatMap[R1 <: R, E1 >: E, B](f: (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.

44.  def flatMapError[R1 <: R, E2](f: (E) ⇒ ZManaged[R1, Nothing, E2])(implicit ev: CanFail[E]): ZManaged[R1, E2, A]

    Effectfully map the error channel

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

46.  def flattenM[R1 <: R, E1 >: E, B](implicit ev: <:<[A, ZIO[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.

47.  def flip: ZManaged[R, A, E]

    Flip the error and result

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

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

50.  def foldCause[B](failure: (Cause[E]) ⇒ B, success: (A) ⇒ B): ZManaged[R, Nothing, B]

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

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

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

53.  def fork: ZManaged[R, Nothing, Fiber.Runtime[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.

54.  def get[B](implicit ev1: <:<[E, Nothing], ev2: <:<[A, Option[B]]): ZManaged[R, Unit, B]

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

55.  final def getClass(): Class[_]

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

56.  def hashCode(): Int

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

57.  def ignore: ZManaged[R, Nothing, Unit]

    Returns a new effect that ignores the success or failure of this effect.

58.  def isFailure: ZManaged[R, Nothing, Boolean]

    Returns whether this managed effect is a failure.

59.  final def isInstanceOf[T0]: Boolean

    Definition Classes

    Any

60.  def isSuccess: ZManaged[R, Nothing, Boolean]

    Returns whether this managed effect is a success.

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

62.  def left[R1 <: R, C]: ZManaged[Either[R1, C], E, Either[A, C]]
63.  def map[B](f: (A) ⇒ B): ZManaged[R, E, B]

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

64.  final def mapEffect[B](f: (A) ⇒ B)(implicit ev: <:<[E, Throwable]): ZManaged[R, Throwable, B]

    Returns an effect whose success is mapped by the specified side effecting f function, translating any thrown exceptions into typed failed effects.

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

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

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

68.  def memoize: ZManaged[Any, Nothing, ZManaged[R, E, A]]
69.  def merge[A1 >: A](implicit ev1: <:<[E, A1], ev2: CanFail[E]): ZManaged[R, Nothing, A1]

    Returns a new effect where the error channel has been merged into the success channel to their common combined type.

70.  final def ne(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

71.  final def none[B](implicit ev: <:<[A, Option[B]]): ZManaged[R, Option[E], Unit]

    Requires the option produced by this value to be None.

72.  final def notify(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

73.  final def notifyAll(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

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

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

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

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

77.  final def optional[E1](implicit ev: <:<[E, Option[E1]]): ZManaged[R, E1, Option[A]]

    Converts an option on errors into an option on values.

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

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

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

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

82.  final def orElseFail[E1](e1: ⇒ E1)(implicit ev: CanFail[E]): ZManaged[R, E1, A]

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

83.  final def orElseOptional[R1 <: R, E1, A1 >: A](that: ⇒ ZManaged[R1, Option[E1], A1])(implicit ev: <:<[E, Option[E1]]): ZManaged[R1, Option[E1], A1]

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

84.  final def orElseSucceed[A1 >: A](a1: ⇒ A1)(implicit ev: CanFail[E]): ZManaged[R, Nothing, A1]

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

85.  def preallocate: ZIO[R, E, Managed[Nothing, A]]

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

    Preallocates the managed resource, resulting in a ZManaged that reserves and acquires immediately and cannot fail. You should take care that you are not interrupted between running preallocate and actually acquiring the resource as you might leak otherwise.

86.  def preallocateManaged: ZManaged[R, E, Managed[Nothing, A]]

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

87.  def provide(r: R)(implicit ev: NeedsEnv[R]): Managed[E, A]

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

88.  def provideCustomLayer[E1 >: E, R1 <: Has[_]](layer: ZLayer[zio.ZEnv, E1, R1])(implicit ev: <:<[zio.ZEnv with R1, R], tagged: zio.Tag[R1]): ZManaged[zio.ZEnv, E1, A]

    Provides the part of the environment that is not part of the ZEnv, leaving a managed effect that only depends on the ZEnv.

    Provides the part of the environment that is not part of the ZEnv, leaving a managed effect that only depends on the ZEnv.

    val loggingLayer: ZLayer[Any, Nothing, Logging] = ???
    
    val managed: ZManaged[ZEnv with Logging, Nothing, Unit] = ???
    
    val managed2 = managed.provideCustomLayer(loggingLayer)

89.  def provideLayer[E1 >: E, R0, R1](layer: ZLayer[R0, E1, R1])(implicit ev1: <:<[R1, R], ev2: NeedsEnv[R]): ZManaged[R0, E1, A]

    Provides a layer to the ZManaged, which translates it to another level.

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

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

    val managed: ZManaged[Console with Logging, Nothing, Unit] = ???
    
    managed.provideSome[Console](env =>
      new Console with Logging {
        val console = env.console
        val logging = new Logging.Service[Any] {
          def log(line: String) = console.putStrLn(line)
        }
      }
    )

91.  final def provideSomeLayer[R0 <: Has[_]]: ProvideSomeLayer[R0, R, E, A]

    Splits the environment into two parts, providing one part using the specified layer and leaving the remainder R0.

    Splits the environment into two parts, providing one part using the specified layer and leaving the remainder R0.

    val clockLayer: ZLayer[Any, Nothing, Clock] = ???
    
    val managed: ZManaged[Clock with Random, Nothing, Unit] = ???
    
    val managed2 = managed.provideSomeLayer[Random](clockLayer)

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

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

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

95.  def reject[E1 >: E](pf: PartialFunction[A, E1]): ZManaged[R, E1, A]

    Fail with the returned value if the PartialFunction matches, otherwise continue with our held value.

96.  def rejectM[R1 <: R, E1 >: E](pf: PartialFunction[A, ZManaged[R1, E1, E1]]): ZManaged[R1, E1, A]

    Continue with the returned computation if the PartialFunction matches, translating the successful match into a failure, otherwise continue with our held value.

97.  def release: ZManaged[R, E, A]

    Runs all the finalizers associated with this scope.

    Runs all the finalizers associated with this scope. This is useful to conceptually "close" a scope when composing multiple managed effects. Note that this is only safe if the result of this managed effect is valid outside its scope.

98.  def retry[R1 <: R, S](policy: Schedule[R1, E, S])(implicit ev: CanFail[E]): ZManaged[R1, E, 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".

99.  def right[R1 <: R, C]: ZManaged[Either[C, R1], E, Either[C, A]]
100.  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.

101.  def sandbox: ZManaged[R, Cause[E], A]

     Exposes the full cause of failure of this effect.

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

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

     Zips this effect with its environment

104.  final def some[B](implicit ev: <:<[A, Option[B]]): ZManaged[R, Option[E], B]

     Converts an option on values into an option on errors.

105.  final def someOrElse[B](default: ⇒ B)(implicit ev: <:<[A, Option[B]]): ZManaged[R, E, B]

     Extracts the optional value, or returns the given 'default'.

106.  final def someOrFail[B, E1 >: E](e: ⇒ E1)(implicit ev: <:<[A, Option[B]]): ZManaged[R, E1, B]

     Extracts the optional value, or fails with the given error 'e'.

107.  final def someOrFailException[B, E1 >: E](implicit ev: <:<[A, Option[B]], ev2: <:<[NoSuchElementException, E1]): ZManaged[R, E1, B]

     Extracts the optional value, or fails with a java.util.NoSuchElementException

108.  final def synchronized[T0](arg0: ⇒ T0): T0

     Definition Classes

     AnyRef

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

110.  def tapBoth[R1 <: R, E1 >: E](f: (E) ⇒ ZManaged[R1, E1, Any], g: (A) ⇒ ZManaged[R1, E1, Any])(implicit ev: CanFail[E]): ZManaged[R1, E1, A]

     Returns an effect that effectfully peeks at the failure or success of the acquired resource.

111.  final def tapCause[R1 <: R, E1 >: E](f: (Cause[E]) ⇒ ZManaged[R1, E1, Any]): ZManaged[R1, E1, A]

     Returns an effect that effectually peeks at the cause of the failure of the acquired resource.

112.  def tapError[R1 <: R, E1 >: E](f: (E) ⇒ ZManaged[R1, E1, Any])(implicit ev: CanFail[E]): ZManaged[R1, E1, A]

     Returns an effect that effectfully peeks at the failure of the acquired resource.

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

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

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

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

116.  def toLayer[A1 >: A](implicit arg0: zio.Tag[A1]): ZLayer[R, E, Has[A1]]

     Constructs a layer from this managed resource.

117.  def toLayerMany[A1 <: Has[_]](implicit ev: <:<[A, A1]): ZLayer[R, E, A1]

     Constructs a layer from this managed resource, which must return one or more services.

118.  def toString(): String

     Definition Classes

     AnyRef → Any

119.  lazy val unit: ZManaged[R, E, Unit]

     Return unit while running the effect

120.  final def unless(b: ⇒ Boolean): ZManaged[R, E, Unit]

     The moral equivalent of if (!p) exp

121.  final def unlessM[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

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

     The inverse operation ZManaged.sandboxed

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

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

125.  def useNow: ZIO[R, E, A]

     Runs the acquire and release actions and returns the result of this managed effect.

     Runs the acquire and release actions and returns the result of this managed effect. Note that this is only safe if the result of this managed effect is valid outside its scope.

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

127.  final def wait(): Unit

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

128.  final def wait(arg0: Long, arg1: Int): Unit

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

129.  final def wait(arg0: Long): Unit

     Definition Classes

     AnyRef

     Annotations

     @throws( ... ) @native()

130.  def when(b: ⇒ Boolean): ZManaged[R, E, Unit]

     The moral equivalent of if (p) exp

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

132.  def withEarlyRelease: ZManaged[R, E, (UIO[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.

133.  def withEarlyReleaseExit(e: Exit[Any, Any]): ZManaged[R, E, (UIO[Any], A)]

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

134.  val zio: ZIO[(R, ReleaseMap), E, (Finalizer, A)]
135.  def zip[R1 <: R, E1 >: E, A1](that: ZManaged[R1, E1, A1]): ZManaged[R1, E1, (A, A1)]

     Named alias for <*>.

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

     Named alias for <*.

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

     Named alias for <&>.

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

     Named alias for <&.

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

     Named alias for &>.

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

     Named alias for *>.

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

142.  def zipWithPar[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 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.

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

     Symbolic alias for join