Type Members
-
-
-
trait
LiftV[F[_], A, B] extends Ops[(A) ⇒ B]
-
Value Members
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
-
final
def
==(arg0: Any): Boolean
-
implicit
def
ApplicativeIdV[A](v: ⇒ A): ApplicativeIdV[A]
-
implicit
def
MonadTransGFGA[F[_[_], _], G[_], A](gfga: G[F[G, A]]): MonadTransGFGA[F, G, A]
-
implicit
def
ToAlignOps[F[_], A](v: F[A])(implicit F0: Align[F]): AlignOps[F, A]
-
implicit
def
ToAlignOpsUnapply[FA](v: FA)(implicit F0: Unapply[Align, FA]): AlignOps[M, A]
-
implicit
def
ToAltOps[F[_], A](v: F[A])(implicit F0: Alt[F]): AltOps[F, A]
-
implicit
def
ToAltOpsUnapply[FA](v: FA)(implicit F0: Unapply[Alt, FA]): AltOps[M, A]
-
implicit
def
ToApplicativeOps[F[_], A](v: F[A])(implicit F0: Applicative[F]): ApplicativeOps[F, A]
-
implicit
def
ToApplicativeOpsUnapply[FA](v: FA)(implicit F0: Unapply[Applicative, FA]): ApplicativeOps[M, A]
-
implicit
def
ToApplicativePlusOps[F[_], A](v: F[A])(implicit F0: ApplicativePlus[F]): ApplicativePlusOps[F, A]
-
-
implicit
def
ToApplyOps[F[_], A](v: F[A])(implicit F0: Apply[F]): ApplyOps[F, A]
-
implicit
def
ToApplyOpsUnapply[FA](v: FA)(implicit F0: Unapply[Apply, FA]): ApplyOps[M, A]
-
implicit
def
ToArrowOps[F[_, _], A, B](v: F[A, B])(implicit F0: Arrow[F]): ArrowOps[F, A, B]
-
implicit
def
ToArrowOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Arrow, FA]): ArrowOps[M, A, B]
-
implicit
def
ToArrowVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Arrow[[β$0$, γ$1$]F[G, β$0$, γ$1$]]): ArrowOps[[β$2$, γ$3$]F[G, β$2$, γ$3$], A, B]
-
implicit
def
ToAssociativeOps[F[_, _], A, B](v: F[A, B])(implicit F0: Associative[F]): AssociativeOps[F, A, B]
-
implicit
def
ToAssociativeOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Associative, FA]): AssociativeOps[M, A, B]
-
implicit
def
ToAssociativeVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Associative[[β$0$, γ$1$]F[G, β$0$, γ$1$]]): AssociativeOps[[β$2$, γ$3$]F[G, β$2$, γ$3$], A, B]
-
implicit
def
ToBandOps[F](v: F)(implicit F0: Band[F]): BandOps[F]
-
implicit
def
ToBifoldableOps[F[_, _], A, B](v: F[A, B])(implicit F0: Bifoldable[F]): BifoldableOps[F, A, B]
-
implicit
def
ToBifoldableOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Bifoldable, FA]): BifoldableOps[M, A, B]
-
implicit
def
ToBifoldableVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Bifoldable[[β$0$, γ$1$]F[G, β$0$, γ$1$]]): BifoldableOps[[β$2$, γ$3$]F[G, β$2$, γ$3$], A, B]
-
implicit
def
ToBifunctorOps[F[_, _], A, B](v: F[A, B])(implicit F0: Bifunctor[F]): BifunctorOps[F, A, B]
-
implicit
def
ToBifunctorOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Bifunctor, FA]): BifunctorOps[M, A, B]
-
implicit
def
ToBifunctorVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Bifunctor[[β$0$, γ$1$]F[G, β$0$, γ$1$]]): BifunctorOps[[β$2$, γ$3$]F[G, β$2$, γ$3$], A, B]
-
implicit
def
ToBindOps[F[_], A](v: F[A])(implicit F0: Bind[F]): BindOps[F, A]
-
implicit
def
ToBindOpsUnapply[FA](v: FA)(implicit F0: Unapply[Bind, FA]): BindOps[M, A]
-
implicit
def
ToBitraverseOps[F[_, _], A, B](v: F[A, B])(implicit F0: Bitraverse[F]): BitraverseOps[F, A, B]
-
implicit
def
ToBitraverseOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Bitraverse, FA]): BitraverseOps[M, A, B]
-
implicit
def
ToBitraverseVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Bitraverse[[β$0$, γ$1$]F[G, β$0$, γ$1$]]): BitraverseOps[[β$2$, γ$3$]F[G, β$2$, γ$3$], A, B]
-
implicit
def
ToCatchableOps[F[_], A](v: F[A])(implicit F0: Catchable[F]): CatchableOps[F, A]
-
implicit
def
ToCatchableOpsUnapply[FA](v: FA)(implicit F0: Unapply[Catchable, FA]): CatchableOps[M, A]
-
implicit
def
ToCategoryOps[F[_, _], A, B](v: F[A, B])(implicit F0: Category[F]): CategoryOps[F, A, B]
-
implicit
def
ToCategoryOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Category, FA]): CategoryOps[M, A, B]
-
implicit
def
ToCategoryVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Category[[β$0$, γ$1$]F[G, β$0$, γ$1$]]): CategoryOps[[β$2$, γ$3$]F[G, β$2$, γ$3$], A, B]
-
implicit
def
ToChoiceOps[F[_, _], A, B](v: F[A, B])(implicit F0: Choice[F]): ChoiceOps[F, A, B]
-
implicit
def
ToChoiceOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Choice, FA]): ChoiceOps[M, A, B]
-
implicit
def
ToChoiceVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Choice[[β$0$, γ$1$]F[G, β$0$, γ$1$]]): ChoiceOps[[β$2$, γ$3$]F[G, β$2$, γ$3$], A, B]
-
implicit
def
ToComonadOps[F[_], A](v: F[A])(implicit F0: Comonad[F]): ComonadOps[F, A]
-
implicit
def
ToComonadOpsUnapply[FA](v: FA)(implicit F0: Unapply[Comonad, FA]): ComonadOps[M, A]
-
implicit
def
ToComposeOps[F[_, _], A, B](v: F[A, B])(implicit F0: Compose[F]): ComposeOps[F, A, B]
-
implicit
def
ToComposeOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Compose, FA]): ComposeOps[M, A, B]
-
implicit
def
ToComposeVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Compose[[β$0$, γ$1$]F[G, β$0$, γ$1$]]): ComposeOps[[β$2$, γ$3$]F[G, β$2$, γ$3$], A, B]
-
implicit
def
ToContravariantOps[F[_], A](v: F[A])(implicit F0: Contravariant[F]): ContravariantOps[F, A]
-
-
implicit
def
ToCozipOps[F[_], A](v: F[A])(implicit F0: Cozip[F]): CozipOps[F, A]
-
implicit
def
ToCozipOpsUnapply[FA](v: FA)(implicit F0: Unapply[Cozip, FA]): CozipOps[M, A]
-
implicit
def
ToEnumOps[F](v: F)(implicit F0: Enum[F]): EnumOps[F]
-
implicit
def
ToEqualOps[F](v: F)(implicit F0: Equal[F]): EqualOps[F]
-
implicit
def
ToFoldable1Ops[F[_], A](v: F[A])(implicit F0: Foldable1[F]): Foldable1Ops[F, A]
-
implicit
def
ToFoldable1OpsUnapply[FA](v: FA)(implicit F0: Unapply[Foldable1, FA]): Foldable1Ops[M, A]
-
implicit
def
ToFoldableOps[F[_], A](v: F[A])(implicit F0: Foldable[F]): FoldableOps[F, A]
-
implicit
def
ToFoldableOpsUnapply[FA](v: FA)(implicit F0: Unapply[Foldable, FA]): FoldableOps[M, A]
-
implicit
def
ToFunctorIdV[A](v: A): FunctorIdV[A]
-
implicit
def
ToFunctorOps[F[_], A](v: F[A])(implicit F0: Functor[F]): FunctorOps[F, A]
-
implicit
def
ToFunctorOpsUnapply[FA](v: FA)(implicit F0: Unapply[Functor, FA]): FunctorOps[M, A]
-
implicit
def
ToLiftV[F[_], A, B](v: (A) ⇒ B): LiftV[F, A, B]
-
implicit
def
ToMonadErrorIdOps[E](v: E): MonadErrorIdOps[E]
-
implicit
def
ToMonadErrorOps[F[_], S, A](v: F[A])(implicit F0: MonadError[F, S]): MonadErrorOps[F, S, A]
-
implicit
def
ToMonadListenOps[F[_], A, W](v: F[A])(implicit F0: MonadListen[F, W]): MonadListenOps[F, W, A]
-
implicit
def
ToMonadOps[F[_], A](v: F[A])(implicit F0: Monad[F]): MonadOps[F, A]
-
implicit
def
ToMonadOpsUnapply[FA](v: FA)(implicit F0: Unapply[Monad, FA]): MonadOps[M, A]
-
implicit
def
ToMonadPlusOps[F[_], A](v: F[A])(implicit F0: MonadPlus[F]): MonadPlusOps[F, A]
-
implicit
def
ToMonadPlusOpsUnapply[FA](v: FA)(implicit F0: Unapply[MonadPlus, FA]): MonadPlusOps[M, A]
-
implicit
def
ToMonadTellOps[F[_], S, A](v: F[A])(implicit F0: MonadTell[F, S]): MonadTellOps[F, S, A]
-
implicit
def
ToMonoidOps[F](v: F)(implicit F0: Monoid[F]): MonoidOps[F]
-
implicit
def
ToOptionalOps[F[_], A](v: F[A])(implicit F0: Optional[F]): OptionalOps[F, A]
-
implicit
def
ToOptionalOpsUnapply[FA](v: FA)(implicit F0: Unapply[Optional, FA]): OptionalOps[M, A]
-
implicit
def
ToOrderOps[F](v: F)(implicit F0: Order[F]): OrderOps[F]
-
implicit
def
ToPlusEmptyOps[F[_], A](v: F[A])(implicit F0: PlusEmpty[F]): PlusEmptyOps[F, A]
-
implicit
def
ToPlusEmptyOpsUnapply[FA](v: FA)(implicit F0: Unapply[PlusEmpty, FA]): PlusEmptyOps[M, A]
-
implicit
def
ToPlusOps[F[_], A](v: F[A])(implicit F0: Plus[F]): PlusOps[F, A]
-
implicit
def
ToPlusOpsUnapply[FA](v: FA)(implicit F0: Unapply[Plus, FA]): PlusOps[M, A]
-
implicit
def
ToProChoiceOps[F[_, _], A, B](v: F[A, B])(implicit F0: ProChoice[F]): ProChoiceOps[F, A, B]
-
implicit
def
ToProChoiceOpsUnapply[FA](v: FA)(implicit F0: Unapply2[ProChoice, FA]): ProChoiceOps[M, A, B]
-
implicit
def
ToProChoiceVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: ProChoice[[β$0$, γ$1$]F[G, β$0$, γ$1$]]): ProChoiceOps[[β$2$, γ$3$]F[G, β$2$, γ$3$], A, B]
-
implicit
def
ToProfunctorOps[F[_, _], A, B](v: F[A, B])(implicit F0: Profunctor[F]): ProfunctorOps[F, A, B]
-
implicit
def
ToProfunctorOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Profunctor, FA]): ProfunctorOps[M, A, B]
-
implicit
def
ToProfunctorVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Profunctor[[β$0$, γ$1$]F[G, β$0$, γ$1$]]): ProfunctorOps[[β$2$, γ$3$]F[G, β$2$, γ$3$], A, B]
-
implicit
def
ToSemigroupOps[F](v: F)(implicit F0: Semigroup[F]): SemigroupOps[F]
-
implicit
def
ToShowOps[F](v: F)(implicit F0: Show[F]): ShowOps[F]
-
implicit
def
ToSplitOps[F[_, _], A, B](v: F[A, B])(implicit F0: Split[F]): SplitOps[F, A, B]
-
implicit
def
ToSplitOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Split, FA]): SplitOps[M, A, B]
-
implicit
def
ToSplitVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Split[[β$0$, γ$1$]F[G, β$0$, γ$1$]]): SplitOps[[β$2$, γ$3$]F[G, β$2$, γ$3$], A, B]
-
implicit
def
ToStrongOps[F[_, _], A, B](v: F[A, B])(implicit F0: Strong[F]): StrongOps[F, A, B]
-
implicit
def
ToStrongOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Strong, FA]): StrongOps[M, A, B]
-
implicit
def
ToStrongVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Strong[[β$0$, γ$1$]F[G, β$0$, γ$1$]]): StrongOps[[β$2$, γ$3$]F[G, β$2$, γ$3$], A, B]
-
implicit
def
ToTraverse1Ops[F[_], A](v: F[A])(implicit F0: Traverse1[F]): Traverse1Ops[F, A]
-
implicit
def
ToTraverse1OpsUnapply[FA](v: FA)(implicit F0: Unapply[Traverse1, FA]): Traverse1Ops[M, A]
-
implicit
def
ToTraverseOps[F[_], A](v: F[A])(implicit F0: Traverse[F]): TraverseOps[F, A]
-
implicit
def
ToTraverseOpsUnapply[FA](v: FA)(implicit F0: Unapply[Traverse, FA]): TraverseOps[M, A]
-
implicit
def
ToUnzipOps[F[_], A](v: F[A])(implicit F0: Unzip[F]): UnzipOps[F, A]
-
implicit
def
ToUnzipOpsUnapply[FA](v: FA)(implicit F0: Unapply[Unzip, FA]): UnzipOps[M, A]
-
implicit
def
ToUnzipPairOps[F[_], A, B](v: F[(A, B)])(implicit F0: Unzip[F]): UnzipPairOps[F, A, B]
-
implicit
def
ToZipOps[F[_], A](v: F[A])(implicit F0: Zip[F]): ZipOps[F, A]
-
implicit
def
ToZipOpsUnapply[FA](v: FA)(implicit F0: Unapply[Zip, FA]): ZipOps[M, A]
-
def
^[F[_], A, B, C](fa: ⇒ F[A], fb: ⇒ F[B])(f: (A, B) ⇒ C)(implicit F: Apply[F]): F[C]
-
def
^^[F[_], A, B, C, D](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C])(f: (A, B, C) ⇒ D)(implicit F: Apply[F]): F[D]
-
def
^^^[F[_], A, B, C, D, E](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D])(f: (A, B, C, D) ⇒ E)(implicit F: Apply[F]): F[E]
-
def
^^^^[F[_], A, B, C, D, E, I](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E])(f: (A, B, C, D, E) ⇒ I)(implicit F: Apply[F]): F[I]
-
def
^^^^^[F[_], A, B, C, D, E, I, J](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], fi: ⇒ F[I])(f: (A, B, C, D, E, I) ⇒ J)(implicit F: Apply[F]): F[J]
-
def
^^^^^^[F[_], A, B, C, D, E, I, J, K](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], fi: ⇒ F[I], fj: ⇒ F[J])(f: (A, B, C, D, E, I, J) ⇒ K)(implicit F: Apply[F]): F[K]
-
final
def
asInstanceOf[T0]: T0
-
def
clone(): AnyRef
-
-
-
-
def
finalize(): Unit
-
final
def
getClass(): Class[_]
-
def
hashCode(): Int
-
final
def
isInstanceOf[T0]: Boolean
-
def
mempty[F[_], A](implicit F: PlusEmpty[F]): F[A]
-
def
mzero[F](implicit F: Monoid[F]): F
-
-
final
def
notify(): Unit
-
final
def
notifyAll(): Unit
-
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
-
def
toString(): String
-
final
def
wait(): Unit
-
final
def
wait(arg0: Long, arg1: Int): Unit
-
final
def
wait(arg0: Long): Unit
-
def
∅[F](implicit F: Monoid[F]): F
