implicit object BindingInstances extends Monad[Binding]
Ordering
- Alphabetic
- By Inheritance
Inherited
- BindingInstances
- Monad
- Bind
- Applicative
- Apply
- Functor
- InvariantFunctor
- AnyRef
- Any
- Hide All
- Show All
Visibility
- Public
- All
Type Members
-
trait
ApplicativeLaw extends scalaz.Applicative.ApplyLaw
- Definition Classes
- Applicative
-
trait
ApplyLaw extends scalaz.Apply.FunctorLaw
- Definition Classes
- Apply
-
trait
BindLaw extends scalaz.Bind.ApplyLaw
- Definition Classes
- Bind
-
trait
FunctorLaw extends scalaz.Functor.InvariantFunctorLaw
- Definition Classes
- Functor
-
trait
InvariantFunctorLaw extends AnyRef
- Definition Classes
- InvariantFunctor
-
trait
MonadLaw extends scalaz.Monad.ApplicativeLaw with scalaz.Monad.BindLaw
- Definition Classes
- Monad
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
ap[A, B](fa: ⇒ Binding[A])(f: ⇒ Binding[(A) ⇒ B]): Binding[B]
- Definition Classes
- Bind → Apply
-
def
ap2[A, B, C](fa: ⇒ Binding[A], fb: ⇒ Binding[B])(f: Binding[(A, B) ⇒ C]): Binding[C]
- Definition Classes
- Apply
-
def
ap3[A, B, C, D](fa: ⇒ Binding[A], fb: ⇒ Binding[B], fc: ⇒ Binding[C])(f: Binding[(A, B, C) ⇒ D]): Binding[D]
- Definition Classes
- Apply
-
def
ap4[A, B, C, D, E](fa: ⇒ Binding[A], fb: ⇒ Binding[B], fc: ⇒ Binding[C], fd: ⇒ Binding[D])(f: Binding[(A, B, C, D) ⇒ E]): Binding[E]
- Definition Classes
- Apply
-
def
ap5[A, B, C, D, E, R](fa: ⇒ Binding[A], fb: ⇒ Binding[B], fc: ⇒ Binding[C], fd: ⇒ Binding[D], fe: ⇒ Binding[E])(f: Binding[(A, B, C, D, E) ⇒ R]): Binding[R]
- Definition Classes
- Apply
-
def
ap6[A, B, C, D, E, FF, R](fa: ⇒ Binding[A], fb: ⇒ Binding[B], fc: ⇒ Binding[C], fd: ⇒ Binding[D], fe: ⇒ Binding[E], ff: ⇒ Binding[FF])(f: Binding[(A, B, C, D, E, FF) ⇒ R]): Binding[R]
- Definition Classes
- Apply
-
def
ap7[A, B, C, D, E, FF, G, R](fa: ⇒ Binding[A], fb: ⇒ Binding[B], fc: ⇒ Binding[C], fd: ⇒ Binding[D], fe: ⇒ Binding[E], ff: ⇒ Binding[FF], fg: ⇒ Binding[G])(f: Binding[(A, B, C, D, E, FF, G) ⇒ R]): Binding[R]
- Definition Classes
- Apply
-
def
ap8[A, B, C, D, E, FF, G, H, R](fa: ⇒ Binding[A], fb: ⇒ Binding[B], fc: ⇒ Binding[C], fd: ⇒ Binding[D], fe: ⇒ Binding[E], ff: ⇒ Binding[FF], fg: ⇒ Binding[G], fh: ⇒ Binding[H])(f: Binding[(A, B, C, D, E, FF, G, H) ⇒ R]): Binding[R]
- Definition Classes
- Apply
-
def
apF[A, B](f: ⇒ Binding[(A) ⇒ B]): (Binding[A]) ⇒ Binding[B]
- Definition Classes
- Apply
-
def
applicativeLaw: ApplicativeLaw
- Definition Classes
- Applicative
-
val
applicativeSyntax: ApplicativeSyntax[Binding]
- Definition Classes
- Applicative
-
def
apply[A, B](fa: Binding[A])(f: (A) ⇒ B): Binding[B]
- Definition Classes
- Functor
-
def
apply10[A, B, C, D, E, FF, G, H, I, J, R](fa: ⇒ Binding[A], fb: ⇒ Binding[B], fc: ⇒ Binding[C], fd: ⇒ Binding[D], fe: ⇒ Binding[E], ff: ⇒ Binding[FF], fg: ⇒ Binding[G], fh: ⇒ Binding[H], fi: ⇒ Binding[I], fj: ⇒ Binding[J])(f: (A, B, C, D, E, FF, G, H, I, J) ⇒ R): Binding[R]
- Definition Classes
- Apply
-
def
apply11[A, B, C, D, E, FF, G, H, I, J, K, R](fa: ⇒ Binding[A], fb: ⇒ Binding[B], fc: ⇒ Binding[C], fd: ⇒ Binding[D], fe: ⇒ Binding[E], ff: ⇒ Binding[FF], fg: ⇒ Binding[G], fh: ⇒ Binding[H], fi: ⇒ Binding[I], fj: ⇒ Binding[J], fk: ⇒ Binding[K])(f: (A, B, C, D, E, FF, G, H, I, J, K) ⇒ R): Binding[R]
- Definition Classes
- Apply
-
def
apply12[A, B, C, D, E, FF, G, H, I, J, K, L, R](fa: ⇒ Binding[A], fb: ⇒ Binding[B], fc: ⇒ Binding[C], fd: ⇒ Binding[D], fe: ⇒ Binding[E], ff: ⇒ Binding[FF], fg: ⇒ Binding[G], fh: ⇒ Binding[H], fi: ⇒ Binding[I], fj: ⇒ Binding[J], fk: ⇒ Binding[K], fl: ⇒ Binding[L])(f: (A, B, C, D, E, FF, G, H, I, J, K, L) ⇒ R): Binding[R]
- Definition Classes
- Apply
-
def
apply2[A, B, C](fa: ⇒ Binding[A], fb: ⇒ Binding[B])(f: (A, B) ⇒ C): Binding[C]
- Definition Classes
- Applicative → Apply
-
def
apply3[A, B, C, D](fa: ⇒ Binding[A], fb: ⇒ Binding[B], fc: ⇒ Binding[C])(f: (A, B, C) ⇒ D): Binding[D]
- Definition Classes
- Apply
-
def
apply4[A, B, C, D, E](fa: ⇒ Binding[A], fb: ⇒ Binding[B], fc: ⇒ Binding[C], fd: ⇒ Binding[D])(f: (A, B, C, D) ⇒ E): Binding[E]
- Definition Classes
- Apply
-
def
apply5[A, B, C, D, E, R](fa: ⇒ Binding[A], fb: ⇒ Binding[B], fc: ⇒ Binding[C], fd: ⇒ Binding[D], fe: ⇒ Binding[E])(f: (A, B, C, D, E) ⇒ R): Binding[R]
- Definition Classes
- Apply
-
def
apply6[A, B, C, D, E, FF, R](fa: ⇒ Binding[A], fb: ⇒ Binding[B], fc: ⇒ Binding[C], fd: ⇒ Binding[D], fe: ⇒ Binding[E], ff: ⇒ Binding[FF])(f: (A, B, C, D, E, FF) ⇒ R): Binding[R]
- Definition Classes
- Apply
-
def
apply7[A, B, C, D, E, FF, G, R](fa: ⇒ Binding[A], fb: ⇒ Binding[B], fc: ⇒ Binding[C], fd: ⇒ Binding[D], fe: ⇒ Binding[E], ff: ⇒ Binding[FF], fg: ⇒ Binding[G])(f: (A, B, C, D, E, FF, G) ⇒ R): Binding[R]
- Definition Classes
- Apply
-
def
apply8[A, B, C, D, E, FF, G, H, R](fa: ⇒ Binding[A], fb: ⇒ Binding[B], fc: ⇒ Binding[C], fd: ⇒ Binding[D], fe: ⇒ Binding[E], ff: ⇒ Binding[FF], fg: ⇒ Binding[G], fh: ⇒ Binding[H])(f: (A, B, C, D, E, FF, G, H) ⇒ R): Binding[R]
- Definition Classes
- Apply
-
def
apply9[A, B, C, D, E, FF, G, H, I, R](fa: ⇒ Binding[A], fb: ⇒ Binding[B], fc: ⇒ Binding[C], fd: ⇒ Binding[D], fe: ⇒ Binding[E], ff: ⇒ Binding[FF], fg: ⇒ Binding[G], fh: ⇒ Binding[H], fi: ⇒ Binding[I])(f: (A, B, C, D, E, FF, G, H, I) ⇒ R): Binding[R]
- Definition Classes
- Apply
-
def
applyApplicative: Applicative[[α]\/[Binding[α], α]]
- Definition Classes
- Apply
-
def
applyLaw: ApplyLaw
- Definition Classes
- Apply
-
val
applySyntax: ApplySyntax[Binding]
- Definition Classes
- Apply
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
bicompose[G[_, _]](implicit arg0: Bifunctor[G]): Bifunctor[[α, β]Binding[G[α, β]]]
- Definition Classes
- Functor
-
def
bind[A, B](fa: Binding[A])(f: (A) ⇒ Binding[B]): Binding[B]
- Definition Classes
- BindingInstances → Bind
-
def
bindLaw: BindLaw
- Definition Classes
- Bind
-
val
bindSyntax: BindSyntax[Binding]
- Definition Classes
- Bind
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
def
compose[G[_]](implicit G0: Applicative[G]): Applicative[[α]Binding[G[α]]]
- Definition Classes
- Applicative
-
def
compose[G[_]](implicit G0: Apply[G]): Apply[[α]Binding[G[α]]]
- Definition Classes
- Apply
-
def
compose[G[_]](implicit G0: Functor[G]): Functor[[α]Binding[G[α]]]
- Definition Classes
- Functor
-
def
counzip[A, B](a: \/[Binding[A], Binding[B]]): Binding[\/[A, B]]
- Definition Classes
- Functor
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
filterM[A](l: List[A])(f: (A) ⇒ Binding[Boolean]): Binding[List[A]]
- Definition Classes
- Applicative
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
flip: Applicative[Binding]
- Definition Classes
- Applicative
-
def
forever[A, B](fa: Binding[A]): Binding[B]
- Definition Classes
- Bind
-
def
fpair[A](fa: Binding[A]): Binding[(A, A)]
- Definition Classes
- Functor
-
def
fproduct[A, B](fa: Binding[A])(f: (A) ⇒ B): Binding[(A, B)]
- Definition Classes
- Functor
-
def
functorLaw: FunctorLaw
- Definition Classes
- Functor
-
val
functorSyntax: FunctorSyntax[Binding]
- Definition Classes
- Functor
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
icompose[G[_]](implicit G0: Contravariant[G]): Contravariant[[α]Binding[G[α]]]
- Definition Classes
- Functor
-
def
ifM[B](value: Binding[Boolean], ifTrue: ⇒ Binding[B], ifFalse: ⇒ Binding[B]): Binding[B]
- Definition Classes
- BindingInstances → Bind
-
def
invariantFunctorLaw: InvariantFunctorLaw
- Definition Classes
- InvariantFunctor
-
val
invariantFunctorSyntax: InvariantFunctorSyntax[Binding]
- Definition Classes
- InvariantFunctor
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
iterateUntil[A](f: Binding[A])(p: (A) ⇒ Boolean): Binding[A]
- Definition Classes
- Monad
-
def
iterateWhile[A](f: Binding[A])(p: (A) ⇒ Boolean): Binding[A]
- Definition Classes
- Monad
-
def
join[A](ffa: Binding[Binding[A]]): Binding[A]
- Definition Classes
- Bind
-
def
lift[A, B](f: (A) ⇒ B): (Binding[A]) ⇒ Binding[B]
- Definition Classes
- Functor
-
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): (Binding[A], Binding[B], Binding[C], Binding[D], Binding[E], Binding[FF], Binding[G], Binding[H], Binding[I], Binding[J]) ⇒ Binding[R]
- Definition Classes
- Apply
-
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): (Binding[A], Binding[B], Binding[C], Binding[D], Binding[E], Binding[FF], Binding[G], Binding[H], Binding[I], Binding[J], Binding[K]) ⇒ Binding[R]
- Definition Classes
- Apply
-
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): (Binding[A], Binding[B], Binding[C], Binding[D], Binding[E], Binding[FF], Binding[G], Binding[H], Binding[I], Binding[J], Binding[K], Binding[L]) ⇒ Binding[R]
- Definition Classes
- Apply
-
def
lift2[A, B, C](f: (A, B) ⇒ C): (Binding[A], Binding[B]) ⇒ Binding[C]
- Definition Classes
- Apply
-
def
lift3[A, B, C, D](f: (A, B, C) ⇒ D): (Binding[A], Binding[B], Binding[C]) ⇒ Binding[D]
- Definition Classes
- Apply
-
def
lift4[A, B, C, D, E](f: (A, B, C, D) ⇒ E): (Binding[A], Binding[B], Binding[C], Binding[D]) ⇒ Binding[E]
- Definition Classes
- Apply
-
def
lift5[A, B, C, D, E, R](f: (A, B, C, D, E) ⇒ R): (Binding[A], Binding[B], Binding[C], Binding[D], Binding[E]) ⇒ Binding[R]
- Definition Classes
- Apply
-
def
lift6[A, B, C, D, E, FF, R](f: (A, B, C, D, E, FF) ⇒ R): (Binding[A], Binding[B], Binding[C], Binding[D], Binding[E], Binding[FF]) ⇒ Binding[R]
- Definition Classes
- Apply
-
def
lift7[A, B, C, D, E, FF, G, R](f: (A, B, C, D, E, FF, G) ⇒ R): (Binding[A], Binding[B], Binding[C], Binding[D], Binding[E], Binding[FF], Binding[G]) ⇒ Binding[R]
- Definition Classes
- Apply
-
def
lift8[A, B, C, D, E, FF, G, H, R](f: (A, B, C, D, E, FF, G, H) ⇒ R): (Binding[A], Binding[B], Binding[C], Binding[D], Binding[E], Binding[FF], Binding[G], Binding[H]) ⇒ Binding[R]
- Definition Classes
- Apply
-
def
lift9[A, B, C, D, E, FF, G, H, I, R](f: (A, B, C, D, E, FF, G, H, I) ⇒ R): (Binding[A], Binding[B], Binding[C], Binding[D], Binding[E], Binding[FF], Binding[G], Binding[H], Binding[I]) ⇒ Binding[R]
- Definition Classes
- Apply
-
def
map[A, B](fa: Binding[A])(f: (A) ⇒ B): Binding[B]
- Definition Classes
- BindingInstances → Monad → Applicative → Functor
-
def
mapply[A, B](a: A)(f: Binding[(A) ⇒ B]): Binding[B]
- Definition Classes
- Functor
-
def
monadLaw: MonadLaw
- Definition Classes
- Monad
-
val
monadSyntax: MonadSyntax[Binding]
- Definition Classes
- Monad
-
def
mproduct[A, B](fa: Binding[A])(f: (A) ⇒ Binding[B]): Binding[(A, B)]
- Definition Classes
- Bind
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
point[A](a: ⇒ A): Binding[A]
- Definition Classes
- BindingInstances → Applicative
- Annotations
- @inline()
-
def
product[G[_]](implicit G0: Monad[G]): Monad[[α](Binding[α], G[α])]
- Definition Classes
- Monad
-
def
product[G[_]](implicit G0: Bind[G]): Bind[[α](Binding[α], G[α])]
- Definition Classes
- Bind
-
def
product[G[_]](implicit G0: Applicative[G]): Applicative[[α](Binding[α], G[α])]
- Definition Classes
- Applicative
-
def
product[G[_]](implicit G0: Apply[G]): Apply[[α](Binding[α], G[α])]
- Definition Classes
- Apply
-
def
product[G[_]](implicit G0: Functor[G]): Functor[[α](Binding[α], G[α])]
- Definition Classes
- Functor
-
final
def
pure[A](a: ⇒ A): Binding[A]
- Definition Classes
- Applicative
-
def
replicateM[A](n: Int, fa: Binding[A]): Binding[List[A]]
- Definition Classes
- Applicative
-
def
replicateM_[A](n: Int, fa: Binding[A]): Binding[Unit]
- Definition Classes
- Applicative
-
def
sequence[A, G[_]](as: G[Binding[A]])(implicit arg0: Traverse[G]): Binding[G[A]]
- Definition Classes
- Applicative
-
def
sequence1[A, G[_]](as: G[Binding[A]])(implicit arg0: Traverse1[G]): Binding[G[A]]
- Definition Classes
- Apply
-
def
strengthL[A, B](a: A, f: Binding[B]): Binding[(A, B)]
- Definition Classes
- Functor
-
def
strengthR[A, B](f: Binding[A], b: B): Binding[(A, B)]
- Definition Classes
- Functor
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
def
traverse[A, G[_], B](value: G[A])(f: (A) ⇒ Binding[B])(implicit G: Traverse[G]): Binding[G[B]]
- Definition Classes
- Applicative
-
def
traverse1[A, G[_], B](value: G[A])(f: (A) ⇒ Binding[B])(implicit G: Traverse1[G]): Binding[G[B]]
- Definition Classes
- Apply
-
def
tuple2[A, B](fa: ⇒ Binding[A], fb: ⇒ Binding[B]): Binding[(A, B)]
- Definition Classes
- Apply
-
def
tuple3[A, B, C](fa: ⇒ Binding[A], fb: ⇒ Binding[B], fc: ⇒ Binding[C]): Binding[(A, B, C)]
- Definition Classes
- Apply
-
def
tuple4[A, B, C, D](fa: ⇒ Binding[A], fb: ⇒ Binding[B], fc: ⇒ Binding[C], fd: ⇒ Binding[D]): Binding[(A, B, C, D)]
- Definition Classes
- Apply
-
def
tuple5[A, B, C, D, E](fa: ⇒ Binding[A], fb: ⇒ Binding[B], fc: ⇒ Binding[C], fd: ⇒ Binding[D], fe: ⇒ Binding[E]): Binding[(A, B, C, D, E)]
- Definition Classes
- Apply
-
def
unlessM[A](cond: Boolean)(f: ⇒ Binding[A]): Binding[Unit]
- Definition Classes
- Applicative
-
def
untilM[G[_], A](f: Binding[A], cond: ⇒ Binding[Boolean])(implicit G: MonadPlus[G]): Binding[G[A]]
- Definition Classes
- BindingInstances → Monad
-
def
untilM_[A](f: Binding[A], cond: ⇒ Binding[Boolean]): Binding[Unit]
- Definition Classes
- BindingInstances → Monad
-
def
void[A](fa: Binding[A]): Binding[Unit]
- Definition Classes
- Functor
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
def
whenM[A](cond: Boolean)(f: ⇒ Binding[A]): Binding[Unit]
- Definition Classes
- Applicative
-
def
whileM[G[_], A](p: Binding[Boolean], body: ⇒ Binding[A])(implicit G: MonadPlus[G]): Binding[G[A]]
- Definition Classes
- BindingInstances → Monad
-
def
whileM_[A](p: Binding[Boolean], body: ⇒ Binding[A]): Binding[Unit]
- Definition Classes
- BindingInstances → Monad
-
def
widen[A, B](fa: Binding[A])(implicit ev: <~<[A, B]): Binding[B]
- Definition Classes
- Functor
-
def
xmap[A, B](fa: Binding[A], f: (A) ⇒ B, g: (B) ⇒ A): Binding[B]
- Definition Classes
- Functor → InvariantFunctor
-
def
xmapb[A, B](ma: Binding[A])(b: Bijection[A, B]): Binding[B]
- Definition Classes
- InvariantFunctor
-
def
xmapi[A, B](ma: Binding[A])(iso: scalaz.Isomorphism.<=>[A, B]): Binding[B]
- Definition Classes
- InvariantFunctor