trait
SemigroupApply extends Apply[[α]F]
Type Members
-
trait
ApplyLaw extends FunctorLaw
-
trait
FunctorLaw extends InvariantFunctorLaw
-
Value Members
-
final
def
!=(arg0: AnyRef): Boolean
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
-
final
def
==(arg0: AnyRef): Boolean
-
final
def
==(arg0: Any): Boolean
-
def
ap[A, B](fa: ⇒ F)(f: ⇒ F): F
-
def
ap2[A, B, C](fa: ⇒ F, fb: ⇒ F)(f: F): F
-
def
ap3[A, B, C, D](fa: ⇒ F, fb: ⇒ F, fc: ⇒ F)(f: F): F
-
def
ap4[A, B, C, D, E](fa: ⇒ F, fb: ⇒ F, fc: ⇒ F, fd: ⇒ F)(f: F): F
-
def
ap5[A, B, C, D, E, R](fa: ⇒ F, fb: ⇒ F, fc: ⇒ F, fd: ⇒ F, fe: ⇒ F)(f: F): F
-
def
ap6[A, B, C, D, E, FF, R](fa: ⇒ F, fb: ⇒ F, fc: ⇒ F, fd: ⇒ F, fe: ⇒ F, ff: ⇒ F)(f: F): F
-
def
ap7[A, B, C, D, E, FF, G, R](fa: ⇒ F, fb: ⇒ F, fc: ⇒ F, fd: ⇒ F, fe: ⇒ F, ff: ⇒ F, fg: ⇒ F)(f: F): F
-
def
ap8[A, B, C, D, E, FF, G, H, R](fa: ⇒ F, fb: ⇒ F, fc: ⇒ F, fd: ⇒ F, fe: ⇒ F, ff: ⇒ F, fg: ⇒ F, fh: ⇒ F)(f: F): F
-
def
apF[A, B](f: ⇒ F): (F) ⇒ F
-
def
apply[A, B](fa: F)(f: (A) ⇒ B): F
-
def
apply10[A, B, C, D, E, FF, G, H, I, J, R](fa: ⇒ F, fb: ⇒ F, fc: ⇒ F, fd: ⇒ F, fe: ⇒ F, ff: ⇒ F, fg: ⇒ F, fh: ⇒ F, fi: ⇒ F, fj: ⇒ F)(f: (A, B, C, D, E, FF, G, H, I, J) ⇒ R): F
-
def
apply11[A, B, C, D, E, FF, G, H, I, J, K, R](fa: ⇒ F, fb: ⇒ F, fc: ⇒ F, fd: ⇒ F, fe: ⇒ F, ff: ⇒ F, fg: ⇒ F, fh: ⇒ F, fi: ⇒ F, fj: ⇒ F, fk: ⇒ F)(f: (A, B, C, D, E, FF, G, H, I, J, K) ⇒ R): F
-
def
apply12[A, B, C, D, E, FF, G, H, I, J, K, L, R](fa: ⇒ F, fb: ⇒ F, fc: ⇒ F, fd: ⇒ F, fe: ⇒ F, ff: ⇒ F, fg: ⇒ F, fh: ⇒ F, fi: ⇒ F, fj: ⇒ F, fk: ⇒ F, fl: ⇒ F)(f: (A, B, C, D, E, FF, G, H, I, J, K, L) ⇒ R): F
-
def
apply2[A, B, C](fa: ⇒ F, fb: ⇒ F)(f: (A, B) ⇒ C): F
-
def
apply3[A, B, C, D](fa: ⇒ F, fb: ⇒ F, fc: ⇒ F)(f: (A, B, C) ⇒ D): F
-
def
apply4[A, B, C, D, E](fa: ⇒ F, fb: ⇒ F, fc: ⇒ F, fd: ⇒ F)(f: (A, B, C, D) ⇒ E): F
-
def
apply5[A, B, C, D, E, R](fa: ⇒ F, fb: ⇒ F, fc: ⇒ F, fd: ⇒ F, fe: ⇒ F)(f: (A, B, C, D, E) ⇒ R): F
-
def
apply6[A, B, C, D, E, FF, R](fa: ⇒ F, fb: ⇒ F, fc: ⇒ F, fd: ⇒ F, fe: ⇒ F, ff: ⇒ F)(f: (A, B, C, D, E, FF) ⇒ R): F
-
def
apply7[A, B, C, D, E, FF, G, R](fa: ⇒ F, fb: ⇒ F, fc: ⇒ F, fd: ⇒ F, fe: ⇒ F, ff: ⇒ F, fg: ⇒ F)(f: (A, B, C, D, E, FF, G) ⇒ R): F
-
def
apply8[A, B, C, D, E, FF, G, H, R](fa: ⇒ F, fb: ⇒ F, fc: ⇒ F, fd: ⇒ F, fe: ⇒ F, ff: ⇒ F, fg: ⇒ F, fh: ⇒ F)(f: (A, B, C, D, E, FF, G, H) ⇒ R): F
-
def
apply9[A, B, C, D, E, FF, G, H, I, R](fa: ⇒ F, fb: ⇒ F, fc: ⇒ F, fd: ⇒ F, fe: ⇒ F, ff: ⇒ F, fg: ⇒ F, fh: ⇒ F, fi: ⇒ F)(f: (A, B, C, D, E, FF, G, H, I) ⇒ R): F
-
def
applyApplicative: Applicative[[α]\/[F, α]]
-
-
val
applySyntax: ApplySyntax[[α]F]
-
final
def
asInstanceOf[T0]: T0
-
def
bicompose[G[_, _]](implicit arg0: Bifunctor[G]): Bifunctor[[α, β]F]
-
def
clone(): AnyRef
-
def
compose[G[_]](implicit G0: Apply[G]): Apply[[α]F]
-
def
compose[G[_]](implicit G0: Functor[G]): Functor[[α]F]
-
def
counzip[A, B](a: \/[F, F]): F
-
final
def
eq(arg0: AnyRef): Boolean
-
def
equals(arg0: Any): Boolean
-
def
finalize(): Unit
-
def
fpair[A](fa: F): F
-
def
fproduct[A, B](fa: F)(f: (A) ⇒ B): F
-
-
-
final
def
getClass(): java.lang.Class[_]
-
def
hashCode(): Int
-
-
-
-
final
def
isInstanceOf[T0]: Boolean
-
def
lift[A, B](f: (A) ⇒ B): (F) ⇒ F
-
def
lift10[A, B, C, D, E, FF, G, H, I, J, R](f: (A, B, C, D, E, FF, G, H, I, J) ⇒ R): (F, F, F, F, F, F, F, F, F, F) ⇒ F
-
def
lift11[A, B, C, D, E, FF, G, H, I, J, K, R](f: (A, B, C, D, E, FF, G, H, I, J, K) ⇒ R): (F, F, F, F, F, F, F, F, F, F, F) ⇒ F
-
def
lift12[A, B, C, D, E, FF, G, H, I, J, K, L, R](f: (A, B, C, D, E, FF, G, H, I, J, K, L) ⇒ R): (F, F, F, F, F, F, F, F, F, F, F, F) ⇒ F
-
def
lift2[A, B, C](f: (A, B) ⇒ C): (F, F) ⇒ F
-
def
lift3[A, B, C, D](f: (A, B, C) ⇒ D): (F, F, F) ⇒ F
-
def
lift4[A, B, C, D, E](f: (A, B, C, D) ⇒ E): (F, F, F, F) ⇒ F
-
def
lift5[A, B, C, D, E, R](f: (A, B, C, D, E) ⇒ R): (F, F, F, F, F) ⇒ F
-
def
lift6[A, B, C, D, E, FF, R](f: (A, B, C, D, E, FF) ⇒ R): (F, F, F, F, F, F) ⇒ F
-
def
lift7[A, B, C, D, E, FF, G, R](f: (A, B, C, D, E, FF, G) ⇒ R): (F, F, F, F, F, F, F) ⇒ F
-
def
lift8[A, B, C, D, E, FF, G, H, R](f: (A, B, C, D, E, FF, G, H) ⇒ R): (F, F, F, F, F, F, F, F) ⇒ F
-
def
lift9[A, B, C, D, E, FF, G, H, I, R](f: (A, B, C, D, E, FF, G, H, I) ⇒ R): (F, F, F, F, F, F, F, F, F) ⇒ F
-
def
map[A, B](fa: F)(f: (A) ⇒ B): F
-
def
mapply[A, B](a: A)(f: F): F
-
final
def
ne(arg0: AnyRef): Boolean
-
final
def
notify(): Unit
-
final
def
notifyAll(): Unit
-
def
product[G[_]](implicit G0: Apply[G]): Apply[[α](F, G[α])]
-
def
product[G[_]](implicit G0: Functor[G]): Functor[[α](F, G[α])]
-
def
sequence1[A, G[_]](as: G[F])(implicit arg0: Traverse1[G]): F
-
def
strengthL[A, B](a: A, f: F): F
-
def
strengthR[A, B](f: F, b: B): F
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
-
def
toString(): String
-
def
traverse1[A, G[_], B](value: G[A])(f: (A) ⇒ F)(implicit G: Traverse1[G]): F
-
def
tuple2[A, B](fa: ⇒ F, fb: ⇒ F): F
-
def
tuple3[A, B, C](fa: ⇒ F, fb: ⇒ F, fc: ⇒ F): F
-
def
tuple4[A, B, C, D](fa: ⇒ F, fb: ⇒ F, fc: ⇒ F, fd: ⇒ F): F
-
def
tuple5[A, B, C, D, E](fa: ⇒ F, fb: ⇒ F, fc: ⇒ F, fd: ⇒ F, fe: ⇒ F): F
-
def
void[A](fa: F): F
-
final
def
wait(): Unit
-
final
def
wait(arg0: Long, arg1: Int): Unit
-
final
def
wait(arg0: Long): Unit
-
def
xmap[A, B](fa: F, f: (A) ⇒ B, g: (B) ⇒ A): F
-
def
xmapb[A, B](ma: F)(b: Bijection[A, B]): F
-
def
xmapi[A, B](ma: F)(iso: <=>[A, B]): F
Deprecated Value Members
-
def
zip: Zip[[α]F]
Inherited from Apply[[α]F]
Inherited from AnyRef
Inherited from Any