trait
MA
[M[_], A]
extends PimpedType[M[A]] with MASugar[M, A]
Abstract Value Members
-
val
value
: M[A]
Concrete Value Members
-
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]
-
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]
-
def
asStream
[B]
(f: (Stream[A]) ⇒ Stream[B])(implicit r: Foldable[M], m: Monoid[M[B]], p: Pure[M]): M[B]
-
-
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]
-
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
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]]
-
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
index
(n: Int)(implicit i: Index[M]): Option[A]
-
def
index_!
(n: Int)(implicit i: Index[M]): A
-
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]]
-
def
liftwWith
[F[_]]
(implicit f: Functor[M], p: Pure[F]): ~>[[α](A) ⇒ α, [α]WriterT[M, F[α], A]]
-
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]
-
def
putWith
[W]
(w: (A) ⇒ W)(implicit f: Functor[M]): WriterT[M, W, A]
-
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]]
-
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]]
-
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]
(implicit m: <:<[A, M[B]], b: Bind[M]): M[B]
-
def
↦
[F[_], B]
(f: (A) ⇒ F[B])(implicit a: Applicative[F], t: Traverse[M]): F[M[B]]
-
def
∀
(p: (A) ⇒ Boolean)(implicit r: Foldable[M]): Boolean
-
def
∃
(p: (A) ⇒ Boolean)(implicit r: Foldable[M]): Boolean
-
def
∈:
(a: A)(implicit r: Foldable[M], eq: Equal[A]): Boolean
-
def
∋
(a: A)(implicit r: Foldable[M], eq: Equal[A]): Boolean
-
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: (A) ⇒ B)(implicit t: Functor[M]): M[B]
-
def
∘∘
[N[_], B, C]
(f: (B) ⇒ C)(implicit m: <:<[A, N[B]], f1: Functor[M], f2: Functor[N]): M[N[C]]
-
Inherited from AnyRef
Inherited from Any