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], BindParent[M], Apply[M], ApplyParent[M], Functor[M], InvariantFunctor[M], AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. BindRecʹ
  2. BindRec
  3. Bind
  4. BindParent
  5. Apply
  6. ApplyParent
  7. Functor
  8. InvariantFunctor
  9. AnyRef
  10. 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. def discardLeft[A, B](fa: ⇒ M[A], fb: ⇒ M[B]): M[B]
    Definition Classes
    ApplyParent
  39. def discardRight[A, B](fa: ⇒ M[A], fb: ⇒ M[B]): M[A]
    Definition Classes
    ApplyParent
  40. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  41. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  42. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  43. def flip: Apply[M]
    Definition Classes
    ApplyParent
  44. def forever[A, B](fa: M[A]): M[B]
    Definition Classes
    BindRec → Bind → ApplyParent
  45. def fpair[A](fa: M[A]): M[(A, A)]
    Definition Classes
    Functor
  46. def fproduct[A, B](fa: M[A])(f: (A) ⇒ B): M[(A, B)]
    Definition Classes
    Functor
  47. def functorLaw: FunctorLaw
    Definition Classes
    Functor
  48. val functorSyntax: FunctorSyntax[M]
    Definition Classes
    Functor
  49. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
  50. def hashCode(): Int
    Definition Classes
    AnyRef → Any
  51. def icompose[G[_]](implicit G0: Contravariant[G]): Contravariant[[α]M[G[α]]]
    Definition Classes
    Functor
  52. def ifM[B](value: M[Boolean], ifTrue: ⇒ M[B], ifFalse: ⇒ M[B]): M[B]
    Definition Classes
    Bind
  53. def invariantFunctorLaw: InvariantFunctorLaw
    Definition Classes
    InvariantFunctor
  54. val invariantFunctorSyntax: InvariantFunctorSyntax[M]
    Definition Classes
    InvariantFunctor
  55. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  56. def join[A](ffa: M[M[A]]): M[A]
    Definition Classes
    Bind
  57. def lift[A, B](f: (A) ⇒ B): (M[A]) ⇒ M[B]
    Definition Classes
    Functor
  58. 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
  59. 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
  60. 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
  61. def lift2[A, B, C](f: (A, B) ⇒ C): (M[A], M[B]) ⇒ M[C]
    Definition Classes
    Apply
  62. def lift3[A, B, C, D](f: (A, B, C) ⇒ D): (M[A], M[B], M[C]) ⇒ M[D]
    Definition Classes
    Apply
  63. 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
  64. 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
  65. 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
  66. 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
  67. 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
  68. 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
  69. def mapply[A, B](a: A)(f: M[(A) ⇒ B]): M[B]
    Definition Classes
    Functor
  70. def mproduct[A, B](fa: M[A])(f: (A) ⇒ M[B]): M[(A, B)]
    Definition Classes
    Bind
  71. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  72. final def notify(): Unit
    Definition Classes
    AnyRef
  73. final def notifyAll(): Unit
    Definition Classes
    AnyRef
  74. def product[G[_]](implicit G0: BindRec[G]): BindRec[[α](M[α], G[α])]
    Definition Classes
    BindRec
  75. def product[G[_]](implicit G0: Bind[G]): Bind[[α](M[α], G[α])]
    Definition Classes
    Bind
  76. def product[G[_]](implicit G0: Apply[G]): Apply[[α](M[α], G[α])]
    Definition Classes
    Apply
  77. def product[G[_]](implicit G0: Functor[G]): Functor[[α](M[α], G[α])]
    Definition Classes
    Functor
  78. def sequence1[A, G[_]](as: G[M[A]])(implicit arg0: Traverse1[G]): M[G[A]]
    Definition Classes
    Apply
  79. def strengthL[A, B](a: A, f: M[B]): M[(A, B)]
    Definition Classes
    Functor
  80. def strengthR[A, B](f: M[A], b: B): M[(A, B)]
    Definition Classes
    Functor
  81. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  82. def tailrecM[A, B](f: (A) ⇒ M[\/[A, B]])(a: A): M[B]
    Definition Classes
    BindRecʹ → BindRec
  83. def toString(): String
    Definition Classes
    AnyRef → Any
  84. def traverse1[A, G[_], B](value: G[A])(f: (A) ⇒ M[B])(implicit G: Traverse1[G]): M[G[B]]
    Definition Classes
    Apply
  85. def tuple2[A, B](fa: ⇒ M[A], fb: ⇒ M[B]): M[(A, B)]
    Definition Classes
    Apply
  86. def tuple3[A, B, C](fa: ⇒ M[A], fb: ⇒ M[B], fc: ⇒ M[C]): M[(A, B, C)]
    Definition Classes
    Apply
  87. 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
  88. 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
  89. def void[A](fa: M[A]): M[Unit]
    Definition Classes
    Functor
  90. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  91. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  92. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  93. def widen[A, B](fa: M[A])(implicit ev: <~<[A, B]): M[B]
    Definition Classes
    Functor
  94. def xmap[A, B](fa: M[A], f: (A) ⇒ B, g: (B) ⇒ A): M[B]
    Definition Classes
    Functor → InvariantFunctor
  95. def xmapb[A, B](ma: M[A])(b: Bijection[A, B]): M[B]
    Definition Classes
    InvariantFunctor
  96. 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 BindParent[M]

Inherited from Apply[M]

Inherited from ApplyParent[M]

Inherited from Functor[M]

Inherited from InvariantFunctor[M]

Inherited from AnyRef

Inherited from Any

Ungrouped