Packages

object ZManaged extends ZManagedPlatformSpecific with Serializable

Linear Supertypes
Serializable, ZManagedPlatformSpecific, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ZManaged
  2. Serializable
  3. ZManagedPlatformSpecific
  4. AnyRef
  5. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Type Members

  1. final class AccessManagedPartiallyApplied[R] extends AnyVal
  2. final class AccessPartiallyApplied[R] extends AnyVal
  3. final class AccessZIOPartiallyApplied[R] extends AnyVal
  4. type Finalizer = (Exit[Any, Any]) => UIO[Any]

    A finalizer used in a ReleaseMap.

    A finalizer used in a ReleaseMap. The Exit value passed to it is the result of executing ZManaged#use or an arbitrary value passed into ReleaseMap#release.

  5. final class IfManaged[R, E] extends AnyVal
  6. abstract class PreallocationScope extends AnyRef

    A scope in which resources can be safely preallocated.

    A scope in which resources can be safely preallocated. Passing a ZManaged to the apply method will create (inside an effect) a managed resource which is already acquired and cannot fail.

  7. final class ProvideSomeLayer[R0, -R, +E, +A] extends AnyVal
  8. implicit final class RefineToOrDieOps[R, E <: Throwable, A] extends AnyVal
  9. abstract class ReleaseMap extends Serializable

    A ReleaseMap represents the finalizers associated with a scope.

    A ReleaseMap represents the finalizers associated with a scope.

    The design of ReleaseMap is inspired by ResourceT, written by Michael Snoyman @snoyberg. (https://github.com/snoyberg/conduit/blob/master/resourcet/Control/Monad/Trans/Resource/Internal.hs)

  10. abstract class Scope extends AnyRef

    A scope in which ZManaged values can be safely allocated.

    A scope in which ZManaged values can be safely allocated. Passing a managed resource to the apply method will return an effect that allocates the resource and returns it with an early-release handle.

  11. final class ServiceAtPartiallyApplied[Service] extends AnyVal
  12. final class ServiceWithManagedPartiallyApplied[Service] extends AnyVal
  13. final class ServiceWithPartiallyApplied[Service] extends AnyVal
  14. final class UnlessManaged[R, E] extends AnyVal
  15. final class UpdateService[-R, +E, +A, M] extends AnyVal
  16. final class UpdateServiceAt[-R, +E, +A, Service] extends AnyVal
  17. final class WhenManaged[R, E] extends AnyVal
  18. sealed trait ZManagedConstructor[Input] extends AnyRef

    A ZManagedConstructor[Input] knows how to construct a ZManaged value from an input of type Input.

    A ZManagedConstructor[Input] knows how to construct a ZManaged value from an input of type Input. This allows the type of the ZManaged value constructed to depend on Input.

  19. trait ZManagedConstructorLowPriority1 extends ZManagedConstructorLowPriority2
  20. trait ZManagedConstructorLowPriority2 extends AnyRef

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. def absolve[R, E, A](v: => ZManaged[R, E, Either[E, A]]): ZManaged[R, E, A]

    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.

  5. def access[R]: AccessPartiallyApplied[R]

    Create a managed that accesses the environment.

  6. def accessManaged[R]: AccessManagedPartiallyApplied[R]

    Create a managed that accesses the environment.

  7. def accessZIO[R]: AccessZIOPartiallyApplied[R]

    Create a managed that accesses the environment.

  8. def acquireRelease[R, R1 <: R, E, A](acquire: => ZIO[R, E, A])(release: => ZIO[R1, Nothing, Any]): ZManaged[R1, E, A]

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action that does not need access to the resource.

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action that does not need access to the resource. The acquire and release actions will be performed uninterruptibly.

  9. def acquireReleaseAttempt[A](acquire: => A)(release: => Any): ZManaged[Any, Throwable, A]

    Lifts a synchronous effect into ZManaged[R, Throwable, A] with a release action that does not need access to the resource.

    Lifts a synchronous effect into ZManaged[R, Throwable, A] with a release action that does not need access to the resource. The acquire and release actions will be performed uninterruptibly.

  10. def acquireReleaseAttemptWith[A](acquire: => A)(release: (A) => Any): ZManaged[Any, Throwable, A]

    Lifts a synchronous effect into ZManaged[R, Throwable, A] with a release action.

    Lifts a synchronous effect into ZManaged[R, Throwable, A] with a release action. The acquire and release actions will be performed uninterruptibly.

  11. def acquireReleaseExit[R, R1 <: R, E, A](acquire: => ZIO[R, E, A])(release: (Exit[Any, Any]) => ZIO[R1, Nothing, Any]): ZManaged[R1, E, A]

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action that does not need access to the resource but handles Exit.

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action that does not need access to the resource but handles Exit. The acquire and release actions will be performed uninterruptibly.

  12. def acquireReleaseExitWith[R, R1 <: R, E, A](acquire: => ZIO[R, E, A])(release: (A, Exit[Any, Any]) => ZIO[R1, Nothing, Any]): ZManaged[R1, E, A]

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action that handles Exit.

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action that handles Exit. The acquire and release actions will be performed uninterruptibly.

  13. def acquireReleaseInterruptible[R, R1 <: R, E, A](acquire: => ZIO[R, E, A])(release: => ZIO[R1, Nothing, Any]): ZManaged[R1, E, A]

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action that does not require access to the resource.

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action that does not require access to the resource. The acquire action will be performed interruptibly, while release will be performed uninterruptibly.

  14. def acquireReleaseInterruptibleWith[R, R1 <: R, E, A](acquire: => ZIO[R, E, A])(release: (A) => URIO[R1, Any]): ZManaged[R1, E, A]

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action.

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action. The acquire action will be performed interruptibly, while release will be performed uninterruptibly.

  15. def acquireReleaseSucceed[A](acquire: => A)(release: => Any): ZManaged[Any, Nothing, A]

    Lifts a synchronous effect that does not throw exceptions into a ZManaged[Any, Nothing, A] with a release action that does not need access to the resource.

    Lifts a synchronous effect that does not throw exceptions into a ZManaged[Any, Nothing, A] with a release action that does not need access to the resource. The acquire and release actions will be performed uninterruptibly.

  16. def acquireReleaseSucceedWith[A](acquire: => A)(release: (A) => Any): ZManaged[Any, Nothing, A]

    Lifts a synchronous effect that does not throw exceptions into a ZManaged[Any, Nothing, A] with a release action.

    Lifts a synchronous effect that does not throw exceptions into a ZManaged[Any, Nothing, A] with a release action. The acquire and release actions will be performed uninterruptibly.

  17. def acquireReleaseWith[R, R1 <: R, E, A](acquire: => ZIO[R, E, A])(release: (A) => ZIO[R1, Nothing, Any]): ZManaged[R1, E, A]

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action.

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action. The acquire and release actions will be performed uninterruptibly.

  18. def apply[R, E, A](run0: ZIO[(R, ReleaseMap), E, (Finalizer, A)]): ZManaged[R, E, A]

    Creates new ZManaged from a ZIO value that uses a ReleaseMap and returns a resource and a finalizer.

    Creates new ZManaged from a ZIO value that uses a ReleaseMap and returns a resource and a finalizer.

    The correct usage of this constructor consists of: - Properly registering a finalizer in the ReleaseMap as part of the ZIO value; - Managing interruption safety - take care to use ZIO.uninterruptible or ZIO.uninterruptibleMask to verify that the finalizer is registered in the ReleaseMap after acquiring the value; - Returning the finalizer returned from ReleaseMap#add. This is important to prevent double-finalization.

  19. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  20. def attempt[A](r: => A): ZManaged[Any, Throwable, A]

    Lifts a synchronous side-effect into a ZManaged[R, Throwable, A], translating any thrown exceptions into typed failed effects.

  21. val blocking: ZManaged[Any, Nothing, Unit]

    Returns a managed effect that describes shifting to the blocking executor as the acquire action and shifting back to the original executor as the release action.

    Returns a managed effect that describes shifting to the blocking executor as the acquire action and shifting back to the original executor as the release action.

    Definition Classes
    ZManagedPlatformSpecific
  22. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  23. def collect[R, E, A, B, Collection[+Element] <: Iterable[Element]](in: Collection[A])(f: (A) => ZManaged[R, Option[E], B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]]): ZManaged[R, E, Collection[B]]

    Evaluate each effect in the structure from left to right, collecting the the successful values and discarding the empty cases.

    Evaluate each effect in the structure from left to right, collecting the the successful values and discarding the empty cases. For a parallel version, see collectPar.

  24. def collectAll[R, E, A, Collection[+Element] <: Iterable[Element]](ms: Collection[ZManaged[R, E, A]])(implicit bf: zio.BuildFrom[Collection[ZManaged[R, E, A]], A, Collection[A]]): ZManaged[R, E, Collection[A]]

    Evaluate each effect in the structure from left to right, and collect the results.

    Evaluate each effect in the structure from left to right, and collect the results. For a parallel version, see collectAllPar.

  25. def collectAllDiscard[R, E, A](ms: => Iterable[ZManaged[R, E, A]]): ZManaged[R, E, Unit]

    Evaluate each effect in the structure from left to right, and discard the results.

    Evaluate each effect in the structure from left to right, and discard the results. For a parallel version, see collectAllParDiscard.

  26. def collectAllPar[R, E, A, Collection[+Element] <: Iterable[Element]](as: Collection[ZManaged[R, E, A]])(implicit bf: zio.BuildFrom[Collection[ZManaged[R, E, A]], A, Collection[A]]): ZManaged[R, E, Collection[A]]

    Evaluate each effect in the structure in parallel, and collect the results.

    Evaluate each effect in the structure in parallel, and collect the results. For a sequential version, see collectAll.

  27. def collectAllParDiscard[R, E, A](as: => Iterable[ZManaged[R, E, A]]): ZManaged[R, E, Unit]

    Evaluate each effect in the structure in parallel, and discard the results.

    Evaluate each effect in the structure in parallel, and discard the results. For a sequential version, see collectAllDiscard.

  28. def collectAllParN[R, E, A, Collection[+Element] <: Iterable[Element]](n: => Int)(as: Collection[ZManaged[R, E, A]])(implicit bf: zio.BuildFrom[Collection[ZManaged[R, E, A]], A, Collection[A]]): ZManaged[R, E, Collection[A]]

    Evaluate each effect in the structure in parallel, and collect the results.

    Evaluate each effect in the structure in parallel, and collect the results. For a sequential version, see collectAll.

    Unlike CollectAllPar, this method will use at most n fibers.

  29. def collectAllParNDiscard[R, E, A](n: => Int)(as: => Iterable[ZManaged[R, E, A]]): ZManaged[R, E, Unit]

    Evaluate each effect in the structure in parallel, and discard the results.

    Evaluate each effect in the structure in parallel, and discard the results. For a sequential version, see collectAllDiscard.

    Unlike collectAllParDiscard, this method will use at most n fibers.

  30. def collectFirst[R, E, A, B](as: => Iterable[A])(f: (A) => ZManaged[R, E, Option[B]]): ZManaged[R, E, Option[B]]

    Collects the first element of the Iterable[A] for which the effectual function f returns Some.

  31. def collectPar[R, E, A, B, Collection[+Element] <: Iterable[Element]](in: Collection[A])(f: (A) => ZManaged[R, Option[E], B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]]): ZManaged[R, E, Collection[B]]

    Evaluate each effect in the structure in parallel, collecting the the successful values and discarding the empty cases.

  32. def collectParN[R, E, A, B, Collection[+Element] <: Iterable[Element]](n: => Int)(in: Collection[A])(f: (A) => ZManaged[R, Option[E], B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]]): ZManaged[R, E, Collection[B]]

    Evaluate each effect in the structure in parallel, collecting the the successful values and discarding the empty cases.

    Evaluate each effect in the structure in parallel, collecting the the successful values and discarding the empty cases.

    Unlike collectPar, this method will use at most up to n fibers.

  33. def cond[E, A](predicate: => Boolean, result: => A, error: => E): Managed[E, A]

    Similar to Either.cond, evaluate the predicate, return the given A as success if predicate returns true, and the given E as error otherwise

  34. def die(t: => Throwable): ZManaged[Any, Nothing, Nothing]

    Returns an effect that dies with the specified Throwable.

    Returns an effect that dies with the specified Throwable. This method can be used for terminating a fiber because a defect has been detected in the code.

  35. def dieMessage(message: => String): ZManaged[Any, Nothing, Nothing]

    Returns an effect that dies with a java.lang.RuntimeException having the specified text message.

    Returns an effect that dies with a java.lang.RuntimeException having the specified text message. This method can be used for terminating a fiber because a defect has been detected in the code.

  36. def done[E, A](r: => Exit[E, A]): ZManaged[Any, E, A]

    Returns an effect from a lazily evaluated zio.Exit value.

  37. def environment[R]: ZManaged[R, Nothing, R]

    Accesses the whole environment of the effect.

  38. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  39. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  40. def exists[R, E, A](as: => Iterable[A])(f: (A) => ZManaged[R, E, Boolean]): ZManaged[R, E, Boolean]

    Determines whether any element of the Iterable[A] satisfies the effectual predicate f.

  41. def fail[E](error: => E): ZManaged[Any, E, Nothing]

    Returns an effect that models failure with the specified error.

    Returns an effect that models failure with the specified error. The moral equivalent of throw for pure code.

  42. def failCause[E](cause: => Cause[E]): ZManaged[Any, E, Nothing]

    Returns an effect that models failure with the specified Cause.

  43. lazy val fiberId: ZManaged[Any, Nothing, FiberId]

    Returns an effect that succeeds with the FiberId of the caller.

  44. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  45. def finalizer[R](f: => URIO[R, Any]): ZManaged[R, Nothing, Unit]

    Creates an effect that only executes the provided finalizer as its release action.

  46. def finalizerExit[R](f: (Exit[Any, Any]) => URIO[R, Any]): ZManaged[R, Nothing, Unit]

    Creates an effect that only executes the provided function as its release action.

  47. def finalizerRef[R](initial: => Finalizer): ZManaged[R, Nothing, Ref[Finalizer]]

    Creates an effect that executes a finalizer stored in a Ref.

    Creates an effect that executes a finalizer stored in a Ref. The Ref is yielded as the result of the effect, allowing for control flows that require mutating finalizers.

  48. def firstSuccessOf[R, E, A](first: => ZManaged[R, E, A], rest: => Iterable[ZManaged[R, E, A]]): ZManaged[R, E, A]

    Returns a managed resource that attempts to acquire the first managed resource and in case of failure, attempts to acquire each of the specified managed resources in order until one of them is successfully acquired, ensuring that the acquired resource is properly released after being used.

  49. def flatten[R, E, A](zManaged: => ZManaged[R, E, ZManaged[R, E, A]]): ZManaged[R, E, A]

    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.

  50. def flattenZIO[R, E, A](zManaged: => ZManaged[R, E, ZIO[R, E, A]]): ZManaged[R, E, A]

    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.

  51. def foldLeft[R, E, S, A](in: => Iterable[A])(zero: => S)(f: (S, A) => ZManaged[R, E, S]): ZManaged[R, E, S]

    Folds an Iterable[A] using an effectual function f, working sequentially from left to right.

  52. def forall[R, E, A](as: => Iterable[A])(f: (A) => ZManaged[R, E, Boolean]): ZManaged[R, E, Boolean]

    Determines whether all elements of the Iterable[A] satisfy the effectual predicate f.

  53. final def foreach[R, E, A1, A2](in: Option[A1])(f: (A1) => ZManaged[R, E, A2]): ZManaged[R, E, Option[A2]]

    Applies the function f if the argument is non-empty and returns the results in a new Option[A2].

  54. def foreach[R, E, A1, A2, Collection[+Element] <: Iterable[Element]](in: Collection[A1])(f: (A1) => ZManaged[R, E, A2])(implicit bf: zio.BuildFrom[Collection[A1], A2, Collection[A2]]): ZManaged[R, E, Collection[A2]]

    Applies the function f to each element of the Collection[A] and returns the results in a new Collection[B].

    Applies the function f to each element of the Collection[A] and returns the results in a new Collection[B].

    For a parallel version of this method, see foreachPar. If you do not need the results, see foreachDiscard for a more efficient implementation.

  55. def foreachDiscard[R, E, A](as: => Iterable[A])(f: (A) => ZManaged[R, E, Any]): ZManaged[R, E, Unit]

    Applies the function f to each element of the Iterable[A] and runs produced effects sequentially.

    Applies the function f to each element of the Iterable[A] and runs produced effects sequentially.

    Equivalent to foreach(as)(f).unit, but without the cost of building the list of results.

  56. final def foreachExec[R, E, A, B, Collection[+Element] <: Iterable[Element]](as: Collection[A])(exec: => ExecutionStrategy)(f: (A) => ZManaged[R, E, B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]]): ZManaged[R, E, Collection[B]]

    Applies the function f to each element of the Collection[A] and returns the result in a new Collection[B] using the specified execution strategy.

  57. def foreachPar[R, E, A1, A2, Collection[+Element] <: Iterable[Element]](as: Collection[A1])(f: (A1) => ZManaged[R, E, A2])(implicit bf: zio.BuildFrom[Collection[A1], A2, Collection[A2]]): ZManaged[R, E, Collection[A2]]

    Applies the function f to each element of the Collection[A] in parallel, and returns the results in a new Collection[B].

    Applies the function f to each element of the Collection[A] in parallel, and returns the results in a new Collection[B].

    For a sequential version of this method, see foreach.

  58. def foreachParDiscard[R, E, A](as: => Iterable[A])(f: (A) => ZManaged[R, E, Any]): ZManaged[R, E, Unit]

    Applies the function f to each element of the Iterable[A] and runs produced effects in parallel, discarding the results.

    Applies the function f to each element of the Iterable[A] and runs produced effects in parallel, discarding the results.

    For a sequential version of this method, see foreachDiscard.

  59. def foreachParN[R, E, A1, A2, Collection[+Element] <: Iterable[Element]](n0: => Int)(as: Collection[A1])(f: (A1) => ZManaged[R, E, A2])(implicit bf: zio.BuildFrom[Collection[A1], A2, Collection[A2]]): ZManaged[R, E, Collection[A2]]

    Applies the function f to each element of the Collection[A] in parallel, and returns the results in a new Collection[B].

    Applies the function f to each element of the Collection[A] in parallel, and returns the results in a new Collection[B].

    Unlike foreachPar, this method will use at most up to n fibers.

  60. def foreachParNDiscard[R, E, A](n0: => Int)(as: => Iterable[A])(f: (A) => ZManaged[R, E, Any]): ZManaged[R, E, Unit]

    Applies the function f to each element of the Iterable[A] and runs produced effects in parallel, discarding the results.

    Applies the function f to each element of the Iterable[A] and runs produced effects in parallel, discarding the results.

    Unlike foreachParDiscard, this method will use at most up to n fibers.

  61. def from[Input](input: => Input)(implicit constructor: ZManagedConstructor[Input]): Out

    Constructs a ZManaged value of the appropriate type for the specified input.

  62. def fromAutoCloseable[R, E, A <: AutoCloseable](fa: => ZIO[R, E, A]): ZManaged[R, E, A]

    Creates a ZManaged from an AutoCloseable resource.

    Creates a ZManaged from an AutoCloseable resource. The resource's close method will be used as the release action.

  63. def fromEither[E, A](v: => Either[E, A]): ZManaged[Any, E, A]

    Lifts an Either into a ZManaged value.

  64. def fromOption[A](v: => Option[A]): ZManaged[Any, Option[Nothing], A]

    Lifts an Option into a ZManaged but preserves the error as an option in the error channel, making it easier to compose in some scenarios.

  65. def fromReservation[R, E, A](reservation: => Reservation[R, E, A]): ZManaged[R, E, A]

    Lifts a pure Reservation[R, E, A] into ZManaged[R, E, A].

    Lifts a pure Reservation[R, E, A] into ZManaged[R, E, A]. The acquisition step is performed interruptibly.

  66. def fromReservationZIO[R, E, A](reservation: => ZIO[R, E, Reservation[R, E, A]]): ZManaged[R, E, A]

    Creates a ZManaged from a Reservation produced by an effect.

    Creates a ZManaged from a Reservation produced by an effect. Evaluating the effect that produces the reservation will be performed *uninterruptibly*, while the acquisition step of the reservation will be performed *interruptibly*. The release step will be performed uninterruptibly as usual.

    This two-phase acquisition allows for resource acquisition flows that can be safely interrupted and released.

  67. def fromTry[A](value: => Try[A]): TaskManaged[A]

    Lifts a Try into a ZManaged.

  68. def fromZIO[R, E, A](fa: => ZIO[R, E, A]): ZManaged[R, E, A]

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with no release action.

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with no release action. The effect will be performed interruptibly.

  69. def fromZIOUninterruptible[R, E, A](fa: => ZIO[R, E, A]): ZManaged[R, E, A]

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with no release action.

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with no release action. The effect will be performed uninterruptibly. You usually want the ZManaged.fromZIO variant.

  70. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  71. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  72. def ifManaged[R, E](b: => ZManaged[R, E, Boolean]): IfManaged[R, E]

    Runs onTrue if the result of b is true and onFalse otherwise.

  73. lazy val interrupt: ZManaged[Any, Nothing, Nothing]

    Returns an effect that is interrupted as if by the fiber calling this method.

  74. def interruptAs(fiberId: => FiberId): ZManaged[Any, Nothing, Nothing]

    Returns an effect that is interrupted as if by the specified fiber.

  75. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  76. def iterate[R, E, S](initial: => S)(cont: (S) => Boolean)(body: (S) => ZManaged[R, E, S]): ZManaged[R, E, S]

    Iterates with the specified effectual function.

    Iterates with the specified effectual function. The moral equivalent of:

    var s = initial
    
    while (cont(s)) {
      s = body(s)
    }
    
    s
  77. def lock(executor: => Executor): ZManaged[Any, Nothing, Unit]

    Returns a managed effect that describes shifting to the specified executor as the acquire action and shifting back to the original executor as the release action.

  78. def loop[R, E, A, S](initial: => S)(cont: (S) => Boolean, inc: (S) => S)(body: (S) => ZManaged[R, E, A]): ZManaged[R, E, List[A]]

    Loops with the specified effectual function, collecting the results into a list.

    Loops with the specified effectual function, collecting the results into a list. The moral equivalent of:

    var s  = initial
    var as = List.empty[A]
    
    while (cont(s)) {
      as = body(s) :: as
      s  = inc(s)
    }
    
    as.reverse
  79. def loopDiscard[R, E, S](initial: => S)(cont: (S) => Boolean, inc: (S) => S)(body: (S) => ZManaged[R, E, Any]): ZManaged[R, E, Unit]

    Loops with the specified effectual function purely for its effects.

    Loops with the specified effectual function purely for its effects. The moral equivalent of:

    var s = initial
    
    while (cont(s)) {
      body(s)
      s = inc(s)
    }
  80. def memoize[R, E, A, B](f: (A) => ZManaged[R, E, B]): ZManaged[Any, Nothing, (A) => ZIO[R, E, B]]

    Returns a memoized version of the specified resourceful function in the context of a managed scope.

    Returns a memoized version of the specified resourceful function in the context of a managed scope. Each time the memoized function is evaluated a new resource will be acquired, if the function has not already been evaluated with that input, or else the previously acquired resource will be returned. All resources acquired by evaluating the function will be released at the end of the scope.

  81. def mergeAll[R, E, A, B](in: => Iterable[ZManaged[R, E, A]])(zero: => B)(f: (B, A) => B): ZManaged[R, E, B]

    Merges an Iterable[ZManaged] to a single ZManaged, working sequentially.

  82. def mergeAllPar[R, E, A, B](in: => Iterable[ZManaged[R, E, A]])(zero: => B)(f: (B, A) => B): ZManaged[R, E, B]

    Merges an Iterable[ZManaged] to a single ZManaged, working in parallel.

    Merges an Iterable[ZManaged] to a single ZManaged, working in parallel.

    Due to the parallel nature of this combinator, f must be both: - commutative: f(a, b) == f(b, a) - associative: f(a, f(b, c)) == f(f(a, b), c)

  83. def mergeAllParN[R, E, A, B](n0: => Int)(in: => Iterable[ZManaged[R, E, A]])(zero: => B)(f: (B, A) => B): ZManaged[R, E, B]

    Merges an Iterable[ZManaged] to a single ZManaged, working in parallel.

    Merges an Iterable[ZManaged] to a single ZManaged, working in parallel.

    Due to the parallel nature of this combinator, f must be both: - commutative: f(a, b) == f(b, a) - associative: f(a, f(b, c)) == f(f(a, b), c)

    Unlike mergeAllPar, this method will use at most up to n fibers.

  84. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  85. lazy val never: ZManaged[Any, Nothing, Nothing]

    Returns a ZManaged that never acquires a resource.

  86. val none: Managed[Nothing, Option[Nothing]]

    Returns a ZManaged with the empty value.

  87. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  88. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  89. def onExecutor(executor: => Executor): ZManaged[Any, Nothing, Unit]

    Returns a managed effect that describes shifting to the specified executor as the acquire action and shifting back to the original executor as the release action.

  90. lazy val preallocationScope: Managed[Nothing, PreallocationScope]

    Creates a scope in which resources can be safely preallocated.

  91. def readFile(path: String): ZManaged[Any, IOException, ZInputStream]
    Definition Classes
    ZManagedPlatformSpecific
  92. def readFile(path: Path): ZManaged[Any, IOException, ZInputStream]
    Definition Classes
    ZManagedPlatformSpecific
  93. def readURI(uri: URI): ZManaged[Any, IOException, ZInputStream]
    Definition Classes
    ZManagedPlatformSpecific
  94. def readURL(url: String): ZManaged[Any, IOException, ZInputStream]
    Definition Classes
    ZManagedPlatformSpecific
  95. def readURL(url: URL): ZManaged[Any, IOException, ZInputStream]
    Definition Classes
    ZManagedPlatformSpecific
  96. def reduceAll[R, E, A](a: => ZManaged[R, E, A], as: => Iterable[ZManaged[R, E, A]])(f: (A, A) => A): ZManaged[R, E, A]

    Reduces an Iterable[IO] to a single IO, working sequentially.

  97. def reduceAllPar[R, E, A](a: => ZManaged[R, E, A], as: => Iterable[ZManaged[R, E, A]])(f: (A, A) => A): ZManaged[R, E, A]

    Reduces an Iterable[IO] to a single IO, working in parallel.

  98. def reduceAllParN[R, E, A](n0: => Int)(a: => ZManaged[R, E, A], as: => Iterable[ZManaged[R, E, A]])(f: (A, A) => A): ZManaged[R, E, A]

    Reduces an Iterable[IO] to a single IO, working in parallel.

    Reduces an Iterable[IO] to a single IO, working in parallel.

    Unlike mergeAllPar, this method will use at most up to n fibers.

    This is not implemented in terms of ZIO.foreach / ZManaged.zipWithPar as otherwise all reservation phases would always run, causing unnecessary work

  99. lazy val releaseMap: ZManaged[Any, Nothing, ReleaseMap]

    Provides access to the entire map of resources allocated by this ZManaged.

  100. def runtime[R]: ZManaged[R, Nothing, Runtime[R]]

    Returns an ZManaged that accesses the runtime, which can be used to (unsafely) execute tasks.

    Returns an ZManaged that accesses the runtime, which can be used to (unsafely) execute tasks. This is useful for integration with legacy code that must call back into ZIO code.

  101. def sandbox[R, E, A](v: ZManaged[R, E, A]): ZManaged[R, Cause[E], A]
  102. lazy val scope: Managed[Nothing, Scope]

    Creates a scope in which resources can be safely allocated into together with a release action.

  103. def service[A](implicit arg0: zio.Tag[A]): ZManaged[Has[A], Nothing, A]

    Accesses the specified service in the environment of the effect.

  104. def serviceAt[Service]: ServiceAtPartiallyApplied[Service]

    Accesses the service corresponding to the specified key in the environment.

  105. def serviceWith[Service]: ServiceWithPartiallyApplied[Service]

    Effectfully accesses the specified service in the environment of the effect.

    Effectfully accesses the specified service in the environment of the effect.

    def foo(int: Int) = ZManaged.serviceWith[Foo](_.foo(int))
  106. def serviceWithManaged[Service]: ServiceWithManagedPartiallyApplied[Service]

    Effectfully accesses the specified managed service in the environment of the effect .

    Effectfully accesses the specified managed service in the environment of the effect .

    Especially useful for creating "accessor" methods on Services' companion objects accessing managed resources.

    trait Foo {
     def start(): ZManaged[Any, Nothing, Unit]
    }
    
    def start: ZManaged[Has[Foo], Nothing, Unit] =
     ZManaged.serviceWithManaged[Foo](_.start())
  107. def shift(executor: => Executor): ZManaged[Any, Nothing, Unit]

    Returns a managed effect that describes shifting to the specified executor as the acquire action with no release action.

  108. def some[A](a: => A): UManaged[Option[A]]

    Returns an effect with the optional value.

  109. def succeed[A](r: => A): ZManaged[Any, Nothing, A]

    Lifts a lazy, pure value into a Managed.

  110. def suspend[R, E, A](zManaged: => ZManaged[R, E, A]): ZManaged[R, E, A]

    Returns a lazily constructed Managed.

  111. def switchable[R, E, A]: ZManaged[R, Nothing, (ZManaged[R, E, A]) => ZIO[R, E, A]]

    Returns a ZManaged value that represents a managed resource that can be safely swapped within the scope of the ZManaged.

    Returns a ZManaged value that represents a managed resource that can be safely swapped within the scope of the ZManaged. The function provided inside the ZManaged can be used to switch the resource currently in use.

    When the resource is switched, the finalizer for the previous finalizer will be executed uninterruptibly. If the effect executing inside the ZManaged#use is interrupted, the finalizer for the resource currently in use is guaranteed to execute.

    This constructor can be used to create an expressive control flow that uses several instances of a managed resource. For example:

    def makeWriter: Task[FileWriter]
    trait FileWriter {
      def write(data: Int): Task[Unit]
      def close: UIO[Unit]
    }
    
    val elements = List(1, 2, 3, 4)
    val writingProgram =
      ZManaged.switchable[Any, Throwable, FileWriter].use { switchWriter =>
        ZIO.foreachDiscard(elements) { element =>
          for {
            writer <- switchWriter(makeWriter.toManaged(_.close))
            _      <- writer.write(element)
          } yield ()
        }
      }
  112. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  113. def toString(): String
    Definition Classes
    AnyRef → Any
  114. lazy val unit: ZManaged[Any, Nothing, Unit]

    Returns the effect resulting from mapping the success of this effect to unit.

  115. def unless[R, E, A](b: => Boolean)(zManaged: => ZManaged[R, E, A]): ZManaged[R, E, Option[A]]

    The moral equivalent of if (!p) exp

  116. def unlessManaged[R, E](b: => ZManaged[R, E, Boolean]): UnlessManaged[R, E]

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

  117. def unsandbox[R, E, A](v: => ZManaged[R, Cause[E], A]): ZManaged[R, E, A]

    The inverse operation to sandbox.

    The inverse operation to sandbox. Submerges the full cause of failure.

  118. def unwrap[R, E, A](fa: => ZIO[R, E, ZManaged[R, E, A]]): ZManaged[R, E, A]

    Unwraps a ZManaged that is inside a ZIO.

  119. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  120. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  121. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  122. def when[R, E, A](b: => Boolean)(zManaged: => ZManaged[R, E, A]): ZManaged[R, E, Option[A]]

    The moral equivalent of if (p) exp

  123. def whenCase[R, E, A, B](a: => A)(pf: PartialFunction[A, ZManaged[R, E, B]]): ZManaged[R, E, Option[B]]

    Runs an effect when the supplied PartialFunction matches for the given value, otherwise does nothing.

  124. def whenCaseManaged[R, E, A, B](a: => ZManaged[R, E, A])(pf: PartialFunction[A, ZManaged[R, E, B]]): ZManaged[R, E, Option[B]]

    Runs an effect when the supplied PartialFunction matches for the given effectful value, otherwise does nothing.

  125. def whenManaged[R, E](b: => ZManaged[R, E, Boolean]): WhenManaged[R, E]

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

  126. def withChildren[R, E, A](get: (UIO[Chunk[Fiber.Runtime[Any, Any]]]) => ZManaged[R, E, A]): ZManaged[R, E, A]

    Locally installs a supervisor and an effect that succeeds with all the children that have been forked in the returned effect.

  127. def withRuntimeConfig(runtimeConfig: => RuntimeConfig): ZManaged[Any, Nothing, Unit]

    Returns a managed effect that describes setting the runtime configuration to the specified value as the acquire action and setting it back to the original runtime configuration as the release action.

  128. def writeFile(path: Path): ZManaged[Any, IOException, ZOutputStream]
    Definition Classes
    ZManagedPlatformSpecific
  129. def writeFile(path: String): ZManaged[Any, IOException, ZOutputStream]
    Definition Classes
    ZManagedPlatformSpecific
  130. object Finalizer
  131. object ReleaseMap extends Serializable
  132. object ZManagedConstructor extends ZManagedConstructorLowPriority1

Deprecated Value Members

  1. def accessM[R]: AccessZIOPartiallyApplied[R]

    Create a managed that accesses the environment.

    Create a managed that accesses the environment.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use accessZIO

  2. def collectAllParN_[R, E, A](n: => Int)(as: => Iterable[ZManaged[R, E, A]]): ZManaged[R, E, Unit]

    Evaluate each effect in the structure in parallel, and discard the results.

    Evaluate each effect in the structure in parallel, and discard the results. For a sequential version, see collectAll_.

    Unlike CollectAllPar_, this method will use at most n fibers.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use collectAllParNDiscard

  3. def collectAllPar_[R, E, A](as: => Iterable[ZManaged[R, E, A]]): ZManaged[R, E, Unit]

    Evaluate each effect in the structure in parallel, and discard the results.

    Evaluate each effect in the structure in parallel, and discard the results. For a sequential version, see collectAll_.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use collectAllParDiscard

  4. def collectAll_[R, E, A](ms: => Iterable[ZManaged[R, E, A]]): ZManaged[R, E, Unit]

    Evaluate each effect in the structure from left to right, and discard the results.

    Evaluate each effect in the structure from left to right, and discard the results. For a parallel version, see collectAllPar_.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use collectAllDiscard

  5. def effect[A](r: => A): ZManaged[Any, Throwable, A]

    Lifts a synchronous side-effect into a ZManaged[R, Throwable, A], translating any thrown exceptions into typed failed effects.

    Lifts a synchronous side-effect into a ZManaged[R, Throwable, A], translating any thrown exceptions into typed failed effects.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use attempt

  6. def effectTotal[A](r: => A): ZManaged[Any, Nothing, A]

    Lifts a by-name, pure value into a Managed.

    Lifts a by-name, pure value into a Managed.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use succeed

  7. def flattenM[R, E, A](zManaged: => ZManaged[R, E, ZIO[R, E, A]]): ZManaged[R, E, A]

    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.

    Annotations
    @deprecated
    Deprecated

    (Since version 2,0.0) use flattenZIO

  8. def foreachParN_[R, E, A](n: => Int)(as: => Iterable[A])(f: (A) => ZManaged[R, E, Any]): ZManaged[R, E, Unit]

    Applies the function f to each element of the Iterable[A] and runs produced effects in parallel, discarding the results.

    Applies the function f to each element of the Iterable[A] and runs produced effects in parallel, discarding the results.

    Unlike foreachPar_, this method will use at most up to n fibers.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use foreachParNDiscard

  9. def foreachPar_[R, E, A](as: => Iterable[A])(f: (A) => ZManaged[R, E, Any]): ZManaged[R, E, Unit]

    Applies the function f to each element of the Iterable[A] and runs produced effects in parallel, discarding the results.

    Applies the function f to each element of the Iterable[A] and runs produced effects in parallel, discarding the results.

    For a sequential version of this method, see foreach_.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use foreachParDiscard

  10. def foreach_[R, E, A](as: => Iterable[A])(f: (A) => ZManaged[R, E, Any]): ZManaged[R, E, Unit]

    Applies the function f to each element of the Iterable[A] and runs produced effects sequentially.

    Applies the function f to each element of the Iterable[A] and runs produced effects sequentially.

    Equivalent to foreach(as)(f).unit, but without the cost of building the list of results.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use foreachDiscard

  11. def fromEffect[R, E, A](fa: => ZIO[R, E, A]): ZManaged[R, E, A]

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with no release action.

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with no release action. The effect will be performed interruptibly.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use fromZIO

  12. def fromEffectUninterruptible[R, E, A](fa: => ZIO[R, E, A]): ZManaged[R, E, A]

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with no release action.

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with no release action. The effect will be performed uninterruptibly. You usually want the ZManaged.fromZIO variant.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use fromZIOUninterruptible

  13. def fromFunction[R, A](f: (R) => A): ZManaged[R, Nothing, A]

    Lifts a function R => A into a ZManaged[R, Nothing, A].

    Lifts a function R => A into a ZManaged[R, Nothing, A].

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use access

  14. def fromFunctionM[R, E, A](f: (R) => ZManaged[Any, E, A]): ZManaged[R, E, A]

    Lifts an effectful function whose effect requires no environment into an effect that requires the input to the function.

    Lifts an effectful function whose effect requires no environment into an effect that requires the input to the function.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use accessManaged

  15. def halt[E](cause: => Cause[E]): ZManaged[Any, E, Nothing]

    Returns an effect that models failure with the specified Cause.

    Returns an effect that models failure with the specified Cause.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use failCause

  16. def ifM[R, E](b: => ZManaged[R, E, Boolean]): IfManaged[R, E]

    Runs onTrue if the result of b is true and onFalse otherwise.

    Runs onTrue if the result of b is true and onFalse otherwise.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use ifManaged

  17. def loop_[R, E, S](initial: => S)(cont: (S) => Boolean, inc: (S) => S)(body: (S) => ZManaged[R, E, Any]): ZManaged[R, E, Unit]

    Loops with the specified effectual function purely for its effects.

    Loops with the specified effectual function purely for its effects. The moral equivalent of:

    var s = initial
    
    while (cont(s)) {
      body(s)
      s = inc(s)
    }
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use loopDiscard

  18. def make[R, R1 <: R, E, A](acquire: => ZIO[R, E, A])(release: (A) => ZIO[R1, Nothing, Any]): ZManaged[R1, E, A]

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action.

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action. The acquire and release actions will be performed uninterruptibly.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use acquireReleaseWith

  19. def makeEffect[A](acquire: => A)(release: (A) => Any): ZManaged[Any, Throwable, A]

    Lifts a synchronous effect into ZManaged[R, Throwable, A] with a release action.

    Lifts a synchronous effect into ZManaged[R, Throwable, A] with a release action. The acquire and release actions will be performed uninterruptibly.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use acquireReleaseAttemptWith

  20. def makeEffectTotal[A](acquire: => A)(release: (A) => Any): ZManaged[Any, Nothing, A]

    Lifts a synchronous effect that does not throw exceptions into a ZManaged[Any, Nothing, A] with a release action.

    Lifts a synchronous effect that does not throw exceptions into a ZManaged[Any, Nothing, A] with a release action. The acquire and release actions will be performed uninterruptibly.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use acquireReleaseSucceedWith

  21. def makeEffectTotal_[A](acquire: => A)(release: => Any): ZManaged[Any, Nothing, A]

    Lifts a synchronous effect that does not throw exceptions into a ZManaged[Any, Nothing, A] with a release action that does not need access to the resource.

    Lifts a synchronous effect that does not throw exceptions into a ZManaged[Any, Nothing, A] with a release action that does not need access to the resource. The acquire and release actions will be performed uninterruptibly.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use acquireReleaseSucceed

  22. def makeEffect_[A](acquire: => A)(release: => Any): ZManaged[Any, Throwable, A]

    Lifts a synchronous effect into ZManaged[R, Throwable, A] with a release action that does not need access to the resource.

    Lifts a synchronous effect into ZManaged[R, Throwable, A] with a release action that does not need access to the resource. The acquire and release actions will be performed uninterruptibly.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use acquireReleaseAttempt

  23. def makeExit[R, R1 <: R, E, A](acquire: ZIO[R, E, A])(release: (A, Exit[Any, Any]) => ZIO[R1, Nothing, Any]): ZManaged[R1, E, A]

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action that handles Exit.

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action that handles Exit. The acquire and release actions will be performed uninterruptibly.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use acquireReleaseExitWith

  24. def makeExit_[R, R1 <: R, E, A](acquire: => ZIO[R, E, A])(release: (Exit[Any, Any]) => ZIO[R1, Nothing, Any]): ZManaged[R1, E, A]

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action that does not need access to the resource but handles Exit.

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action that does not need access to the resource but handles Exit. The acquire and release actions will be performed uninterruptibly.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use acquireReleaseExit

  25. def makeInterruptible[R, R1 <: R, E, A](acquire: => ZIO[R, E, A])(release: (A) => URIO[R, Any]): ZManaged[R, E, A]

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action.

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action. The acquire action will be performed interruptibly, while release will be performed uninterruptibly.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use acquireReleaseInterruptibleWith

  26. def makeInterruptible_[R, R1 <: R, E, A](acquire: => ZIO[R, E, A])(release: => ZIO[R1, Nothing, Any]): ZManaged[R1, E, A]

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action that does not require access to the resource.

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action that does not require access to the resource. The acquire action will be performed interruptibly, while release will be performed uninterruptibly.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use acquireReleaseInterruptible

  27. def makeReserve[R, E, A](reservation: => ZIO[R, E, Reservation[R, E, A]]): ZManaged[R, E, A]

    Creates a ZManaged from a Reservation produced by an effect.

    Creates a ZManaged from a Reservation produced by an effect. Evaluating the effect that produces the reservation will be performed *uninterruptibly*, while the acquisition step of the reservation will be performed *interruptibly*. The release step will be performed uninterruptibly as usual.

    This two-phase acquisition allows for resource acquisition flows that can be safely interrupted and released.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use fromReservationZIO

  28. def make_[R, R1 <: R, E, A](acquire: => ZIO[R, E, A])(release: => ZIO[R1, Nothing, Any]): ZManaged[R1, E, A]

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action that does not need access to the resource.

    Lifts a ZIO[R, E, A] into ZManaged[R, E, A] with a release action that does not need access to the resource. The acquire and release actions will be performed uninterruptibly.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use acquireRelease

  29. def mapN[R, E, A, B, C, D, F](zManaged1: => ZManaged[R, E, A], zManaged2: => ZManaged[R, E, B], zManaged3: => ZManaged[R, E, C], zManaged4: => ZManaged[R, E, D])(f: (A, B, C, D) => F): ZManaged[R, E, F]

    Sequentially zips the specified effects using the specified combiner function.

    Sequentially zips the specified effects using the specified combiner function.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use zip

  30. def mapN[R, E, A, B, C, D](zManaged1: => ZManaged[R, E, A], zManaged2: => ZManaged[R, E, B], zManaged3: => ZManaged[R, E, C])(f: (A, B, C) => D): ZManaged[R, E, D]

    Sequentially zips the specified effects using the specified combiner function.

    Sequentially zips the specified effects using the specified combiner function.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use zip

  31. def mapN[R, E, A, B, C](zManaged1: => ZManaged[R, E, A], zManaged2: => ZManaged[R, E, B])(f: (A, B) => C): ZManaged[R, E, C]

    Sequentially zips the specified effects using the specified combiner function.

    Sequentially zips the specified effects using the specified combiner function.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use zip

  32. def mapParN[R, E, A, B, C, D, F](zManaged1: => ZManaged[R, E, A], zManaged2: => ZManaged[R, E, B], zManaged3: => ZManaged[R, E, C], zManaged4: => ZManaged[R, E, D])(f: (A, B, C, D) => F): ZManaged[R, E, F]

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

    Returns an effect that executes the specified effects in parallel, combining their results with the specified f function. If any effect fails, then the other effects will be interrupted.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use zipPar

  33. def mapParN[R, E, A, B, C, D](zManaged1: => ZManaged[R, E, A], zManaged2: => ZManaged[R, E, B], zManaged3: => ZManaged[R, E, C])(f: (A, B, C) => D): ZManaged[R, E, D]

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

    Returns an effect that executes the specified effects in parallel, combining their results with the specified f function. If any effect fails, then the other effects will be interrupted.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use zipPar

  34. def mapParN[R, E, A, B, C](zManaged1: => ZManaged[R, E, A], zManaged2: => ZManaged[R, E, B])(f: (A, B) => C): ZManaged[R, E, C]

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

    Returns an effect that executes the specified effects in parallel, combining their results with the specified f function. If any effect fails, then the other effects will be interrupted.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use zipPar

  35. def require[R, E, A](error: => E): (ZManaged[R, E, Option[A]]) => ZManaged[R, E, A]

    Requires that the given ZManaged[E, Option[A]] contain a value.

    Requires that the given ZManaged[E, Option[A]] contain a value. If there is no value, then the specified error will be raised.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use someOrFail

  36. def reserve[R, E, A](reservation: => Reservation[R, E, A]): ZManaged[R, E, A]

    Lifts a pure Reservation[R, E, A] into ZManaged[R, E, A].

    Lifts a pure Reservation[R, E, A] into ZManaged[R, E, A]. The acquisition step is performed interruptibly.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use fromReservation

  37. def services[A, B, C, D](implicit arg0: zio.Tag[A], arg1: zio.Tag[B], arg2: zio.Tag[C], arg3: zio.Tag[D]): ZManaged[Has[A] with Has[B] with Has[C] with Has[D], Nothing, (A, B, C, D)]

    Accesses the specified services in the environment of the effect.

    Accesses the specified services in the environment of the effect.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use service

  38. def services[A, B, C](implicit arg0: zio.Tag[A], arg1: zio.Tag[B], arg2: zio.Tag[C]): ZManaged[Has[A] with Has[B] with Has[C], Nothing, (A, B, C)]

    Accesses the specified services in the environment of the effect.

    Accesses the specified services in the environment of the effect.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use service

  39. def services[A, B](implicit arg0: zio.Tag[A], arg1: zio.Tag[B]): ZManaged[Has[A] with Has[B], Nothing, (A, B)]

    Accesses the specified services in the environment of the effect.

    Accesses the specified services in the environment of the effect.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use service

  40. def unlessM[R, E](b: => ZManaged[R, E, Boolean]): UnlessManaged[R, E]

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

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

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use unlessManaged

  41. def whenCaseM[R, E, A, B](a: => ZManaged[R, E, A])(pf: PartialFunction[A, ZManaged[R, E, B]]): ZManaged[R, E, Option[B]]

    Runs an effect when the supplied PartialFunction matches for the given effectful value, otherwise does nothing.

    Runs an effect when the supplied PartialFunction matches for the given effectful value, otherwise does nothing.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use whenCaseManaged

  42. def whenM[R, E](b: => ZManaged[R, E, Boolean]): WhenManaged[R, E]

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

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

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use whenManaged

Inherited from Serializable

Inherited from ZManagedPlatformSpecific

Inherited from AnyRef

Inherited from Any

Ungrouped