Packages

t

org.specs2.control.eff

BindRecʹ

trait BindRecʹ[M[_]] extends BindRec[M]

Papers over the parameter order change in Scalaz 7.3

Linear Supertypes
BindRec[M], Bind[M], Apply[M], Functor[M], InvariantFunctor[M], AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. BindRecʹ
  2. BindRec
  3. Bind
  4. Apply
  5. Functor
  6. InvariantFunctor
  7. AnyRef
  8. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. trait ApplyLaw extends scalaz.Apply.FunctorLaw
    Definition Classes
    Apply
  2. trait BindLaw extends scalaz.Bind.ApplyLaw
    Definition Classes
    Bind
  3. trait BindRecLaw extends scalaz.BindRec.BindLaw
    Definition Classes
    BindRec
  4. trait FunctorLaw extends scalaz.Functor.InvariantFunctorLaw
    Definition Classes
    Functor
  5. trait InvariantFunctorLaw extends AnyRef
    Definition Classes
    InvariantFunctor

Abstract Value Members

  1. abstract def bind[A, B](fa: M[A])(f: (A) ⇒ M[B]): M[B]
    Definition Classes
    Bind
  2. abstract def map[A, B](fa: M[A])(f: (A) ⇒ B): M[B]
    Definition Classes
    Functor
  3. abstract def tailrecM[A, B](a: A)(f: (A) ⇒ M[\/[A, B]]): M[B]

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. def ap[A, B](fa: ⇒ M[A])(f: ⇒ M[(A) ⇒ B]): M[B]
    Definition Classes
    Bind → Apply
  5. def ap2[A, B, C](fa: ⇒ M[A], fb: ⇒ M[B])(f: M[(A, B) ⇒ C]): M[C]
    Definition Classes
    Apply
  6. def ap3[A, B, C, D](fa: ⇒ M[A], fb: ⇒ M[B], fc: ⇒ M[C])(f: M[(A, B, C) ⇒ D]): M[D]
    Definition Classes
    Apply
  7. 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]
    Definition Classes
    Apply
  8. 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]
    Definition Classes
    Apply
  9. 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]
    Definition Classes
    Apply
  10. 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]
    Definition Classes
    Apply
  11. 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]
    Definition Classes
    Apply
  12. def apF[A, B](f: ⇒ M[(A) ⇒ B]): (M[A]) ⇒ M[B]
    Definition Classes
    Apply
  13. def apply[A, B](fa: M[A])(f: (A) ⇒ B): M[B]
    Definition Classes
    Functor
  14. 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]
    Definition Classes
    Apply
  15. 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]
    Definition Classes
    Apply
  16. 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]
    Definition Classes
    Apply
  17. def apply2[A, B, C](fa: ⇒ M[A], fb: ⇒ M[B])(f: (A, B) ⇒ C): M[C]
    Definition Classes
    Apply
  18. def apply3[A, B, C, D](fa: ⇒ M[A], fb: ⇒ M[B], fc: ⇒ M[C])(f: (A, B, C) ⇒ D): M[D]
    Definition Classes
    Apply
  19. 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]
    Definition Classes
    Apply
  20. 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]
    Definition Classes
    Apply
  21. 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]
    Definition Classes
    Apply
  22. 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]
    Definition Classes
    Apply
  23. 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]
    Definition Classes
    Apply
  24. 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]
    Definition Classes
    Apply
  25. def applyApplicative: Applicative[[α]\/[M[α], α]]
    Definition Classes
    Apply
  26. def applyLaw: ApplyLaw
    Definition Classes
    Apply
  27. val applySyntax: ApplySyntax[M]
    Definition Classes
    Apply
  28. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  29. def bicompose[G[_, _]](implicit arg0: Bifunctor[G]): Bifunctor[[α, β]M[G[α, β]]]
    Definition Classes
    Functor
  30. def bindLaw: BindLaw
    Definition Classes
    Bind
  31. def bindRecLaw: BindRecLaw
    Definition Classes
    BindRec
  32. val bindRecSyntax: BindRecSyntax[M]
    Definition Classes
    BindRec
  33. val bindSyntax: BindSyntax[M]
    Definition Classes
    Bind
  34. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  35. def compose[G[_]](implicit G0: Apply[G]): Apply[[α]M[G[α]]]
    Definition Classes
    Apply
  36. def compose[G[_]](implicit G0: Functor[G]): Functor[[α]M[G[α]]]
    Definition Classes
    Functor
  37. def counzip[A, B](a: \/[M[A], M[B]]): M[\/[A, B]]
    Definition Classes
    Functor
  38. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  39. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  40. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  41. def forever[A, B](fa: M[A]): M[B]
    Definition Classes
    BindRec → Bind
  42. def fpair[A](fa: M[A]): M[(A, A)]
    Definition Classes
    Functor
  43. def fproduct[A, B](fa: M[A])(f: (A) ⇒ B): M[(A, B)]
    Definition Classes
    Functor
  44. def functorLaw: FunctorLaw
    Definition Classes
    Functor
  45. val functorSyntax: FunctorSyntax[M]
    Definition Classes
    Functor
  46. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
  47. def hashCode(): Int
    Definition Classes
    AnyRef → Any
  48. def icompose[G[_]](implicit G0: Contravariant[G]): Contravariant[[α]M[G[α]]]
    Definition Classes
    Functor
  49. def ifM[B](value: M[Boolean], ifTrue: ⇒ M[B], ifFalse: ⇒ M[B]): M[B]
    Definition Classes
    Bind
  50. def invariantFunctorLaw: InvariantFunctorLaw
    Definition Classes
    InvariantFunctor
  51. val invariantFunctorSyntax: InvariantFunctorSyntax[M]
    Definition Classes
    InvariantFunctor
  52. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  53. def join[A](ffa: M[M[A]]): M[A]
    Definition Classes
    Bind
  54. def lift[A, B](f: (A) ⇒ B): (M[A]) ⇒ M[B]
    Definition Classes
    Functor
  55. 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]
    Definition Classes
    Apply
  56. 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]
    Definition Classes
    Apply
  57. 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]
    Definition Classes
    Apply
  58. def lift2[A, B, C](f: (A, B) ⇒ C): (M[A], M[B]) ⇒ M[C]
    Definition Classes
    Apply
  59. def lift3[A, B, C, D](f: (A, B, C) ⇒ D): (M[A], M[B], M[C]) ⇒ M[D]
    Definition Classes
    Apply
  60. def lift4[A, B, C, D, E](f: (A, B, C, D) ⇒ E): (M[A], M[B], M[C], M[D]) ⇒ M[E]
    Definition Classes
    Apply
  61. 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]
    Definition Classes
    Apply
  62. 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]
    Definition Classes
    Apply
  63. 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]
    Definition Classes
    Apply
  64. 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]
    Definition Classes
    Apply
  65. 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]
    Definition Classes
    Apply
  66. def mapply[A, B](a: A)(f: M[(A) ⇒ B]): M[B]
    Definition Classes
    Functor
  67. def mproduct[A, B](fa: M[A])(f: (A) ⇒ M[B]): M[(A, B)]
    Definition Classes
    Bind
  68. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  69. final def notify(): Unit
    Definition Classes
    AnyRef
  70. final def notifyAll(): Unit
    Definition Classes
    AnyRef
  71. def product[G[_]](implicit G0: BindRec[G]): BindRec[[α](M[α], G[α])]
    Definition Classes
    BindRec
  72. def product[G[_]](implicit G0: Bind[G]): Bind[[α](M[α], G[α])]
    Definition Classes
    Bind
  73. def product[G[_]](implicit G0: Apply[G]): Apply[[α](M[α], G[α])]
    Definition Classes
    Apply
  74. def product[G[_]](implicit G0: Functor[G]): Functor[[α](M[α], G[α])]
    Definition Classes
    Functor
  75. def sequence1[A, G[_]](as: G[M[A]])(implicit arg0: Traverse1[G]): M[G[A]]
    Definition Classes
    Apply
  76. def strengthL[A, B](a: A, f: M[B]): M[(A, B)]
    Definition Classes
    Functor
  77. def strengthR[A, B](f: M[A], b: B): M[(A, B)]
    Definition Classes
    Functor
  78. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  79. def tailrecM[A, B](f: (A) ⇒ M[\/[A, B]])(a: A): M[B]
    Definition Classes
    BindRecʹ → BindRec
  80. def toString(): String
    Definition Classes
    AnyRef → Any
  81. def traverse1[A, G[_], B](value: G[A])(f: (A) ⇒ M[B])(implicit G: Traverse1[G]): M[G[B]]
    Definition Classes
    Apply
  82. def tuple2[A, B](fa: ⇒ M[A], fb: ⇒ M[B]): M[(A, B)]
    Definition Classes
    Apply
  83. def tuple3[A, B, C](fa: ⇒ M[A], fb: ⇒ M[B], fc: ⇒ M[C]): M[(A, B, C)]
    Definition Classes
    Apply
  84. def tuple4[A, B, C, D](fa: ⇒ M[A], fb: ⇒ M[B], fc: ⇒ M[C], fd: ⇒ M[D]): M[(A, B, C, D)]
    Definition Classes
    Apply
  85. 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)]
    Definition Classes
    Apply
  86. def void[A](fa: M[A]): M[Unit]
    Definition Classes
    Functor
  87. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  88. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  89. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  90. def widen[A, B](fa: M[A])(implicit ev: <~<[A, B]): M[B]
    Definition Classes
    Functor
  91. def xmap[A, B](fa: M[A], f: (A) ⇒ B, g: (B) ⇒ A): M[B]
    Definition Classes
    Functor → InvariantFunctor
  92. def xmapb[A, B](ma: M[A])(b: Bijection[A, B]): M[B]
    Definition Classes
    InvariantFunctor
  93. def xmapi[A, B](ma: M[A])(iso: scalaz.Isomorphism.<=>[A, B]): M[B]
    Definition Classes
    InvariantFunctor

Inherited from BindRec[M]

Inherited from Bind[M]

Inherited from Apply[M]

Inherited from Functor[M]

Inherited from InvariantFunctor[M]

Inherited from AnyRef

Inherited from Any

Ungrouped