MAB

val value : M[A, B]

def ! (n: Int)(implicit i: Index[[X]M[A, X]]): Option[B]

def !! (n: Int)(implicit r: Foldable[[X]M[A, X]]): B

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

def &&& [C] (k: M[A, C])(implicit a: Arrow[M]): M[A, (B, C)]

def &: (a: B): ViewL[[X]M[A, X], B]

def *** [C, D] (k: M[C, D])(implicit a: Arrow[M]): M[(A, C), (B, D)]

def *> [B] (b: M[A, B])(implicit t: Functor[[X]M[A, X]], a: Apply[[X]M[A, X]]): M[A, B]

def +>: (a: B)(implicit s: Semigroup[M[A, B]], q: Pure[[X]M[A, X]]): M[A, B]

def -!- (n: Int)(implicit i: Index[[X]M[A, X]]): B

def :& (a: B): ViewR[[X]M[A, X], B]

def :-> [D] (g: (B) ⇒ D)(implicit b: Bifunctor[M]): M[A, D]

def <* [B] (b: M[A, B])(implicit t: Functor[[X]M[A, X]], a: Apply[[X]M[A, X]]): M[A, B]

def <*****> [B, C, D, E, F] (b: M[A, B], c: M[A, C], d: M[A, D], e: M[A, E])(z: (B, B, C, D, E) ⇒ F)(implicit t: Functor[[X]M[A, X]], a: Apply[[X]M[A, X]]): M[A, F]

def <****> [B, C, D, E] (b: M[A, B], c: M[A, C], d: M[A, D])(z: (B, B, C, D) ⇒ E)(implicit t: Functor[[X]M[A, X]], a: Apply[[X]M[A, X]]): M[A, E]

def <***> [B, C, D] (b: M[A, B], c: M[A, C])(z: (B, B, C) ⇒ D)(implicit t: Functor[[X]M[A, X]], a: Apply[[X]M[A, X]]): M[A, D]

def <**> [B, C] (b: M[A, B])(z: (B, B) ⇒ C)(implicit t: Functor[[X]M[A, X]], a: Apply[[X]M[A, X]]): M[A, C]

def <*> [B] (f: M[A, (B) ⇒ B])(implicit a: Apply[[X]M[A, X]]): M[A, B]

def <+> (z: ⇒ M[A, B])(implicit p: Plus[[X]M[A, X]]): M[A, B]

def <+>: (a: B)(implicit p: Plus[[X]M[A, X]], q: Pure[[X]M[A, X]]): M[A, B]

def <---> (w: M[A, B])(implicit l: Length[[X]M[A, X]], ind: Index[[X]M[A, X]], equ: Equal[B]): Int

def <-: [C] (f: (A) ⇒ C)(implicit b: Bifunctor[M]): M[C, B]

def <<< [C] (k: M[C, A])(implicit c: Category[M]): M[C, B]

def <<^ [C] (f: (C) ⇒ A)(implicit a: Arrow[M]): M[C, B]

def <|****|> [B, C, D, E] (b: M[A, B], c: M[A, C], d: M[A, D], e: M[A, E])(implicit t: Functor[[X]M[A, X]], a: Apply[[X]M[A, X]]): M[A, (B, B, C, D, E)]

def <|***|> [B, C, D] (b: M[A, B], c: M[A, C], d: M[A, D])(implicit t: Functor[[X]M[A, X]], a: Apply[[X]M[A, X]]): M[A, (B, B, C, D)]

def <|**|> [B, C] (b: M[A, B], c: M[A, C])(implicit t: Functor[[X]M[A, X]], a: Apply[[X]M[A, X]]): M[A, (B, B, C)]

def <|*|> [B] (b: M[A, B])(implicit t: Functor[[X]M[A, X]], a: Apply[[X]M[A, X]]): M[A, (B, B)]

def == (arg0: AnyRef): Boolean

def == (arg0: Any): Boolean

def =>> [B] (f: (M[A, B]) ⇒ B)(implicit w: Comonad[[X]M[A, X]]): M[A, B]

def >>= [B] (f: (B) ⇒ M[A, B])(implicit b: Bind[[X]M[A, X]]): M[A, B]

def >>=| [B] (f: ⇒ M[A, B])(implicit b: Bind[[X]M[A, X]]): M[A, B]

def >>> [C] (k: M[B, C])(implicit c: Category[M]): M[A, C]

def >>^ [C] (f: (B) ⇒ C)(implicit a: Arrow[M]): M[A, C]

def >| [B] (f: ⇒ B)(implicit t: Functor[[X]M[A, X]]): M[A, B]

def >|> [B] (f: ⇒ M[A, B])(implicit b: Bind[[X]M[A, X]]): M[A, B]

Alias for >>=|

def ^<< [C] (f: (B) ⇒ C)(implicit a: Arrow[M]): M[A, C]

def ^>> [C] (f: (C) ⇒ A)(implicit a: Arrow[M]): M[C, B]

def all (p: (B) ⇒ Boolean)(implicit r: Foldable[[X]M[A, X]]): Boolean

def any (p: (B) ⇒ Boolean)(implicit r: Foldable[[X]M[A, X]]): Boolean

def asInstanceOf [T0] : T0

def asMA : MA[[X]M[A, X], B]

Use this to force implicit conversion of M[A] to MA[M, A].

def asMAB : MAB[M, A, B]

def asStream [B] (f: (Stream[B]) ⇒ Stream[B])(implicit r: Foldable[[X]M[A, X]], m: Monoid[M[A, B]], p: Pure[[X]M[A, X]]): M[A, B]

def bktree (implicit f: Foldable[[X]M[A, X]], m: MetricSpace[B]): BKTree[B]

def clone (): AnyRef

def cojoin (implicit j: Cojoin[[X]M[A, X]]): M[A, M[A, B]]

def collapse (implicit t: Traverse[[X]M[A, X]], m: Monoid[B]): B

def comp [N[_], B] (implicit n: <:<[B, N[B]], f: Functor[[X]M[A, X]]): MA[[α]M[A, N[α]], B]

Returns a MA with the type parameter M equal to [A] M[N[A]], given that type A is constructed from type constructor N.

def copure (implicit p: Copure[[X]M[A, X]]): B

def count (implicit r: Foldable[[X]M[A, X]]): Int

def digits (implicit c: <:<[B, Char], t: Functor[[X]M[A, X]]): M[A, Option[Digit]]

def element (a: B)(implicit r: Foldable[[X]M[A, X]], eq: Equal[B]): Boolean

def empty (implicit r: Foldable[[X]M[A, X]]): Boolean

def eq (arg0: AnyRef): Boolean

def equals (arg0: Any): Boolean

def finalize (): Unit

def first [C] (implicit a: Arrow[M]): M[(A, C), (B, C)]

def flatMap [B] (f: (B) ⇒ M[A, B])(implicit b: Bind[[X]M[A, X]]): M[A, B]

def foldLeftM [N[_], B] (b: B)(f: (B, B) ⇒ N[B])(implicit fr: Foldable[[X]M[A, X]], m: Monad[N]): N[B]

def foldMap [B] (f: (B) ⇒ B)(implicit r: Foldable[[X]M[A, X]], m: Monoid[B]): B

def foldMapDefault [B] (f: (B) ⇒ B)(implicit t: Traverse[[X]M[A, X]], m: Monoid[B]): B

def foldReduce [B] (implicit f: Foldable[[X]M[A, X]], r: Reducer[B, B]): B

def foldRightM [N[_], B] (b: B)(f: (B, B) ⇒ N[B])(implicit fr: Foldable[[X]M[A, X]], m: Monad[N]): N[B]

def foldl [B] (b: B)(f: (B, B) ⇒ B)(implicit r: Foldable[[X]M[A, X]]): B

def foldl1 (f: (B, B) ⇒ B)(implicit r: Foldable[[X]M[A, X]]): Option[B]

def foldr [B] (b: B)(f: (B, ⇒ B) ⇒ B)(implicit r: Foldable[[X]M[A, X]]): B

def foldr1 (f: (B, ⇒ B) ⇒ B)(implicit r: Foldable[[X]M[A, X]]): Option[B]

def foreach (f: (B) ⇒ Unit)(implicit e: Each[[X]M[A, X]]): Unit

def forever [B] (implicit b: Bind[[X]M[A, X]]): M[A, B]

def fpair (implicit f: Functor[[X]M[A, X]]): M[A, (B, B)]

def fpure [N[_]] (implicit f: Functor[[X]M[A, X]], p: Pure[N]): M[A, N[B]]

def getClass (): java.lang.Class[_]

def getOrElseM (a: M[A, Option[B]])(implicit m: Monad[[X]M[A, X]]): M[A, B]

def hashCode (): Int

def ifM [B] (t: ⇒ M[A, B], f: ⇒ M[A, B])(implicit a: Monad[[X]M[A, X]], b: <:<[B, Boolean]): M[A, B]

def isInstanceOf [T0] : Boolean

def join [B] (implicit m: <:<[B, M[A, B]], b: Bind[[X]M[A, X]]): M[A, B]

def len (implicit l: Length[[X]M[A, X]]): Int

def liftw [F[_]] (implicit f: Functor[[X]M[A, X]], p: Pure[F]): ~>[Id, [α]WriterT[[X]M[A, X], F[α], B]]

Puts the given write value into a writer transformer, lifted into a pointed functor, and associates with this M[A] value

def liftwWith [F[_]] (implicit f: Functor[[X]M[A, X]], p: Pure[F]): ~>[[α](B) ⇒ α, [α]WriterT[[X]M[A, X], F[α], B]]

Puts the given write value that is produced by applying the given function into a writer transformer, lifted into a pointed functor, and associates with this M[A] value

def listl (implicit r: Foldable[[X]M[A, X]]): List[B]

def listr (implicit r: Foldable[[X]M[A, X]]): List[B]

def longDigits (implicit d: <:<[B, Digit], t: Foldable[[X]M[A, X]]): Long

def map [B] (f: (B) ⇒ B)(implicit t: Functor[[X]M[A, X]]): M[A, B]

def map2 [N[_], B, C] (f: (B) ⇒ C)(implicit m: <:<[B, N[B]], f1: Functor[[X]M[A, X]], f2: Functor[N]): M[A, N[C]]

def maximum (implicit r: Foldable[[X]M[A, X]], ord: Order[B]): Option[B]

def minimum (implicit r: Foldable[[X]M[A, X]], ord: Order[B]): Option[B]

def ne (arg0: AnyRef): Boolean

def notify (): Unit

def notifyAll (): Unit

def parBind [B] (f: (B) ⇒ M[A, B])(implicit m: Monad[[X]M[A, X]], s: Strategy, t: Traverse[[X]M[A, X]]): Promise[M[A, B]]

def parMap [B] (f: (B) ⇒ B)(implicit s: Strategy, t: Traverse[[X]M[A, X]]): Promise[M[A, B]]

def parZipWith [B, C] (bs: M[A, B])(f: (B, B) ⇒ C)(implicit z: Applicative[[X]M[A, X]], s: Strategy, t: Traverse[[X]M[A, X]]): Promise[M[A, C]]

def para [B] (b: B, f: (⇒ B, ⇒ M[A, B], B) ⇒ B)(implicit p: Paramorphism[[X]M[A, X]]): B

def product (implicit a: Arrow[M]): M[(A, A), (B, B)]

def put [W] (w: W)(implicit f: Functor[[X]M[A, X]]): WriterT[[X]M[A, X], W, B]

Puts the given write value into a writer transformer and associates with this M[A] value

def putWith [W] (w: (B) ⇒ W)(implicit f: Functor[[X]M[A, X]]): WriterT[[X]M[A, X], W, B]

Puts the write value that is produced by applying the given function into a writer transformer and associates with this M[A] value

def replicateM [N[_]] (n: Int)(implicit m: Monad[[X]M[A, X]], p: Pure[N], d: Monoid[N[B]]): M[A, N[B]]

def replicateM_ (n: Int)(implicit m: Monad[[X]M[A, X]]): M[A, Unit]

def second [C] (implicit a: Arrow[M]): M[(C, A), (C, B)]

def selectSplit (p: (B) ⇒ Boolean)(implicit r: Foldable[[X]M[A, X]]): List[List[B]]

Selects groups of elements that satisfy p and discards others.

def sequence [N[_], B] (implicit a: <:<[B, N[B]], t: Traverse[[X]M[A, X]], n: Applicative[N]): N[M[A, B]]

def splitWith (p: (B) ⇒ Boolean)(implicit r: Foldable[[X]M[A, X]]): List[List[B]]

Splits the elements into groups that alternatively satisfy and don't satisfy the predicate p.

def stream (implicit r: Foldable[[X]M[A, X]]): Stream[B]

def sum (implicit r: Foldable[[X]M[A, X]], m: Monoid[B]): B

def sumr (implicit r: Foldable[[X]M[A, X]], m: Monoid[B]): B

def synchronized [T0] (arg0: ⇒ T0): T0

def toString (): String

def traverse [F[_], B] (f: (B) ⇒ F[B])(implicit a: Applicative[F], t: Traverse[[X]M[A, X]]): F[M[A, B]]

def traverseDigits (implicit c: <:<[B, Char], t: Traverse[[X]M[A, X]]): Option[M[A, Digit]]

def traverse_ [F[_], B] (f: (B) ⇒ F[B])(implicit a: Applicative[F], t: Foldable[[X]M[A, X]]): F[Unit]

def wait (): Unit

def wait (arg0: Long, arg1: Int): Unit

def wait (arg0: Long): Unit

def xmap [B] (f: (B) ⇒ B)(g: (B) ⇒ B)(implicit xf: InvariantFunctor[[X]M[A, X]]): M[A, B]

def zipWithA [F[_], B, C] (b: M[A, B])(f: (B, B) ⇒ F[C])(implicit a: Applicative[[X]M[A, X]], t: Traverse[[X]M[A, X]], z: Applicative[F]): F[M[A, C]]

def |>| (f: (B) ⇒ Unit)(implicit e: Each[[X]M[A, X]]): Unit

def |@| [B] (b: M[A, B]): ApplicativeBuilder[[X]M[A, X], B, B]

Accumulates values MA[A] and MA[B], and returns an ApplicativeBuilder that can accumulate further such values.

def μ [B] (implicit m: <:<[B, M[A, B]], b: Bind[[X]M[A, X]]): M[A, B]

Alias for join

def ↦ [F[_], B] (f: (B) ⇒ F[B])(implicit a: Applicative[F], t: Traverse[[X]M[A, X]]): F[M[A, B]]

Alias for traverse

def ∀ (p: (B) ⇒ Boolean)(implicit r: Foldable[[X]M[A, X]]): Boolean

Alias for all

def ∃ (p: (B) ⇒ Boolean)(implicit r: Foldable[[X]M[A, X]]): Boolean

Alias for any

def ∈: (a: B)(implicit r: Foldable[[X]M[A, X]], eq: Equal[B]): Boolean

Right associative alias for element

def ∋ (a: B)(implicit r: Foldable[[X]M[A, X]], eq: Equal[B]): Boolean

Alias for element

def ∗ [B] (f: (B) ⇒ M[A, B])(implicit b: Bind[[X]M[A, X]]): M[A, B]

Alias for >>= and flatMap

def ∗| [B] (f: ⇒ M[A, B])(implicit b: Bind[[X]M[A, X]]): M[A, B]

Alias for >>=|

def ∘ [B] (f: (B) ⇒ B)(implicit t: Functor[[X]M[A, X]]): M[A, B]

Alias for map

def ∘∘ [N[_], B, C] (f: (B) ⇒ C)(implicit m: <:<[B, N[B]], f1: Functor[[X]M[A, X]], f2: Functor[N]): M[A, N[C]]

Alias for map2

def ⊛ [B] (b: M[A, B]): ApplicativeBuilder[[X]M[A, X], B, B]

Alias for |@|

def ⋘ [C] (k: M[C, A])(implicit c: Category[M]): M[C, B]

def ⋙ [C] (k: M[B, C])(implicit c: Category[M]): M[A, C]