implicit
object
AttemptMonad extends IsomorphismMonad[Attempt, InvalidOr]
Type Members
-
trait
ApplicativeLaw extends scalaz.Applicative.ApplyLaw
-
trait
ApplyLaw extends scalaz.Apply.FunctorLaw
-
trait
BindLaw extends scalaz.Bind.ApplyLaw
-
trait
FunctorLaw extends scalaz.Functor.InvariantFunctorLaw
-
trait
InvariantFunctorLaw extends AnyRef
-
trait
MonadLaw extends scalaz.Monad.ApplicativeLaw with scalaz.Monad.BindLaw
Value Members
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
-
final
def
==(arg0: Any): Boolean
-
-
def
ap[A, B](fa: ⇒ Attempt[A])(f: ⇒ Attempt[(A) ⇒ B]): Attempt[B]
-
def
ap2[A, B, C](fa: ⇒ Attempt[A], fb: ⇒ Attempt[B])(f: Attempt[(A, B) ⇒ C]): Attempt[C]
-
def
ap3[A, B, C, D](fa: ⇒ Attempt[A], fb: ⇒ Attempt[B], fc: ⇒ Attempt[C])(f: Attempt[(A, B, C) ⇒ D]): Attempt[D]
-
def
ap4[A, B, C, D, E](fa: ⇒ Attempt[A], fb: ⇒ Attempt[B], fc: ⇒ Attempt[C], fd: ⇒ Attempt[D])(f: Attempt[(A, B, C, D) ⇒ E]): Attempt[E]
-
def
ap5[A, B, C, D, E, R](fa: ⇒ Attempt[A], fb: ⇒ Attempt[B], fc: ⇒ Attempt[C], fd: ⇒ Attempt[D], fe: ⇒ Attempt[E])(f: Attempt[(A, B, C, D, E) ⇒ R]): Attempt[R]
-
def
ap6[A, B, C, D, E, FF, R](fa: ⇒ Attempt[A], fb: ⇒ Attempt[B], fc: ⇒ Attempt[C], fd: ⇒ Attempt[D], fe: ⇒ Attempt[E], ff: ⇒ Attempt[FF])(f: Attempt[(A, B, C, D, E, FF) ⇒ R]): Attempt[R]
-
def
ap7[A, B, C, D, E, FF, G, R](fa: ⇒ Attempt[A], fb: ⇒ Attempt[B], fc: ⇒ Attempt[C], fd: ⇒ Attempt[D], fe: ⇒ Attempt[E], ff: ⇒ Attempt[FF], fg: ⇒ Attempt[G])(f: Attempt[(A, B, C, D, E, FF, G) ⇒ R]): Attempt[R]
-
def
ap8[A, B, C, D, E, FF, G, H, R](fa: ⇒ Attempt[A], fb: ⇒ Attempt[B], fc: ⇒ Attempt[C], fd: ⇒ Attempt[D], fe: ⇒ Attempt[E], ff: ⇒ Attempt[FF], fg: ⇒ Attempt[G], fh: ⇒ Attempt[H])(f: Attempt[(A, B, C, D, E, FF, G, H) ⇒ R]): Attempt[R]
-
-
-
val
applicativeSyntax: ApplicativeSyntax[Attempt]
-
def
apply[A, B](fa: Attempt[A])(f: (A) ⇒ B): Attempt[B]
-
def
apply10[A, B, C, D, E, FF, G, H, I, J, R](fa: ⇒ Attempt[A], fb: ⇒ Attempt[B], fc: ⇒ Attempt[C], fd: ⇒ Attempt[D], fe: ⇒ Attempt[E], ff: ⇒ Attempt[FF], fg: ⇒ Attempt[G], fh: ⇒ Attempt[H], fi: ⇒ Attempt[I], fj: ⇒ Attempt[J])(f: (A, B, C, D, E, FF, G, H, I, J) ⇒ R): Attempt[R]
-
def
apply11[A, B, C, D, E, FF, G, H, I, J, K, R](fa: ⇒ Attempt[A], fb: ⇒ Attempt[B], fc: ⇒ Attempt[C], fd: ⇒ Attempt[D], fe: ⇒ Attempt[E], ff: ⇒ Attempt[FF], fg: ⇒ Attempt[G], fh: ⇒ Attempt[H], fi: ⇒ Attempt[I], fj: ⇒ Attempt[J], fk: ⇒ Attempt[K])(f: (A, B, C, D, E, FF, G, H, I, J, K) ⇒ R): Attempt[R]
-
def
apply12[A, B, C, D, E, FF, G, H, I, J, K, L, R](fa: ⇒ Attempt[A], fb: ⇒ Attempt[B], fc: ⇒ Attempt[C], fd: ⇒ Attempt[D], fe: ⇒ Attempt[E], ff: ⇒ Attempt[FF], fg: ⇒ Attempt[G], fh: ⇒ Attempt[H], fi: ⇒ Attempt[I], fj: ⇒ Attempt[J], fk: ⇒ Attempt[K], fl: ⇒ Attempt[L])(f: (A, B, C, D, E, FF, G, H, I, J, K, L) ⇒ R): Attempt[R]
-
def
apply2[A, B, C](fa: ⇒ Attempt[A], fb: ⇒ Attempt[B])(f: (A, B) ⇒ C): Attempt[C]
-
def
apply3[A, B, C, D](fa: ⇒ Attempt[A], fb: ⇒ Attempt[B], fc: ⇒ Attempt[C])(f: (A, B, C) ⇒ D): Attempt[D]
-
def
apply4[A, B, C, D, E](fa: ⇒ Attempt[A], fb: ⇒ Attempt[B], fc: ⇒ Attempt[C], fd: ⇒ Attempt[D])(f: (A, B, C, D) ⇒ E): Attempt[E]
-
def
apply5[A, B, C, D, E, R](fa: ⇒ Attempt[A], fb: ⇒ Attempt[B], fc: ⇒ Attempt[C], fd: ⇒ Attempt[D], fe: ⇒ Attempt[E])(f: (A, B, C, D, E) ⇒ R): Attempt[R]
-
def
apply6[A, B, C, D, E, FF, R](fa: ⇒ Attempt[A], fb: ⇒ Attempt[B], fc: ⇒ Attempt[C], fd: ⇒ Attempt[D], fe: ⇒ Attempt[E], ff: ⇒ Attempt[FF])(f: (A, B, C, D, E, FF) ⇒ R): Attempt[R]
-
def
apply7[A, B, C, D, E, FF, G, R](fa: ⇒ Attempt[A], fb: ⇒ Attempt[B], fc: ⇒ Attempt[C], fd: ⇒ Attempt[D], fe: ⇒ Attempt[E], ff: ⇒ Attempt[FF], fg: ⇒ Attempt[G])(f: (A, B, C, D, E, FF, G) ⇒ R): Attempt[R]
-
def
apply8[A, B, C, D, E, FF, G, H, R](fa: ⇒ Attempt[A], fb: ⇒ Attempt[B], fc: ⇒ Attempt[C], fd: ⇒ Attempt[D], fe: ⇒ Attempt[E], ff: ⇒ Attempt[FF], fg: ⇒ Attempt[G], fh: ⇒ Attempt[H])(f: (A, B, C, D, E, FF, G, H) ⇒ R): Attempt[R]
-
def
apply9[A, B, C, D, E, FF, G, H, I, R](fa: ⇒ Attempt[A], fb: ⇒ Attempt[B], fc: ⇒ Attempt[C], fd: ⇒ Attempt[D], fe: ⇒ Attempt[E], ff: ⇒ Attempt[FF], fg: ⇒ Attempt[G], fh: ⇒ Attempt[H], fi: ⇒ Attempt[I])(f: (A, B, C, D, E, FF, G, H, I) ⇒ R): Attempt[R]
-
def
applyApplicative: Applicative[[α]\/[Attempt[α], α]]
-
-
val
applySyntax: ApplySyntax[Attempt]
-
final
def
asInstanceOf[T0]: T0
-
def
bicompose[G[_, _]](implicit arg0: Bifunctor[G]): Bifunctor[[α, β]Attempt[G[α, β]]]
-
-
-
val
bindSyntax: BindSyntax[Attempt]
-
def
clone(): AnyRef
-
def
compose[G[_]](implicit G0: Applicative[G]): Applicative[[α]Attempt[G[α]]]
-
def
compose[G[_]](implicit G0: Apply[G]): Apply[[α]Attempt[G[α]]]
-
def
compose[G[_]](implicit G0: Functor[G]): Functor[[α]Attempt[G[α]]]
-
def
counzip[A, B](a: \/[Attempt[A], Attempt[B]]): Attempt[\/[A, B]]
-
final
def
eq(arg0: AnyRef): Boolean
-
def
equals(arg0: Any): Boolean
-
def
filterM[A](l: List[A])(f: (A) ⇒ Attempt[Boolean]): Attempt[List[A]]
-
def
finalize(): Unit
-
def
flip: Applicative[Attempt]
-
def
forever[A, B](fa: Attempt[A]): Attempt[B]
-
def
fpair[A](fa: Attempt[A]): Attempt[(A, A)]
-
def
fproduct[A, B](fa: Attempt[A])(f: (A) ⇒ B): Attempt[(A, B)]
-
-
val
functorSyntax: FunctorSyntax[Attempt]
-
final
def
getClass(): Class[_]
-
def
hashCode(): Int
-
def
icompose[G[_]](implicit G0: Contravariant[G]): Contravariant[[α]Attempt[G[α]]]
-
def
ifM[B](value: Attempt[Boolean], ifTrue: ⇒ Attempt[B], ifFalse: ⇒ Attempt[B]): Attempt[B]
-
-
val
invariantFunctorSyntax: InvariantFunctorSyntax[Attempt]
-
final
def
isInstanceOf[T0]: Boolean
-
-
def
iterateUntil[A](f: Attempt[A])(p: (A) ⇒ Boolean): Attempt[A]
-
def
iterateWhile[A](f: Attempt[A])(p: (A) ⇒ Boolean): Attempt[A]
-
-
def
lift[A, B](f: (A) ⇒ B): (Attempt[A]) ⇒ Attempt[B]
-
-
-
-
def
lift2[A, B, C](f: (A, B) ⇒ C): (Attempt[A], Attempt[B]) ⇒ Attempt[C]
-
def
lift3[A, B, C, D](f: (A, B, C) ⇒ D): (Attempt[A], Attempt[B], Attempt[C]) ⇒ Attempt[D]
-
def
lift4[A, B, C, D, E](f: (A, B, C, D) ⇒ E): (Attempt[A], Attempt[B], Attempt[C], Attempt[D]) ⇒ Attempt[E]
-
-
-
-
-
-
def
map[A, B](fa: Attempt[A])(f: (A) ⇒ B): Attempt[B]
-
def
mapply[A, B](a: A)(f: Attempt[(A) ⇒ B]): Attempt[B]
-
-
val
monadSyntax: MonadSyntax[Attempt]
-
final
def
ne(arg0: AnyRef): Boolean
-
final
def
notify(): Unit
-
final
def
notifyAll(): Unit
-
def
point[A](a: ⇒ A): Attempt[A]
-
def
product[G[_]](implicit G0: Applicative[G]): Applicative[[α](Attempt[α], G[α])]
-
def
product[G[_]](implicit G0: Apply[G]): Apply[[α](Attempt[α], G[α])]
-
def
product[G[_]](implicit G0: Functor[G]): Functor[[α](Attempt[α], G[α])]
-
final
def
pure[A](a: ⇒ A): Attempt[A]
-
def
replicateM[A](n: Int, fa: Attempt[A]): Attempt[List[A]]
-
def
replicateM_[A](n: Int, fa: Attempt[A]): Attempt[Unit]
-
def
sequence[A, G[_]](as: G[Attempt[A]])(implicit arg0: Traverse[G]): Attempt[G[A]]
-
def
sequence1[A, G[_]](as: G[Attempt[A]])(implicit arg0: Traverse1[G]): Attempt[G[A]]
-
def
strengthL[A, B](a: A, f: Attempt[B]): Attempt[(A, B)]
-
def
strengthR[A, B](f: Attempt[A], b: B): Attempt[(A, B)]
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
-
def
toString(): String
-
def
traverse[A, G[_], B](value: G[A])(f: (A) ⇒ Attempt[B])(implicit G: Traverse[G]): Attempt[G[B]]
-
def
traverse1[A, G[_], B](value: G[A])(f: (A) ⇒ Attempt[B])(implicit G: Traverse1[G]): Attempt[G[B]]
-
def
tuple2[A, B](fa: ⇒ Attempt[A], fb: ⇒ Attempt[B]): Attempt[(A, B)]
-
def
tuple3[A, B, C](fa: ⇒ Attempt[A], fb: ⇒ Attempt[B], fc: ⇒ Attempt[C]): Attempt[(A, B, C)]
-
def
tuple4[A, B, C, D](fa: ⇒ Attempt[A], fb: ⇒ Attempt[B], fc: ⇒ Attempt[C], fd: ⇒ Attempt[D]): Attempt[(A, B, C, D)]
-
def
tuple5[A, B, C, D, E](fa: ⇒ Attempt[A], fb: ⇒ Attempt[B], fc: ⇒ Attempt[C], fd: ⇒ Attempt[D], fe: ⇒ Attempt[E]): Attempt[(A, B, C, D, E)]
-
def
unlessM[A](cond: Boolean)(f: ⇒ Attempt[A]): Attempt[Unit]
-
def
untilM[G[_], A](f: Attempt[A], cond: ⇒ Attempt[Boolean])(implicit G: MonadPlus[G]): Attempt[G[A]]
-
def
untilM_[A](f: Attempt[A], cond: ⇒ Attempt[Boolean]): Attempt[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: ⇒ Attempt[A]): Attempt[Unit]
-
def
whileM[G[_], A](p: Attempt[Boolean], body: ⇒ Attempt[A])(implicit G: MonadPlus[G]): Attempt[G[A]]
-
def
whileM_[A](p: Attempt[Boolean], body: ⇒ Attempt[A]): Attempt[Unit]
-
def
xmap[A, B](fa: Attempt[A], f: (A) ⇒ B, g: (B) ⇒ A): Attempt[B]
-
def
xmapb[A, B](ma: Attempt[A])(b: scalaz.BijectionT.Bijection[A, B]): Attempt[B]
-
def
xmapi[A, B](ma: Attempt[A])(iso: scalaz.Isomorphism.<=>[A, B]): Attempt[B]
Deprecated Value Members
-
Inherited from Applicative[Attempt]
Inherited from InvariantFunctor[Attempt]
Inherited from AnyRef
Inherited from Any