object Error2Instance extends Error2Instance[Nothing]
- Alphabetic
 - By Inheritance
 
- Error2Instance
 - Error2Instance
 - 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
 
 
Value Members
-   final  def !=(arg0: Any): Boolean
- Definition Classes
 - AnyRef → Any
 
 -   final  def ##: Int
- Definition Classes
 - AnyRef → Any
 
 -   final  def *>[E, A, B](f: FreeError[Nothing, E, A], next: => FreeError[Nothing, E, B]): FreeError[Nothing, E, B]
execute two operations in order, return result of second operation
execute two operations in order, return result of second operation
- Definition Classes
 - Error2Instance → Monad2 → Applicative2
 - Annotations
 - @inline()
 
 -   final  def <*[E, A, B](f: FreeError[Nothing, E, A], next: => FreeError[Nothing, E, B]): FreeError[Nothing, 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
 - Error2Instance → Monad2 → Applicative2
 - Annotations
 - @inline()
 
 -   final  def ==(arg0: Any): Boolean
- Definition Classes
 - AnyRef → Any
 
 -    def InnerF: Functor2[[+β$4$, +γ$5$]FreeError[Nothing, β$4$, γ$5$]]
- Definition Classes
 - ApplicativeError2 → Bifunctor2
 
 -    def accumulateErrorsImpl[ColL[_], ColR[x] <: IterableOnce[x], E, E1, A, B, B1, AC](col: ColR[A])(effect: (A) => FreeError[Nothing, E, B], onLeft: (E) => IterableOnce[E1], init: AC, onRight: (AC, B) => AC, end: (AC) => B1)(implicit buildL: Factory[E1, ColL[E1]]): FreeError[Nothing, ColL[E1], B1]
- Attributes
 - protected
 - Definition Classes
 - ErrorAccumulatingOps2
 
 -   final  def as[E, A, B](r: FreeError[Nothing, E, A])(v: => B): FreeError[Nothing, E, B]
- Definition Classes
 - Error2Instance → Functor2
 - Annotations
 - @inline()
 
 -   final  def asInstanceOf[T0]: T0
- Definition Classes
 - Any
 
 -    def attempt[E, A](r: FreeError[Nothing, E, A]): FreeError[Nothing, Nothing, Either[E, A]]
- Definition Classes
 - Error2
 
 -    def bimap[E, A, E2, B](r: FreeError[Nothing, E, A])(f: (E) => E2, g: (A) => B): FreeError[Nothing, E2, B]
- Definition Classes
 - Error2 → Bifunctor2
 
 -   final  def catchAll[E, A, E2](r: FreeError[Nothing, E, A])(f: (E) => FreeError[Nothing, E2, A]): FreeError[Nothing, E2, A]
- Definition Classes
 - Error2Instance → Error2
 - Annotations
 - @inline()
 
 -   final  def catchSome[E, A, E1 >: E](r: FreeError[Nothing, E, A])(f: PartialFunction[E, FreeError[Nothing, E1, A]]): FreeError[Nothing, E1, A]
- Definition Classes
 - Error2Instance → Error2
 - Annotations
 - @inline()
 
 -    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) => FreeError[Nothing, E, Option[B]]): FreeError[Nothing, E, List[B]]
- Definition Classes
 - Applicative2
 
 -    def collectFirst[E, A, B](l: Iterable[A])(f: (A) => FreeError[Nothing, E, Option[B]]): FreeError[Nothing, E, Option[B]]
- Definition Classes
 - Monad2
 
 -   final  def eq(arg0: AnyRef): Boolean
- Definition Classes
 - AnyRef
 
 -    def equals(arg0: AnyRef): Boolean
- Definition Classes
 - AnyRef → Any
 
 -   final  def fail[E](v: => E): FreeError[Nothing, E, Nothing]
- Definition Classes
 - Error2Instance → ApplicativeError2
 - Annotations
 - @inline()
 
 -    def filter[E, A](l: Iterable[A])(f: (A) => FreeError[Nothing, E, Boolean]): FreeError[Nothing, 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) => FreeError[Nothing, E, Boolean]): FreeError[Nothing, E, Option[A]]
- Definition Classes
 - Monad2
 
 -   final  def flatMap[E, A, B](r: FreeError[Nothing, E, A])(f: (A) => FreeError[Nothing, E, B]): FreeError[Nothing, E, B]
- Definition Classes
 - Error2Instance → Monad2
 - Annotations
 - @inline()
 
 -    def flatSequence[E, A](l: Iterable[FreeError[Nothing, E, Iterable[A]]]): FreeError[Nothing, E, List[A]]
- Definition Classes
 - Applicative2
 
 -    def flatSequenceAccumErrors[ColR[x] <: IterableOnce[x], ColIn[x] <: IterableOnce[x], ColL[_], E, A](col: ColR[FreeError[Nothing, ColL[E], ColIn[A]]])(implicit buildR: Factory[A, ColR[A]], buildL: Factory[E, ColL[E]], iterL: (ColL[E]) => IterableOnce[E]): FreeError[Nothing, ColL[E], ColR[A]]
flatSequencewith error accumulationflatSequencewith error accumulation- Definition Classes
 - ErrorAccumulatingOps2
 
 -    def flatTraverse[E, A, B](l: Iterable[A])(f: (A) => FreeError[Nothing, E, Iterable[B]]): FreeError[Nothing, 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) => FreeError[Nothing, ColL[E], ColIn[B]])(implicit buildR: Factory[B, ColR[B]], buildL: Factory[E, ColL[E]], iterL: (ColL[E]) => IterableOnce[E]): FreeError[Nothing, ColL[E], ColR[B]]
flatTraversewith error accumulationflatTraversewith error accumulation- Definition Classes
 - ErrorAccumulatingOps2
 
 -    def flatten[E, A](r: FreeError[Nothing, E, FreeError[Nothing, E, A]]): FreeError[Nothing, E, A]
- Definition Classes
 - Monad2
 
 -    def flip[E, A](r: FreeError[Nothing, E, A]): FreeError[Nothing, A, E]
- Definition Classes
 - Error2
 
 -    def foldLeft[E, A, AC](l: Iterable[A])(z: AC)(f: (AC, A) => FreeError[Nothing, E, AC]): FreeError[Nothing, E, AC]
- Definition Classes
 - Monad2
 
 -   final  def forever[E, A](r: FreeError[Nothing, E, A]): FreeError[Nothing, E, Nothing]
- Definition Classes
 - Applicative2
 - Annotations
 - @inline()
 
 -   final  def fromAttempt[A](effect: => A): FreeError[Nothing, Throwable, A]
For lazy monads: alias for IO2#syncThrowable.
For lazy monads: alias for IO2#syncThrowable. For strict monads, shorthand for
F.fromTry(Try(effect))- Definition Classes
 - Error2Instance → ApplicativeError2
 - Annotations
 - @inline()
 
 -   final  def fromEither[E, V](effect: => Either[E, V]): FreeError[Nothing, E, V]
- Definition Classes
 - Error2Instance → ApplicativeError2
 - Annotations
 - @inline()
 
 -   final  def fromOption[E, A](errorOnNone: => E)(effect: => Option[A]): FreeError[Nothing, E, A]
- Definition Classes
 - Error2Instance → ApplicativeError2
 - Annotations
 - @inline()
 
 -    def fromOption[E, A](errorOnNone: => E, r: FreeError[Nothing, E, Option[A]]): FreeError[Nothing, E, A]
Extracts the optional value or fails with the
errorOnNoneerrorExtracts the optional value or fails with the
errorOnNoneerror- Definition Classes
 - Error2
 
 -    def fromOptionF[E, A](fallbackOnNone: => FreeError[Nothing, E, A], r: FreeError[Nothing, E, Option[A]]): FreeError[Nothing, E, A]
Extracts the optional value, or executes the
fallbackOnNoneeffectExtracts the optional value, or executes the
fallbackOnNoneeffect- Definition Classes
 - Monad2
 
 -    def fromOptionOr[E, A](valueOnNone: => A, r: FreeError[Nothing, E, Option[A]]): FreeError[Nothing, E, A]
Extracts the optional value, or returns the given
valueOnNonevalueExtracts the optional value, or returns the given
valueOnNonevalue- Definition Classes
 - Functor2
 
 -   final  def fromTry[A](effect: => Try[A]): FreeError[Nothing, Throwable, A]
- Definition Classes
 - Error2Instance → ApplicativeError2
 - Annotations
 - @inline()
 
 -   final  def getClass(): Class[_ <: AnyRef]
- Definition Classes
 - AnyRef → Any
 - Annotations
 - @native()
 
 -   final  def guarantee[E, A](f: FreeError[Nothing, E, A], cleanup: FreeError[Nothing, Nothing, Unit]): FreeError[Nothing, E, A]
- Definition Classes
 - Error2Instance → Guarantee2
 - Annotations
 - @inline()
 
 -    def hashCode(): Int
- Definition Classes
 - AnyRef → Any
 - Annotations
 - @native()
 
 -   final  def ifThenElse[E, E1, A](cond: FreeError[Nothing, E, Boolean])(ifTrue: => FreeError[Nothing, E1, A], ifFalse: => FreeError[Nothing, E1, A])(implicit ev: <:<[E, E1]): FreeError[Nothing, E1, A]
- Definition Classes
 - Monad2
 - Annotations
 - @inline()
 
 -   final  def ifThenElse[E, A](cond: Boolean)(ifTrue: => FreeError[Nothing, E, A], ifFalse: => FreeError[Nothing, E, A]): FreeError[Nothing, E, A]
- Definition Classes
 - Applicative2
 - Annotations
 - @inline()
 
 -   final  def ifThenFail[E](cond: Boolean)(errorIfTrue: => E): FreeError[Nothing, E, Unit]
- Definition Classes
 - ApplicativeError2
 - Annotations
 - @inline()
 
 -   final  def isInstanceOf[T0]: Boolean
- Definition Classes
 - Any
 
 -    def iterateUntil[E, A](r: FreeError[Nothing, E, A])(p: (A) => Boolean): FreeError[Nothing, 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) => FreeError[Nothing, E, A])(p: (A) => Boolean): FreeError[Nothing, 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: FreeError[Nothing, E, A])(p: (A) => Boolean): FreeError[Nothing, 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) => FreeError[Nothing, E, A])(p: (A) => Boolean): FreeError[Nothing, 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: FreeError[Nothing, E, A])(f: (E) => FreeError[Nothing, Nothing, E2]): FreeError[Nothing, E2, A]
- Definition Classes
 - Error2
 
 -    def leftMap[E, A, E2](r: FreeError[Nothing, E, A])(f: (E) => E2): FreeError[Nothing, E2, A]
- Definition Classes
 - Bifunctor2
 
 -    def leftMap2[E, A, E2, E3](firstOp: FreeError[Nothing, E, A], secondOp: => FreeError[Nothing, E2, A])(f: (E, E2) => E3): FreeError[Nothing, 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: FreeError[Nothing, E, A])(f: (A) => B): FreeError[Nothing, E, B]
 -    def map2[E, A, B, C](r1: FreeError[Nothing, E, A], r2: => FreeError[Nothing, E, B])(f: (A, B) => C): FreeError[Nothing, 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: FreeError[Nothing, E, A], f: => FreeError[Nothing, E2, A]): FreeError[Nothing, 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[FreeError[Nothing, E, A]]): FreeError[Nothing, Nothing, (List[E], List[A])]
- Definition Classes
 - Error2
 - Annotations
 - @nowarn()
 
 -   final  def pure[A](a: A): FreeError[Nothing, Nothing, A]
- Definition Classes
 - Error2Instance → Applicative2
 - Annotations
 - @inline()
 
 -    def redeem[E, A, E2, B](r: FreeError[Nothing, E, A])(err: (E) => FreeError[Nothing, E2, B], succ: (A) => FreeError[Nothing, E2, B]): FreeError[Nothing, E2, B]
- Definition Classes
 - Error2
 
 -    def redeemPure[E, A, B](r: FreeError[Nothing, E, A])(err: (E) => B, succ: (A) => B): FreeError[Nothing, Nothing, B]
- Definition Classes
 - Error2
 
 -    def retryUntil[E, A](r: FreeError[Nothing, E, A])(f: (E) => Boolean): FreeError[Nothing, 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: FreeError[Nothing, E, A])(f: (E) => FreeError[Nothing, Nothing, Boolean]): FreeError[Nothing, 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: FreeError[Nothing, E, A])(f: (E) => Boolean): FreeError[Nothing, 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: FreeError[Nothing, E, A])(f: (E) => FreeError[Nothing, Nothing, Boolean]): FreeError[Nothing, 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[FreeError[Nothing, E, A]]): FreeError[Nothing, E, List[A]]
- Definition Classes
 - Applicative2
 
 -    def sequenceAccumErrors[ColR[x] <: IterableOnce[x], ColL[_], E, A](col: ColR[FreeError[Nothing, ColL[E], A]])(implicit buildR: Factory[A, ColR[A]], buildL: Factory[E, ColL[E]], iterL: (ColL[E]) => IterableOnce[E]): FreeError[Nothing, ColL[E], ColR[A]]
sequencewith error accumulationsequencewith error accumulation- Definition Classes
 - ErrorAccumulatingOps2
 
 -    def sequenceAccumErrorsNEList[ColR[x] <: IterableOnce[x], E, A](col: ColR[FreeError[Nothing, E, A]])(implicit buildR: Factory[A, ColR[A]]): FreeError[Nothing, NEList[E], ColR[A]]
sequencewith error accumulationsequencewith error accumulation- Definition Classes
 - ErrorAccumulatingOps2
 
 -    def sequenceAccumErrors_[ColR[x] <: IterableOnce[x], ColL[_], E, A](col: ColR[FreeError[Nothing, ColL[E], A]])(implicit buildL: Factory[E, ColL[E]], iterL: (ColL[E]) => IterableOnce[E]): FreeError[Nothing, ColL[E], Unit]
sequence_with error accumulationsequence_with error accumulation- Definition Classes
 - ErrorAccumulatingOps2
 
 -    def sequence_[E](l: Iterable[FreeError[Nothing, E, Unit]]): FreeError[Nothing, E, Unit]
- Definition Classes
 - Applicative2
 
 -   final  def synchronized[T0](arg0: => T0): T0
- Definition Classes
 - AnyRef
 
 -    def tailRecM[E, A, B](a: A)(f: (A) => FreeError[Nothing, E, Either[A, B]]): FreeError[Nothing, E, B]
- Definition Classes
 - Monad2
 
 -    def tap[E, A](r: FreeError[Nothing, E, A], f: (A) => FreeError[Nothing, E, Unit]): FreeError[Nothing, E, A]
- Definition Classes
 - Monad2
 
 -    def tapBoth[E, A, E1 >: E](r: FreeError[Nothing, E, A])(err: (E) => FreeError[Nothing, E1, Unit], succ: (A) => FreeError[Nothing, E1, Unit]): FreeError[Nothing, E1, A]
- Definition Classes
 - Error2
 
 -    def tapError[E, A, E1 >: E](r: FreeError[Nothing, E, A])(f: (E) => FreeError[Nothing, E1, Unit]): FreeError[Nothing, E1, A]
- Definition Classes
 - Error2
 
 -    def toString(): String
- Definition Classes
 - AnyRef → Any
 
 -   final  def traverse[E, A, B](o: Option[A])(f: (A) => FreeError[Nothing, E, B]): FreeError[Nothing, E, Option[B]]
- Definition Classes
 - Applicative2
 - Annotations
 - @inline()
 
 -    def traverse[E, A, B](l: Iterable[A])(f: (A) => FreeError[Nothing, E, B]): FreeError[Nothing, E, List[B]]
- Definition Classes
 - Applicative2
 
 -    def traverseAccumErrors[ColR[x] <: IterableOnce[x], ColL[_], E, A, B](col: ColR[A])(f: (A) => FreeError[Nothing, ColL[E], B])(implicit buildR: Factory[B, ColR[B]], buildL: Factory[E, ColL[E]], iterL: (ColL[E]) => IterableOnce[E]): FreeError[Nothing, ColL[E], ColR[B]]
traversewith error accumulationtraversewith error accumulation- Definition Classes
 - ErrorAccumulatingOps2
 
 -    def traverseAccumErrorsNEList[ColR[x] <: IterableOnce[x], E, A, B](col: ColR[A])(f: (A) => FreeError[Nothing, E, B])(implicit buildR: Factory[B, ColR[B]]): FreeError[Nothing, NEList[E], ColR[B]]
traversewith error accumulationtraversewith error accumulation- Definition Classes
 - ErrorAccumulatingOps2
 
 -    def traverseAccumErrors_[ColR[x] <: IterableOnce[x], ColL[_], E, A](col: ColR[A])(f: (A) => FreeError[Nothing, ColL[E], Unit])(implicit buildL: Factory[E, ColL[E]], iterL: (ColL[E]) => IterableOnce[E]): FreeError[Nothing, ColL[E], Unit]
traverse_with error accumulationtraverse_with error accumulation- Definition Classes
 - ErrorAccumulatingOps2
 
 -    def traverse_[E, A](l: Iterable[A])(f: (A) => FreeError[Nothing, E, Unit]): FreeError[Nothing, E, Unit]
- Definition Classes
 - Applicative2
 
 -    def unit: FreeError[Nothing, Nothing, Unit]
- Definition Classes
 - Applicative2
 
 -   final  def unless[E, E1](cond: FreeError[Nothing, E, Boolean])(ifFalse: => FreeError[Nothing, E1, Unit])(implicit ev: <:<[E, E1]): FreeError[Nothing, E1, Unit]
- Definition Classes
 - Monad2
 - Annotations
 - @inline()
 
 -   final  def unless[E](cond: Boolean)(ifFalse: => FreeError[Nothing, E, Unit]): FreeError[Nothing, E, Unit]
- Definition Classes
 - Applicative2
 - Annotations
 - @inline()
 
 -   final  def void[E, A](r: FreeError[Nothing, E, A]): FreeError[Nothing, E, Unit]
- Definition Classes
 - Error2Instance → Functor2
 - Annotations
 - @inline()
 
 -   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: FreeError[Nothing, E, Boolean])(ifTrue: => FreeError[Nothing, E1, Unit])(implicit ev: <:<[E, E1]): FreeError[Nothing, E1, Unit]
- Definition Classes
 - Monad2
 - Annotations
 - @inline()
 
 -   final  def when[E](cond: Boolean)(ifTrue: => FreeError[Nothing, E, Unit]): FreeError[Nothing, E, Unit]
- Definition Classes
 - Applicative2
 - Annotations
 - @inline()
 
 -   final  def widen[E, A, A1](r: FreeError[Nothing, E, A])(implicit ev: <:<[A, A1]): FreeError[Nothing, E, A1]
- Definition Classes
 - Functor2
 - Annotations
 - @inline()
 
 -   final  def widenBoth[E, A, E1, A1](r: FreeError[Nothing, E, A])(implicit ev: <:<[E, E1], ev2: <:<[A, A1]): FreeError[Nothing, E1, A1]
- Definition Classes
 - Bifunctor2
 - Annotations
 - @inline()
 
 -   final  def widenError[E, A, E1](r: FreeError[Nothing, E, A])(implicit ev: <:<[E, E1]): FreeError[Nothing, E1, A]
- Definition Classes
 - Bifunctor2
 - Annotations
 - @inline()
 
 -   final  def withFilter[E, A](r: FreeError[Nothing, E, A])(predicate: (A) => Boolean)(implicit filter: WithFilter[E], pos: SourceFilePositionMaterializer): FreeError[Nothing, 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()
 
 -    def zip[E, A, B](firstOp: FreeError[Nothing, E, A], secondOp: => FreeError[Nothing, E, B]): FreeError[Nothing, E, (A, B)]
- Definition Classes
 - Applicative2