Object

com.eharmony.aloha.algebra.tries

TryScalazMonad

Related Doc: package tries

Permalink

implicit object TryScalazMonad extends Monad[Try]

A scalaz monad type class instance for scala.lang.Try.

Linear Supertypes
Monad[Try], Bind[Try], Applicative[Try], Apply[Try], Functor[Try], AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. TryScalazMonad
  2. Monad
  3. Bind
  4. Applicative
  5. Apply
  6. Functor
  7. AnyRef
  8. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. trait ApplicativeLaw extends scalaz.Applicative.FunctorLaw

    Permalink
    Definition Classes
    Applicative

  2. trait FunctorLaw extends AnyRef

    Permalink
    Definition Classes
    Functor

  3. trait MonadLaw extends scalaz.Monad.ApplicativeLaw

    Permalink
    Definition Classes
    Monad

Value Members

  1. final def !=(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any

  2. final def ##(): Int

    Permalink
    Definition Classes
    AnyRef → Any

  3. final def ==(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any

  4. def ap[A, B](fa: ⇒ Try[A])(f: ⇒ Try[(A) ⇒ B]): Try[B]

    Permalink
    Definition Classes
    Bind → Apply

  5. def ap2[A, B, C](fa: ⇒ Try[A], fb: ⇒ Try[B])(f: Try[(A, B) ⇒ C]): Try[C]

    Permalink
    Definition Classes
    Apply

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

    Permalink
    Definition Classes
    Apply

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

    Permalink
    Definition Classes
    Apply

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

    Permalink
    Definition Classes
    Apply

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

    Permalink
    Definition Classes
    Apply

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

    Permalink
    Definition Classes
    Apply

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

    Permalink
    Definition Classes
    Apply

  12. def apF[A, B](f: ⇒ Try[(A) ⇒ B]): (Try[A]) ⇒ Try[B]

    Permalink
    Definition Classes
    Apply

  13. def applicativeLaw: ApplicativeLaw

    Permalink
    Definition Classes
    Applicative

  14. val applicativeSyntax: ApplicativeSyntax[Try]

    Permalink
    Definition Classes
    Applicative

  15. def apply[A, B](fa: Try[A])(f: (A) ⇒ B): Try[B]

    Permalink
    Definition Classes
    Functor

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

    Permalink
    Definition Classes
    Apply

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

    Permalink
    Definition Classes
    Apply

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

    Permalink
    Definition Classes
    Apply

  19. def apply2[A, B, C](fa: ⇒ Try[A], fb: ⇒ Try[B])(f: (A, B) ⇒ C): Try[C]

    Permalink
    Definition Classes
    Applicative → Apply

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

    Permalink
    Definition Classes
    Apply

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

    Permalink
    Definition Classes
    Apply

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

    Permalink
    Definition Classes
    Apply

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

    Permalink
    Definition Classes
    Apply

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

    Permalink
    Definition Classes
    Apply

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

    Permalink
    Definition Classes
    Apply

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

    Permalink
    Definition Classes
    Apply

  27. val applySyntax: ApplySyntax[Try]

    Permalink
    Definition Classes
    Apply

  28. final def asInstanceOf[T0]: T0

    Permalink
    Definition Classes
    Any

  29. def bind[A, B](fa: Try[A])(f: (A) ⇒ Try[B]): Try[B]

    Permalink
    Definition Classes
    TryScalazMonad → Bind

  30. val bindSyntax: BindSyntax[Try]

    Permalink
    Definition Classes
    Bind

  31. def clone(): AnyRef

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  32. def compose[G[_]](implicit G0: Applicative[G]): Applicative[[α]Try[G[α]]]

    Permalink
    Definition Classes
    Applicative

  33. def compose[G[_]](implicit G0: Apply[G]): Apply[[α]Try[G[α]]]

    Permalink
    Definition Classes
    Apply

  34. def compose[G[_]](implicit G0: Functor[G]): Functor[[α]Try[G[α]]]

    Permalink
    Definition Classes
    Functor

  35. def counzip[A, B](a: \/[Try[A], Try[B]]): Try[\/[A, B]]

    Permalink
    Definition Classes
    Functor

  36. final def eq(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef

  37. def equals(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any

  38. def filterM[A](l: List[A])(f: (A) ⇒ Try[Boolean]): Try[List[A]]

    Permalink
    Definition Classes
    Applicative

  39. def finalize(): Unit

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )

  40. def flip: Applicative[Try]

    Permalink
    Definition Classes
    Applicative

  41. def fpair[A](fa: Try[A]): Try[(A, A)]

    Permalink
    Definition Classes
    Functor

  42. def fproduct[A, B](fa: Try[A])(f: (A) ⇒ B): Try[(A, B)]

    Permalink
    Definition Classes
    Functor

  43. def functorLaw: FunctorLaw

    Permalink
    Definition Classes
    Functor

  44. val functorSyntax: FunctorSyntax[Try]

    Permalink
    Definition Classes
    Functor

  45. final def getClass(): Class[_]

    Permalink
    Definition Classes
    AnyRef → Any

  46. def hashCode(): Int

    Permalink
    Definition Classes
    AnyRef → Any

  47. def ifM[B](value: Try[Boolean], ifTrue: ⇒ Try[B], ifFalse: ⇒ Try[B]): Try[B]

    Permalink
    Definition Classes
    Bind

  48. final def isInstanceOf[T0]: Boolean

    Permalink
    Definition Classes
    Any

  49. def join[A](ffa: Try[Try[A]]): Try[A]

    Permalink
    Definition Classes
    Bind

  50. def lift[A, B](f: (A) ⇒ B): (Try[A]) ⇒ Try[B]

    Permalink
    Definition Classes
    Functor

  51. 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): (Try[A], Try[B], Try[C], Try[D], Try[E], Try[FF], Try[G], Try[H], Try[I], Try[J]) ⇒ Try[R]

    Permalink
    Definition Classes
    Apply

  52. 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): (Try[A], Try[B], Try[C], Try[D], Try[E], Try[FF], Try[G], Try[H], Try[I], Try[J], Try[K]) ⇒ Try[R]

    Permalink
    Definition Classes
    Apply

  53. 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): (Try[A], Try[B], Try[C], Try[D], Try[E], Try[FF], Try[G], Try[H], Try[I], Try[J], Try[K], Try[L]) ⇒ Try[R]

    Permalink
    Definition Classes
    Apply

  54. def lift2[A, B, C](f: (A, B) ⇒ C): (Try[A], Try[B]) ⇒ Try[C]

    Permalink
    Definition Classes
    Apply

  55. def lift3[A, B, C, D](f: (A, B, C) ⇒ D): (Try[A], Try[B], Try[C]) ⇒ Try[D]

    Permalink
    Definition Classes
    Apply

  56. def lift4[A, B, C, D, E](f: (A, B, C, D) ⇒ E): (Try[A], Try[B], Try[C], Try[D]) ⇒ Try[E]

    Permalink
    Definition Classes
    Apply

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

    Permalink
    Definition Classes
    Apply

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

    Permalink
    Definition Classes
    Apply

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

    Permalink
    Definition Classes
    Apply

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

    Permalink
    Definition Classes
    Apply

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

    Permalink
    Definition Classes
    Apply

  62. def map[A, B](fa: Try[A])(f: (A) ⇒ B): Try[B]

    Permalink
    Definition Classes
    Monad → Applicative → Functor

  63. def mapply[A, B](a: A)(f: Try[(A) ⇒ B]): Try[B]

    Permalink
    Definition Classes
    Functor

  64. def monadLaw: MonadLaw

    Permalink
    Definition Classes
    Monad

  65. val monadSyntax: MonadSyntax[Try]

    Permalink
    Definition Classes
    Monad

  66. final def ne(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef

  67. final def notify(): Unit

    Permalink
    Definition Classes
    AnyRef

  68. final def notifyAll(): Unit

    Permalink
    Definition Classes
    AnyRef

  69. def point[A](a: ⇒ A): Try[A]

    Permalink
    Definition Classes
    TryScalazMonad → Applicative

  70. def product[G[_]](implicit G0: Applicative[G]): Applicative[[α](Try[α], G[α])]

    Permalink
    Definition Classes
    Applicative

  71. def product[G[_]](implicit G0: Apply[G]): Apply[[α](Try[α], G[α])]

    Permalink
    Definition Classes
    Apply

  72. def product[G[_]](implicit G0: Functor[G]): Functor[[α](Try[α], G[α])]

    Permalink
    Definition Classes
    Functor

  73. def pure[A](a: ⇒ A): Try[A]

    Permalink
    Definition Classes
    Applicative

  74. def replicateM[A](n: Int, fa: Try[A]): Try[List[A]]

    Permalink
    Definition Classes
    Applicative

  75. def replicateM_[A](n: Int, fa: Try[A]): Try[Unit]

    Permalink
    Definition Classes
    Applicative

  76. def sequence[A, G[_]](as: G[Try[A]])(implicit arg0: Traverse[G]): Try[G[A]]

    Permalink
    Definition Classes
    Applicative

  77. def sequence1[A, G[_]](as: G[Try[A]])(implicit arg0: Traverse1[G]): Try[G[A]]

    Permalink
    Definition Classes
    Apply

  78. def strengthL[A, B](a: A, f: Try[B]): Try[(A, B)]

    Permalink
    Definition Classes
    Functor

  79. def strengthR[A, B](f: Try[A], b: B): Try[(A, B)]

    Permalink
    Definition Classes
    Functor

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

    Permalink
    Definition Classes
    AnyRef

  81. def toString(): String

    Permalink
    Definition Classes
    AnyRef → Any

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

    Permalink
    Definition Classes
    Applicative

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

    Permalink
    Definition Classes
    Apply

  84. def tuple2[A, B](fa: ⇒ Try[A], fb: ⇒ Try[B]): Try[(A, B)]

    Permalink
    Definition Classes
    Apply

  85. def tuple3[A, B, C](fa: ⇒ Try[A], fb: ⇒ Try[B], fc: Try[C]): Try[(A, B, C)]

    Permalink
    Definition Classes
    Apply

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

    Permalink
    Definition Classes
    Apply

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

    Permalink
    Definition Classes
    Apply

  88. def void[A](fa: Try[A]): Try[Unit]

    Permalink
    Definition Classes
    Functor

  89. final def wait(): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

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

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  91. final def wait(arg0: Long): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

Deprecated Value Members

  1. def map2[A, B, C](fa: ⇒ Try[A], fb: ⇒ Try[B])(f: (A, B) ⇒ C): Try[C]

    Permalink
    Definition Classes
    Apply
    Annotations
    @deprecated
    Deprecated

    (Since version 7) given F: Apply[F] use F.apply2(a,b)(f) instead, or given implicitly[Apply[F]], use ^(a,b)(f)

  2. def map3[A, B, C, D](fa: ⇒ Try[A], fb: ⇒ Try[B], fc: ⇒ Try[C])(f: (A, B, C) ⇒ D): Try[D]

    Permalink
    Definition Classes
    Apply
    Annotations
    @deprecated
    Deprecated

    (Since version 7) given F: Apply[F] use F.apply3(a,b,c)(f) instead, or given implicitly[Apply[F]], use ^^(a,b,c)(f)

  3. def map4[A, B, C, D, E](fa: ⇒ Try[A], fb: ⇒ Try[B], fc: ⇒ Try[C], fd: ⇒ Try[D])(f: (A, B, C, D) ⇒ E): Try[E]

    Permalink
    Definition Classes
    Apply
    Annotations
    @deprecated
    Deprecated

    (Since version 7) given F: Apply[F] use F.apply4(a,b,c,d)(f) instead, or given implicitly[Apply[F]], use ^^^(a,b,c,d)(f)

  4. def zip: Zip[Try]

    Permalink
    Definition Classes
    Apply
    Annotations
    @deprecated
    Deprecated

    (Since version 7.1.0) Apply#zip produces unlawful instances

Inherited from Monad[Try]

Inherited from Bind[Try]

Inherited from Applicative[Try]

Inherited from Apply[Try]

Inherited from Functor[Try]

Inherited from AnyRef

Inherited from Any

Ungrouped