ToTypeClassOps

trait ToZipOps
trait ToZipOps0
trait ToBindOps
trait ToPlusOps
trait ToEnumOps
trait ToShowOps
class Object
trait Matchable
class Any
object Scalaz
object all

Type members

Inherited classlikes

Inherited from
ToApplicativeOps
trait FunctorIdV[A]
Inherited from
ToFunctorOps
trait LiftV[F[_], A, B]
Inherited from
ToFunctorOps
final
class UnzipPairOps[F[_], A, B]
Inherited from
ToUnzipOps

Value members

Inherited methods

def ^[F[_], A, B, C](fa: => F[A], fb: => F[B])(f: (A, B) => C)(implicit F: Apply[F]): F[C]
Inherited from
ToApplyOps
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]
Inherited from
ToApplyOps
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]
Inherited from
ToApplyOps
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]
Inherited from
ToApplyOps
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]
Inherited from
ToApplyOps
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]
Inherited from
ToApplyOps
def mempty[F[_], A](implicit F: PlusEmpty[F]): F[A]
Inherited from
ToPlusEmptyOps
def mzero[F](implicit F: Monoid[F]): F
Inherited from
ToMonoidOps
def ∅[F](implicit F: Monoid[F]): F
Inherited from
ToMonoidOps

Implicits

Inherited implicits

implicit
def ApplicativeIdV[A](v: => A): ApplicativeIdV[A]
Inherited from
ToApplicativeOps
implicit
def ToAlignOps[F[_], A](v: F[A])(implicit F0: Align[F]): AlignOps[F, A]
Inherited from
ToAlignOps
implicit
def ToAlignOpsUnapply[FA](v: FA)(implicit F0: Unapply[[F[_]] =>> Align[F], FA]): AlignOps[M, A]
Inherited from
ToAlignOps0
implicit
def ToApplicativeOps[F[_], A](v: F[A])(implicit F0: Applicative[F]): ApplicativeOps[F, A]
Inherited from
ToApplicativeOps
implicit
def ToApplicativeOpsUnapply[FA](v: FA)(implicit F0: Unapply[[F[_]] =>> Applicative[F], FA]): ApplicativeOps[M, A]
Inherited from
ToApplicativeOps0
implicit
def ToApplicativePlusOps[F[_], A](v: F[A])(implicit F0: ApplicativePlus[F]): ApplicativePlusOps[F, A]
Inherited from
ToApplicativePlusOps
implicit
def ToApplicativePlusOpsUnapply[FA](v: FA)(implicit F0: Unapply[[F[_]] =>> ApplicativePlus[F], FA]): ApplicativePlusOps[M, A]
Inherited from
ToApplicativePlusOps0
implicit
def ToApplyOps[F[_], A](v: F[A])(implicit F0: Apply[F]): ApplyOps[F, A]
Inherited from
ToApplyOps
implicit
def ToApplyOpsUnapply[FA](v: FA)(implicit F0: Unapply[[F[_]] =>> Apply[F], FA]): ApplyOps[M, A]
Inherited from
ToApplyOps0
implicit
def ToArrowOps[F[_, _], A, B](v: F[A, B])(implicit F0: Arrow[F]): ArrowOps[F, A, B]
Inherited from
ToArrowOps
implicit
def ToArrowOpsUnapply[FA](v: FA)(implicit F0: Unapply2[[=>:[_, _]] =>> Arrow[=>:], FA]): ArrowOps[M, A, B]
Inherited from
ToArrowOps0
implicit
def ToArrowVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Arrow[[_, _] =>> F[G, _$9, _$10]]): ArrowOps[[_, _] =>> F[G, _$11, _$12], A, B]
Inherited from
ToArrowOps
implicit
def ToAssociativeOps[F[_, _], A, B](v: F[A, B])(implicit F0: Associative[F]): AssociativeOps[F, A, B]
Inherited from
ToAssociativeOps
implicit
def ToAssociativeOpsUnapply[FA](v: FA)(implicit F0: Unapply2[[=>:[_, _]] =>> Associative[=>:], FA]): AssociativeOps[M, A, B]
Inherited from
ToAssociativeOps0
implicit
def ToAssociativeVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Associative[[_, _] =>> F[G, _$11, _$12]]): AssociativeOps[[_, _] =>> F[G, _$13, _$14], A, B]
Inherited from
ToAssociativeOps
implicit
def ToBifoldableOps[F[_, _], A, B](v: F[A, B])(implicit F0: Bifoldable[F]): BifoldableOps[F, A, B]
Inherited from
ToBifoldableOps
implicit
def ToBifoldableOpsUnapply[FA](v: FA)(implicit F0: Unapply2[[F[_, _]] =>> Bifoldable[F], FA]): BifoldableOps[M, A, B]
Inherited from
ToBifoldableOps0
implicit
def ToBifoldableVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Bifoldable[[_, _] =>> F[G, _$9, _$10]]): BifoldableOps[[_, _] =>> F[G, _$11, _$12], A, B]
Inherited from
ToBifoldableOps
implicit
def ToBifunctorOps[F[_, _], A, B](v: F[A, B])(implicit F0: Bifunctor[F]): BifunctorOps[F, A, B]
Inherited from
ToBifunctorOps
implicit
def ToBifunctorOpsUnapply[FA](v: FA)(implicit F0: Unapply2[[F[_, _]] =>> Bifunctor[F], FA]): BifunctorOps[M, A, B]
Inherited from
ToBifunctorOps0
implicit
def ToBifunctorVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Bifunctor[[_, _] =>> F[G, _$11, _$12]]): BifunctorOps[[_, _] =>> F[G, _$13, _$14], A, B]
Inherited from
ToBifunctorOps
implicit
def ToBindOps[F[_], A](v: F[A])(implicit F0: Bind[F]): BindOps[F, A]
Inherited from
ToBindOps
implicit
def ToBindOpsUnapply[FA](v: FA)(implicit F0: Unapply[[F[_]] =>> Bind[F], FA]): BindOps[M, A]
Inherited from
ToBindOps0
implicit
def ToBitraverseOps[F[_, _], A, B](v: F[A, B])(implicit F0: Bitraverse[F]): BitraverseOps[F, A, B]
Inherited from
ToBitraverseOps
implicit
def ToBitraverseOpsUnapply[FA](v: FA)(implicit F0: Unapply2[[F[_, _]] =>> Bitraverse[F], FA]): BitraverseOps[M, A, B]
Inherited from
ToBitraverseOps0
implicit
def ToBitraverseVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Bitraverse[[_, _] =>> F[G, _$11, _$12]]): BitraverseOps[[_, _] =>> F[G, _$13, _$14], A, B]
Inherited from
ToBitraverseOps
implicit
def ToCatchableOps[F[_], A](v: F[A])(implicit F0: Catchable[F]): CatchableOps[F, A]
Inherited from
ToCatchableOps
implicit
def ToCatchableOpsUnapply[FA](v: FA)(implicit F0: Unapply[[F[_]] =>> Catchable[F], FA]): CatchableOps[M, A]
Inherited from
ToCatchableOps0
implicit
def ToCategoryOps[F[_, _], A, B](v: F[A, B])(implicit F0: Category[F]): CategoryOps[F, A, B]
Inherited from
ToCategoryOps
implicit
def ToCategoryOpsUnapply[FA](v: FA)(implicit F0: Unapply2[[=>:[_, _]] =>> Category[=>:], FA]): CategoryOps[M, A, B]
Inherited from
ToCategoryOps0
implicit
def ToCategoryVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Category[[_, _] =>> F[G, _$9, _$10]]): CategoryOps[[_, _] =>> F[G, _$11, _$12], A, B]
Inherited from
ToCategoryOps
implicit
def ToChoiceOps[F[_, _], A, B](v: F[A, B])(implicit F0: Choice[F]): ChoiceOps[F, A, B]
Inherited from
ToChoiceOps
implicit
def ToChoiceOpsUnapply[FA](v: FA)(implicit F0: Unapply2[[=>:[_, _]] =>> Choice[=>:], FA]): ChoiceOps[M, A, B]
Inherited from
ToChoiceOps0
implicit
def ToChoiceVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Choice[[_, _] =>> F[G, _$9, _$10]]): ChoiceOps[[_, _] =>> F[G, _$11, _$12], A, B]
Inherited from
ToChoiceOps
implicit
def ToCobindOps[F[_], A](v: F[A])(implicit F0: Cobind[F]): CobindOps[F, A]
Inherited from
ToCobindOps
implicit
def ToCobindOpsUnapply[FA](v: FA)(implicit F0: Unapply[[F[_]] =>> Cobind[F], FA]): CobindOps[M, A]
Inherited from
ToCobindOps0
implicit
def ToComonadOps[F[_], A](v: F[A])(implicit F0: Comonad[F]): ComonadOps[F, A]
Inherited from
ToComonadOps
implicit
def ToComonadOpsUnapply[FA](v: FA)(implicit F0: Unapply[[F[_]] =>> Comonad[F], FA]): ComonadOps[M, A]
Inherited from
ToComonadOps0
implicit
def ToComposeOps[F[_, _], A, B](v: F[A, B])(implicit F0: Compose[F]): ComposeOps[F, A, B]
Inherited from
ToComposeOps
implicit
def ToComposeOpsUnapply[FA](v: FA)(implicit F0: Unapply2[[=>:[_, _]] =>> Compose[=>:], FA]): ComposeOps[M, A, B]
Inherited from
ToComposeOps0
implicit
def ToComposeVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Compose[[_, _] =>> F[G, _$9, _$10]]): ComposeOps[[_, _] =>> F[G, _$11, _$12], A, B]
Inherited from
ToComposeOps
implicit
def ToContravariantOps[F[_], A](v: F[A])(implicit F0: Contravariant[F]): ContravariantOps[F, A]
Inherited from
ToContravariantOps
implicit
def ToContravariantOpsUnapply[FA](v: FA)(implicit F0: Unapply[[F[_]] =>> Contravariant[F], FA]): ContravariantOps[M, A]
Inherited from
ToContravariantOps0
implicit
def ToCozipOps[F[_], A](v: F[A])(implicit F0: Cozip[F]): CozipOps[F, A]
Inherited from
ToCozipOps
implicit
def ToCozipOpsUnapply[FA](v: FA)(implicit F0: Unapply[[F[_]] =>> Cozip[F], FA]): CozipOps[M, A]
Inherited from
ToCozipOps0
implicit
def ToEnumOps[F](v: F)(implicit F0: Enum[F]): EnumOps[F]
Inherited from
ToEnumOps
implicit
def ToEqualOps[F](v: F)(implicit F0: Equal[F]): EqualOps[F]
Inherited from
ToEqualOps
implicit
def ToFoldable1Ops[F[_], A](v: F[A])(implicit F0: Foldable1[F]): Foldable1Ops[F, A]
Inherited from
ToFoldable1Ops
implicit
def ToFoldable1OpsUnapply[FA](v: FA)(implicit F0: Unapply[[F[_]] =>> Foldable1[F], FA]): Foldable1Ops[M, A]
Inherited from
ToFoldable1Ops0
implicit
def ToFoldableOps[F[_], A](v: F[A])(implicit F0: Foldable[F]): FoldableOps[F, A]
Inherited from
ToFoldableOps
implicit
def ToFoldableOpsUnapply[FA](v: FA)(implicit F0: Unapply[[F[_]] =>> Foldable[F], FA]): FoldableOps[M, A]
Inherited from
ToFoldableOps0
implicit
def ToFunctorIdV[A](v: A): FunctorIdV[A]
Inherited from
ToFunctorOps
implicit
def ToFunctorOps[F[_], A](v: F[A])(implicit F0: Functor[F]): FunctorOps[F, A]
Inherited from
ToFunctorOps
implicit
def ToFunctorOpsUnapply[FA](v: FA)(implicit F0: Unapply[[F[_]] =>> Functor[F], FA]): FunctorOps[M, A]
Inherited from
ToFunctorOps0
implicit
def ToInvariantFunctorOps[F[_], A](v: F[A])(implicit F0: InvariantFunctor[F]): InvariantFunctorOps[F, A]
Inherited from
ToInvariantFunctorOps
implicit
def ToInvariantFunctorOpsUnapply[FA](v: FA)(implicit F0: Unapply[[F[_]] =>> InvariantFunctor[F], FA]): InvariantFunctorOps[M, A]
implicit
def ToLiftV[F[_], A, B](v: A => B): LiftV[F, A, B]
Inherited from
ToFunctorOps
implicit
Inherited from
ToMonadErrorOps
implicit
def ToMonadErrorOps[F[_], S, A](v: F[A])(implicit F0: MonadError[F, S]): MonadErrorOps[F, S, A]
Inherited from
ToMonadErrorOps
implicit
def ToMonadListenOps[F[_], A, W](v: F[A])(implicit F0: MonadListen[F, W]): MonadListenOps[F, W, A]
Inherited from
ToMonadListenOps
implicit
def ToMonadOps[F[_], A](v: F[A])(implicit F0: Monad[F]): MonadOps[F, A]
Inherited from
ToMonadOps
implicit
def ToMonadOpsUnapply[FA](v: FA)(implicit F0: Unapply[[F[_]] =>> Monad[F], FA]): MonadOps[M, A]
Inherited from
ToMonadOps0
implicit
def ToMonadPlusOps[F[_], A](v: F[A])(implicit F0: MonadPlus[F]): MonadPlusOps[F, A]
Inherited from
ToMonadPlusOps
implicit
def ToMonadPlusOpsUnapply[FA](v: FA)(implicit F0: Unapply[[F[_]] =>> MonadPlus[F], FA]): MonadPlusOps[M, A]
Inherited from
ToMonadPlusOps0
implicit
def ToMonadTellOps[F[_], S, A](v: F[A])(implicit F0: MonadTell[F, S]): MonadTellOps[F, S, A]
Inherited from
ToMonadTellOps
implicit
def ToMonoidOps[F](v: F)(implicit F0: Monoid[F]): MonoidOps[F]
Inherited from
ToMonoidOps
implicit
def ToOptionalOps[F[_], A](v: F[A])(implicit F0: Optional[F]): OptionalOps[F, A]
Inherited from
ToOptionalOps
implicit
def ToOptionalOpsUnapply[FA](v: FA)(implicit F0: Unapply[[F[_]] =>> Optional[F], FA]): OptionalOps[M, A]
Inherited from
ToOptionalOps0
implicit
def ToOrderOps[F](v: F)(implicit F0: Order[F]): OrderOps[F]
Inherited from
ToOrderOps
implicit
def ToPlusEmptyOps[F[_], A](v: F[A])(implicit F0: PlusEmpty[F]): PlusEmptyOps[F, A]
Inherited from
ToPlusEmptyOps
implicit
def ToPlusEmptyOpsUnapply[FA](v: FA)(implicit F0: Unapply[[F[_]] =>> PlusEmpty[F], FA]): PlusEmptyOps[M, A]
Inherited from
ToPlusEmptyOps0
implicit
def ToPlusOps[F[_], A](v: F[A])(implicit F0: Plus[F]): PlusOps[F, A]
Inherited from
ToPlusOps
implicit
def ToPlusOpsUnapply[FA](v: FA)(implicit F0: Unapply[[F[_]] =>> Plus[F], FA]): PlusOps[M, A]
Inherited from
ToPlusOps0
implicit
def ToProfunctorOps[F[_, _], A, B](v: F[A, B])(implicit F0: Profunctor[F]): ProfunctorOps[F, A, B]
Inherited from
ToProfunctorOps
implicit
def ToProfunctorOpsUnapply[FA](v: FA)(implicit F0: Unapply2[[=>:[_, _]] =>> Profunctor[=>:], FA]): ProfunctorOps[M, A, B]
Inherited from
ToProfunctorOps0
implicit
def ToProfunctorVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Profunctor[[_, _] =>> F[G, _$9, _$10]]): ProfunctorOps[[_, _] =>> F[G, _$11, _$12], A, B]
Inherited from
ToProfunctorOps
implicit
def ToSemigroupOps[F](v: F)(implicit F0: Semigroup[F]): SemigroupOps[F]
Inherited from
ToSemigroupOps
implicit
def ToShowOps[F](v: F)(implicit F0: Show[F]): ShowOps[F]
Inherited from
ToShowOps
implicit
def ToSplitOps[F[_, _], A, B](v: F[A, B])(implicit F0: Split[F]): SplitOps[F, A, B]
Inherited from
ToSplitOps
implicit
def ToSplitOpsUnapply[FA](v: FA)(implicit F0: Unapply2[[=>:[_, _]] =>> Split[=>:], FA]): SplitOps[M, A, B]
Inherited from
ToSplitOps0
implicit
def ToSplitVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Split[[_, _] =>> F[G, _$9, _$10]]): SplitOps[[_, _] =>> F[G, _$11, _$12], A, B]
Inherited from
ToSplitOps
implicit
def ToStrongOps[F[_, _], A, B](v: F[A, B])(implicit F0: Strong[F]): StrongOps[F, A, B]
Inherited from
ToStrongOps
implicit
def ToStrongOpsUnapply[FA](v: FA)(implicit F0: Unapply2[[=>:[_, _]] =>> Strong[=>:], FA]): StrongOps[M, A, B]
Inherited from
ToStrongOps0
implicit
def ToStrongVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Strong[[_, _] =>> F[G, _$9, _$10]]): StrongOps[[_, _] =>> F[G, _$11, _$12], A, B]
Inherited from
ToStrongOps
implicit
def ToTraverse1Ops[F[_], A](v: F[A])(implicit F0: Traverse1[F]): Traverse1Ops[F, A]
Inherited from
ToTraverse1Ops
implicit
def ToTraverse1OpsUnapply[FA](v: FA)(implicit F0: Unapply[[F[_]] =>> Traverse1[F], FA]): Traverse1Ops[M, A]
Inherited from
ToTraverse1Ops0
implicit
def ToTraverseOps[F[_], A](v: F[A])(implicit F0: Traverse[F]): TraverseOps[F, A]
Inherited from
ToTraverseOps
implicit
def ToTraverseOpsUnapply[FA](v: FA)(implicit F0: Unapply[[F[_]] =>> Traverse[F], FA]): TraverseOps[M, A]
Inherited from
ToTraverseOps0
implicit
def ToUnzipOps[F[_], A](v: F[A])(implicit F0: Unzip[F]): UnzipOps[F, A]
Inherited from
ToUnzipOps
implicit
def ToUnzipOpsUnapply[FA](v: FA)(implicit F0: Unapply[[F[_]] =>> Unzip[F], FA]): UnzipOps[M, A]
Inherited from
ToUnzipOps0
implicit
def ToUnzipPairOps[F[_], A, B](v: F[(A, B)])(implicit F0: Unzip[F]): UnzipPairOps[F, A, B]
Inherited from
ToUnzipOps
implicit
def ToZipOps[F[_], A](v: F[A])(implicit F0: Zip[F]): ZipOps[F, A]
Inherited from
ToZipOps
implicit
def ToZipOpsUnapply[FA](v: FA)(implicit F0: Unapply[[F[_]] =>> Zip[F], FA]): ZipOps[M, A]
Inherited from
ToZipOps0