sealed
trait
MAB[M[_, _], A, B] extends PimpedType[M[A, B]] with MA[[X]M[A, X], B]
Abstract Value Members
-
abstract
val
value: M[A, B]
Concrete Value Members
-
final
def
!=(arg0: AnyRef): Boolean
-
final
def
!=(arg0: Any): Boolean
-
final
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)]
-
final
def
==(arg0: AnyRef): Boolean
-
final
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
-
final
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
-
final
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]]
-
final
def
getClass(): 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
-
final
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]): ~>[Scalaz.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]
-
final
def
ne(arg0: AnyRef): Boolean
-
final
def
notify(): Unit
-
final
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
-
final
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]
-
final
def
wait(): Unit
-
final
def
wait(arg0: Long, arg1: Int): Unit
-
final
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