MA

val value : M[A]

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

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

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def == (arg0: AnyRef): Boolean

def == (arg0: Any): Boolean

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

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

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

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

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

Alias for >>=|

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

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

def asInstanceOf [T0] : T0

def asMA : MA[M, A]

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

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

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

def clone (): AnyRef

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

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

def comp [N[_], B] (implicit n: <:<[A, N[B]], f: Functor[M]): MA[[α]M[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[M]): A

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

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

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

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

def eq (arg0: AnyRef): Boolean

def equals (arg0: Any): Boolean

def finalize (): Unit

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def hashCode (): Int

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

def isInstanceOf [T0] : Boolean

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

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

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

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[M], p: Pure[F]): ~>[[α](A) ⇒ α, [α]WriterT[M, F[α], A]]

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[M]): List[A]

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

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

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

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

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

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

def ne (arg0: AnyRef): Boolean

def notify (): Unit

def notifyAll (): Unit

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

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

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

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

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

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

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

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[M], p: Pure[N], d: Monoid[N[A]]): M[N[A]]

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

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

Selects groups of elements that satisfy p and discards others.

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

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

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

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

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

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

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

def toString (): String

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

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

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

def wait (): Unit

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

def wait (arg0: Long): Unit

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

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

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

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

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

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

Alias for join

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

Alias for traverse

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

Alias for all

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

Alias for any

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

Right associative alias for element

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

Alias for element

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

Alias for >>= and flatMap

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

Alias for >>=|

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

Alias for map

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

Alias for map2

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

Alias for |@|