class Monad2Instance[S[_, _]] extends Monad2[[+β$4$, +γ$5$]Free[S, β$4$, γ$5$]]
- Alphabetic
- By Inheritance
- Monad2Instance
- Monad2
- Applicative2
- Functor2
- RootBifunctor
- Root
- PredefinedHelper
- DivergenceHelper
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Instance Constructors
-  new Monad2Instance()
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
 
-    def *>[E, A, B](f: Free[S, E, A], next: => Free[S, E, B]): Free[S, E, B]execute two operations in order, return result of second operation execute two operations in order, return result of second operation - Definition Classes
- Monad2Instance → Monad2 → Applicative2
- Annotations
- @inline()
 
-    def <*[E, A, B](f: Free[S, E, A], next: => Free[S, E, B]): Free[S, 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
- Monad2Instance → Monad2 → Applicative2
- Annotations
- @inline()
 
-   final  def ==(arg0: Any): Boolean- Definition Classes
- AnyRef → Any
 
-    def as[E, A, B](r: Free[S, E, A])(v: => B): Free[S, E, B]- Definition Classes
- Monad2Instance → Functor2
- Annotations
- @inline()
 
-   final  def asInstanceOf[T0]: T0- Definition Classes
- Any
 
-    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) => Free[S, E, Option[B]]): Free[S, E, List[B]]- Definition Classes
- Applicative2
 
-    def collectFirst[E, A, B](l: Iterable[A])(f: (A) => Free[S, E, Option[B]]): Free[S, 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) => Free[S, E, Boolean]): Free[S, 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) => Free[S, E, Boolean]): Free[S, E, Option[A]]- Definition Classes
- Monad2
 
-    def flatMap[E, A, B](r: Free[S, E, A])(f: (A) => Free[S, E, B]): Free[S, E, B]- Definition Classes
- Monad2Instance → Monad2
- Annotations
- @inline()
 
-    def flatSequence[E, A](l: Iterable[Free[S, E, Iterable[A]]]): Free[S, E, List[A]]- Definition Classes
- Applicative2
 
-    def flatTraverse[E, A, B](l: Iterable[A])(f: (A) => Free[S, E, Iterable[B]]): Free[S, E, List[B]]- Definition Classes
- Applicative2
 
-    def flatten[E, A](r: Free[S, E, Free[S, E, A]]): Free[S, E, A]- Definition Classes
- Monad2
 
-    def foldLeft[E, A, AC](l: Iterable[A])(z: AC)(f: (AC, A) => Free[S, E, AC]): Free[S, E, AC]- Definition Classes
- Monad2
 
-   final  def forever[E, A](r: Free[S, E, A]): Free[S, E, Nothing]- Definition Classes
- Applicative2
- Annotations
- @inline()
 
-    def fromOptionF[E, A](fallbackOnNone: => Free[S, E, A], r: Free[S, E, Option[A]]): Free[S, 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: Free[S, E, Option[A]]): Free[S, E, A]Extracts the optional value, or returns the given valueOnNonevalueExtracts the optional value, or returns the given valueOnNonevalue- Definition Classes
- Functor2
 
-   final  def getClass(): Class[_ <: AnyRef]- Definition Classes
- AnyRef → Any
- Annotations
- @native()
 
-    def hashCode(): Int- Definition Classes
- AnyRef → Any
- Annotations
- @native()
 
-   final  def ifThenElse[E, E1, A](cond: Free[S, E, Boolean])(ifTrue: => Free[S, E1, A], ifFalse: => Free[S, E1, A])(implicit ev: <:<[E, E1]): Free[S, E1, A]- Definition Classes
- Monad2
- Annotations
- @inline()
 
-   final  def ifThenElse[E, A](cond: Boolean)(ifTrue: => Free[S, E, A], ifFalse: => Free[S, E, A]): Free[S, E, A]- Definition Classes
- Applicative2
- Annotations
- @inline()
 
-   final  def isInstanceOf[T0]: Boolean- Definition Classes
- Any
 
-    def iterateUntil[E, A](r: Free[S, E, A])(p: (A) => Boolean): Free[S, 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) => Free[S, E, A])(p: (A) => Boolean): Free[S, 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: Free[S, E, A])(p: (A) => Boolean): Free[S, 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) => Free[S, E, A])(p: (A) => Boolean): Free[S, 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 map[E, A, B](r: Free[S, E, A])(f: (A) => B): Free[S, E, B]
-    def map2[E, A, B, C](r1: Free[S, E, A], r2: => Free[S, E, B])(f: (A, B) => C): Free[S, 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 pure[A](a: A): Free[S, Nothing, A]- Definition Classes
- Monad2Instance → Applicative2
- Annotations
- @inline()
 
-    def sequence[E, A](l: Iterable[Free[S, E, A]]): Free[S, E, List[A]]- Definition Classes
- Applicative2
 
-    def sequence_[E](l: Iterable[Free[S, E, Unit]]): Free[S, E, Unit]- Definition Classes
- Applicative2
 
-   final  def synchronized[T0](arg0: => T0): T0- Definition Classes
- AnyRef
 
-    def tailRecM[E, A, B](a: A)(f: (A) => Free[S, E, Either[A, B]]): Free[S, E, B]- Definition Classes
- Monad2
 
-    def tap[E, A](r: Free[S, E, A], f: (A) => Free[S, E, Unit]): Free[S, E, A]- Definition Classes
- Monad2
 
-    def toString(): String- Definition Classes
- AnyRef → Any
 
-   final  def traverse[E, A, B](o: Option[A])(f: (A) => Free[S, E, B]): Free[S, E, Option[B]]- Definition Classes
- Applicative2
- Annotations
- @inline()
 
-    def traverse[E, A, B](l: Iterable[A])(f: (A) => Free[S, E, B]): Free[S, E, List[B]]- Definition Classes
- Applicative2
 
-    def traverse_[E, A](l: Iterable[A])(f: (A) => Free[S, E, Unit]): Free[S, E, Unit]- Definition Classes
- Applicative2
 
-    def unit: Free[S, Nothing, Unit]- Definition Classes
- Applicative2
 
-   final  def unless[E, E1](cond: Free[S, E, Boolean])(ifFalse: => Free[S, E1, Unit])(implicit ev: <:<[E, E1]): Free[S, E1, Unit]- Definition Classes
- Monad2
- Annotations
- @inline()
 
-   final  def unless[E](cond: Boolean)(ifFalse: => Free[S, E, Unit]): Free[S, E, Unit]- Definition Classes
- Applicative2
- Annotations
- @inline()
 
-    def void[E, A](r: Free[S, E, A]): Free[S, E, Unit]- Definition Classes
- Monad2Instance → 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: Free[S, E, Boolean])(ifTrue: => Free[S, E1, Unit])(implicit ev: <:<[E, E1]): Free[S, E1, Unit]- Definition Classes
- Monad2
- Annotations
- @inline()
 
-   final  def when[E](cond: Boolean)(ifTrue: => Free[S, E, Unit]): Free[S, E, Unit]- Definition Classes
- Applicative2
- Annotations
- @inline()
 
-   final  def widen[E, A, A1](r: Free[S, E, A])(implicit ev: <:<[A, A1]): Free[S, E, A1]- Definition Classes
- Functor2
- Annotations
- @inline()
 
-    def zip[E, A, B](firstOp: Free[S, E, A], secondOp: => Free[S, E, B]): Free[S, E, (A, B)]- Definition Classes
- Applicative2