trait Error3[F[-_, +_, +_]] extends ApplicativeError3[F] with Monad3[F] with ErrorAccumulatingOps3[F]
Linear Supertypes
Known Subclasses
Ordering
- Alphabetic
- By Inheritance
Inherited
- Error3
- ErrorAccumulatingOps3
- Monad3
- ApplicativeError3
- Bifunctor3
- Guarantee3
- Applicative3
- Functor3
- RootBifunctor
- Root
- PredefinedHelper
- DivergenceHelper
- AnyRef
- Any
- Hide All
- Show All
Visibility
- Public
- Protected
Type Members
- type Divergence = Nondivergent
- Definition Classes
- DivergenceHelper
- type IsPredefined = NotPredefined
- Definition Classes
- PredefinedHelper
Abstract Value Members
- abstract def catchAll[R, E, A, E2](r: F[R, E, A])(f: (E) => F[R, E2, A]): F[R, E2, A]
- abstract def fail[E](v: => E): F[Any, E, Nothing]
- Definition Classes
- ApplicativeError3
- abstract def flatMap[R, E, A, B](r: F[R, E, A])(f: (A) => F[R, E, B]): F[R, E, B]
- Definition Classes
- Monad3
- abstract def fromEither[E, V](effect: => Either[E, V]): F[Any, E, V]
- Definition Classes
- ApplicativeError3
- abstract def fromOption[E, A](errorOnNone: => E)(effect: => Option[A]): F[Any, E, A]
- Definition Classes
- ApplicativeError3
- abstract def fromTry[A](effect: => Try[A]): F[Any, Throwable, A]
- Definition Classes
- ApplicativeError3
- abstract def guarantee[R, E, A](f: F[R, E, A], cleanup: F[R, Nothing, Unit]): F[R, E, A]
- Definition Classes
- Guarantee3
- abstract def pure[A](a: A): F[Any, Nothing, A]
- Definition Classes
- Applicative3
Concrete Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- def *>[R, E, A, B](f: F[R, E, A], next: => F[R, E, B]): F[R, E, B]
execute two operations in order, return result of second operation
execute two operations in order, return result of second operation
- Definition Classes
- Monad3 → Applicative3
- def <*[R, E, A, B](f: F[R, E, A], next: => F[R, E, B]): F[R, 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
- Monad3 → Applicative3
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def InnerF: Functor3[F]
- Definition Classes
- ApplicativeError3 → Bifunctor3
- def accumulateErrorsImpl[ColL[_], ColR[x] <: IterableOnce[x], R, E, E1, A, B, B1, AC](col: ColR[A])(effect: (A) => F[R, E, B], onLeft: (E) => IterableOnce[E1], init: AC, onRight: (AC, B) => AC, end: (AC) => B1)(implicit buildL: Factory[E1, ColL[E1]]): F[R, ColL[E1], B1]
- Attributes
- protected[this]
- Definition Classes
- ErrorAccumulatingOps3
- def as[R, E, A, B](r: F[R, E, A])(v: => B): F[R, E, B]
- Definition Classes
- Functor3
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def attempt[R, E, A](r: F[R, E, A]): F[R, Nothing, Either[E, A]]
- def bimap[R, E, A, E2, B](r: F[R, E, A])(f: (E) => E2, g: (A) => B): F[R, E2, B]
- Definition Classes
- Error3 → Bifunctor3
- def catchSome[R, E, A, E1 >: E](r: F[R, E, A])(f: PartialFunction[E, F[R, E1, A]]): F[R, E1, A]
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def collect[R, E, A, B](l: Iterable[A])(f: (A) => F[R, E, Option[B]]): F[R, E, List[B]]
- Definition Classes
- Applicative3
- def collectFirst[R, E, A, B](l: Iterable[A])(f: (A) => F[R, E, Option[B]]): F[R, E, Option[B]]
- Definition Classes
- Monad3
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def filter[R, E, A](l: Iterable[A])(f: (A) => F[R, E, Boolean]): F[R, E, List[A]]
- Definition Classes
- Applicative3
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def find[R, E, A](l: Iterable[A])(f: (A) => F[R, E, Boolean]): F[R, E, Option[A]]
- Definition Classes
- Monad3
- def flatSequence[R, E, A](l: Iterable[F[R, E, Iterable[A]]]): F[R, E, List[A]]
- Definition Classes
- Applicative3
- def flatSequenceAccumErrors[ColR[x] <: IterableOnce[x], ColIn[x] <: IterableOnce[x], ColL[_], R, E, A](col: ColR[F[R, ColL[E], ColIn[A]]])(implicit buildR: Factory[A, ColR[A]], buildL: Factory[E, ColL[E]], iterL: (ColL[E]) => IterableOnce[E]): F[R, ColL[E], ColR[A]]
flatSequencewith error accumulationflatSequencewith error accumulation- Definition Classes
- ErrorAccumulatingOps3
- def flatTraverse[R, E, A, B](l: Iterable[A])(f: (A) => F[R, E, Iterable[B]]): F[R, E, List[B]]
- Definition Classes
- Applicative3
- def flatTraverseAccumErrors[ColR[x] <: IterableOnce[x], ColIn[x] <: IterableOnce[x], ColL[_], R, E, A, B](col: ColR[A])(f: (A) => F[R, ColL[E], ColIn[B]])(implicit buildR: Factory[B, ColR[B]], buildL: Factory[E, ColL[E]], iterL: (ColL[E]) => IterableOnce[E]): F[R, ColL[E], ColR[B]]
flatTraversewith error accumulationflatTraversewith error accumulation- Definition Classes
- ErrorAccumulatingOps3
- def flatten[R, E, A](r: F[R, E, F[R, E, A]]): F[R, E, A]
- Definition Classes
- Monad3
- def flip[R, E, A](r: F[R, E, A]): F[R, A, E]
- def foldLeft[R, E, A, AC](l: Iterable[A])(z: AC)(f: (AC, A) => F[R, E, AC]): F[R, E, AC]
- Definition Classes
- Monad3
- final def forever[R, E, A](r: F[R, E, A]): F[R, E, Nothing]
- Definition Classes
- Applicative3
- Annotations
- @inline()
- def fromOption[R, E, A](errorOnNone: => E, r: F[R, E, Option[A]]): F[R, E, A]
Extracts the optional value or fails with the
errorOnNoneerror - def fromOptionF[R, E, A](fallbackOnNone: => F[R, E, A], r: F[R, E, Option[A]]): F[R, E, A]
Extracts the optional value, or executes the
fallbackOnNoneeffectExtracts the optional value, or executes the
fallbackOnNoneeffect- Definition Classes
- Monad3
- def fromOptionOr[R, E, A](valueOnNone: => A, r: F[R, E, Option[A]]): F[R, E, A]
Extracts the optional value, or returns the given
valueOnNonevalueExtracts the optional value, or returns the given
valueOnNonevalue- Definition Classes
- Functor3
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- final def ifThenElse[R, E, E1, A](cond: F[R, E, Boolean])(ifTrue: => F[R, E1, A], ifFalse: => F[R, E1, A])(implicit ev: <:<[E, E1]): F[R, E1, A]
- Definition Classes
- Monad3
- Annotations
- @inline()
- final def ifThenElse[R, E, A](cond: Boolean)(ifTrue: => F[R, E, A], ifFalse: => F[R, E, A]): F[R, E, A]
- Definition Classes
- Applicative3
- Annotations
- @inline()
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def iterateUntil[R, E, A](r: F[R, E, A])(p: (A) => Boolean): F[R, 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
- Monad3
- def iterateUntilF[R, E, A](init: A)(f: (A) => F[R, E, A])(p: (A) => Boolean): F[R, 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
- Monad3
- def iterateWhile[R, E, A](r: F[R, E, A])(p: (A) => Boolean): F[R, 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
- Monad3
- def iterateWhileF[R, E, A](init: A)(f: (A) => F[R, E, A])(p: (A) => Boolean): F[R, 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
- Monad3
- def leftFlatMap[R, E, A, E2](r: F[R, E, A])(f: (E) => F[R, Nothing, E2]): F[R, E2, A]
- def leftMap[R, E, A, E2](r: F[R, E, A])(f: (E) => E2): F[R, E2, A]
- Definition Classes
- Bifunctor3
- def leftMap2[R, E, A, E2, E3](firstOp: F[R, E, A], secondOp: => F[R, E2, A])(f: (E, E2) => E3): F[R, 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
- Error3 → ApplicativeError3
- def map[R, E, A, B](r: F[R, E, A])(f: (A) => B): F[R, E, B]
- def map2[R, E, A, B, C](r1: F[R, E, A], r2: => F[R, E, B])(f: (A, B) => C): F[R, E, C]
execute two operations in order, map their results
execute two operations in order, map their results
- Definition Classes
- Monad3 → Applicative3
- 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[R, E, A, E2](r: F[R, E, A], f: => F[R, E2, A]): F[R, E2, A]
execute second operation only if the first one fails
execute second operation only if the first one fails
- Definition Classes
- Error3 → ApplicativeError3
- def partition[R, E, A](l: Iterable[F[R, E, A]]): F[R, Nothing, (List[E], List[A])]
- Annotations
- @nowarn()
- def redeem[R, E, A, E2, B](r: F[R, E, A])(err: (E) => F[R, E2, B], succ: (A) => F[R, E2, B]): F[R, E2, B]
- def redeemPure[R, E, A, B](r: F[R, E, A])(err: (E) => B, succ: (A) => B): F[R, Nothing, B]
- def retryUntil[R, E, A](r: F[R, E, A])(f: (E) => Boolean): F[R, E, A]
Retries this effect until its error satisfies the specified predicate.
- def retryUntilF[R, R1 <: R, E, A](r: F[R, E, A])(f: (E) => F[R1, Nothing, Boolean]): F[R1, E, A]
Retries this effect until its error satisfies the specified effectful predicate.
- def retryWhile[R, E, A](r: F[R, E, A])(f: (E) => Boolean): F[R, E, A]
Retries this effect while its error satisfies the specified predicate.
- def retryWhileF[R, R1 <: R, E, A](r: F[R, E, A])(f: (E) => F[R1, Nothing, Boolean]): F[R1, E, A]
Retries this effect while its error satisfies the specified effectful predicate.
- def sequence[R, E, A](l: Iterable[F[R, E, A]]): F[R, E, List[A]]
- Definition Classes
- Applicative3
- def sequenceAccumErrors[ColR[x] <: IterableOnce[x], ColL[_], R, E, A](col: ColR[F[R, ColL[E], A]])(implicit buildR: Factory[A, ColR[A]], buildL: Factory[E, ColL[E]], iterL: (ColL[E]) => IterableOnce[E]): F[R, ColL[E], ColR[A]]
sequencewith error accumulationsequencewith error accumulation- Definition Classes
- ErrorAccumulatingOps3
- def sequenceAccumErrorsNEList[ColR[x] <: IterableOnce[x], R, E, A](col: ColR[F[R, E, A]])(implicit buildR: Factory[A, ColR[A]]): F[R, NEList[E], ColR[A]]
sequencewith error accumulationsequencewith error accumulation- Definition Classes
- ErrorAccumulatingOps3
- def sequenceAccumErrors_[ColR[x] <: IterableOnce[x], ColL[_], R, E, A](col: ColR[F[R, ColL[E], A]])(implicit buildL: Factory[E, ColL[E]], iterL: (ColL[E]) => IterableOnce[E]): F[R, ColL[E], Unit]
sequence_with error accumulationsequence_with error accumulation- Definition Classes
- ErrorAccumulatingOps3
- def sequence_[R, E](l: Iterable[F[R, E, Unit]]): F[R, E, Unit]
- Definition Classes
- Applicative3
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def tailRecM[R, E, A, B](a: A)(f: (A) => F[R, E, Either[A, B]]): F[R, E, B]
- Definition Classes
- Monad3
- def tap[R, E, A](r: F[R, E, A], f: (A) => F[R, E, Unit]): F[R, E, A]
- Definition Classes
- Monad3
- def tapBoth[R, E, A, E1 >: E](r: F[R, E, A])(err: (E) => F[R, E1, Unit], succ: (A) => F[R, E1, Unit]): F[R, E1, A]
- def tapError[R, E, A, E1 >: E](r: F[R, E, A])(f: (E) => F[R, E1, Unit]): F[R, E1, A]
- def toString(): String
- Definition Classes
- AnyRef → Any
- final def traverse[R, E, A, B](o: Option[A])(f: (A) => F[R, E, B]): F[R, E, Option[B]]
- Definition Classes
- Applicative3
- Annotations
- @inline()
- def traverse[R, E, A, B](l: Iterable[A])(f: (A) => F[R, E, B]): F[R, E, List[B]]
- Definition Classes
- Applicative3
- def traverseAccumErrors[ColR[x] <: IterableOnce[x], ColL[_], R, E, A, B](col: ColR[A])(f: (A) => F[R, ColL[E], B])(implicit buildR: Factory[B, ColR[B]], buildL: Factory[E, ColL[E]], iterL: (ColL[E]) => IterableOnce[E]): F[R, ColL[E], ColR[B]]
traversewith error accumulationtraversewith error accumulation- Definition Classes
- ErrorAccumulatingOps3
- def traverseAccumErrors_[ColR[x] <: IterableOnce[x], ColL[_], R, E, A](col: ColR[A])(f: (A) => F[R, ColL[E], Unit])(implicit buildL: Factory[E, ColL[E]], iterL: (ColL[E]) => IterableOnce[E]): F[R, ColL[E], Unit]
traverse_with error accumulationtraverse_with error accumulation- Definition Classes
- ErrorAccumulatingOps3
- def traverse_[R, E, A](l: Iterable[A])(f: (A) => F[R, E, Unit]): F[R, E, Unit]
- Definition Classes
- Applicative3
- def unit: F[Any, Nothing, Unit]
- Definition Classes
- Applicative3
- final def unless[R, E, E1](cond: F[R, E, Boolean])(ifFalse: => F[R, E1, Unit])(implicit ev: <:<[E, E1]): F[R, E1, Unit]
- Definition Classes
- Monad3
- Annotations
- @inline()
- final def unless[R, E](cond: Boolean)(ifFalse: => F[R, E, Unit]): F[R, E, Unit]
- Definition Classes
- Applicative3
- Annotations
- @inline()
- def void[R, E, A](r: F[R, E, A]): F[R, E, Unit]
- Definition Classes
- Functor3
- 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[R, E, E1](cond: F[R, E, Boolean])(ifTrue: => F[R, E1, Unit])(implicit ev: <:<[E, E1]): F[R, E1, Unit]
- Definition Classes
- Monad3
- Annotations
- @inline()
- final def when[R, E](cond: Boolean)(ifTrue: => F[R, E, Unit]): F[R, E, Unit]
- Definition Classes
- Applicative3
- Annotations
- @inline()
- final def widen[R, E, A, A1](r: F[R, E, A])(implicit ev: <:<[A, A1]): F[R, E, A1]
- Definition Classes
- Functor3
- Annotations
- @inline()
- final def widenBoth[R, E, A, E1, A1](r: F[R, E, A])(implicit ev: <:<[E, E1], ev2: <:<[A, A1]): F[R, E1, A1]
- Definition Classes
- Bifunctor3
- Annotations
- @inline()
- final def widenError[R, E, A, E1](r: F[R, E, A])(implicit ev: <:<[E, E1]): F[R, E1, A]
- Definition Classes
- Bifunctor3
- Annotations
- @inline()
- final def withFilter[R, E, A](r: F[R, E, A])(predicate: (A) => Boolean)(implicit filter: WithFilter[E], pos: SourceFilePositionMaterializer): F[R, 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(())
- Annotations
- @inline()