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

   Returns an effectful function that extracts out the first element of a tuple.

5.  final def _2[R, E, A, B](implicit ev: <:<[R, (A, B)]): ZManaged[R, E, B]

   Returns an effectful function that extracts out the second element of a tuple.

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

7.  final def asInstanceOf[T0]: T0

   Definition Classes

   Any

8.  def clone(): AnyRef

   Attributes

   protected[java.lang]

   Definition Classes

   AnyRef

   Annotations

   @throws(classOf[java.lang.CloneNotSupportedException]) @native()

9.  final def collectAll[R, E, A1, A2](ms: Iterable[ZManaged[R, E, A2]]): ZManaged[R, E, List[A2]]

   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.

10.  final def collectAllPar[R, E, A](as: Iterable[ZManaged[R, E, A]]): ZManaged[R, E, List[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.

11.  final def collectAllParN[R, E, A](n: Int)(as: Iterable[ZManaged[R, E, A]]): ZManaged[R, E, List[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.

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

13.  final def dieMessage(message: String): ZManaged[Any, Throwable, 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.

14.  final def done[E, A](r: Exit[E, A]): ZManaged[Any, E, A]

    Returns an effect from a zio.Exit value.

15.  final def environment[R]: ZManaged[R, Nothing, R]

    Accesses the whole environment of the effect.

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

    Definition Classes

    AnyRef

17.  def equals(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef → Any

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

19.  def finalize(): Unit

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

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

20.  final def finalizer[R](f: ZIO[R, Nothing, _]): ZManaged[R, Nothing, Unit]

    Creates an effect that only executes the UIO value as its release action.

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

22.  final def foreach[R, E, A1, A2](as: Iterable[A1])(f: (A1) => ZManaged[R, E, A2]): ZManaged[R, E, List[A2]]

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

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

    For a parallel version of this method, see foreachPar.

23.  final def foreachPar[R, E, A1, A2](as: Iterable[A1])(f: (A1) => ZManaged[R, E, A2]): ZManaged[R, E, List[A2]]

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

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

    For a sequential version of this method, see foreach.

24.  final def foreachParN[R, E, A1, A2](n: Int)(as: Iterable[A1])(f: (A1) => ZManaged[R, E, A2]): ZManaged[R, E, List[A2]]

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

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

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

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

26.  final def foreachPar_[R, E, A](as: Iterable[A])(f: (A) => ZManaged[R, E, _]): 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_.

27.  final def foreach_[R, E, A](as: Iterable[A])(f: (A) => ZManaged[R, E, _]): 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).void, but without the cost of building the list of results.

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

29.  final def fromEffect[R, E, A](fa: ZIO[R, E, A]): ZManaged[R, E, A]

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

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

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

    Lifts an Either into a ZManaged value.

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

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

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

33.  final def getClass(): Class[_ <: AnyRef]

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

34.  final def halt[E](cause: Cause[E]): ZManaged[Any, E, Nothing]

    Returns an effect that models failure with the specified Cause.

35.  def hashCode(): Int

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

36.  final def identity[R]: ZManaged[R, Nothing, R]

    Returns the identity effectful function, which performs no effects

37.  final val interrupt: ZManaged[Any, Nothing, Nothing]

    Returns an effect that is interrupted.

38.  final def isInstanceOf[T0]: Boolean

    Definition Classes

    Any

39.  final def make[R, E, A](acquire: ZIO[R, E, A])(release: (A) => ZIO[R, Nothing, _]): ZManaged[R, E, A]

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

40.  final def makeExit[R, E, A](acquire: ZIO[R, E, A])(release: (A, Exit[_, _]) => ZIO[R, Nothing, _]): ZManaged[R, E, A]

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

41.  final 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[IO] to a single IO, working sequentially.

42.  final 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[IO] to a single IO, working in parallel.

43.  final def mergeAllParN[R, E, A, B](n: Int)(in: Iterable[ZManaged[R, E, A]])(zero: B)(f: (B, A) => B): ZManaged[R, E, B]

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

    Merges 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

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

    Definition Classes

    AnyRef

45.  val never: ZManaged[Any, Nothing, Nothing]

    Returns a ZManaged that never acquires a resource.

46.  final def notify(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

47.  final def notifyAll(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

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

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

50.  final def reduceAllParN[R, E, A](n: Long)(a1: 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

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

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

53.  final def sandbox[R, E, A](v: ZManaged[R, E, A]): ZManaged[R, Cause[E], A]
54.  final def sequence[R, E, A1, A2](ms: Iterable[ZManaged[R, E, A2]]): ZManaged[R, E, List[A2]]

    Alias for ZManaged.collectAll

55.  final def sequencePar[R, E, A](as: Iterable[ZManaged[R, E, A]]): ZManaged[R, E, List[A]]

    Alias for ZManaged.collectAllPar

56.  final def sequenceParN[R, E, A](n: Int)(as: Iterable[ZManaged[R, E, A]]): ZManaged[R, E, List[A]]

    Alias for ZManaged.collectAllParN

57.  final def succeed[R, A](r: A): ZManaged[R, Nothing, A]

    Lifts a strict, pure value into a Managed.

58.  final def succeedLazy[R, A](r: => A): ZManaged[R, Nothing, A]

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

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

    Returns a lazily constructed Managed.

60.  final def swap[R, E, A, B](implicit ev: <:<[R, (A, B)]): ZManaged[R, E, (B, A)]

    Returns an effectful function that merely swaps the elements in a Tuple2.

61.  final def synchronized[T0](arg0: => T0): T0

    Definition Classes

    AnyRef

62.  def toString(): String

    Definition Classes

    AnyRef → Any

63.  final def traverse[R, E, A1, A2](as: Iterable[A1])(f: (A1) => ZManaged[R, E, A2]): ZManaged[R, E, List[A2]]

    Alias for ZManaged.foreach

64.  final def traversePar[R, E, A1, A2](as: Iterable[A1])(f: (A1) => ZManaged[R, E, A2]): ZManaged[R, E, List[A2]]

    Alias for ZManaged.foreachPar

65.  final def traverseParN[R, E, A1, A2](n: Int)(as: Iterable[A1])(f: (A1) => ZManaged[R, E, A2]): ZManaged[R, E, List[A2]]

    Alias for ZManaged.foreachParN

66.  final def traverseParN_[R, E, A](n: Int)(as: Iterable[A])(f: (A) => ZManaged[R, E, Any]): ZManaged[R, E, Unit]

    Alias for ZManaged.foreachParN_

67.  final def traversePar_[R, E, A](as: Iterable[A])(f: (A) => ZManaged[R, E, _]): ZManaged[R, E, Unit]

    Alias for ZManaged.foreachPar_

68.  final def traverse_[R, E, A](as: Iterable[A])(f: (A) => ZManaged[R, E, _]): ZManaged[R, E, Unit]

    Alias for ZManaged.foreach_

69.  final val unit: ZManaged[Any, Nothing, Unit]

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

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

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

72.  final def wait(): Unit

    Definition Classes

    AnyRef

    Annotations

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

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

    Definition Classes

    AnyRef

    Annotations

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

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

    Definition Classes

    AnyRef

    Annotations

    @throws(classOf[java.lang.InterruptedException]) @native()

75.  final def when[R, E](b: Boolean)(zManaged: ZManaged[R, E, _]): ZManaged[R, E, Unit]

    The moral equivalent of if (p) exp

76.  final def whenCase[R, E, A](a: A)(pf: PartialFunction[A, ZManaged[R, E, _]]): ZManaged[R, E, Unit]

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

77.  final def whenCaseM[R, E, A](a: ZManaged[R, E, A])(pf: PartialFunction[A, ZManaged[R, E, _]]): ZManaged[R, E, Unit]

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

78.  final def whenM[R, E](b: ZManaged[R, E, Boolean])(zManaged: ZManaged[R, E, _]): ZManaged[R, E, Unit]

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