MA

abstract val value: M[A]

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final 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)]

final def ==(arg0: AnyRef): Boolean

final 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

final 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

final 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 foldIndex(n: Int)(implicit r: Foldable[M]): A

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]]

final def getClass(): 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 index(n: Int)(implicit i: Index[M]): Option[A]

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

final 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]): ~>[Scalaz.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]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final 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

final 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]

final def wait(): Unit

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

final 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 |@|