trait
MonadCatchIO[M[_]] extends MonadIO[M]
Type Members
-
trait
ApplicativeLaw extends Applicative.ApplyLaw
-
trait
ApplyLaw extends Apply.FunctorLaw
-
trait
BindLaw extends Bind.ApplyLaw
-
trait
FlippedApply extends Apply[F]
-
trait
FunctorLaw extends Functor.InvariantFunctorLaw
-
trait
InvariantFunctorLaw extends AnyRef
-
trait
MonadLaw extends Monad.ApplicativeLaw with Monad.BindLaw
Abstract Value Members
-
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]
-
abstract
def
liftIO[A](ioa: IO[A]): M[A]
-
abstract
def
point[A](a: ⇒ A): M[A]
Concrete Value Members
-
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
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[α], α]]
-
-
-
-
final
def
applying1[Z, A1](f: (A1) ⇒ Z)(implicit a1: M[A1]): M[Z]
-
final
def
applying2[Z, A1, A2](f: (A1, A2) ⇒ Z)(implicit a1: M[A1], a2: M[A2]): M[Z]
-
final
def
applying3[Z, A1, A2, A3](f: (A1, A2, A3) ⇒ Z)(implicit a1: M[A1], a2: M[A2], a3: M[A3]): M[Z]
-
final
def
applying4[Z, A1, A2, A3, A4](f: (A1, A2, A3, A4) ⇒ Z)(implicit a1: M[A1], a2: M[A2], a3: M[A3], a4: M[A4]): M[Z]
-
final
def
asInstanceOf[T0]: T0
-
def
bicompose[G[_, _]](implicit arg0: Bifunctor[G]): Bifunctor[[α, β]M[G[α, β]]]
-
-
-
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]]
-
def
discardLeft[A, B](fa: ⇒ M[A], fb: ⇒ M[B]): M[B]
-
def
discardRight[A, B](fa: ⇒ M[A], fb: ⇒ M[B]): M[A]
-
-
-
def
filterM[A](l: IList[A])(f: (A) ⇒ M[Boolean]): M[IList[A]]
-
def
filterM[A](l: List[A])(f: (A) ⇒ M[Boolean]): M[List[A]]
-
def
finalize(): Unit
-
-
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)]
-
-
-
final
def
getClass(): Class[_]
-
def
hashCode(): Int
-
-
def
ifM[B](value: M[Boolean], ifTrue: ⇒ M[B], ifFalse: ⇒ M[B]): M[B]
-
-
-
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]
-
-
def
liftReducer[A, B](implicit r: Reducer[A, B]): Reducer[M[A], M[B]]
-
def
map[A, B](fa: M[A])(f: (A) ⇒ B): M[B]
-
def
mapply[A, B](a: A)(f: M[(A) ⇒ B]): M[B]
-
-
-
-
def
mproduct[A, B](fa: M[A])(f: (A) ⇒ M[B]): M[(A, B)]
-
-
final
def
notify(): Unit
-
final
def
notifyAll(): Unit
-
def
product[G[_]](implicit G0: Monad[G]): Monad[[α](M[α], G[α])]
-
def
product[G[_]](implicit G0: Bind[G]): Bind[[α](M[α], G[α])]
-
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[IList[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
unfoldrOpt[S, A, B](seed: S)(f: (S) ⇒ Maybe[(M[A], S)])(implicit R: Reducer[A, B]): Maybe[M[B]]
-
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
widen[A, B](fa: M[A])(implicit ev: <~<[A, B]): M[B]
-
final
def
xderiving0[Z](z: Z): M[Z]
-
final
def
xderiving1[Z, A1](f: (A1) ⇒ Z, g: (Z) ⇒ A1)(implicit a1: M[A1]): M[Z]
-
final
def
xderiving2[Z, A1, A2](f: (A1, A2) ⇒ Z, g: (Z) ⇒ (A1, A2))(implicit a1: M[A1], a2: M[A2]): M[Z]
-
final
def
xderiving3[Z, A1, A2, A3](f: (A1, A2, A3) ⇒ Z, g: (Z) ⇒ (A1, A2, A3))(implicit a1: M[A1], a2: M[A2], a3: M[A3]): M[Z]
-
final
def
xderiving4[Z, A1, A2, A3, A4](f: (A1, A2, A3, A4) ⇒ Z, g: (Z) ⇒ (A1, A2, A3, A4))(implicit a1: M[A1], a2: M[A2], a3: M[A3], a4: M[A4]): M[Z]
-
def
xmap[A, B](fa: M[A], f: (A) ⇒ B, g: (B) ⇒ A): M[B]
-
def
xmapb[A, B](ma: M[A])(b: Bijection[A, B]): M[B]
-
def
xmapi[A, B](ma: M[A])(iso: Isomorphism.<=>[A, B]): M[B]
-
def
xproduct0[Z](z: ⇒ Z): M[Z]
-
def
xproduct1[Z, A1](a1: M[A1])(f: (A1) ⇒ Z, g: (Z) ⇒ A1): M[Z]
-
def
xproduct2[Z, A1, A2](a1: ⇒ M[A1], a2: ⇒ M[A2])(f: (A1, A2) ⇒ Z, g: (Z) ⇒ (A1, A2)): M[Z]
-
def
xproduct3[Z, A1, A2, A3](a1: ⇒ M[A1], a2: ⇒ M[A2], a3: ⇒ M[A3])(f: (A1, A2, A3) ⇒ Z, g: (Z) ⇒ (A1, A2, A3)): M[Z]
-
def
xproduct4[Z, A1, A2, A3, A4](a1: ⇒ M[A1], a2: ⇒ M[A2], a3: ⇒ M[A3], a4: ⇒ M[A4])(f: (A1, A2, A3, A4) ⇒ Z, g: (Z) ⇒ (A1, A2, A3, A4)): M[Z]