Scalaz

object Scalaz extends StateFunctions with ToTypeClassOps with ToDataOps with AllInstances with AllFunctions with ToAllStdOps with IdInstances

Source: Scalaz.scala

Linear Supertypes

IdInstances, ToAllStdOps, ToTryOps, ToEitherOps, ToMapOps, ToTupleOps, ToStringOps, ToFunction1Ops, ToFunction2Ops, ToVectorOps, ToStreamOps, ToListOps, ToOptionIdOps, ToOptionOps, ToBooleanOps, AllFunctions, FunctionFunctions, StringFunctions, OrderingFunctions, BooleanFunctions, StreamFunctions, OptionFunctions, ListFunctions, AllInstances, CallableInstances, EnumInstances, BigIntegerInstances, std.java.util.MapInstances, std.math.OrderingInstances, BigInts, BigDecimalInstances, TypeConstraintInstances, PartialFunctionInstances, EitherInstances, EitherInstances0, FutureInstances, FutureInstances1, VectorInstances, VectorInstances0, TupleInstances, TupleInstances2, TupleInstances1, TupleInstances0, StreamInstances, StringInstances, SetInstances, OptionInstances, OptionInstances0, std.MapInstances, MapFunctions, std.MapInstances0, ListInstances, ListInstances0, FunctionInstances, FunctionInstances0, FunctionInstances1, AnyValInstances, ToDataOps, ToMaybeOps, ToTheseOps, ToNelOps, ToEitherOps, ToKleisliOps, ToKleisliOps0, ToValidationOps, ToStateOps, ToWriterOps, ToReducerOps, ToTreeOps, ToIdOps, ToTypeClassOps, ToAlignOps, ToAlignOps0, ToCatchableOps, ToCatchableOps0, ToOptionalOps, ToOptionalOps0, ToTraverse1Ops, ToTraverse1Ops0, ToFoldable1Ops, ToFoldable1Ops0, ToMonadErrorOps, ToMonadListenOps, ToMonadTellOps, ToUnzipOps, ToUnzipOps0, ToZipOps, ToZipOps0, ToChoiceOps, ToChoiceOps0, ToArrowOps, ToStrongOps, ToProfunctorOps, ToProfunctorOps0, ToStrongOps0, ToSplitOps, ToSplitOps0, ToArrowOps0, ToCategoryOps, ToCategoryOps0, ToComposeOps, ToComposeOps0, ToBitraverseOps, ToBitraverseOps0, ToAssociativeOps, ToAssociativeOps0, ToBifunctorOps, ToBifunctorOps0, ToTraverseOps, ToFoldableOps, ToFoldableOps0, ToTraverseOps0, ToMonadPlusOps, ToMonadPlusOps0, ToApplicativePlusOps, ToApplicativePlusOps0, ToCozipOps, ToCozipOps0, ToBifoldableOps, ToBifoldableOps0, ToComonadOps, ToCobindOps, ToCobindOps0, ToComonadOps0, ToMonadOps, ToMonadOps0, ToBindOps, ToBindOps0, ToApplicativeOps, ToApplicativeOps0, ToApplyOps, ToApplyOps0, ToContravariantOps, ToContravariantOps0, ToFunctorOps, ToInvariantFunctorOps, ToInvariantFunctorOps0, ToFunctorOps0, ToPlusEmptyOps, ToPlusOps, ToPlusOps0, ToPlusEmptyOps0, ToEnumOps, ToOrderOps, ToShowOps, ToEqualOps, ToMonoidOps, ToSemigroupOps, StateFunctions, IndexedStateFunctions, AnyRef, Any

Ordering

Alphabetic
By Inheritance

Inherited

Scalaz
IdInstances
ToAllStdOps
ToTryOps
ToEitherOps
ToMapOps
ToTupleOps
ToStringOps
ToFunction1Ops
ToFunction2Ops
ToVectorOps
ToStreamOps
ToListOps
ToOptionIdOps
ToOptionOps
ToBooleanOps
AllFunctions
FunctionFunctions
StringFunctions
OrderingFunctions
BooleanFunctions
StreamFunctions
OptionFunctions
ListFunctions
AllInstances
CallableInstances
EnumInstances
BigIntegerInstances
MapInstances
OrderingInstances
BigInts
BigDecimalInstances
TypeConstraintInstances
PartialFunctionInstances
EitherInstances
EitherInstances0
FutureInstances
FutureInstances1
VectorInstances
VectorInstances0
TupleInstances
TupleInstances2
TupleInstances1
TupleInstances0
StreamInstances
StringInstances
SetInstances
OptionInstances
OptionInstances0
MapInstances
MapFunctions
MapInstances0
ListInstances
ListInstances0
FunctionInstances
FunctionInstances0
FunctionInstances1
AnyValInstances
ToDataOps
ToMaybeOps
ToTheseOps
ToNelOps
ToEitherOps
ToKleisliOps
ToKleisliOps0
ToValidationOps
ToStateOps
ToWriterOps
ToReducerOps
ToTreeOps
ToIdOps
ToTypeClassOps
ToAlignOps
ToAlignOps0
ToCatchableOps
ToCatchableOps0
ToOptionalOps
ToOptionalOps0
ToTraverse1Ops
ToTraverse1Ops0
ToFoldable1Ops
ToFoldable1Ops0
ToMonadErrorOps
ToMonadListenOps
ToMonadTellOps
ToUnzipOps
ToUnzipOps0
ToZipOps
ToZipOps0
ToChoiceOps
ToChoiceOps0
ToArrowOps
ToStrongOps
ToProfunctorOps
ToProfunctorOps0
ToStrongOps0
ToSplitOps
ToSplitOps0
ToArrowOps0
ToCategoryOps
ToCategoryOps0
ToComposeOps
ToComposeOps0
ToBitraverseOps
ToBitraverseOps0
ToAssociativeOps
ToAssociativeOps0
ToBifunctorOps
ToBifunctorOps0
ToTraverseOps
ToFoldableOps
ToFoldableOps0
ToTraverseOps0
ToMonadPlusOps
ToMonadPlusOps0
ToApplicativePlusOps
ToApplicativePlusOps0
ToCozipOps
ToCozipOps0
ToBifoldableOps
ToBifoldableOps0
ToComonadOps
ToCobindOps
ToCobindOps0
ToComonadOps0
ToMonadOps
ToMonadOps0
ToBindOps
ToBindOps0
ToApplicativeOps
ToApplicativeOps0
ToApplyOps
ToApplyOps0
ToContravariantOps
ToContravariantOps0
ToFunctorOps
ToInvariantFunctorOps
ToInvariantFunctorOps0
ToFunctorOps0
ToPlusEmptyOps
ToPlusOps
ToPlusOps0
ToPlusEmptyOps0
ToEnumOps
ToOrderOps
ToShowOps
ToEqualOps
ToMonoidOps
ToSemigroupOps
StateFunctions
IndexedStateFunctions
AnyRef
Any

Hide All
Show All

Visibility

Public
All

Type Members

type Id[X] = X
The strict identity type constructor.
The strict identity type constructor. Can be thought of as Tuple1, but with no runtime representation.
Definition Classes
IdInstances
type Identity[+X] = Need[X]
Definition Classes
IdInstances
trait ApplicativeIdV[A] extends Ops[A]
Definition Classes
ToApplicativeOps
trait FunctorIdV[A] extends Ops[A]
Definition Classes
ToFunctorOps
trait LiftV[F[_], A, B] extends Ops[(A) ⇒ B]
Definition Classes
ToFunctorOps
final class UnzipPairOps[F[_], A, B] extends AnyRef
Definition Classes
ToUnzipOps

Value Members

final def !=(arg0: Any): Boolean
Definition Classes
AnyRef → Any
final def ##(): Int
Definition Classes
AnyRef → Any
val <:<: Category[<:<]
Definition Classes
TypeConstraintInstances
final def <^>[A, B](as: List[A])(f: (NonEmptyList[A]) ⇒ B)(implicit arg0: Monoid[B]): B
Returns f applied to the contents of as if non-empty, otherwise, the zero element of the Monoid for the type B.
Returns f applied to the contents of as if non-empty, otherwise, the zero element of the Monoid for the type B.
Definition Classes
ListFunctions
val =:=: Category[=:=]
Definition Classes
TypeConstraintInstances
final def ==(arg0: Any): Boolean
Definition Classes
AnyRef → Any
implicit def ApplicativeIdV[A](v: ⇒ A): ApplicativeIdV[A]
Definition Classes
ToApplicativeOps
implicit val BigDecimalMultiplicationNewType: Monoid[@@[BigDecimal, Multiplication]]
Definition Classes
BigDecimalInstances
def FirstLeftProjectionEIso2[E]: Isomorphism.<~>[[α]AnyRef { ... /* 2 definitions in type refinement */ }, [β$10$]Either[E, β$10$]]
scala.Either.LeftProjection is isomorphic to scala.Either, when the type parameter E is partially applied.
scala.Either.LeftProjection is isomorphic to scala.Either, when the type parameter E is partially applied.
Definition Classes
EitherInstances
val FirstLeftProjectionIso2: Isomorphism.<~~>[[α, β]AnyRef { ... /* 2 definitions in type refinement */ }, Either]
scala.Either.LeftProjection is isomorphic to scala.Either
scala.Either.LeftProjection is isomorphic to scala.Either
Definition Classes
EitherInstances
def FirstRightProjectionAIso2[A]: Isomorphism.<~>[[α]AnyRef { ... /* 2 definitions in type refinement */ }, [α$14$]Either[α$14$, A]]
scala.Either.RightProjection is isomorphic to scala.Either, when the type parameter A is partially applied.
scala.Either.RightProjection is isomorphic to scala.Either, when the type parameter A is partially applied.
Definition Classes
EitherInstances
val FirstRightProjectionIso2: Isomorphism.<~~>[[α, β]AnyRef { ... /* 2 definitions in type refinement */ }, Either]
scala.Either.RightProjection is isomorphic to scala.Either
scala.Either.RightProjection is isomorphic to scala.Either
Definition Classes
EitherInstances
def LastLeftProjectionEIso2[E]: Isomorphism.<~>[[α]AnyRef { ... /* 2 definitions in type refinement */ }, [β$11$]Either[E, β$11$]]
scala.Either.LeftProjection is isomorphic to scala.Either, when the type parameter E is partially applied.
scala.Either.LeftProjection is isomorphic to scala.Either, when the type parameter E is partially applied.
Definition Classes
EitherInstances
val LastLeftProjectionIso2: Isomorphism.<~~>[[α, β]AnyRef { ... /* 2 definitions in type refinement */ }, Either]
scala.Either.LeftProjection is isomorphic to scala.Either
scala.Either.LeftProjection is isomorphic to scala.Either
Definition Classes
EitherInstances
def LastRightProjectionAIso2[A]: Isomorphism.<~>[[α]AnyRef { ... /* 2 definitions in type refinement */ }, [α$15$]Either[α$15$, A]]
scala.Either.RightProjection is isomorphic to scala.Either, when the type parameter A is partially applied.
scala.Either.RightProjection is isomorphic to scala.Either, when the type parameter A is partially applied.
Definition Classes
EitherInstances
val LastRightProjectionIso2: Isomorphism.<~~>[[α, β]AnyRef { ... /* 2 definitions in type refinement */ }, Either]
scala.Either.RightProjection is isomorphic to scala.Either
scala.Either.RightProjection is isomorphic to scala.Either
Definition Classes
EitherInstances
def LeftProjectionEIso2[E]: Isomorphism.<~>[[β$8$]LeftProjection[E, β$8$], [β$9$]Either[E, β$9$]]
scala.Either.LeftProjection is isomorphic to scala.Either, when the type parameter E is partially applied.
scala.Either.LeftProjection is isomorphic to scala.Either, when the type parameter E is partially applied.
Definition Classes
EitherInstances
val LeftProjectionIso2: Isomorphism.<~~>[LeftProjection, Either]
scala.Either.LeftProjection is isomorphic to scala.Either
scala.Either.LeftProjection is isomorphic to scala.Either
Definition Classes
EitherInstances
def RightProjectionAIso2[A]: Isomorphism.<~>[[α$12$]RightProjection[α$12$, A], [α$13$]Either[α$13$, A]]
scala.Either.RightProjection is isomorphic to scala.Either, when the type parameter A is partially applied.
scala.Either.RightProjection is isomorphic to scala.Either, when the type parameter A is partially applied.
Definition Classes
EitherInstances
val RightProjectionIso2: Isomorphism.<~~>[RightProjection, Either]
scala.Either.RightProjection is isomorphic to scala.Either
scala.Either.RightProjection is isomorphic to scala.Either
Definition Classes
EitherInstances
implicit def ToAlignOps[F[_], A](v: F[A])(implicit F0: Align[F]): AlignOps[F, A]
Definition Classes
ToAlignOps
implicit def ToAlignOpsUnapply[FA](v: FA)(implicit F0: Unapply[Align, FA]): AlignOps[M, A]
Definition Classes
ToAlignOps0
implicit def ToApplicativeOps[F[_], A](v: F[A])(implicit F0: Applicative[F]): ApplicativeOps[F, A]
Definition Classes
ToApplicativeOps
implicit def ToApplicativeOpsUnapply[FA](v: FA)(implicit F0: Unapply[Applicative, FA]): ApplicativeOps[M, A]
Definition Classes
ToApplicativeOps0
implicit def ToApplicativePlusOps[F[_], A](v: F[A])(implicit F0: ApplicativePlus[F]): ApplicativePlusOps[F, A]
Definition Classes
ToApplicativePlusOps
implicit def ToApplicativePlusOpsUnapply[FA](v: FA)(implicit F0: Unapply[ApplicativePlus, FA]): ApplicativePlusOps[M, A]
Definition Classes
ToApplicativePlusOps0
implicit def ToApplyOps[F[_], A](v: F[A])(implicit F0: Apply[F]): ApplyOps[F, A]
Definition Classes
ToApplyOps
implicit def ToApplyOpsUnapply[FA](v: FA)(implicit F0: Unapply[Apply, FA]): ApplyOps[M, A]
Definition Classes
ToApplyOps0
implicit def ToArrowOps[F[_, _], A, B](v: F[A, B])(implicit F0: Arrow[F]): ArrowOps[F, A, B]
Definition Classes
ToArrowOps
implicit def ToArrowOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Arrow, FA]): ArrowOps[M, A, B]
Definition Classes
ToArrowOps0
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]
Definition Classes
ToArrowOps
implicit def ToAssociativeOps[F[_, _], A, B](v: F[A, B])(implicit F0: Associative[F]): AssociativeOps[F, A, B]
Definition Classes
ToAssociativeOps
implicit def ToAssociativeOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Associative, FA]): AssociativeOps[M, A, B]
Definition Classes
ToAssociativeOps0
implicit def ToAssociativeVFromKleisliLike[G[_], F[G[_], _, _], A, B](v: F[G, A, B])(implicit F0: Associative[[β$2$, γ$3$]F[G, β$2$, γ$3$]]): AssociativeOps[[β$4$, γ$5$]F[G, β$4$, γ$5$], A, B]
Definition Classes
ToAssociativeOps
implicit def ToBifoldableOps[F[_, _], A, B](v: F[A, B])(implicit F0: Bifoldable[F]): BifoldableOps[F, A, B]
Definition Classes
ToBifoldableOps
implicit def ToBifoldableOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Bifoldable, FA]): BifoldableOps[M, A, B]
Definition Classes
ToBifoldableOps0
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]
Definition Classes
ToBifoldableOps
implicit def ToBifunctorOps[F[_, _], A, B](v: F[A, B])(implicit F0: Bifunctor[F]): BifunctorOps[F, A, B]
Definition Classes
ToBifunctorOps
implicit def ToBifunctorOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Bifunctor, FA]): BifunctorOps[M, A, B]
Definition Classes
ToBifunctorOps0
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]
Definition Classes
ToBifunctorOps
implicit def ToBindOps[F[_], A](v: F[A])(implicit F0: Bind[F]): BindOps[F, A]
Definition Classes
ToBindOps
implicit def ToBindOpsUnapply[FA](v: FA)(implicit F0: Unapply[Bind, FA]): BindOps[M, A]
Definition Classes
ToBindOps0
implicit def ToBitraverseOps[F[_, _], A, B](v: F[A, B])(implicit F0: Bitraverse[F]): BitraverseOps[F, A, B]
Definition Classes
ToBitraverseOps
implicit def ToBitraverseOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Bitraverse, FA]): BitraverseOps[M, A, B]
Definition Classes
ToBitraverseOps0
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]
Definition Classes
ToBitraverseOps
implicit def ToBooleanOpsFromBoolean(a: Boolean): BooleanOps
Definition Classes
ToBooleanOps
implicit def ToCatchableOps[F[_], A](v: F[A])(implicit F0: Catchable[F]): CatchableOps[F, A]
Definition Classes
ToCatchableOps
implicit def ToCatchableOpsUnapply[FA](v: FA)(implicit F0: Unapply[Catchable, FA]): CatchableOps[M, A]
Definition Classes
ToCatchableOps0
implicit def ToCategoryOps[F[_, _], A, B](v: F[A, B])(implicit F0: Category[F]): CategoryOps[F, A, B]
Definition Classes
ToCategoryOps
implicit def ToCategoryOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Category, FA]): CategoryOps[M, A, B]
Definition Classes
ToCategoryOps0
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]
Definition Classes
ToCategoryOps
implicit def ToChoiceOps[F[_, _], A, B](v: F[A, B])(implicit F0: Choice[F]): ChoiceOps[F, A, B]
Definition Classes
ToChoiceOps
implicit def ToChoiceOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Choice, FA]): ChoiceOps[M, A, B]
Definition Classes
ToChoiceOps0
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]
Definition Classes
ToChoiceOps
implicit def ToCobindOps[F[_], A](v: F[A])(implicit F0: Cobind[F]): CobindOps[F, A]
Definition Classes
ToCobindOps
implicit def ToCobindOpsUnapply[FA](v: FA)(implicit F0: Unapply[Cobind, FA]): CobindOps[M, A]
Definition Classes
ToCobindOps0
implicit def ToComonadOps[F[_], A](v: F[A])(implicit F0: Comonad[F]): ComonadOps[F, A]
Definition Classes
ToComonadOps
implicit def ToComonadOpsUnapply[FA](v: FA)(implicit F0: Unapply[Comonad, FA]): ComonadOps[M, A]
Definition Classes
ToComonadOps0
implicit def ToComposeOps[F[_, _], A, B](v: F[A, B])(implicit F0: Compose[F]): ComposeOps[F, A, B]
Definition Classes
ToComposeOps
implicit def ToComposeOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Compose, FA]): ComposeOps[M, A, B]
Definition Classes
ToComposeOps0
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]
Definition Classes
ToComposeOps
implicit def ToContravariantOps[F[_], A](v: F[A])(implicit F0: Contravariant[F]): ContravariantOps[F, A]
Definition Classes
ToContravariantOps
implicit def ToContravariantOpsUnapply[FA](v: FA)(implicit F0: Unapply[Contravariant, FA]): ContravariantOps[M, A]
Definition Classes
ToContravariantOps0
implicit def ToCozipOps[F[_], A](v: F[A])(implicit F0: Cozip[F]): CozipOps[F, A]
Definition Classes
ToCozipOps
implicit def ToCozipOpsUnapply[FA](v: FA)(implicit F0: Unapply[Cozip, FA]): CozipOps[M, A]
Definition Classes
ToCozipOps0
implicit def ToEitherOps[A](a: A): EitherOps[A]
Definition Classes
ToEitherOps
implicit def ToEitherOpsFromEither[A, B](e: Either[A, B]): EitherOps[A, B]
Definition Classes
ToEitherOps
implicit def ToEnumOps[F](v: F)(implicit F0: Enum[F]): EnumOps[F]
Definition Classes
ToEnumOps
implicit def ToEqualOps[F](v: F)(implicit F0: Equal[F]): EqualOps[F]
Definition Classes
ToEqualOps
implicit def ToFoldable1Ops[F[_], A](v: F[A])(implicit F0: Foldable1[F]): Foldable1Ops[F, A]
Definition Classes
ToFoldable1Ops
implicit def ToFoldable1OpsUnapply[FA](v: FA)(implicit F0: Unapply[Foldable1, FA]): Foldable1Ops[M, A]
Definition Classes
ToFoldable1Ops0
implicit def ToFoldableOps[F[_], A](v: F[A])(implicit F0: Foldable[F]): FoldableOps[F, A]
Definition Classes
ToFoldableOps
implicit def ToFoldableOpsUnapply[FA](v: FA)(implicit F0: Unapply[Foldable, FA]): FoldableOps[M, A]
Definition Classes
ToFoldableOps0
implicit def ToFunction1OpsFromBoolean[A, B](f: (A) ⇒ B): Function1Ops[A, B]
Definition Classes
ToFunction1Ops
implicit def ToFunction2Ops[T1, T2, R](f: (T1, T2) ⇒ R): Function2Ops[T1, T2, R]
Definition Classes
ToFunction2Ops
implicit def ToFunctorIdV[A](v: A): FunctorIdV[A]
Definition Classes
ToFunctorOps
implicit def ToFunctorOps[F[_], A](v: F[A])(implicit F0: Functor[F]): FunctorOps[F, A]
Definition Classes
ToFunctorOps
implicit def ToFunctorOpsUnapply[FA](v: FA)(implicit F0: Unapply[Functor, FA]): FunctorOps[M, A]
Definition Classes
ToFunctorOps0
implicit def ToIdOps[A](a: A): IdOps[A]
Definition Classes
ToIdOps
implicit def ToInvariantFunctorOps[F[_], A](v: F[A])(implicit F0: InvariantFunctor[F]): InvariantFunctorOps[F, A]
Definition Classes
ToInvariantFunctorOps
implicit def ToInvariantFunctorOpsUnapply[FA](v: FA)(implicit F0: Unapply[InvariantFunctor, FA]): InvariantFunctorOps[M, A]
Definition Classes
ToInvariantFunctorOps0
implicit def ToKleisliFAOps[F[_], A](fa: F[A]): KleisliFAOps[F, A]
Definition Classes
ToKleisliOps
implicit def ToKleisliIdOps[A](a: A): KleisliIdOps[A]
Definition Classes
ToKleisliOps
implicit def ToKleisliOpsUnapply[FA](v: FA)(implicit F0: Unapply[Monad, FA]): KleisliFAOps[M, A]
Definition Classes
ToKleisliOps0
implicit def ToLiftV[F[_], A, B](v: (A) ⇒ B): LiftV[F, A, B]
Definition Classes
ToFunctorOps
implicit def ToListOpsFromList[A](a: List[A]): ListOps[A]
Definition Classes
ToListOps
implicit def ToMapOpsFromMap[K, V](m: Map[K, V]): MapOps[K, V]
Definition Classes
ToMapOps
implicit def ToMaybeOps[A](a: A): MaybeOps[A]
Definition Classes
ToMaybeOps
implicit def ToMonadErrorIdOps[E](v: E): MonadErrorIdOps[E]
Definition Classes
ToMonadErrorOps
implicit def ToMonadErrorOps[F[_], S, A](v: F[A])(implicit F0: MonadError[F, S]): MonadErrorOps[F, S, A]
Definition Classes
ToMonadErrorOps
implicit def ToMonadListenOps[F[_], A, W](v: F[A])(implicit F0: MonadListen[F, W]): MonadListenOps[F, W, A]
Definition Classes
ToMonadListenOps
implicit def ToMonadOps[F[_], A](v: F[A])(implicit F0: Monad[F]): MonadOps[F, A]
Definition Classes
ToMonadOps
implicit def ToMonadOpsUnapply[FA](v: FA)(implicit F0: Unapply[Monad, FA]): MonadOps[M, A]
Definition Classes
ToMonadOps0
implicit def ToMonadPlusOps[F[_], A](v: F[A])(implicit F0: MonadPlus[F]): MonadPlusOps[F, A]
Definition Classes
ToMonadPlusOps
implicit def ToMonadPlusOpsUnapply[FA](v: FA)(implicit F0: Unapply[MonadPlus, FA]): MonadPlusOps[M, A]
Definition Classes
ToMonadPlusOps0
implicit def ToMonadTellOps[F[_], S, A](v: F[A])(implicit F0: MonadTell[F, S]): MonadTellOps[F, S, A]
Definition Classes
ToMonadTellOps
implicit def ToMonoidOps[F](v: F)(implicit F0: Monoid[F]): MonoidOps[F]
Definition Classes
ToMonoidOps
implicit def ToNelOps[A](a: A): NelOps[A]
Definition Classes
ToNelOps
implicit def ToOptionIdOps[A](a: A): OptionIdOps[A]
Definition Classes
ToOptionIdOps
implicit def ToOptionOpsFromOption[A](a: Option[A]): OptionOps[A]
Definition Classes
ToOptionOps
implicit def ToOptionalOps[F[_], A](v: F[A])(implicit F0: Optional[F]): OptionalOps[F, A]
Definition Classes
ToOptionalOps
implicit def ToOptionalOpsUnapply[FA](v: FA)(implicit F0: Unapply[Optional, FA]): OptionalOps[M, A]
Definition Classes
ToOptionalOps0
implicit def ToOrderOps[F](v: F)(implicit F0: Order[F]): OrderOps[F]
Definition Classes
ToOrderOps
implicit def ToPlusEmptyOps[F[_], A](v: F[A])(implicit F0: PlusEmpty[F]): PlusEmptyOps[F, A]
Definition Classes
ToPlusEmptyOps
implicit def ToPlusEmptyOpsUnapply[FA](v: FA)(implicit F0: Unapply[PlusEmpty, FA]): PlusEmptyOps[M, A]
Definition Classes
ToPlusEmptyOps0
implicit def ToPlusOps[F[_], A](v: F[A])(implicit F0: Plus[F]): PlusOps[F, A]
Definition Classes
ToPlusOps
implicit def ToPlusOpsUnapply[FA](v: FA)(implicit F0: Unapply[Plus, FA]): PlusOps[M, A]
Definition Classes
ToPlusOps0
implicit def ToProfunctorOps[F[_, _], A, B](v: F[A, B])(implicit F0: Profunctor[F]): ProfunctorOps[F, A, B]
Definition Classes
ToProfunctorOps
implicit def ToProfunctorOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Profunctor, FA]): ProfunctorOps[M, A, B]
Definition Classes
ToProfunctorOps0
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]
Definition Classes
ToProfunctorOps
implicit def ToReducerOps[A](a: A): ReducerOps[A]
Definition Classes
ToReducerOps
final def ToScalazOrderFromOrdering[A](oa: scala.math.Ordering[A]): Order[A]
Definition Classes
OrderingFunctions
implicit def ToSemigroupOps[F](v: F)(implicit F0: Semigroup[F]): SemigroupOps[F]
Definition Classes
ToSemigroupOps
implicit def ToShowOps[F](v: F)(implicit F0: Show[F]): ShowOps[F]
Definition Classes
ToShowOps
implicit def ToSplitOps[F[_, _], A, B](v: F[A, B])(implicit F0: Split[F]): SplitOps[F, A, B]
Definition Classes
ToSplitOps
implicit def ToSplitOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Split, FA]): SplitOps[M, A, B]
Definition Classes
ToSplitOps0
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]
Definition Classes
ToSplitOps
implicit def ToStateOps[A](a: A): StateOps[A]
Definition Classes
ToStateOps
implicit def ToStreamOpsFromStream[A](a: Stream[A]): StreamOps[A]
Definition Classes
ToStreamOps
implicit def ToStringOpsFromString(a: String): StringOps
Definition Classes
ToStringOps
implicit def ToStrongOps[F[_, _], A, B](v: F[A, B])(implicit F0: Strong[F]): StrongOps[F, A, B]
Definition Classes
ToStrongOps
implicit def ToStrongOpsUnapply[FA](v: FA)(implicit F0: Unapply2[Strong, FA]): StrongOps[M, A, B]
Definition Classes
ToStrongOps0
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]
Definition Classes
ToStrongOps
implicit def ToTheseOps[A](a: A): TheseOps[A]
Definition Classes
ToTheseOps
implicit def ToThesePairOps[A, B](a: (A, B)): ThesePairOps[A, B]
Definition Classes
ToTheseOps
implicit def ToTraverse1Ops[F[_], A](v: F[A])(implicit F0: Traverse1[F]): Traverse1Ops[F, A]
Definition Classes
ToTraverse1Ops
implicit def ToTraverse1OpsUnapply[FA](v: FA)(implicit F0: Unapply[Traverse1, FA]): Traverse1Ops[M, A]
Definition Classes
ToTraverse1Ops0
implicit def ToTraverseOps[F[_], A](v: F[A])(implicit F0: Traverse[F]): TraverseOps[F, A]
Definition Classes
ToTraverseOps
implicit def ToTraverseOpsUnapply[FA](v: FA)(implicit F0: Unapply[Traverse, FA]): TraverseOps[M, A]
Definition Classes
ToTraverseOps0
implicit def ToTreeOps[A](a: A): TreeOps[A]
Definition Classes
ToTreeOps
implicit def ToTryOpsFromTry[A](a: Try[A]): TryOps[A]
Definition Classes
ToTryOps
implicit def ToTuple10Ops[A, B, C, D, E, F, G, H, I, J](t: (A, B, C, D, E, F, G, H, I, J)): Tuple10Ops[A, B, C, D, E, F, G, H, I, J]
Definition Classes
ToTupleOps
implicit def ToTuple11Ops[A, B, C, D, E, F, G, H, I, J, K](t: (A, B, C, D, E, F, G, H, I, J, K)): Tuple11Ops[A, B, C, D, E, F, G, H, I, J, K]
Definition Classes
ToTupleOps
implicit def ToTuple12Ops[A, B, C, D, E, F, G, H, I, J, K, L](t: (A, B, C, D, E, F, G, H, I, J, K, L)): Tuple12Ops[A, B, C, D, E, F, G, H, I, J, K, L]
Definition Classes
ToTupleOps
implicit def ToTuple2Ops[A, B](t: (A, B)): Tuple2Ops[A, B]
Definition Classes
ToTupleOps
implicit def ToTuple3Ops[A, B, C](t: (A, B, C)): Tuple3Ops[A, B, C]
Definition Classes
ToTupleOps
implicit def ToTuple4Ops[A, B, C, D](t: (A, B, C, D)): Tuple4Ops[A, B, C, D]
Definition Classes
ToTupleOps
implicit def ToTuple5Ops[A, B, C, D, E](t: (A, B, C, D, E)): Tuple5Ops[A, B, C, D, E]
Definition Classes
ToTupleOps
implicit def ToTuple6Ops[A, B, C, D, E, F](t: (A, B, C, D, E, F)): Tuple6Ops[A, B, C, D, E, F]
Definition Classes
ToTupleOps
implicit def ToTuple7Ops[A, B, C, D, E, F, G](t: (A, B, C, D, E, F, G)): Tuple7Ops[A, B, C, D, E, F, G]
Definition Classes
ToTupleOps
implicit def ToTuple8Ops[A, B, C, D, E, F, G, H](t: (A, B, C, D, E, F, G, H)): Tuple8Ops[A, B, C, D, E, F, G, H]
Definition Classes
ToTupleOps
implicit def ToTuple9Ops[A, B, C, D, E, F, G, H, I](t: (A, B, C, D, E, F, G, H, I)): Tuple9Ops[A, B, C, D, E, F, G, H, I]
Definition Classes
ToTupleOps
implicit def ToUnzipOps[F[_], A](v: F[A])(implicit F0: Unzip[F]): UnzipOps[F, A]
Definition Classes
ToUnzipOps
implicit def ToUnzipOpsUnapply[FA](v: FA)(implicit F0: Unapply[Unzip, FA]): UnzipOps[M, A]
Definition Classes
ToUnzipOps0
implicit def ToUnzipPairOps[F[_], A, B](v: F[(A, B)])(implicit F0: Unzip[F]): UnzipPairOps[F, A, B]
Definition Classes
ToUnzipOps
implicit def ToValidationOps[A](a: A): ValidationOps[A]
Definition Classes
ToValidationOps
implicit def ToVectorOpsFromVector[A](a: Vector[A]): VectorOps[A]
Definition Classes
ToVectorOps
implicit def ToWriterOps[A](a: A): WriterOps[A]
Definition Classes
ToWriterOps
implicit def ToZipOps[F[_], A](v: F[A])(implicit F0: Zip[F]): ZipOps[F, A]
Definition Classes
ToZipOps
implicit def ToZipOpsUnapply[FA](v: FA)(implicit F0: Unapply[Zip, FA]): ZipOps[M, A]
Definition Classes
ToZipOps0
def ^[F[_], A, B, C](fa: ⇒ F[A], fb: ⇒ F[B])(f: (A, B) ⇒ C)(implicit F: Apply[F]): F[C]
Definition Classes
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]
Definition Classes
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]
Definition Classes
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]
Definition Classes
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]
Definition Classes
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]
Definition Classes
ToApplyOps
final def adjacentPairs[A](as: List[A]): List[(A, A)]
[(as(0), as(1)), (as(1), as(2)), ... (as(size-2), as(size-1))]
[(as(0), as(1)), (as(1), as(2)), ... (as(size-2), as(size-1))]
Definition Classes
ListFunctions
final def allPairs[A](as: List[A]): List[(A, A)]
Combinations of as and as, excluding same-element pairs.
Combinations of as and as, excluding same-element pairs.
Definition Classes
ListFunctions
final def alter[K, A](m: Map[K, A], k: K)(f: (Option[A]) ⇒ Option[A]): Map[K, A]
Vary the value of m get k.
Vary the value of m get k.
Definition Classes
MapFunctions
final def asInstanceOf[T0]: T0
Definition Classes
Any
implicit val bigDecimalInstance: Monoid[BigDecimal] with Enum[BigDecimal] with Show[BigDecimal]
Definition Classes
BigDecimalInstances
implicit val bigIntInstance: Monoid[BigInt] with Enum[BigInt] with Show[BigInt]
Definition Classes
BigInts
implicit val bigIntMultiplication: Monoid[@@[BigInt, Multiplication]] with Order[@@[BigInt, Multiplication]] with Show[@@[BigInt, Multiplication]]
Definition Classes
BigInts
implicit val bigIntegerInstance: Monoid[BigInteger] with Enum[BigInteger] with Show[BigInteger]
Definition Classes
BigIntegerInstances
implicit val bigIntegerMultiplication: Monoid[@@[BigInteger, Multiplication]] with Order[@@[BigInteger, Multiplication]] with Show[@@[BigInteger, Multiplication]]
Definition Classes
BigIntegerInstances
implicit val booleanConjunctionNewTypeInstance: Monoid[@@[Boolean, Conjunction]] with Enum[@@[Boolean, Conjunction]] with Band[@@[Boolean, Conjunction]]
Definition Classes
AnyValInstances
implicit val booleanDisjunctionNewTypeInstance: Monoid[@@[Boolean, Tags.Disjunction]] with Enum[@@[Boolean, Tags.Disjunction]] with Band[@@[Boolean, Tags.Disjunction]]
Definition Classes
AnyValInstances
final def breakM[A, M[_]](as: List[A])(p: (A) ⇒ M[Boolean])(implicit arg0: Monad[M]): M[(List[A], List[A])]
spanM with p's complement.
spanM with p's complement.
Definition Classes
ListFunctions
implicit val byteInstance: Monoid[Byte] with Enum[Byte] with Show[Byte]
Definition Classes
AnyValInstances
implicit val byteMultiplicationNewType: Monoid[@@[Byte, Multiplication]] with Enum[@@[Byte, Multiplication]]
Definition Classes
AnyValInstances
implicit val callableMonad: Monad[Callable]
Definition Classes
CallableInstances
implicit def callableOrder[A](implicit arg0: Order[A]): Order[Callable[A]]
Definition Classes
CallableInstances
final def cata[A, X](oa: Option[A])(some: (A) ⇒ X, none: ⇒ X): X
Catamorphism over the option.
Catamorphism over the option. Returns the provided function some applied to item contained in the Option if it is defined, otherwise, the provided value none.
Definition Classes
OptionFunctions
implicit val char: Monoid[Char] with Enum[Char] with Show[Char]
Definition Classes
AnyValInstances
implicit val charMultiplicationNewType: Monoid[@@[Char, Multiplication]] with Enum[@@[Char, Multiplication]]
Definition Classes
AnyValInstances
def charsNel(s: String, e: ⇒ NonEmptyList[Char]): NonEmptyList[Char]
Constructs a non-empty list with the given string if it is not empty, otherwise, returns the second argument.
Constructs a non-empty list with the given string if it is not empty, otherwise, returns the second argument.
Definition Classes
StringFunctions
def charsNel(s: String): Option[NonEmptyList[Char]]
Constructs a non-empty list with the value if it is not empty, otherwise, throws an error.
Constructs a non-empty list with the value if it is not empty, otherwise, throws an error.
Definition Classes
StringFunctions
def clone(): AnyRef
Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@native() @throws(classOf[java.lang.CloneNotSupportedException])
final def conditional(p: Boolean, q: ⇒ Boolean): Boolean
Conditional.
Conditional.
```
p q  p --> q
0 0  1
0 1  1
1 0  0
1 1  1
```
Definition Classes
BooleanFunctions
final def conjunction(p: Boolean, q: ⇒ Boolean): Boolean
Conjunction.
Conjunction. (AND)
```
p q  p ∧ q
0 0  0
0 1  0
1 0  0
1 1  1
```
Definition Classes
BooleanFunctions
def constantIndexedState[S1, S2, A](a: A, s: ⇒ S2): IndexedState[S1, S2, A]
Definition Classes
IndexedStateFunctions
def constantState[S, A](a: A, s: ⇒ S): State[S, A]
Definition Classes
StateFunctions
final def disjunction(p: Boolean, q: ⇒ Boolean): Boolean
Disjunction.
Disjunction. (OR)
```
p q  p ∨ q
0 0  0
0 1  1
1 0  1
1 1  1
```
Definition Classes
BooleanFunctions
implicit val doubleInstance: Order[Double] with Show[Double]
Definition Classes
AnyValInstances
implicit def eitherAssociative: Associative[Either]
Definition Classes
EitherInstances
implicit def eitherEqual[A, B](implicit A0: Equal[A], B0: Equal[B]): Equal[Either[A, B]]
Definition Classes
EitherInstances0
implicit def eitherFirstLeftEqual[A, X](implicit A0: Equal[A]): Equal[@@[LeftProjection[A, X], First]]
Definition Classes
EitherInstances0
val eitherFirstLeftInstance: IsomorphismBifunctor[[α, β]AnyRef { ... /* 2 definitions in type refinement */ }, Either]
Definition Classes
EitherInstances
implicit def eitherFirstLeftMonoid[A, X](implicit MonoidX: Monoid[X]): Monoid[@@[LeftProjection[A, X], First]]
Definition Classes
EitherInstances
implicit def eitherFirstLeftOrder[A, X](implicit OrderA: Order[A]): Order[@@[LeftProjection[A, X], First]]
Definition Classes
EitherInstances
implicit def eitherFirstLeftRInstance[R]: Monad[[α]AnyRef { ... /* 2 definitions in type refinement */ }]
Definition Classes
EitherInstances
implicit def eitherFirstLeftSemigroup[A, X](implicit arg0: Semigroup[A]): Semigroup[@@[LeftProjection[A, X], First]]
Definition Classes
EitherInstances0
implicit def eitherFirstRightEqual[X, A](implicit A0: Equal[A]): Equal[@@[RightProjection[X, A], First]]
Definition Classes
EitherInstances0
implicit def eitherFirstRightLInstance[L]: Monad[[α]AnyRef { ... /* 2 definitions in type refinement */ }]
Definition Classes
EitherInstances
implicit def eitherFirstRightMonoid[X, A](implicit MonoidX: Monoid[X]): Monoid[@@[RightProjection[X, A], First]]
Definition Classes
EitherInstances
implicit def eitherFirstRightOrder[X, A](implicit OrderA: Order[A]): Order[@@[RightProjection[X, A], First]]
Definition Classes
EitherInstances
implicit def eitherFirstRightSemigroup[X, A](implicit arg0: Semigroup[A]): Semigroup[@@[RightProjection[X, A], First]]
Definition Classes
EitherInstances0
implicit val eitherInstance: Bitraverse[Either]
Definition Classes
EitherInstances
implicit def eitherLastLeftEqual[A, X](implicit A0: Equal[A]): Equal[@@[LeftProjection[A, X], Last]]
Definition Classes
EitherInstances0
implicit def eitherLastLeftMonoid[A, X](implicit MonoidX: Monoid[X]): Monoid[@@[LeftProjection[A, X], Last]]
Definition Classes
EitherInstances
implicit def eitherLastLeftOrder[A, X](implicit OrderA: Order[A]): Order[@@[LeftProjection[A, X], Last]]
Definition Classes
EitherInstances
implicit def eitherLastLeftRInstance[R]: Monad[[α]AnyRef { ... /* 2 definitions in type refinement */ }]
Definition Classes
EitherInstances
implicit def eitherLastLeftSemigroup[A, X](implicit arg0: Semigroup[A]): Semigroup[@@[LeftProjection[A, X], Last]]
Definition Classes
EitherInstances0
implicit def eitherLastRightEqual[X, A](implicit A0: Equal[A]): Equal[@@[RightProjection[X, A], Last]]
Definition Classes
EitherInstances0
implicit def eitherLastRightLInstance[L]: Monad[[α]AnyRef { ... /* 2 definitions in type refinement */ }]
Definition Classes
EitherInstances
implicit def eitherLastRightMonoid[X, A](implicit MonoidX: Monoid[X]): Monoid[@@[RightProjection[X, A], Last]]
Definition Classes
EitherInstances
implicit def eitherLastRightOrder[X, A](implicit OrderA: Order[A]): Order[@@[RightProjection[X, A], Last]]
Definition Classes
EitherInstances
implicit def eitherLastRightSemigroup[X, A](implicit arg0: Semigroup[A]): Semigroup[@@[RightProjection[X, A], Last]]
Definition Classes
EitherInstances0
implicit def eitherLeftEqual[A, X](implicit A0: Equal[A]): Equal[LeftProjection[A, X]]
Definition Classes
EitherInstances0
val eitherLeftInstance: IsomorphismBifunctor[LeftProjection, Either]
Definition Classes
EitherInstances
implicit def eitherLeftMonoid[A, X](implicit MonoidA: Monoid[A], MonoidX: Monoid[X]): Monoid[LeftProjection[A, X]]
Definition Classes
EitherInstances
implicit def eitherLeftOrder[A, X](implicit OrderA: Order[A]): Order[LeftProjection[A, X]]
Definition Classes
EitherInstances
implicit def eitherLeftRInstance[R]: Monad[[α$21$]LeftProjection[α$21$, R]] { def point[A](a: => A): scala.util.Either.LeftProjection[A,Nothing] }
Definition Classes
EitherInstances
implicit def eitherLeftSemigroup[A, X](implicit SemigroupA: Semigroup[A], MonoidX: Monoid[X]): Semigroup[LeftProjection[A, X]]
Definition Classes
EitherInstances0
implicit def eitherMonad[L]: Traverse[[β$0$]Either[L, β$0$]] with MonadError[[β$1$]Either[L, β$1$], L] with BindRec[[β$2$]Either[L, β$2$]] with Cozip[[β$3$]Either[L, β$3$]]
Right biased monad
Right biased monad
Definition Classes
EitherInstances
implicit def eitherOrder[A, B](implicit OrderA: Order[A], OrderB: Order[B]): Order[Either[A, B]]
Definition Classes
EitherInstances
implicit def eitherRightEqual[X, A](implicit A0: Equal[A]): Equal[RightProjection[X, A]]
Definition Classes
EitherInstances0
val eitherRightInstance: IsomorphismBifunctor[RightProjection, Either]
Definition Classes
EitherInstances
implicit def eitherRightLInstance[L]: Monad[[β$16$]RightProjection[L, β$16$]] { def point[A](a: => A): scala.util.Either.RightProjection[Nothing,A] }
Definition Classes
EitherInstances
implicit def eitherRightMonoid[X, A](implicit MonoidX: Monoid[X], MonoidA: Monoid[A]): Monoid[RightProjection[X, A]]
Definition Classes
EitherInstances
implicit def eitherRightOrder[X, A](implicit OrderA: Order[A]): Order[RightProjection[X, A]]
Definition Classes
EitherInstances
implicit def eitherRightSemigroup[X, A](implicit MonoidX: Monoid[X], SemigroupA: Semigroup[A]): Semigroup[RightProjection[X, A]]
Definition Classes
EitherInstances0
implicit def eitherShow[A, B](implicit SA: Show[A], SB: Show[B]): Show[Either[A, B]]
Definition Classes
EitherInstances
final def emptyOrPure[M[_], A](cond: Boolean)(a: ⇒ A)(implicit M: Applicative[M], M0: PlusEmpty[M]): M[A]
Returns the value a lifted into the context M if cond is false, otherwise, the empty value for M.
Returns the value a lifted into the context M if cond is false, otherwise, the empty value for M.
Definition Classes
BooleanFunctions
final def emptyOrPureNT[M[_]](cond: Boolean)(implicit M: Applicative[M], M0: PlusEmpty[M]): ~>[Id.Id, M]
Definition Classes
BooleanFunctions
implicit def enumInstance[E <: java.lang.Enum[E]]: Equal[E]
Definition Classes
EnumInstances
final def eq(arg0: AnyRef): Boolean
Definition Classes
AnyRef
def equals(arg0: Any): Boolean
Definition Classes
AnyRef → Any
final def filterM[A, M[_]](as: List[A])(p: (A) ⇒ M[Boolean])(implicit arg0: Applicative[M]): M[List[A]]
Definition Classes
ListFunctions
def finalize(): Unit
Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.Throwable])
final def findM[A, M[_]](as: List[A])(p: (A) ⇒ M[Boolean])(implicit arg0: Monad[M]): M[Option[A]]
Run p(a)s left-to-right until it yields a true value, answering Some(that), or None if nothing matched p.
Run p(a)s left-to-right until it yields a true value, answering Some(that), or None if nothing matched p.
Definition Classes
ListFunctions
final def fix[A](f: (⇒ A) ⇒ A): A
f(f(f(... for referentially transparent f.
f(f(f(... for referentially transparent f.
Definition Classes
FunctionFunctions
Since
7.0.1
implicit val floatInstance: Order[Float] with Show[Float]
Definition Classes
AnyValInstances
final def fold[A](cond: Boolean, t: ⇒ A, f: ⇒ A): A
returns
t if cond is true, f otherwise
Definition Classes
BooleanFunctions
final def fold[A, X](oa: Option[A])(some: (A) ⇒ X, none: ⇒ X): X
Alias for cata
Alias for cata
Definition Classes
OptionFunctions
final def foldLift[F[_], A, B](oa: Option[A])(b: ⇒ B, k: (F[A]) ⇒ B)(implicit p: Applicative[F]): B
Returns the given value if None, otherwise lifts the Some value and passes it to the given function.
Returns the given value if None, otherwise lifts the Some value and passes it to the given function.
Definition Classes
OptionFunctions
final def foldLiftOpt[A, B](oa: Option[A])(b: ⇒ B, k: (Option[A]) ⇒ B): B
Returns the given value if None, otherwise lifts the Some value to Option and passes it to the given function.
Returns the given value if None, otherwise lifts the Some value to Option and passes it to the given function.
Definition Classes
OptionFunctions
implicit def function0Equal[R](implicit arg0: Equal[R]): Equal[() ⇒ R]
Definition Classes
FunctionInstances
implicit val function0Instance: Traverse[Function0] with Monad[Function0] with BindRec[Function0] with Comonad[Function0] with Distributive[Function0]
Definition Classes
FunctionInstances
implicit def function1Cobind[A, R](implicit A0: Semigroup[A]): Cobind[[β$0$](A) ⇒ β$0$]
Definition Classes
FunctionInstances1
implicit def function1Comonad[A, R](implicit A0: Monoid[A]): Comonad[[β$1$](A) ⇒ β$1$]
Definition Classes
FunctionInstances0
implicit def function1Contravariant[R]: Contravariant[[α$22$](α$22$) ⇒ R]
Definition Classes
FunctionInstances
implicit def function1Covariant[T]: Monad[[β$12$](T) ⇒ β$12$] with BindRec[[β$13$](T) ⇒ β$13$] with Zip[[β$14$](T) ⇒ β$14$] with Unzip[[β$15$](T) ⇒ β$15$] with Distributive[[β$16$](T) ⇒ β$16$]
Definition Classes
FunctionInstances
implicit def function1CovariantByName[T]: Monad[[β$2$](⇒ T) ⇒ β$2$] with BindRec[[β$3$](⇒ T) ⇒ β$3$] with Zip[[β$4$](⇒ T) ⇒ β$4$] with Unzip[[β$5$](⇒ T) ⇒ β$5$] with Distributive[[β$6$](⇒ T) ⇒ β$6$]
Definition Classes
FunctionInstances0
implicit val function1Instance: Arrow[Function1] with Choice[Function1] with ProChoice[Function1]
Definition Classes
FunctionInstances
implicit def function1Monoid[A, R](implicit R0: Monoid[R]): Monoid[(A) ⇒ R]
Definition Classes
FunctionInstances0
implicit def function1Semigroup[A, R](implicit R0: Semigroup[R]): Semigroup[(A) ⇒ R]
Definition Classes
FunctionInstances1
implicit def function2Instance[T1, T2]: Monad[[γ$24$](T1, T2) ⇒ γ$24$] with BindRec[[γ$25$](T1, T2) ⇒ γ$25$]
Definition Classes
FunctionInstances
implicit def function3Instance[T1, T2, T3]: Monad[[δ$28$](T1, T2, T3) ⇒ δ$28$] with BindRec[[δ$29$](T1, T2, T3) ⇒ δ$29$]
Definition Classes
FunctionInstances
implicit def function4Instance[T1, T2, T3, T4]: Monad[[ε$32$](T1, T2, T3, T4) ⇒ ε$32$] with BindRec[[ε$33$](T1, T2, T3, T4) ⇒ ε$33$]
Definition Classes
FunctionInstances
implicit def function5Instance[T1, T2, T3, T4, T5]: Monad[[ζ$36$](T1, T2, T3, T4, T5) ⇒ ζ$36$] with BindRec[[ζ$37$](T1, T2, T3, T4, T5) ⇒ ζ$37$]
Definition Classes
FunctionInstances
implicit def function6Instance[T1, T2, T3, T4, T5, T6]: Monad[[η$40$](T1, T2, T3, T4, T5, T6) ⇒ η$40$] with BindRec[[η$41$](T1, T2, T3, T4, T5, T6) ⇒ η$41$]
Definition Classes
FunctionInstances
implicit def function7Instance[T1, T2, T3, T4, T5, T6, T7]: Monad[[θ$44$](T1, T2, T3, T4, T5, T6, T7) ⇒ θ$44$] with BindRec[[θ$45$](T1, T2, T3, T4, T5, T6, T7) ⇒ θ$45$]
Definition Classes
FunctionInstances
implicit def function8Instance[T1, T2, T3, T4, T5, T6, T7, T8]: Monad[[ι$48$](T1, T2, T3, T4, T5, T6, T7, T8) ⇒ ι$48$] with BindRec[[ι$49$](T1, T2, T3, T4, T5, T6, T7, T8) ⇒ ι$49$]
Definition Classes
FunctionInstances
def futureComonad(duration: Duration)(implicit executionContext: ExecutionContext): Comonad[Future]
Requires explicit usage as the use of Await.result.
Requires explicit usage as the use of Await.result. Can throw an exception, which is inherently bad.
Definition Classes
FutureInstances
implicit def futureInstance(implicit ec: ExecutionContext): Nondeterminism[Future] with Cobind[Future] with MonadError[Future, Throwable] with Catchable[Future]
Definition Classes
FutureInstances1
implicit def futureMonoid[A](implicit g: Monoid[A], ec: ExecutionContext): Monoid[Future[A]]
Definition Classes
FutureInstances
implicit def futureSemigroup[A](implicit m: Semigroup[A], ec: ExecutionContext): Semigroup[Future[A]]
Definition Classes
FutureInstances1
def get[S]: State[S, S]
Definition Classes
StateFunctions
final def getClass(): Class[_]
Definition Classes
AnyRef → Any
Annotations
@native()
final def getOrAdd[F[_], K, A](m: Map[K, A], k: K)(fa: ⇒ F[A])(implicit F: Applicative[F]): F[(Map[K, A], A)]
Grab a value out of Map if it's present.
Grab a value out of Map if it's present. Otherwise evaluate a value to be placed at that key in the Map.
Definition Classes
MapFunctions
def gets[S, T](f: (S) ⇒ T): State[S, T]
Definition Classes
StateFunctions
final def groupBy1[A, B](as: List[A])(f: (A) ⇒ B): Map[B, NonEmptyList[A]]
As with the standard library groupBy but preserving the fact that the values in the Map must be non-empty
As with the standard library groupBy but preserving the fact that the values in the Map must be non-empty
Definition Classes
ListFunctions
final def groupWhen[A](as: List[A])(p: (A, A) ⇒ Boolean): List[NonEmptyList[A]]
groupWhenM specialized to scalaz.Id.Id.
groupWhenM specialized to scalaz.Id.Id.
Definition Classes
ListFunctions
final def groupWhenM[A, M[_]](as: List[A])(p: (A, A) ⇒ M[Boolean])(implicit arg0: Monad[M]): M[List[NonEmptyList[A]]]
Split at each point where p(as(n), as(n+1)) yields false.
Split at each point where p(as(n), as(n+1)) yields false.
Definition Classes
ListFunctions
def hashCode(): Int
Definition Classes
AnyRef → Any
Annotations
@native()
final def heads[A](as: Stream[A]): Stream[Stream[A]]
[as take 1, as take 2, ..., as]
[as take 1, as take 2, ..., as]
Definition Classes
StreamFunctions
def iModify[S1, S2](f: (S1) ⇒ S2): IndexedState[S1, S2, Unit]
Definition Classes
IndexedStateFunctions
def iPut[S1, S2](s: S2): IndexedState[S1, S2, Unit]
Definition Classes
IndexedStateFunctions
val id: Traverse1[Id] with Monad[Id] with BindRec[Id] with Comonad[Id] with Distributive[Id] with Zip[Id] with Unzip[Id] with Align[Id] with Cozip[Id] with Optional[Id]
Definition Classes
IdInstances
def init[S]: State[S, S]
Definition Classes
StateFunctions
final def initz[A](as: List[A]): List[List[A]]
[Nil, as take 1, as take 2, ..., as]
[Nil, as take 1, as take 2, ..., as]
Definition Classes
ListFunctions
final def insertWith[K, A](m1: Map[K, A], k: K, v: A)(f: (A, A) ⇒ A): Map[K, A]
As with Map.updated, but resolve a collision with f.
As with Map.updated, but resolve a collision with f. The first argument is guaranteed to be from m1.
Definition Classes
MapFunctions
implicit val intInstance: Monoid[Int] with Enum[Int] with Show[Int]
Definition Classes
AnyValInstances
implicit val intMultiplicationNewType: Monoid[@@[Int, Multiplication]] with Enum[@@[Int, Multiplication]]
Definition Classes
AnyValInstances
final def interleave[A](s1: Stream[A], s2: Stream[A]): Stream[A]
Definition Classes
StreamFunctions
final def intersectWith[K, A, B, C](m1: Map[K, A], m2: Map[K, B])(f: (A, B) ⇒ C): Map[K, C]
Collect only elements with matching keys, joining their associated values with f.
Collect only elements with matching keys, joining their associated values with f.
Definition Classes
MapFunctions
final def intersectWithKey[K, A, B, C](m1: Map[K, A], m2: Map[K, B])(f: (K, A, B) ⇒ C): Map[K, C]
Like intersectWith, but tell f about the key.
Like intersectWith, but tell f about the key.
Definition Classes
MapFunctions
final def intersperse[A](as: Stream[A], a: A): Stream[A]
Intersperse the element a between each adjacent pair of elements in as
Intersperse the element a between each adjacent pair of elements in as
Definition Classes
StreamFunctions
final def intersperse[A](as: List[A], a: A): List[A]
Intersperse the element a between each adjacent pair of elements in as
Intersperse the element a between each adjacent pair of elements in as
Definition Classes
ListFunctions
final def inverseConditional(p: Boolean, q: ⇒ Boolean): Boolean
Inverse Conditional.
Inverse Conditional.
```
p q  p <-- q
0 0  1
0 1  0
1 0  1
1 1  1
```
Definition Classes
BooleanFunctions
final def isInstanceOf[T0]: Boolean
Definition Classes
Any
implicit def listEqual[A](implicit A0: Equal[A]): Equal[List[A]]
Definition Classes
ListInstances0
implicit val listInstance: Traverse[List] with MonadPlus[List] with BindRec[List] with Zip[List] with Unzip[List] with Align[List] with IsEmpty[List] with Cobind[List]
Definition Classes
ListInstances
implicit def listMonoid[A]: Monoid[List[A]]
Definition Classes
ListInstances
implicit def listOrder[A](implicit A0: Order[A]): Order[List[A]]
Definition Classes
ListInstances
implicit def listShow[A](implicit arg0: Show[A]): Show[List[A]]
Definition Classes
ListInstances
implicit val longInstance: Monoid[Long] with Enum[Long] with Show[Long]
Definition Classes
AnyValInstances
implicit val longMultiplicationNewType: Monoid[@@[Long, Multiplication]] with Enum[@@[Long, Multiplication]]
Definition Classes
AnyValInstances
final def mapAccumLeft[A, B, C](as: List[A])(c: C, f: (C, A) ⇒ (C, B)): (C, List[B])
All of the Bs, in order, and the final C acquired by a stateful left fold over as.
All of the Bs, in order, and the final C acquired by a stateful left fold over as.
Definition Classes
ListFunctions
final def mapAccumRight[A, B, C](as: List[A])(c: C, f: (C, A) ⇒ (C, B)): (C, List[B])
All of the Bs, in order as-wise, and the final C acquired by a stateful right fold over as.
All of the Bs, in order as-wise, and the final C acquired by a stateful right fold over as.
Definition Classes
ListFunctions
implicit def mapBand[K, V](implicit S: Band[V]): Band[Map[K, V]]
Definition Classes
MapInstances0
implicit val mapEntryBitraverse: Bitraverse[Entry]
Definition Classes
MapInstances
implicit def mapEqual[K, V](implicit arg0: Order[K], arg1: Equal[V]): Equal[Map[K, V]]
Definition Classes
MapInstances0
implicit def mapFoldable[K]: Foldable[[β$1$]Map[K, β$1$]]
Definition Classes
MapInstances0
implicit def mapInstance[K]: Traverse[[β$2$]Map[K, β$2$]] with IsEmpty[[β$3$]Map[K, β$3$]] with Bind[[β$4$]Map[K, β$4$]] with Align[[β$5$]Map[K, β$5$]]
Covariant over the value parameter, where plus applies the Last semigroup to values.
Covariant over the value parameter, where plus applies the Last semigroup to values.
Definition Classes
MapInstances
final def mapKeys[K, K2, A](m: Map[K, A])(f: (K) ⇒ K2): Map[K2, A]
Exchange keys of m according to f.
Exchange keys of m according to f. Result may be smaller if f maps two or more Ks to the same K2, in which case the resulting associated value is an arbitrary choice.
Definition Classes
MapFunctions
implicit def mapMonoid[K, V](implicit S: Semigroup[V]): Monoid[Map[K, V]]
Map union monoid, unifying values with V's append.
Map union monoid, unifying values with V's append.
Definition Classes
MapInstances
implicit def mapOrder[K, V](implicit arg0: Order[K], arg1: Order[V]): Order[Map[K, V]]
Definition Classes
MapInstances
implicit def mapShow[K, V](implicit K: Show[K], V: Show[V]): Show[Map[K, V]]
Definition Classes
MapInstances
def mempty[F[_], A](implicit F: PlusEmpty[F]): F[A]
Definition Classes
ToPlusEmptyOps
def modify[S](f: (S) ⇒ S): State[S, Unit]
Definition Classes
StateFunctions
def mzero[F](implicit F: Monoid[F]): F
Definition Classes
ToMonoidOps
final def nand(p: Boolean, q: ⇒ Boolean): Boolean
Negation of Conjunction.
Negation of Conjunction. (NAND)
```
p q  p !&& q
0 0  1
0 1  1
1 0  1
1 1  0
```
Definition Classes
BooleanFunctions
final def ne(arg0: AnyRef): Boolean
Definition Classes
AnyRef
final def negConditional(p: Boolean, q: ⇒ Boolean): Boolean
Negational of Conditional.
Negational of Conditional.
```
p q  p ⇏ q
0 0  0
0 1  0
1 0  1
1 1  0
```
Definition Classes
BooleanFunctions
final def negInverseConditional(p: Boolean, q: ⇒ Boolean): Boolean
Negation of Inverse Conditional.
Negation of Inverse Conditional.
```
p q  p <\- q
0 0  0
0 1  1
1 0  0
1 1  0
```
Definition Classes
BooleanFunctions
final def nil[A]: List[A]
scala.Nil with a sometimes more convenient type
scala.Nil with a sometimes more convenient type
Definition Classes
ListFunctions
final def none[A]: Option[A]
scala.None with a sometimes more convenient type.
scala.None with a sometimes more convenient type.
Definition Classes
OptionFunctions
final def nor(p: Boolean, q: ⇒ Boolean): Boolean
Negation of Disjunction.
Negation of Disjunction. (NOR)
```
p q  p !|| q
0 0  1
0 1  0
1 0  0
1 1  0
```
Definition Classes
BooleanFunctions
final def notify(): Unit
Definition Classes
AnyRef
Annotations
@native()
final def notifyAll(): Unit
Definition Classes
AnyRef
Annotations
@native()
final def option[A](cond: Boolean, a: ⇒ A): Option[A]
Returns the given argument in Some if cond is true, None otherwise.
Returns the given argument in Some if cond is true, None otherwise.
Definition Classes
BooleanFunctions
implicit def optionEqual[A](implicit A0: Equal[A]): Equal[Option[A]]
Definition Classes
OptionInstances0
implicit def optionFirst[A]: Monoid[FirstOption[A]] with Band[FirstOption[A]]
Definition Classes
OptionInstances
implicit def optionFirstMonad: Monad[FirstOption]
Definition Classes
OptionInstances
implicit def optionFirstOrder[A](implicit arg0: Order[A]): Order[FirstOption[A]]
Definition Classes
OptionInstances
implicit def optionFirstShow[A](implicit arg0: Show[A]): Show[FirstOption[A]]
Definition Classes
OptionInstances
implicit val optionInstance: Traverse[Option] with MonadPlus[Option] with BindRec[Option] with Cozip[Option] with Zip[Option] with Unzip[Option] with Align[Option] with IsEmpty[Option] with Cobind[Option] with Optional[Option]
Definition Classes
OptionInstances
implicit def optionLast[A]: Monoid[LastOption[A]] with Band[LastOption[A]]
Definition Classes
OptionInstances
implicit def optionLastMonad: Monad[LastOption]
Definition Classes
OptionInstances
implicit def optionLastOrder[A](implicit arg0: Order[A]): Order[LastOption[A]]
Definition Classes
OptionInstances
implicit def optionLastShow[A](implicit arg0: Show[A]): Show[LastOption[A]]
Definition Classes
OptionInstances
implicit def optionMax[A](implicit o: Order[A]): Monoid[MaxOption[A]] with Band[MaxOption[A]]
Definition Classes
OptionInstances
implicit def optionMaxMonad: Monad[MaxOption]
Definition Classes
OptionInstances
implicit def optionMaxOrder[A](implicit arg0: Order[A]): Order[MaxOption[A]]
Definition Classes
OptionInstances
implicit def optionMaxShow[A](implicit arg0: Show[A]): Show[MaxOption[A]]
Definition Classes
OptionInstances
implicit def optionMin[A](implicit o: Order[A]): Monoid[MinOption[A]] with Band[MinOption[A]]
Definition Classes
OptionInstances
implicit def optionMinMonad: Monad[MinOption]
Definition Classes
OptionInstances
implicit def optionMinOrder[A](implicit arg0: Order[A]): Order[MinOption[A]]
Definition Classes
OptionInstances
implicit def optionMinShow[A](implicit arg0: Show[A]): Show[MinOption[A]]
Definition Classes
OptionInstances
implicit def optionMonoid[A](implicit arg0: Semigroup[A]): Monoid[Option[A]]
Definition Classes
OptionInstances
implicit def optionOrder[A](implicit A0: Order[A]): Order[Option[A]]
Add None as an element less than all As.
Add None as an element less than all As.
Definition Classes
OptionInstances
implicit def optionShow[A](implicit arg0: Show[A]): Show[Option[A]]
Definition Classes
OptionInstances
final def orEmpty[A, M[_]](oa: Option[A])(implicit arg0: Applicative[M], arg1: PlusEmpty[M]): M[A]
Returns the item contained in the Option wrapped in type M if the Option is defined, otherwise, the empty value for type M.
Returns the item contained in the Option wrapped in type M if the Option is defined, otherwise, the empty value for type M.
Definition Classes
OptionFunctions
def orderingMonoid[A]: Monoid[scala.math.Ordering[A]]
Definition Classes
OrderingInstances
def parseBoolean(s: String): Validation[IllegalArgumentException, Boolean]
Definition Classes
StringFunctions
def parseByte(s: String): Validation[NumberFormatException, Byte]
Definition Classes
StringFunctions
def parseDouble(s: String): Validation[NumberFormatException, Double]
Definition Classes
StringFunctions
def parseFloat(s: String): Validation[NumberFormatException, Float]
Definition Classes
StringFunctions
def parseInt(s: String): Validation[NumberFormatException, Int]
Definition Classes
StringFunctions
def parseLong(s: String): Validation[NumberFormatException, Long]
Definition Classes
StringFunctions
def parseShort(s: String): Validation[NumberFormatException, Short]
Definition Classes
StringFunctions
implicit val partialFunctionInstance: Arrow[PartialFunction] with Category[PartialFunction] with Choice[PartialFunction]
Definition Classes
PartialFunctionInstances
final def partitionM[A, M[_]](as: List[A])(p: (A) ⇒ M[Boolean])(implicit F: Applicative[M]): M[(List[A], List[A])]
A pair of passing and failing values of as against p.
A pair of passing and failing values of as against p.
Definition Classes
ListFunctions
def plural(s: String, n: Long): String
Returns the same String value if the given value is 1 otherwise pluralises this String by appending an "s" unless this String ends with "y" and not one of ["ay", "ey", "iy", "oy", "uy"] in which case the 'y' character is chopped and "ies" is appended.
Returns the same String value if the given value is 1 otherwise pluralises this String by appending an "s" unless this String ends with "y" and not one of ["ay", "ey", "iy", "oy", "uy"] in which case the 'y' character is chopped and "ies" is appended.
Definition Classes
StringFunctions
final def pointOrEmpty[M[_], A](cond: Boolean)(a: ⇒ A)(implicit M: Applicative[M], M0: PlusEmpty[M]): M[A]
Returns the value a lifted into the context M if cond is true, otherwise, the empty value for M.
Returns the value a lifted into the context M if cond is true, otherwise, the empty value for M.
Definition Classes
BooleanFunctions
final def pointOrEmptyNT[M[_]](cond: Boolean)(implicit M: Applicative[M], M0: PlusEmpty[M]): ~>[Id.Id, M]
Definition Classes
BooleanFunctions
final def powerset[A](as: List[A]): List[List[A]]
Definition Classes
ListFunctions
def put[S](s: S): State[S, Unit]
Definition Classes
StateFunctions
implicit val setInstance: Foldable[Set] with IsEmpty[Set]
Definition Classes
SetInstances
implicit def setMonoid[A]: Monoid[Set[A]] with SemiLattice[Set[A]]
Definition Classes
SetInstances
implicit def setOrder[A](implicit arg0: Order[A]): Order[Set[A]]
We could derive set equality from Equal[A], but it would be O(n^2). Instead, we require Order[A], reducing the complexity to O(log n)
We could derive set equality from Equal[A], but it would be O(n^2). Instead, we require Order[A], reducing the complexity to O(log n)
If Equal[A].equalIsNatural == true, than Any#== is used.
Definition Classes
SetInstances
implicit def setShow[A](implicit arg0: Show[A]): Show[Set[A]]
Definition Classes
SetInstances
implicit val shortInstance: Monoid[Short] with Enum[Short] with Show[Short]
Definition Classes
AnyValInstances
implicit val shortMultiplicationNewType: Monoid[@@[Short, Multiplication]] with Enum[@@[Short, Multiplication]]
Definition Classes
AnyValInstances
final def some[A](a: A): Option[A]
scala.Some.apply with a sometimes more convenient type.
scala.Some.apply with a sometimes more convenient type.
Definition Classes
OptionFunctions
final def spanM[A, M[_]](as: List[A])(p: (A) ⇒ M[Boolean])(implicit arg0: Monad[M]): M[(List[A], List[A])]
A pair of the longest prefix of passing as against p, and the remainder.
A pair of the longest prefix of passing as against p, and the remainder.
Definition Classes
ListFunctions
def state[S, A](a: A): State[S, A]
Definition Classes
StateFunctions
implicit def streamEqual[A](implicit A0: Equal[A]): Equal[Stream[A]]
Definition Classes
StreamInstances
implicit val streamInstance: Traverse[Stream] with MonadPlus[Stream] with BindRec[Stream] with Zip[Stream] with Unzip[Stream] with Align[Stream] with IsEmpty[Stream] with Cobind[Stream]
Definition Classes
StreamInstances
implicit def streamMonoid[A]: Monoid[Stream[A]]
Definition Classes
StreamInstances
implicit def streamOrder[A](implicit A0: Order[A]): Order[Stream[A]]
Definition Classes
StreamInstances
implicit def streamShow[A](implicit A0: Show[A]): Show[Stream[A]]
Definition Classes
StreamInstances
implicit val streamZipApplicative: Applicative[[α]AnyRef { ... /* 2 definitions in type refinement */ }]
An alternative scalaz.Applicative instance for Stream, discriminated by the type tag scalaz.Tags.Zip, that zips streams together.
An alternative scalaz.Applicative instance for Stream, discriminated by the type tag scalaz.Tags.Zip, that zips streams together.
Example:
```
import scalaz.Tags.Zip
streamZipApplicative.apply2(Zip(Stream(1, 2)), Zip(Stream(3, 4)))(_ * _) // Stream(3, 8)
```
Definition Classes
StreamInstances
final def synchronized[T0](arg0: ⇒ T0): T0
Definition Classes
AnyRef
final def tailOption[A](as: List[A]): Option[List[A]]
Definition Classes
ListFunctions
final def tails[A](as: Stream[A]): Stream[Stream[A]]
[as, as.tail, as.tail.tail, ..., Stream(as.last)]
[as, as.tail, as.tail.tail, ..., Stream(as.last)]
Definition Classes
StreamFunctions
final def tailz[A](as: List[A]): List[List[A]]
[as, as.tail, as.tail.tail, ..., Nil]
[as, as.tail, as.tail.tail, ..., Nil]
Definition Classes
ListFunctions
final def takeUntilM[A, M[_]](as: List[A])(p: (A) ⇒ M[Boolean])(implicit arg0: Monad[M]): M[List[A]]
Run p(a)s and collect as while p yields false.
Run p(a)s and collect as while p yields false. Don't run any ps after the first true.
Definition Classes
ListFunctions
final def takeWhileM[A, M[_]](as: List[A])(p: (A) ⇒ M[Boolean])(implicit arg0: Monad[M]): M[List[A]]
Run p(a)s and collect as while p yields true.
Run p(a)s and collect as while p yields true. Don't run any ps after the first false.
Definition Classes
ListFunctions
def test(p: Boolean): Int
Returns 1 if p is true, or 0 otherwise.
Returns 1 if p is true, or 0 otherwise.
Definition Classes
BooleanFunctions
final def toFailure[A, B](oa: Option[A])(b: ⇒ B): Validation[A, B]
Definition Classes
OptionFunctions
final def toFailureNel[A, B](oa: Option[A])(b: ⇒ B): ValidationNel[A, B]
Definition Classes
OptionFunctions
final def toLeft[A, B](oa: Option[A])(b: ⇒ B): \/[A, B]
Definition Classes
OptionFunctions
final def toMaybe[A](oa: Option[A]): Maybe[A]
Definition Classes
OptionFunctions
final def toNel[A](as: List[A]): Option[NonEmptyList[A]]
Definition Classes
ListFunctions
final def toRight[A, E](oa: Option[A])(e: ⇒ E): \/[E, A]
Definition Classes
OptionFunctions
def toString(): String
Definition Classes
AnyRef → Any
final def toSuccess[A, E](oa: Option[A])(e: ⇒ E): Validation[E, A]
Definition Classes
OptionFunctions
final def toSuccessNel[A, E](oa: Option[A])(e: ⇒ E): ValidationNel[E, A]
Definition Classes
OptionFunctions
final def toZipper[A](as: Stream[A]): Option[Zipper[A]]
Definition Classes
StreamFunctions
final def toZipper[A](as: List[A]): Option[Zipper[A]]
Definition Classes
ListFunctions
implicit val tuple1Cozip: Cozip[Tuple1]
Definition Classes
TupleInstances2
implicit def tuple1Equal[A1](implicit A1: Equal[A1]): Equal[(A1)]
Definition Classes
TupleInstances1
implicit val tuple1Instance: Traverse[Tuple1] with Monad[Tuple1] with Comonad[Tuple1]
Tuple1[A] is isomorphic to Id[X]
Tuple1[A] is isomorphic to Id[X]
Definition Classes
TupleInstances1
implicit def tuple1Monoid[A1](implicit A1: Monoid[A1]): Monoid[(A1)]
Definition Classes
TupleInstances2
implicit def tuple1Order[A1](implicit A1: Order[A1]): Order[(A1)]
Definition Classes
TupleInstances2
implicit def tuple1Semigroup[A1](implicit A1: Semigroup[A1]): Semigroup[(A1)]
Definition Classes
TupleInstances1
implicit def tuple1Show[A1](implicit A1: Show[A1]): Show[(A1)]
Definition Classes
TupleInstances2
implicit val tuple2Associative: Associative[Tuple2]
Definition Classes
TupleInstances1
implicit def tuple2BindRec[A1](implicit arg0: Semigroup[A1]): BindRec[[β$9$](A1, β$9$)]
Product BindRec
Product BindRec
Definition Classes
TupleInstances1
implicit val tuple2Bitraverse: Bitraverse[Tuple2]
Definition Classes
TupleInstances1
implicit def tuple2Cozip[A1]: Cozip[[β$16$](A1, β$16$)]
Definition Classes
TupleInstances2
implicit def tuple2Equal[A1, A2](implicit A1: Equal[A1], A2: Equal[A2]): Equal[(A1, A2)]
Definition Classes
TupleInstances1
implicit def tuple2Instance[A1]: Traverse[[β$0$](A1, β$0$)] with Comonad[[β$1$](A1, β$1$)]
Product functor and comonad
Product functor and comonad
Definition Classes
TupleInstances0
implicit def tuple2Monad[A1](implicit A1: Monoid[A1]): Monad[[β$23$](A1, β$23$)]
Definition Classes
TupleInstances2
implicit def tuple2Monoid[A1, A2](implicit A1: Monoid[A1], A2: Monoid[A2]): Monoid[(A1, A2)]
Definition Classes
TupleInstances2
implicit def tuple2Order[A1, A2](implicit A1: Order[A1], A2: Order[A2]): Order[(A1, A2)]
Definition Classes
TupleInstances2
implicit def tuple2Semigroup[A1, A2](implicit A1: Semigroup[A1], A2: Semigroup[A2]): Semigroup[(A1, A2)]
Definition Classes
TupleInstances1
implicit def tuple2Show[A1, A2](implicit A1: Show[A1], A2: Show[A2]): Show[(A1, A2)]
Definition Classes
TupleInstances2
implicit def tuple3BindRec[A1, A2](implicit arg0: Semigroup[A1], arg1: Semigroup[A2]): BindRec[[γ$10$](A1, A2, γ$10$)]
Definition Classes
TupleInstances1
implicit def tuple3Cozip[A1, A2]: Cozip[[γ$17$](A1, A2, γ$17$)]
Definition Classes
TupleInstances2
implicit def tuple3Equal[A1, A2, A3](implicit A1: Equal[A1], A2: Equal[A2], A3: Equal[A3]): Equal[(A1, A2, A3)]
Definition Classes
TupleInstances1
implicit def tuple3Functor[A1, A2]: Traverse[[γ$3$](A1, A2, γ$3$)]
Definition Classes
TupleInstances0
implicit def tuple3Monad[A1, A2](implicit A1: Monoid[A1], A2: Monoid[A2]): Monad[[γ$24$](A1, A2, γ$24$)]
Definition Classes
TupleInstances2
implicit def tuple3Monoid[A1, A2, A3](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3]): Monoid[(A1, A2, A3)]
Definition Classes
TupleInstances2
implicit def tuple3Order[A1, A2, A3](implicit A1: Order[A1], A2: Order[A2], A3: Order[A3]): Order[(A1, A2, A3)]
Definition Classes
TupleInstances2
implicit def tuple3Semigroup[A1, A2, A3](implicit A1: Semigroup[A1], A2: Semigroup[A2], A3: Semigroup[A3]): Semigroup[(A1, A2, A3)]
Definition Classes
TupleInstances1
implicit def tuple3Show[A1, A2, A3](implicit A1: Show[A1], A2: Show[A2], A3: Show[A3]): Show[(A1, A2, A3)]
Definition Classes
TupleInstances2
implicit def tuple4BindRec[A1, A2, A3](implicit arg0: Semigroup[A1], arg1: Semigroup[A2], arg2: Semigroup[A3]): BindRec[[δ$11$](A1, A2, A3, δ$11$)]
Definition Classes
TupleInstances1
implicit def tuple4Cozip[A1, A2, A3]: Cozip[[δ$18$](A1, A2, A3, δ$18$)]
Definition Classes
TupleInstances2
implicit def tuple4Equal[A1, A2, A3, A4](implicit A1: Equal[A1], A2: Equal[A2], A3: Equal[A3], A4: Equal[A4]): Equal[(A1, A2, A3, A4)]
Definition Classes
TupleInstances1
implicit def tuple4Functor[A1, A2, A3]: Traverse[[δ$4$](A1, A2, A3, δ$4$)]
Definition Classes
TupleInstances0
implicit def tuple4Monad[A1, A2, A3](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3]): Monad[[δ$25$](A1, A2, A3, δ$25$)]
Definition Classes
TupleInstances2
implicit def tuple4Monoid[A1, A2, A3, A4](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3], A4: Monoid[A4]): Monoid[(A1, A2, A3, A4)]
Definition Classes
TupleInstances2
implicit def tuple4Order[A1, A2, A3, A4](implicit A1: Order[A1], A2: Order[A2], A3: Order[A3], A4: Order[A4]): Order[(A1, A2, A3, A4)]
Definition Classes
TupleInstances2
implicit def tuple4Semigroup[A1, A2, A3, A4](implicit A1: Semigroup[A1], A2: Semigroup[A2], A3: Semigroup[A3], A4: Semigroup[A4]): Semigroup[(A1, A2, A3, A4)]
Definition Classes
TupleInstances1
implicit def tuple4Show[A1, A2, A3, A4](implicit A1: Show[A1], A2: Show[A2], A3: Show[A3], A4: Show[A4]): Show[(A1, A2, A3, A4)]
Definition Classes
TupleInstances2
implicit def tuple5BindRec[A1, A2, A3, A4](implicit arg0: Semigroup[A1], arg1: Semigroup[A2], arg2: Semigroup[A3], arg3: Semigroup[A4]): BindRec[[ε$12$](A1, A2, A3, A4, ε$12$)]
Definition Classes
TupleInstances1
implicit def tuple5Cozip[A1, A2, A3, A4]: Cozip[[ε$19$](A1, A2, A3, A4, ε$19$)]
Definition Classes
TupleInstances2
implicit def tuple5Equal[A1, A2, A3, A4, A5](implicit A1: Equal[A1], A2: Equal[A2], A3: Equal[A3], A4: Equal[A4], A5: Equal[A5]): Equal[(A1, A2, A3, A4, A5)]
Definition Classes
TupleInstances1
implicit def tuple5Functor[A1, A2, A3, A4]: Traverse[[ε$5$](A1, A2, A3, A4, ε$5$)]
Definition Classes
TupleInstances0
implicit def tuple5Monad[A1, A2, A3, A4](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3], A4: Monoid[A4]): Monad[[ε$26$](A1, A2, A3, A4, ε$26$)]
Definition Classes
TupleInstances2
implicit def tuple5Monoid[A1, A2, A3, A4, A5](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3], A4: Monoid[A4], A5: Monoid[A5]): Monoid[(A1, A2, A3, A4, A5)]
Definition Classes
TupleInstances2
implicit def tuple5Order[A1, A2, A3, A4, A5](implicit A1: Order[A1], A2: Order[A2], A3: Order[A3], A4: Order[A4], A5: Order[A5]): Order[(A1, A2, A3, A4, A5)]
Definition Classes
TupleInstances2
implicit def tuple5Semigroup[A1, A2, A3, A4, A5](implicit A1: Semigroup[A1], A2: Semigroup[A2], A3: Semigroup[A3], A4: Semigroup[A4], A5: Semigroup[A5]): Semigroup[(A1, A2, A3, A4, A5)]
Definition Classes
TupleInstances1
implicit def tuple5Show[A1, A2, A3, A4, A5](implicit A1: Show[A1], A2: Show[A2], A3: Show[A3], A4: Show[A4], A5: Show[A5]): Show[(A1, A2, A3, A4, A5)]
Definition Classes
TupleInstances2
implicit def tuple6BindRec[A1, A2, A3, A4, A5](implicit arg0: Semigroup[A1], arg1: Semigroup[A2], arg2: Semigroup[A3], arg3: Semigroup[A4], arg4: Semigroup[A5]): BindRec[[ζ$13$](A1, A2, A3, A4, A5, ζ$13$)]
Definition Classes
TupleInstances1
implicit def tuple6Cozip[A1, A2, A3, A4, A5]: Cozip[[ζ$20$](A1, A2, A3, A4, A5, ζ$20$)]
Definition Classes
TupleInstances2
implicit def tuple6Equal[A1, A2, A3, A4, A5, A6](implicit A1: Equal[A1], A2: Equal[A2], A3: Equal[A3], A4: Equal[A4], A5: Equal[A5], A6: Equal[A6]): Equal[(A1, A2, A3, A4, A5, A6)]
Definition Classes
TupleInstances1
implicit def tuple6Functor[A1, A2, A3, A4, A5]: Traverse[[ζ$6$](A1, A2, A3, A4, A5, ζ$6$)]
Definition Classes
TupleInstances0
implicit def tuple6Monad[A1, A2, A3, A4, A5](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3], A4: Monoid[A4], A5: Monoid[A5]): Monad[[ζ$27$](A1, A2, A3, A4, A5, ζ$27$)]
Definition Classes
TupleInstances2
implicit def tuple6Monoid[A1, A2, A3, A4, A5, A6](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3], A4: Monoid[A4], A5: Monoid[A5], A6: Monoid[A6]): Monoid[(A1, A2, A3, A4, A5, A6)]
Definition Classes
TupleInstances2
implicit def tuple6Order[A1, A2, A3, A4, A5, A6](implicit A1: Order[A1], A2: Order[A2], A3: Order[A3], A4: Order[A4], A5: Order[A5], A6: Order[A6]): Order[(A1, A2, A3, A4, A5, A6)]
Definition Classes
TupleInstances2
implicit def tuple6Semigroup[A1, A2, A3, A4, A5, A6](implicit A1: Semigroup[A1], A2: Semigroup[A2], A3: Semigroup[A3], A4: Semigroup[A4], A5: Semigroup[A5], A6: Semigroup[A6]): Semigroup[(A1, A2, A3, A4, A5, A6)]
Definition Classes
TupleInstances1
implicit def tuple6Show[A1, A2, A3, A4, A5, A6](implicit A1: Show[A1], A2: Show[A2], A3: Show[A3], A4: Show[A4], A5: Show[A5], A6: Show[A6]): Show[(A1, A2, A3, A4, A5, A6)]
Definition Classes
TupleInstances2
implicit def tuple7BindRec[A1, A2, A3, A4, A5, A6](implicit arg0: Semigroup[A1], arg1: Semigroup[A2], arg2: Semigroup[A3], arg3: Semigroup[A4], arg4: Semigroup[A5], arg5: Semigroup[A6]): BindRec[[η$14$](A1, A2, A3, A4, A5, A6, η$14$)]
Definition Classes
TupleInstances1
implicit def tuple7Cozip[A1, A2, A3, A4, A5, A6]: Cozip[[η$21$](A1, A2, A3, A4, A5, A6, η$21$)]
Definition Classes
TupleInstances2
implicit def tuple7Equal[A1, A2, A3, A4, A5, A6, A7](implicit A1: Equal[A1], A2: Equal[A2], A3: Equal[A3], A4: Equal[A4], A5: Equal[A5], A6: Equal[A6], A7: Equal[A7]): Equal[(A1, A2, A3, A4, A5, A6, A7)]
Definition Classes
TupleInstances1
implicit def tuple7Functor[A1, A2, A3, A4, A5, A6]: Traverse[[η$7$](A1, A2, A3, A4, A5, A6, η$7$)]
Definition Classes
TupleInstances0
implicit def tuple7Monad[A1, A2, A3, A4, A5, A6](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3], A4: Monoid[A4], A5: Monoid[A5], A6: Monoid[A6]): Monad[[η$28$](A1, A2, A3, A4, A5, A6, η$28$)]
Definition Classes
TupleInstances2
implicit def tuple7Monoid[A1, A2, A3, A4, A5, A6, A7](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3], A4: Monoid[A4], A5: Monoid[A5], A6: Monoid[A6], A7: Monoid[A7]): Monoid[(A1, A2, A3, A4, A5, A6, A7)]
Definition Classes
TupleInstances2
implicit def tuple7Order[A1, A2, A3, A4, A5, A6, A7](implicit A1: Order[A1], A2: Order[A2], A3: Order[A3], A4: Order[A4], A5: Order[A5], A6: Order[A6], A7: Order[A7]): Order[(A1, A2, A3, A4, A5, A6, A7)]
Definition Classes
TupleInstances2
implicit def tuple7Semigroup[A1, A2, A3, A4, A5, A6, A7](implicit A1: Semigroup[A1], A2: Semigroup[A2], A3: Semigroup[A3], A4: Semigroup[A4], A5: Semigroup[A5], A6: Semigroup[A6], A7: Semigroup[A7]): Semigroup[(A1, A2, A3, A4, A5, A6, A7)]
Definition Classes
TupleInstances1
implicit def tuple7Show[A1, A2, A3, A4, A5, A6, A7](implicit A1: Show[A1], A2: Show[A2], A3: Show[A3], A4: Show[A4], A5: Show[A5], A6: Show[A6], A7: Show[A7]): Show[(A1, A2, A3, A4, A5, A6, A7)]
Definition Classes
TupleInstances2
implicit def tuple8BindRec[A1, A2, A3, A4, A5, A6, A7](implicit arg0: Semigroup[A1], arg1: Semigroup[A2], arg2: Semigroup[A3], arg3: Semigroup[A4], arg4: Semigroup[A5], arg5: Semigroup[A6], arg6: Semigroup[A7]): BindRec[[θ$15$](A1, A2, A3, A4, A5, A6, A7, θ$15$)]
Definition Classes
TupleInstances1
implicit def tuple8Cozip[A1, A2, A3, A4, A5, A6, A7]: Cozip[[θ$22$](A1, A2, A3, A4, A5, A6, A7, θ$22$)]
Definition Classes
TupleInstances2
implicit def tuple8Equal[A1, A2, A3, A4, A5, A6, A7, A8](implicit A1: Equal[A1], A2: Equal[A2], A3: Equal[A3], A4: Equal[A4], A5: Equal[A5], A6: Equal[A6], A7: Equal[A7], A8: Equal[A8]): Equal[(A1, A2, A3, A4, A5, A6, A7, A8)]
Definition Classes
TupleInstances1
implicit def tuple8Functor[A1, A2, A3, A4, A5, A6, A7]: Traverse[[θ$8$](A1, A2, A3, A4, A5, A6, A7, θ$8$)]
Definition Classes
TupleInstances0
implicit def tuple8Monad[A1, A2, A3, A4, A5, A6, A7](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3], A4: Monoid[A4], A5: Monoid[A5], A6: Monoid[A6], A7: Monoid[A7]): Monad[[θ$29$](A1, A2, A3, A4, A5, A6, A7, θ$29$)]
Definition Classes
TupleInstances2
implicit def tuple8Monoid[A1, A2, A3, A4, A5, A6, A7, A8](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3], A4: Monoid[A4], A5: Monoid[A5], A6: Monoid[A6], A7: Monoid[A7], A8: Monoid[A8]): Monoid[(A1, A2, A3, A4, A5, A6, A7, A8)]
Definition Classes
TupleInstances2
implicit def tuple8Order[A1, A2, A3, A4, A5, A6, A7, A8](implicit A1: Order[A1], A2: Order[A2], A3: Order[A3], A4: Order[A4], A5: Order[A5], A6: Order[A6], A7: Order[A7], A8: Order[A8]): Order[(A1, A2, A3, A4, A5, A6, A7, A8)]
Definition Classes
TupleInstances2
implicit def tuple8Semigroup[A1, A2, A3, A4, A5, A6, A7, A8](implicit A1: Semigroup[A1], A2: Semigroup[A2], A3: Semigroup[A3], A4: Semigroup[A4], A5: Semigroup[A5], A6: Semigroup[A6], A7: Semigroup[A7], A8: Semigroup[A8]): Semigroup[(A1, A2, A3, A4, A5, A6, A7, A8)]
Definition Classes
TupleInstances1
implicit def tuple8Show[A1, A2, A3, A4, A5, A6, A7, A8](implicit A1: Show[A1], A2: Show[A2], A3: Show[A3], A4: Show[A4], A5: Show[A5], A6: Show[A6], A7: Show[A7], A8: Show[A8]): Show[(A1, A2, A3, A4, A5, A6, A7, A8)]
Definition Classes
TupleInstances2
def unfold[A, B](seed: A)(f: (A) ⇒ Option[(B, A)]): Stream[B]
Definition Classes
StreamFunctions
final def unfoldForest[A, B](as: Stream[A])(f: (A) ⇒ (B, () ⇒ Stream[A])): Stream[Tree[B]]
Definition Classes
StreamFunctions
final def unfoldForestM[A, B, M[_]](as: Stream[A])(f: (A) ⇒ M[(B, Stream[A])])(implicit arg0: Monad[M]): M[Stream[Tree[B]]]
Definition Classes
StreamFunctions
def unfoldm[A, B](seed: A)(f: (A) ⇒ Maybe[(B, A)]): Stream[B]
Definition Classes
StreamFunctions
final def unionWith[K, A](m1: Map[K, A], m2: Map[K, A])(f: (A, A) ⇒ A): Map[K, A]
Union, resolving collisions with f, where the first arg is guaranteed to be from m1, the second from m2.
Union, resolving collisions with f, where the first arg is guaranteed to be from m1, the second from m2.
Definition Classes
MapFunctions
Note
iff f gives rise to a scalaz.Semigroup, so does unionWith(_, _)(f).
final def unionWithKey[K, A](m1: Map[K, A], m2: Map[K, A])(f: (K, A, A) ⇒ A): Map[K, A]
Like unionWith, but telling f about the key.
Like unionWith, but telling f about the key.
Definition Classes
MapFunctions
implicit val unitInstance: Monoid[Unit] with Enum[Unit] with Show[Unit] with SemiLattice[Unit]
Definition Classes
AnyValInstances
final def unless(cond: Boolean)(f: ⇒ Unit): Unit
Executes the given side-effect if cond is false
Executes the given side-effect if cond is false
Definition Classes
BooleanFunctions
final def unlessM[M[_], A](cond: Boolean)(f: ⇒ M[A])(implicit M: Applicative[M]): M[Unit]
Returns the given argument if cond is false, otherwise, unit lifted into M.
Returns the given argument if cond is false, otherwise, unit lifted into M.
Definition Classes
BooleanFunctions
final def unlessMU[MA](cond: Boolean)(f: ⇒ MA)(implicit M: Unapply[Applicative, MA]): M[Unit]
A version of unlessM that infers the type constructor M.
A version of unlessM that infers the type constructor M.
Definition Classes
BooleanFunctions
final def valueOrZero[A](cond: Boolean)(value: ⇒ A)(implicit z: Monoid[A]): A
Returns the given argument if cond is true, otherwise, the zero element for the type of the given argument.
Returns the given argument if cond is true, otherwise, the zero element for the type of the given argument.
Definition Classes
BooleanFunctions
implicit def vectorEqual[A](implicit A0: Equal[A]): Equal[Vector[A]]
Definition Classes
VectorInstances0
implicit val vectorInstance: Traverse[Vector] with MonadPlus[Vector] with BindRec[Vector] with Zip[Vector] with Unzip[Vector] with IsEmpty[Vector] with Align[Vector]
Definition Classes
VectorInstances
implicit def vectorMonoid[A]: Monoid[Vector[A]]
Definition Classes
VectorInstances
implicit def vectorOrder[A](implicit A0: Order[A]): Order[Vector[A]]
Definition Classes
VectorInstances
implicit def vectorShow[A](implicit arg0: Show[A]): Show[Vector[A]]
Definition Classes
VectorInstances
final def wait(): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@native() @throws(classOf[java.lang.InterruptedException])
final def when(cond: Boolean)(f: ⇒ Unit): Unit
Executes the given side-effect if cond is true
Executes the given side-effect if cond is true
Definition Classes
BooleanFunctions
final def whenM[M[_], A](cond: Boolean)(f: ⇒ M[A])(implicit M: Applicative[M]): M[Unit]
Returns the given argument if cond is true, otherwise, unit lifted into M.
Returns the given argument if cond is true, otherwise, unit lifted into M.
Definition Classes
BooleanFunctions
final def whenMU[MA](cond: Boolean)(f: ⇒ MA)(implicit M: Unapply[Applicative, MA]): M[Unit]
A version of whenM that infers the type constructor M.
A version of whenM that infers the type constructor M.
Definition Classes
BooleanFunctions
final def zapp[A, B, C](a: Stream[A])(f: Stream[(A) ⇒ (B) ⇒ C]): Stream[(B) ⇒ C]
Definition Classes
StreamFunctions
final def zeroOrValue[A](cond: Boolean)(value: ⇒ A)(implicit z: Monoid[A]): A
Returns the given argument if cond is false, otherwise, the zero element for the type of the given argument.
Returns the given argument if cond is false, otherwise, the zero element for the type of the given argument.
Definition Classes
BooleanFunctions
final def zipperEnd[A](as: Stream[A]): Option[Zipper[A]]
Definition Classes
StreamFunctions
final def zipperEnd[A](as: List[A]): Option[Zipper[A]]
Definition Classes
ListFunctions
def ∅[F](implicit F: Monoid[F]): F
Definition Classes
ToMonoidOps
implicit object booleanInstance extends Enum[Boolean] with Show[Boolean]
Definition Classes
AnyValInstances
implicit object stringInstance extends Monoid[String] with Show[String] with Equal[String] with Order[String] with IsEmpty[[α]String]
Definition Classes
StringInstances

Deprecated Value Members

def charsNelErr(s: String, message: ⇒ String): NonEmptyList[Char]
Definition Classes
StringFunctions
Annotations
@deprecated
Deprecated
(Since version 7.2) Unsafe. Use charsNel instead
def unsafeCharsNel(s: String): NonEmptyList[Char]
Definition Classes
StringFunctions
Annotations
@deprecated
Deprecated
(Since version 7.2) Unsafe. Use charsNel instead

Packages

Scalaz

object Scalaz extends StateFunctions with ToTypeClassOps with ToDataOps with AllInstances with AllFunctions with ToAllStdOps with IdInstances

Type Members

Value Members

Deprecated Value Members

Inherited from IdInstances

Inherited from ToAllStdOps

Inherited from ToTryOps

Inherited from ToEitherOps

Inherited from ToMapOps

Inherited from ToTupleOps

Inherited from ToStringOps

Inherited from ToFunction1Ops

Inherited from ToFunction2Ops

Inherited from ToVectorOps

Inherited from ToStreamOps

Inherited from ToListOps

Inherited from ToOptionIdOps

Inherited from ToOptionOps

Inherited from ToBooleanOps

Inherited from AllFunctions

Inherited from FunctionFunctions

Inherited from StringFunctions

Inherited from OrderingFunctions

Inherited from BooleanFunctions

Inherited from StreamFunctions

Inherited from OptionFunctions

Inherited from ListFunctions

Inherited from AllInstances

Inherited from CallableInstances

Inherited from EnumInstances

Inherited from BigIntegerInstances

Inherited from std.java.util.MapInstances

Inherited from std.math.OrderingInstances

Inherited from BigInts

Inherited from BigDecimalInstances

Inherited from TypeConstraintInstances

Inherited from PartialFunctionInstances

Inherited from EitherInstances

Inherited from EitherInstances0

Inherited from FutureInstances

Inherited from FutureInstances1

Inherited from VectorInstances

Inherited from VectorInstances0

Inherited from TupleInstances

Inherited from TupleInstances2

Inherited from TupleInstances1

Inherited from TupleInstances0

Inherited from StreamInstances

Inherited from StringInstances

Inherited from SetInstances

Inherited from OptionInstances

Inherited from OptionInstances0

Inherited from std.MapInstances

Inherited from MapFunctions

Inherited from std.MapInstances0

Inherited from ListInstances

Inherited from ListInstances0

Inherited from FunctionInstances

Inherited from FunctionInstances0

Inherited from FunctionInstances1

Inherited from AnyValInstances

Inherited from ToDataOps

Inherited from ToMaybeOps

Inherited from ToTheseOps

Inherited from ToNelOps

Inherited from ToEitherOps

Inherited from ToKleisliOps

Inherited from ToKleisliOps0

Inherited from ToValidationOps

Inherited from ToStateOps

Inherited from ToWriterOps

Inherited from ToReducerOps

Inherited from ToTreeOps

Inherited from ToIdOps

Inherited from ToTypeClassOps

Inherited from ToAlignOps

Inherited from ToAlignOps0

Inherited from ToCatchableOps

Scalaz