object Scalaz extends StateFunctions with ToTypeClassOps with ToDataOps with AllInstances with AllFunctions with ToAllStdOps with IdInstances
- Source
- Scalaz.scala
- Alphabetic
- By Inheritance
- 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
- MapSubMap
- MapSubInstances
- MapSubFunctions
- MapSubInstances0
- MapSub
- 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
- Public
- All
Type Members
-
type
BuildKeyConstraint[K] = DummyImplicit
Evidence on key needed to construct new maps.
-
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
- type XMap[K, +V] = Map[K, V]
-
trait
MapMonoid[K, V] extends Monoid[XMap[K, V]]
- Attributes
- protected[this]
- Definition Classes
- MapSub
-
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 ofas
if non-empty, otherwise, the zero element of theMonoid
for the typeB
.Returns
f
applied to the contents ofas
if non-empty, otherwise, the zero element of theMonoid
for the typeB
.- 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.<~>[[α]TagModule.@@[LeftProjection[E, α], First], [β$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.<~~>[[α, β]TagModule.@@[LeftProjection[α, β], First], Either]
scala.Either.LeftProjection is isomorphic to scala.Either
scala.Either.LeftProjection is isomorphic to scala.Either
- Definition Classes
- EitherInstances
-
def
FirstRightProjectionAIso2[A]: Isomorphism.<~>[[α]TagModule.@@[RightProjection[α, A], First], [α$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.<~~>[[α, β]TagModule.@@[RightProjection[α, β], First], Either]
scala.Either.RightProjection is isomorphic to scala.Either
scala.Either.RightProjection is isomorphic to scala.Either
- Definition Classes
- EitherInstances
-
def
LastLeftProjectionEIso2[E]: Isomorphism.<~>[[α]TagModule.@@[LeftProjection[E, α], Last], [β$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.<~~>[[α, β]TagModule.@@[LeftProjection[α, β], Last], Either]
scala.Either.LeftProjection is isomorphic to scala.Either
scala.Either.LeftProjection is isomorphic to scala.Either
- Definition Classes
- EitherInstances
-
def
LastRightProjectionAIso2[A]: Isomorphism.<~>[[α]TagModule.@@[RightProjection[α, A], Last], [α$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.<~~>[[α, β]TagModule.@@[RightProjection[α, β], Last], 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[Map, std.map.BuildKeyConstraint, 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
ab_+[K, V](m: XMap[K, V], k: K, v: V)(implicit arg0: BuildKeyConstraint[K]): XMap[K, V]
How
MapLike#updated
might be typed in a sane world. -
final
def
ab_-[K, V](m: XMap[K, V], k: K)(implicit arg0: BuildKeyConstraint[K]): XMap[K, V]
As with
ab_+
, but withMapLike#-
. -
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
andas
, excluding same-element pairs.Combinations of
as
andas
, excluding same-element pairs.- Definition Classes
- ListFunctions
-
final
def
alter[K, A](m: XMap[K, A], k: K)(f: (Option[A]) ⇒ Option[A])(implicit arg0: BuildKeyConstraint[K]): XMap[K, A]
Vary the value of
m get k
.Vary the value of
m get k
.- Definition Classes
- MapSubFunctions
-
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
withp
's complement.spanM
withp
's complement.- Definition Classes
- ListFunctions
- final def buildXMap[K, V, K2, V2](implicit arg0: BuildKeyConstraint[K2]): CanBuildFrom[XMap[K, V], (K2, V2), XMap[K2, V2]]
-
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 valuenone
.- 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[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
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[[α, β]TagModule.@@[LeftProjection[α, β], First], 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[[α]TagModule.@@[LeftProjection[α, R], First]]
- 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[[α]TagModule.@@[RightProjection[L, α], First]]
- 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[[α]TagModule.@@[LeftProjection[α, R], Last]]
- 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[[α]TagModule.@@[RightProjection[L, α], Last]]
- 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[[α$22$]LeftProjection[α$22$, R]]
- 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$]]
- 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 contextM
ifcond
isfalse
, otherwise, the empty value forM
.Returns the value
a
lifted into the contextM
ifcond
isfalse
, otherwise, the empty value forM
.- 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[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, answeringSome(that)
, orNone
if nothing matchedp
.Run
p(a)
s left-to-right until it yields a true value, answeringSome(that)
, orNone
if nothing matchedp
.- Definition Classes
- ListFunctions
-
final
def
fix[A](f: (⇒ A) ⇒ A): A
f(f(f(...
for referentially transparentf
.f(f(f(...
for referentially transparentf
.- 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
ifcond
istrue
,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: XMap[K, A], k: K)(fa: ⇒ F[A])(implicit F: Applicative[F], K: BuildKeyConstraint[K]): F[(XMap[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
- MapSubFunctions
-
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-emptyAs 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: XMap[K, A], k: K, v: A)(f: (A, A) ⇒ A)(implicit arg0: BuildKeyConstraint[K]): XMap[K, A]
As with
Map.updated
, but resolve a collision withf
.As with
Map.updated
, but resolve a collision withf
. The first argument is guaranteed to be fromm1
.- Definition Classes
- MapSubFunctions
-
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: XMap[K, A], m2: XMap[K, B])(f: (A, B) ⇒ C)(implicit arg0: BuildKeyConstraint[K]): XMap[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
- MapSubFunctions
-
final
def
intersectWithKey[K, A, B, C](m1: XMap[K, A], m2: XMap[K, B])(f: (K, A, B) ⇒ C)(implicit arg0: BuildKeyConstraint[K]): XMap[K, C]
Like
intersectWith
, but tellf
about the key.Like
intersectWith
, but tellf
about the key.- Definition Classes
- MapSubFunctions
-
final
def
intersperse[A](as: Stream[A], a: A): Stream[A]
Intersperse the element
a
between each adjacent pair of elements inas
Intersperse the element
a
between each adjacent pair of elements inas
- Definition Classes
- StreamFunctions
-
final
def
intersperse[A](as: List[A], a: A): List[A]
Intersperse the element
a
between each adjacent pair of elements inas
Intersperse the element
a
between each adjacent pair of elements inas
- 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
B
s, in order, and the finalC
acquired by a stateful left fold overas
.All of the
B
s, in order, and the finalC
acquired by a stateful left fold overas
.- 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
B
s, in orderas
-wise, and the finalC
acquired by a stateful right fold overas
.All of the
B
s, in orderas
-wise, and the finalC
acquired by a stateful right fold overas
.- Definition Classes
- ListFunctions
-
implicit
val
mapEntryBitraverse: Bitraverse[Entry]
- Definition Classes
- MapInstances
-
implicit
def
mapEqual[K, V](implicit arg0: Order[K], arg1: Equal[V]): Equal[XMap[K, V]]
- Definition Classes
- MapSubInstances0
-
implicit
def
mapFoldable[K]: Foldable[[β$1$]XMap[K, β$1$]]
- Definition Classes
- MapSubInstances0
-
implicit
def
mapInstance[K](implicit arg0: BuildKeyConstraint[K]): Traverse[[β$2$]XMap[K, β$2$]] with IsEmpty[[β$3$]XMap[K, β$3$]] with Bind[[β$4$]XMap[K, β$4$]] with Align[[β$5$]XMap[K, β$5$]]
Covariant over the value parameter, where
plus
applies theLast
semigroup to values.Covariant over the value parameter, where
plus
applies theLast
semigroup to values.- Definition Classes
- MapSubInstances
-
final
def
mapKeys[K, K2, A](m: XMap[K, A])(f: (K) ⇒ K2)(implicit arg0: BuildKeyConstraint[K2]): XMap[K2, A]
Exchange keys of
m
according tof
.Exchange keys of
m
according tof
. Result may be smaller iff
maps two or moreK
s to the sameK2
, in which case the resulting associated value is an arbitrary choice.- Definition Classes
- MapSubFunctions
-
implicit
def
mapMonoid[K, V](implicit arg0: BuildKeyConstraint[K], arg1: Semigroup[V]): Monoid[XMap[K, V]]
Map union monoid, unifying values with
V
'sappend
.Map union monoid, unifying values with
V
'sappend
.- Definition Classes
- MapSubInstances
-
implicit
def
mapOrder[K, V](implicit arg0: Order[K], arg1: Order[V]): Order[XMap[K, V]]
- Definition Classes
- MapSubInstances
-
implicit
def
mapShow[K, V](implicit K: Show[K], V: Show[V]): Show[XMap[K, V]]
- Definition Classes
- MapSubInstances
-
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
ifcond
istrue
,None
otherwise.Returns the given argument in
Some
ifcond
istrue
,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 allA
s.Add
None
as an element less than allA
s.- 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
againstp
.A pair of passing and failing values of
as
againstp
.- 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 contextM
ifcond
istrue
, otherwise, the empty value forM
.Returns the value
a
lifted into the contextM
ifcond
istrue
, otherwise, the empty value forM
.- 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 beO(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 beO(n^2)
. Instead, we require
Order[A], reducing the complexity to
O(log n)If
Equal[A].equalIsNatural == true
, thanAny#==
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
againstp
, and the remainder.A pair of the longest prefix of passing
as
againstp
, 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[[α]TagModule.@@[Stream[α], Tags.Zip]]
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 collectas
whilep
yields false.Run
p(a)
s and collectas
whilep
yields false. Don't run anyp
s 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 collectas
whilep
yields true.Run
p(a)
s and collectas
whilep
yields true. Don't run anyp
s after the first false.- Definition Classes
- ListFunctions
-
def
test(p: Boolean): Int
Returns
1
ifp
is true, or0
otherwise.Returns
1
ifp
is true, or0
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 toId[X]
Tuple1[A]
is isomorphic toId[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: XMap[K, A], m2: XMap[K, A])(f: (A, A) ⇒ A)(implicit arg0: BuildKeyConstraint[K]): XMap[K, A]
Union, resolving collisions with
f
, where the first arg is guaranteed to be fromm1
, the second fromm2
.Union, resolving collisions with
f
, where the first arg is guaranteed to be fromm1
, the second fromm2
.- Definition Classes
- MapSubFunctions
- Note
iff
f
gives rise to a scalaz.Semigroup, so doesunionWith(_, _)(f)
.
-
final
def
unionWithKey[K, A](m1: XMap[K, A], m2: XMap[K, A])(f: (K, A, A) ⇒ A)(implicit arg0: BuildKeyConstraint[K]): XMap[K, A]
Like
unionWith
, but tellingf
about the key.Like
unionWith
, but tellingf
about the key.- Definition Classes
- MapSubFunctions
-
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
isfalse
Executes the given side-effect if
cond
isfalse
- 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
isfalse
, otherwise, unit lifted into M.Returns the given argument if
cond
isfalse
, 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 constructorM
.A version of
unlessM
that infers the type constructorM
.- Definition Classes
- BooleanFunctions
-
final
def
valueOrZero[A](cond: Boolean)(value: ⇒ A)(implicit z: Monoid[A]): A
Returns the given argument if
cond
istrue
, otherwise, the zero element for the type of the given argument.Returns the given argument if
cond
istrue
, 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( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
final
def
when(cond: Boolean)(f: ⇒ Unit): Unit
Executes the given side-effect if
cond
istrue
Executes the given side-effect if
cond
istrue
- 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
istrue
, otherwise, unit lifted into M.Returns the given argument if
cond
istrue
, 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 constructorM
.A version of
whenM
that infers the type constructorM
.- 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
isfalse
, otherwise, the zero element for the type of the given argument.Returns the given argument if
cond
isfalse
, 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