trait
MAB
[M[_, _], A, B]
extends PimpedType[M[A, B]] with MA[[X]M[A, X], B]
Abstract Value Members
-
val
value
: M[A, B]
Concrete Value Members
-
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]
-
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]
-
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
bimap
[C, D]
(f: (A) ⇒ C, g: (B) ⇒ D)(implicit b: Bifunctor[M]): M[C, D]
-
-
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]
-
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
foldIndex
(n: Int)(implicit r: Foldable[[X]M[A, X]]): 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
index
(n: Int)(implicit i: Index[[X]M[A, X]]): Option[B]
-
def
index_!
(n: Int)(implicit i: Index[[X]M[A, X]]): 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]]
-
def
liftwWith
[F[_]]
(implicit f: Functor[[X]M[A, X]], p: Pure[F]): ~>[[α](B) ⇒ α, [α]WriterT[[X]M[A, X], F[α], B]]
-
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]
-
def
putWith
[W]
(w: (B) ⇒ W)(implicit f: Functor[[X]M[A, X]]): WriterT[[X]M[A, X], W, B]
-
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]]
-
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]]
-
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
traverseKleisli
[S, N[_], B]
(g: (B) ⇒ Kleisli[N, S, B])(implicit m: Monad[N], t: Foldable[[X]M[A, X]]): Kleisli[N, S, List[B]]
-
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]
-
def
μ
[B]
(implicit m: <:<[B, M[A, B]], b: Bind[[X]M[A, X]]): M[A, B]
-
def
↦
[F[_], B]
(f: (B) ⇒ F[B])(implicit a: Applicative[F], t: Traverse[[X]M[A, X]]): F[M[A, B]]
-
def
∀
(p: (B) ⇒ Boolean)(implicit r: Foldable[[X]M[A, X]]): Boolean
-
def
∃
(p: (B) ⇒ Boolean)(implicit r: Foldable[[X]M[A, X]]): Boolean
-
def
∈:
(a: B)(implicit r: Foldable[[X]M[A, X]], eq: Equal[B]): Boolean
-
def
∋
(a: B)(implicit r: Foldable[[X]M[A, X]], eq: Equal[B]): Boolean
-
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
∘
[B]
(f: (B) ⇒ B)(implicit t: Functor[[X]M[A, X]]): M[A, B]
-
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]]
-
def
⊛
[B]
(b: M[A, B]): ApplicativeBuilder[[X]M[A, X], B, B]
-
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]
Inherited from MA[[X]M[A, X], B]
Inherited from MASugar[[X]M[A, X], B]
Inherited from AnyRef
Inherited from Any