MonadCatchIO

abstract def bind[A, B](fa: M[A])(f: (A) ⇒ M[B]): M[B]

abstract def except[A](ma: M[A])(handler: (Throwable) ⇒ M[A]): M[A]

Executes the handler if an exception is raised.

abstract def liftIO[A](ioa: IO[A]): M[A]

abstract def point[A](a: ⇒ A): M[A]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def ap[A, B](fa: ⇒ M[A])(f: ⇒ M[(A) ⇒ B]): M[B]

def ap2[A, B, C](fa: ⇒ M[A], fb: ⇒ M[B])(f: M[(A, B) ⇒ C]): M[C]

def ap3[A, B, C, D](fa: ⇒ M[A], fb: ⇒ M[B], fc: ⇒ M[C])(f: M[(A, B, C) ⇒ D]): M[D]

def ap4[A, B, C, D, E](fa: ⇒ M[A], fb: ⇒ M[B], fc: ⇒ M[C], fd: ⇒ M[D])(f: M[(A, B, C, D) ⇒ E]): M[E]

def ap5[A, B, C, D, E, R](fa: ⇒ M[A], fb: ⇒ M[B], fc: ⇒ M[C], fd: ⇒ M[D], fe: ⇒ M[E])(f: M[(A, B, C, D, E) ⇒ R]): M[R]

def ap6[A, B, C, D, E, FF, R](fa: ⇒ M[A], fb: ⇒ M[B], fc: ⇒ M[C], fd: ⇒ M[D], fe: ⇒ M[E], ff: ⇒ M[FF])(f: M[(A, B, C, D, E, FF) ⇒ R]): M[R]

def ap7[A, B, C, D, E, FF, G, R](fa: ⇒ M[A], fb: ⇒ M[B], fc: ⇒ M[C], fd: ⇒ M[D], fe: ⇒ M[E], ff: ⇒ M[FF], fg: ⇒ M[G])(f: M[(A, B, C, D, E, FF, G) ⇒ R]): M[R]

def ap8[A, B, C, D, E, FF, G, H, R](fa: ⇒ M[A], fb: ⇒ M[B], fc: ⇒ M[C], fd: ⇒ M[D], fe: ⇒ M[E], ff: ⇒ M[FF], fg: ⇒ M[G], fh: ⇒ M[H])(f: M[(A, B, C, D, E, FF, G, H) ⇒ R]): M[R]

def apF[A, B](f: ⇒ M[(A) ⇒ B]): (M[A]) ⇒ M[B]

def applicativeLaw: ApplicativeLaw

val applicativeSyntax: ApplicativeSyntax[M]

def apply[A, B](fa: M[A])(f: (A) ⇒ B): M[B]

def apply10[A, B, C, D, E, FF, G, H, I, J, R](fa: ⇒ M[A], fb: ⇒ M[B], fc: ⇒ M[C], fd: ⇒ M[D], fe: ⇒ M[E], ff: ⇒ M[FF], fg: ⇒ M[G], fh: ⇒ M[H], fi: ⇒ M[I], fj: ⇒ M[J])(f: (A, B, C, D, E, FF, G, H, I, J) ⇒ R): M[R]

def apply11[A, B, C, D, E, FF, G, H, I, J, K, R](fa: ⇒ M[A], fb: ⇒ M[B], fc: ⇒ M[C], fd: ⇒ M[D], fe: ⇒ M[E], ff: ⇒ M[FF], fg: ⇒ M[G], fh: ⇒ M[H], fi: ⇒ M[I], fj: ⇒ M[J], fk: ⇒ M[K])(f: (A, B, C, D, E, FF, G, H, I, J, K) ⇒ R): M[R]

def apply12[A, B, C, D, E, FF, G, H, I, J, K, L, R](fa: ⇒ M[A], fb: ⇒ M[B], fc: ⇒ M[C], fd: ⇒ M[D], fe: ⇒ M[E], ff: ⇒ M[FF], fg: ⇒ M[G], fh: ⇒ M[H], fi: ⇒ M[I], fj: ⇒ M[J], fk: ⇒ M[K], fl: ⇒ M[L])(f: (A, B, C, D, E, FF, G, H, I, J, K, L) ⇒ R): M[R]

def apply2[A, B, C](fa: ⇒ M[A], fb: ⇒ M[B])(f: (A, B) ⇒ C): M[C]

def apply3[A, B, C, D](fa: ⇒ M[A], fb: ⇒ M[B], fc: ⇒ M[C])(f: (A, B, C) ⇒ D): M[D]

def apply4[A, B, C, D, E](fa: ⇒ M[A], fb: ⇒ M[B], fc: ⇒ M[C], fd: ⇒ M[D])(f: (A, B, C, D) ⇒ E): M[E]

def apply5[A, B, C, D, E, R](fa: ⇒ M[A], fb: ⇒ M[B], fc: ⇒ M[C], fd: ⇒ M[D], fe: ⇒ M[E])(f: (A, B, C, D, E) ⇒ R): M[R]

def apply6[A, B, C, D, E, FF, R](fa: ⇒ M[A], fb: ⇒ M[B], fc: ⇒ M[C], fd: ⇒ M[D], fe: ⇒ M[E], ff: ⇒ M[FF])(f: (A, B, C, D, E, FF) ⇒ R): M[R]

def apply7[A, B, C, D, E, FF, G, R](fa: ⇒ M[A], fb: ⇒ M[B], fc: ⇒ M[C], fd: ⇒ M[D], fe: ⇒ M[E], ff: ⇒ M[FF], fg: ⇒ M[G])(f: (A, B, C, D, E, FF, G) ⇒ R): M[R]

def apply8[A, B, C, D, E, FF, G, H, R](fa: ⇒ M[A], fb: ⇒ M[B], fc: ⇒ M[C], fd: ⇒ M[D], fe: ⇒ M[E], ff: ⇒ M[FF], fg: ⇒ M[G], fh: ⇒ M[H])(f: (A, B, C, D, E, FF, G, H) ⇒ R): M[R]

def apply9[A, B, C, D, E, FF, G, H, I, R](fa: ⇒ M[A], fb: ⇒ M[B], fc: ⇒ M[C], fd: ⇒ M[D], fe: ⇒ M[E], ff: ⇒ M[FF], fg: ⇒ M[G], fh: ⇒ M[H], fi: ⇒ M[I])(f: (A, B, C, D, E, FF, G, H, I) ⇒ R): M[R]

def applyApplicative: Applicative[[α]\/[M[α], α]]

def applyLaw: ApplyLaw

val applySyntax: ApplySyntax[M]

final def asInstanceOf[T0]: T0

def bicompose[G[_, _]](implicit arg0: Bifunctor[G]): Bifunctor[[α, β]M[G[α, β]]]

def bindLaw: BindLaw

val bindSyntax: BindSyntax[M]

def clone(): AnyRef

def compose[G[_]](implicit G0: Applicative[G]): Applicative[[α]M[G[α]]]

def compose[G[_]](implicit G0: Apply[G]): Apply[[α]M[G[α]]]

def compose[G[_]](implicit G0: Functor[G]): Functor[[α]M[G[α]]]

def counzip[A, B](a: \/[M[A], M[B]]): M[\/[A, B]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filterM[A](l: List[A])(f: (A) ⇒ M[Boolean]): M[List[A]]

def finalize(): Unit

def flip: Applicative[M]

def forever[A, B](fa: M[A]): M[B]

def fpair[A](fa: M[A]): M[(A, A)]

def fproduct[A, B](fa: M[A])(f: (A) ⇒ B): M[(A, B)]

def functorLaw: FunctorLaw

val functorSyntax: FunctorSyntax[M]

final def getClass(): Class[_]

def hashCode(): Int

def icompose[G[_]](implicit G0: Contravariant[G]): Contravariant[[α]M[G[α]]]

def ifM[B](value: M[Boolean], ifTrue: ⇒ M[B], ifFalse: ⇒ M[B]): M[B]

def invariantFunctorLaw: InvariantFunctorLaw

val invariantFunctorSyntax: InvariantFunctorSyntax[M]

final def isInstanceOf[T0]: Boolean

def iterateUntil[A](f: M[A])(p: (A) ⇒ Boolean): M[A]

def iterateWhile[A](f: M[A])(p: (A) ⇒ Boolean): M[A]

def join[A](ffa: M[M[A]]): M[A]

def lift[A, B](f: (A) ⇒ B): (M[A]) ⇒ M[B]

def lift10[A, B, C, D, E, FF, G, H, I, J, R](f: (A, B, C, D, E, FF, G, H, I, J) ⇒ R): (M[A], M[B], M[C], M[D], M[E], M[FF], M[G], M[H], M[I], M[J]) ⇒ M[R]

def lift11[A, B, C, D, E, FF, G, H, I, J, K, R](f: (A, B, C, D, E, FF, G, H, I, J, K) ⇒ R): (M[A], M[B], M[C], M[D], M[E], M[FF], M[G], M[H], M[I], M[J], M[K]) ⇒ M[R]

def lift12[A, B, C, D, E, FF, G, H, I, J, K, L, R](f: (A, B, C, D, E, FF, G, H, I, J, K, L) ⇒ R): (M[A], M[B], M[C], M[D], M[E], M[FF], M[G], M[H], M[I], M[J], M[K], M[L]) ⇒ M[R]

def lift2[A, B, C](f: (A, B) ⇒ C): (M[A], M[B]) ⇒ M[C]

def lift3[A, B, C, D](f: (A, B, C) ⇒ D): (M[A], M[B], M[C]) ⇒ M[D]

def lift4[A, B, C, D, E](f: (A, B, C, D) ⇒ E): (M[A], M[B], M[C], M[D]) ⇒ M[E]

def lift5[A, B, C, D, E, R](f: (A, B, C, D, E) ⇒ R): (M[A], M[B], M[C], M[D], M[E]) ⇒ M[R]

def lift6[A, B, C, D, E, FF, R](f: (A, B, C, D, E, FF) ⇒ R): (M[A], M[B], M[C], M[D], M[E], M[FF]) ⇒ M[R]

def lift7[A, B, C, D, E, FF, G, R](f: (A, B, C, D, E, FF, G) ⇒ R): (M[A], M[B], M[C], M[D], M[E], M[FF], M[G]) ⇒ M[R]

def lift8[A, B, C, D, E, FF, G, H, R](f: (A, B, C, D, E, FF, G, H) ⇒ R): (M[A], M[B], M[C], M[D], M[E], M[FF], M[G], M[H]) ⇒ M[R]

def lift9[A, B, C, D, E, FF, G, H, I, R](f: (A, B, C, D, E, FF, G, H, I) ⇒ R): (M[A], M[B], M[C], M[D], M[E], M[FF], M[G], M[H], M[I]) ⇒ M[R]

val liftIOSyntax: LiftIOSyntax[M]

def map[A, B](fa: M[A])(f: (A) ⇒ B): M[B]

def mapply[A, B](a: A)(f: M[(A) ⇒ B]): M[B]

val monadIOSyntax: MonadIOSyntax[M]

def monadLaw: MonadLaw

val monadSyntax: MonadSyntax[M]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def product[G[_]](implicit G0: Applicative[G]): Applicative[[α](M[α], G[α])]

def product[G[_]](implicit G0: Apply[G]): Apply[[α](M[α], G[α])]

def product[G[_]](implicit G0: Functor[G]): Functor[[α](M[α], G[α])]

final def pure[A](a: ⇒ A): M[A]

def replicateM[A](n: Int, fa: M[A]): M[List[A]]

def replicateM_[A](n: Int, fa: M[A]): M[Unit]

def sequence[A, G[_]](as: G[M[A]])(implicit arg0: Traverse[G]): M[G[A]]

def sequence1[A, G[_]](as: G[M[A]])(implicit arg0: Traverse1[G]): M[G[A]]

def strengthL[A, B](a: A, f: M[B]): M[(A, B)]

def strengthR[A, B](f: M[A], b: B): M[(A, B)]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def traverse[A, G[_], B](value: G[A])(f: (A) ⇒ M[B])(implicit G: Traverse[G]): M[G[B]]

def traverse1[A, G[_], B](value: G[A])(f: (A) ⇒ M[B])(implicit G: Traverse1[G]): M[G[B]]

def tuple2[A, B](fa: ⇒ M[A], fb: ⇒ M[B]): M[(A, B)]

def tuple3[A, B, C](fa: ⇒ M[A], fb: ⇒ M[B], fc: ⇒ M[C]): M[(A, B, C)]

def tuple4[A, B, C, D](fa: ⇒ M[A], fb: ⇒ M[B], fc: ⇒ M[C], fd: ⇒ M[D]): M[(A, B, C, D)]

def tuple5[A, B, C, D, E](fa: ⇒ M[A], fb: ⇒ M[B], fc: ⇒ M[C], fd: ⇒ M[D], fe: ⇒ M[E]): M[(A, B, C, D, E)]

def unlessM[A](cond: Boolean)(f: ⇒ M[A]): M[Unit]

def untilM[G[_], A](f: M[A], cond: ⇒ M[Boolean])(implicit G: MonadPlus[G]): M[G[A]]

def untilM_[A](f: M[A], cond: ⇒ M[Boolean]): M[Unit]

def void[A](fa: M[A]): M[Unit]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def whenM[A](cond: Boolean)(f: ⇒ M[A]): M[Unit]

def whileM[G[_], A](p: M[Boolean], body: ⇒ M[A])(implicit G: MonadPlus[G]): M[G[A]]

def whileM_[A](p: M[Boolean], body: ⇒ M[A]): M[Unit]

def xmap[A, B](fa: M[A], f: (A) ⇒ B, g: (B) ⇒ A): M[B]

def xmapb[A, B](ma: M[A])(b: BijectionT.Bijection[A, B]): M[B]

def xmapi[A, B](ma: M[A])(iso: Isomorphism.<=>[A, B]): M[B]

def zip: Zip[M]