trait Bracket2[F[+_, +_]] extends Error2[F]
- Alphabetic
- By Inheritance
- Bracket2
- Error2
- ErrorAccumulatingOps2
- Monad2
- ApplicativeError2
- Bifunctor2
- Guarantee2
- Applicative2
- Functor2
- RootBifunctor
- Root
- PredefinedHelper
- DivergenceHelper
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Type Members
- type Divergence = Nondivergent
- Definition Classes
- DivergenceHelper
- type IsPredefined = NotPredefined
- Definition Classes
- PredefinedHelper
Abstract Value Members
- abstract def bracketCase[E, A, B](acquire: F[E, A])(release: (A, Exit[E, B]) => F[Nothing, Unit])(use: (A) => F[E, B]): F[E, B]
- abstract def catchAll[E, A, E2](r: F[E, A])(f: (E) => F[E2, A]): F[E2, A]
- Definition Classes
- Error2
- abstract def fail[E](v: => E): F[E, Nothing]
- Definition Classes
- ApplicativeError2
- abstract def flatMap[E, A, B](r: F[E, A])(f: (A) => F[E, B]): F[E, B]
- Definition Classes
- Monad2
- abstract def fromEither[E, V](effect: => Either[E, V]): F[E, V]
- Definition Classes
- ApplicativeError2
- abstract def fromOption[E, A](errorOnNone: => E)(effect: => Option[A]): F[E, A]
- Definition Classes
- ApplicativeError2
- abstract def fromTry[A](effect: => Try[A]): F[Throwable, A]
- Definition Classes
- ApplicativeError2
- abstract def pure[A](a: A): F[Nothing, A]
- Definition Classes
- Applicative2
Concrete Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- def *>[E, A, B](f: F[E, A], next: => F[E, B]): F[E, B]
execute two operations in order, return result of second operation
execute two operations in order, return result of second operation
- Definition Classes
- Monad2 → Applicative2
- def <*[E, A, B](f: F[E, A], next: => F[E, B]): F[E, A]
execute two operations in order, same as
*>
, but return result of first operationexecute two operations in order, same as
*>
, but return result of first operation- Definition Classes
- Monad2 → Applicative2
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def InnerF: Functor2[F]
- Definition Classes
- ApplicativeError2 → Bifunctor2
- def accumulateErrorsImpl[ColL[_], ColR[x] <: IterableOnce[x], E, E1, A, B, B1, AC](col: ColR[A])(effect: (A) => F[E, B], onLeft: (E) => IterableOnce[E1], init: AC, onRight: (AC, B) => AC, end: (AC) => B1)(implicit buildL: Factory[E1, ColL[E1]]): F[ColL[E1], B1]
- Attributes
- protected[this]
- Definition Classes
- ErrorAccumulatingOps2
- def as[E, A, B](r: F[E, A])(v: => B): F[E, B]
- Definition Classes
- Functor2
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def attempt[E, A](r: F[E, A]): F[Nothing, Either[E, A]]
- Definition Classes
- Error2
- def bimap[E, A, E2, B](r: F[E, A])(f: (E) => E2, g: (A) => B): F[E2, B]
- Definition Classes
- Error2 → Bifunctor2
- def bracket[E, A, B](acquire: F[E, A])(release: (A) => F[Nothing, Unit])(use: (A) => F[E, B]): F[E, B]
- final def bracketOnFailure[E, A, B](acquire: F[E, A])(cleanupOnFailure: (A, Failure[E]) => F[Nothing, Unit])(use: (A) => F[E, B]): F[E, B]
Run release action only on a failure – _any failure_, INCLUDING interruption.
Run release action only on a failure – _any failure_, INCLUDING interruption. Do not run release action if
use
finished successfully. - def catchSome[E, A, E1 >: E](r: F[E, A])(f: PartialFunction[E, F[E1, A]]): F[E1, A]
- Definition Classes
- Error2
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def collect[E, A, B](l: Iterable[A])(f: (A) => F[E, Option[B]]): F[E, List[B]]
- Definition Classes
- Applicative2
- def collectFirst[E, A, B](l: Iterable[A])(f: (A) => F[E, Option[B]]): F[E, Option[B]]
- Definition Classes
- Monad2
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def filter[E, A](l: Iterable[A])(f: (A) => F[E, Boolean]): F[E, List[A]]
- Definition Classes
- Applicative2
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def find[E, A](l: Iterable[A])(f: (A) => F[E, Boolean]): F[E, Option[A]]
- Definition Classes
- Monad2
- def flatSequence[E, A](l: Iterable[F[E, Iterable[A]]]): F[E, List[A]]
- Definition Classes
- Applicative2
- def flatSequenceAccumErrors[ColR[x] <: IterableOnce[x], ColIn[x] <: IterableOnce[x], ColL[_], E, A](col: ColR[F[ColL[E], ColIn[A]]])(implicit buildR: Factory[A, ColR[A]], buildL: Factory[E, ColL[E]], iterL: (ColL[E]) => IterableOnce[E]): F[ColL[E], ColR[A]]
flatSequence
with error accumulationflatSequence
with error accumulation- Definition Classes
- ErrorAccumulatingOps2
- def flatTraverse[E, A, B](l: Iterable[A])(f: (A) => F[E, Iterable[B]]): F[E, List[B]]
- Definition Classes
- Applicative2
- def flatTraverseAccumErrors[ColR[x] <: IterableOnce[x], ColIn[x] <: IterableOnce[x], ColL[_], E, A, B](col: ColR[A])(f: (A) => F[ColL[E], ColIn[B]])(implicit buildR: Factory[B, ColR[B]], buildL: Factory[E, ColL[E]], iterL: (ColL[E]) => IterableOnce[E]): F[ColL[E], ColR[B]]
flatTraverse
with error accumulationflatTraverse
with error accumulation- Definition Classes
- ErrorAccumulatingOps2
- def flatten[E, A](r: F[E, F[E, A]]): F[E, A]
- Definition Classes
- Monad2
- def flip[E, A](r: F[E, A]): F[A, E]
- Definition Classes
- Error2
- def foldLeft[E, A, AC](l: Iterable[A])(z: AC)(f: (AC, A) => F[E, AC]): F[E, AC]
- Definition Classes
- Monad2
- final def forever[E, A](r: F[E, A]): F[E, Nothing]
- Definition Classes
- Applicative2
- Annotations
- @inline()
- def fromOption[E, A](errorOnNone: => E, r: F[E, Option[A]]): F[E, A]
Extracts the optional value or fails with the
errorOnNone
errorExtracts the optional value or fails with the
errorOnNone
error- Definition Classes
- Error2
- def fromOptionF[E, A](fallbackOnNone: => F[E, A], r: F[E, Option[A]]): F[E, A]
Extracts the optional value, or executes the
fallbackOnNone
effectExtracts the optional value, or executes the
fallbackOnNone
effect- Definition Classes
- Monad2
- def fromOptionOr[E, A](valueOnNone: => A, r: F[E, Option[A]]): F[E, A]
Extracts the optional value, or returns the given
valueOnNone
valueExtracts the optional value, or returns the given
valueOnNone
value- Definition Classes
- Functor2
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def guarantee[E, A](f: F[E, A], cleanup: F[Nothing, Unit]): F[E, A]
- Definition Classes
- Bracket2 → Guarantee2
- def guaranteeCase[E, A](f: F[E, A], cleanup: (Exit[E, A]) => F[Nothing, Unit]): F[E, A]
- final def guaranteeExceptOnInterrupt[E, A](f: F[E, A], cleanupOnNonInterruption: (Either[Termination, Either[Error[E], Success[A]]]) => F[Nothing, Unit]): F[E, A]
Run cleanup on both _success_ and _failure_, if the failure IS NOT an interruption.
- final def guaranteeOnFailure[E, A](f: F[E, A], cleanupOnFailure: (Failure[E]) => F[Nothing, Unit]): F[E, A]
Run cleanup only on a failure – _any failure_, INCLUDING interruption.
Run cleanup only on a failure – _any failure_, INCLUDING interruption. Do not run cleanup if
use
finished successfully. - final def guaranteeOnInterrupt[E, A](f: F[E, A], cleanupOnInterruption: (Interruption) => F[Nothing, Unit]): F[E, A]
Run cleanup only on interruption.
Run cleanup only on interruption. Do not run cleanup if
use
finished successfully. - def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- final def ifThenElse[E, E1, A](cond: F[E, Boolean])(ifTrue: => F[E1, A], ifFalse: => F[E1, A])(implicit ev: <:<[E, E1]): F[E1, A]
- Definition Classes
- Monad2
- Annotations
- @inline()
- final def ifThenElse[E, A](cond: Boolean)(ifTrue: => F[E, A], ifFalse: => F[E, A]): F[E, A]
- Definition Classes
- Applicative2
- Annotations
- @inline()
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def iterateUntil[E, A](r: F[E, A])(p: (A) => Boolean): F[E, A]
Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.
Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.
- Definition Classes
- Monad2
- def iterateUntilF[E, A](init: A)(f: (A) => F[E, A])(p: (A) => Boolean): F[E, A]
Apply an effectful function iteratively until its result satisfies the given predicate and return that result.
Apply an effectful function iteratively until its result satisfies the given predicate and return that result.
- Definition Classes
- Monad2
- def iterateWhile[E, A](r: F[E, A])(p: (A) => Boolean): F[E, A]
Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.
Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.
- Definition Classes
- Monad2
- def iterateWhileF[E, A](init: A)(f: (A) => F[E, A])(p: (A) => Boolean): F[E, A]
Apply an effectful function iteratively until its result fails to satisfy the given predicate and return that result.
Apply an effectful function iteratively until its result fails to satisfy the given predicate and return that result.
- Definition Classes
- Monad2
- def leftFlatMap[E, A, E2](r: F[E, A])(f: (E) => F[Nothing, E2]): F[E2, A]
- Definition Classes
- Error2
- def leftMap[E, A, E2](r: F[E, A])(f: (E) => E2): F[E2, A]
- Definition Classes
- Bifunctor2
- def leftMap2[E, A, E2, E3](firstOp: F[E, A], secondOp: => F[E2, A])(f: (E, E2) => E3): F[E3, A]
map errors from two operations into a new error if both fail
map errors from two operations into a new error if both fail
- Definition Classes
- Error2 → ApplicativeError2
- def map[E, A, B](r: F[E, A])(f: (A) => B): F[E, B]
- def map2[E, A, B, C](r1: F[E, A], r2: => F[E, B])(f: (A, B) => C): F[E, C]
execute two operations in order, map their results
execute two operations in order, map their results
- Definition Classes
- Monad2 → Applicative2
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def orElse[E, A, E2](r: F[E, A], f: => F[E2, A]): F[E2, A]
execute second operation only if the first one fails
execute second operation only if the first one fails
- Definition Classes
- Error2 → ApplicativeError2
- def partition[E, A](l: Iterable[F[E, A]]): F[Nothing, (List[E], List[A])]
- Definition Classes
- Error2
- Annotations
- @nowarn()
- def redeem[E, A, E2, B](r: F[E, A])(err: (E) => F[E2, B], succ: (A) => F[E2, B]): F[E2, B]
- Definition Classes
- Error2
- def redeemPure[E, A, B](r: F[E, A])(err: (E) => B, succ: (A) => B): F[Nothing, B]
- Definition Classes
- Error2
- def retryUntil[E, A](r: F[E, A])(f: (E) => Boolean): F[E, A]
Retries this effect until its error satisfies the specified predicate.
Retries this effect until its error satisfies the specified predicate.
- Definition Classes
- Error2
- def retryUntilF[E, A](r: F[E, A])(f: (E) => F[Nothing, Boolean]): F[E, A]
Retries this effect until its error satisfies the specified effectful predicate.
Retries this effect until its error satisfies the specified effectful predicate.
- Definition Classes
- Error2
- def retryWhile[E, A](r: F[E, A])(f: (E) => Boolean): F[E, A]
Retries this effect while its error satisfies the specified predicate.
Retries this effect while its error satisfies the specified predicate.
- Definition Classes
- Error2
- def retryWhileF[E, A](r: F[E, A])(f: (E) => F[Nothing, Boolean]): F[E, A]
Retries this effect while its error satisfies the specified effectful predicate.
Retries this effect while its error satisfies the specified effectful predicate.
- Definition Classes
- Error2
- def sequence[E, A](l: Iterable[F[E, A]]): F[E, List[A]]
- Definition Classes
- Applicative2
- def sequenceAccumErrors[ColR[x] <: IterableOnce[x], ColL[_], E, A](col: ColR[F[ColL[E], A]])(implicit buildR: Factory[A, ColR[A]], buildL: Factory[E, ColL[E]], iterL: (ColL[E]) => IterableOnce[E]): F[ColL[E], ColR[A]]
sequence
with error accumulationsequence
with error accumulation- Definition Classes
- ErrorAccumulatingOps2
- def sequenceAccumErrorsNEList[ColR[x] <: IterableOnce[x], E, A](col: ColR[F[E, A]])(implicit buildR: Factory[A, ColR[A]]): F[NEList[E], ColR[A]]
sequence
with error accumulationsequence
with error accumulation- Definition Classes
- ErrorAccumulatingOps2
- def sequenceAccumErrors_[ColR[x] <: IterableOnce[x], ColL[_], E, A](col: ColR[F[ColL[E], A]])(implicit buildL: Factory[E, ColL[E]], iterL: (ColL[E]) => IterableOnce[E]): F[ColL[E], Unit]
sequence_
with error accumulationsequence_
with error accumulation- Definition Classes
- ErrorAccumulatingOps2
- def sequence_[E](l: Iterable[F[E, Unit]]): F[E, Unit]
- Definition Classes
- Applicative2
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def tailRecM[E, A, B](a: A)(f: (A) => F[E, Either[A, B]]): F[E, B]
- Definition Classes
- Monad2
- def tap[E, A](r: F[E, A], f: (A) => F[E, Unit]): F[E, A]
- Definition Classes
- Monad2
- def tapBoth[E, A, E1 >: E](r: F[E, A])(err: (E) => F[E1, Unit], succ: (A) => F[E1, Unit]): F[E1, A]
- Definition Classes
- Error2
- def tapError[E, A, E1 >: E](r: F[E, A])(f: (E) => F[E1, Unit]): F[E1, A]
- Definition Classes
- Error2
- def toString(): String
- Definition Classes
- AnyRef → Any
- final def traverse[E, A, B](o: Option[A])(f: (A) => F[E, B]): F[E, Option[B]]
- Definition Classes
- Applicative2
- Annotations
- @inline()
- def traverse[E, A, B](l: Iterable[A])(f: (A) => F[E, B]): F[E, List[B]]
- Definition Classes
- Applicative2
- def traverseAccumErrors[ColR[x] <: IterableOnce[x], ColL[_], E, A, B](col: ColR[A])(f: (A) => F[ColL[E], B])(implicit buildR: Factory[B, ColR[B]], buildL: Factory[E, ColL[E]], iterL: (ColL[E]) => IterableOnce[E]): F[ColL[E], ColR[B]]
traverse
with error accumulationtraverse
with error accumulation- Definition Classes
- ErrorAccumulatingOps2
- def traverseAccumErrors_[ColR[x] <: IterableOnce[x], ColL[_], E, A](col: ColR[A])(f: (A) => F[ColL[E], Unit])(implicit buildL: Factory[E, ColL[E]], iterL: (ColL[E]) => IterableOnce[E]): F[ColL[E], Unit]
traverse_
with error accumulationtraverse_
with error accumulation- Definition Classes
- ErrorAccumulatingOps2
- def traverse_[E, A](l: Iterable[A])(f: (A) => F[E, Unit]): F[E, Unit]
- Definition Classes
- Applicative2
- def unit: F[Nothing, Unit]
- Definition Classes
- Applicative2
- final def unless[E, E1](cond: F[E, Boolean])(ifFalse: => F[E1, Unit])(implicit ev: <:<[E, E1]): F[E1, Unit]
- Definition Classes
- Monad2
- Annotations
- @inline()
- final def unless[E](cond: Boolean)(ifFalse: => F[E, Unit]): F[E, Unit]
- Definition Classes
- Applicative2
- Annotations
- @inline()
- def void[E, A](r: F[E, A]): F[E, Unit]
- Definition Classes
- Functor2
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- final def when[E, E1](cond: F[E, Boolean])(ifTrue: => F[E1, Unit])(implicit ev: <:<[E, E1]): F[E1, Unit]
- Definition Classes
- Monad2
- Annotations
- @inline()
- final def when[E](cond: Boolean)(ifTrue: => F[E, Unit]): F[E, Unit]
- Definition Classes
- Applicative2
- Annotations
- @inline()
- final def widen[E, A, A1](r: F[E, A])(implicit ev: <:<[A, A1]): F[E, A1]
- Definition Classes
- Functor2
- Annotations
- @inline()
- final def widenBoth[E, A, E1, A1](r: F[E, A])(implicit ev: <:<[E, E1], ev2: <:<[A, A1]): F[E1, A1]
- Definition Classes
- Bifunctor2
- Annotations
- @inline()
- final def widenError[E, A, E1](r: F[E, A])(implicit ev: <:<[E, E1]): F[E1, A]
- Definition Classes
- Bifunctor2
- Annotations
- @inline()
- final def withFilter[E, A](r: F[E, A])(predicate: (A) => Boolean)(implicit filter: WithFilter[E], pos: SourceFilePositionMaterializer): F[E, A]
for-comprehensions sugar:
for-comprehensions sugar:
for { (1, 2) <- F.pure((2, 1)) } yield ()
Use widenError to for pattern matching with non-Throwable errors:
val f = for { (1, 2) <- F.pure((2, 1)).widenError[Option[Unit]] } yield () // f: F[Option[Unit], Unit] = F.fail(Some(())
- Definition Classes
- Error2
- Annotations
- @inline()