trait ApplicativeError[F[_], E] extends Applicative[F]
An applicative that also allows you to raise and or handle an error value.
This type class allows one to abstract over error-handling applicatives.
- Source
- ApplicativeError.scala
- Grouped
- Alphabetic
- By Inheritance
- ApplicativeError
- Applicative
- InvariantMonoidal
- Apply
- ApplyArityFunctions
- InvariantSemigroupal
- Semigroupal
- Functor
- Invariant
- Serializable
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Abstract Value Members
- abstract def ap[A, B](ff: F[(A) => B])(fa: F[A]): F[B]
Given a value and a function in the Apply context, applies the function to the value.
Given a value and a function in the Apply context, applies the function to the value.
Example:
scala> import cats.implicits._ scala> val someF: Option[Int => Long] = Some(_.toLong + 1L) scala> val noneF: Option[Int => Long] = None scala> val someInt: Option[Int] = Some(3) scala> val noneInt: Option[Int] = None scala> Apply[Option].ap(someF)(someInt) res0: Option[Long] = Some(4) scala> Apply[Option].ap(noneF)(someInt) res1: Option[Long] = None scala> Apply[Option].ap(someF)(noneInt) res2: Option[Long] = None scala> Apply[Option].ap(noneF)(noneInt) res3: Option[Long] = None
- Definition Classes
- Apply
- abstract def handleErrorWith[A](fa: F[A])(f: (E) => F[A]): F[A]
Handle any error, potentially recovering from it, by mapping it to an
F[A]
value.Handle any error, potentially recovering from it, by mapping it to an
F[A]
value.- See also
handleError to handle any error by simply mapping it to an
A
value instead of anF[A]
.recoverWith to recover from only certain errors.
- abstract def pure[A](x: A): F[A]
pure
lifts any value into the Applicative Functor.pure
lifts any value into the Applicative Functor.Example:
scala> import cats.implicits._ scala> Applicative[Option].pure(10) res0: Option[Int] = Some(10)
- Definition Classes
- Applicative
- abstract def raiseError[A](e: E): F[A]
Lift an error into the
F
context.Lift an error into the
F
context.Example:
scala> import cats.implicits._ // integer-rounded division scala> def divide[F[_]](dividend: Int, divisor: Int)(implicit F: ApplicativeError[F, String]): F[Int] = | if (divisor === 0) F.raiseError("division by zero") | else F.pure(dividend / divisor) scala> type ErrorOr[A] = Either[String, A] scala> divide[ErrorOr](6, 3) res0: ErrorOr[Int] = Right(2) scala> divide[ErrorOr](6, 0) res1: ErrorOr[Int] = Left(division by zero)
Concrete Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def *>[A, B](fa: F[A])(fb: F[B]): F[B]
Alias for productR.
- final def <*[A, B](fa: F[A])(fb: F[B]): F[A]
Alias for productL.
- final def <*>[A, B](ff: F[(A) => B])(fa: F[A]): F[B]
Alias for ap.
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def adaptError[A](fa: F[A])(pf: PartialFunction[E, E]): F[A]
Transform certain errors using
pf
and rethrow them.Transform certain errors using
pf
and rethrow them. Non matching errors and successful values are not affected by this function.Example:
scala> import cats._, implicits._ scala> def pf: PartialFunction[String, String] = { case "error" => "ERROR" } scala> ApplicativeError[Either[String, *], String].adaptError("error".asLeft[Int])(pf) res0: Either[String,Int] = Left(ERROR) scala> ApplicativeError[Either[String, *], String].adaptError("err".asLeft[Int])(pf) res1: Either[String,Int] = Left(err) scala> ApplicativeError[Either[String, *], String].adaptError(1.asRight[String])(pf) res2: Either[String,Int] = Right(1)
The same function is available in
ApplicativeErrorOps
asadaptErr
- it cannot have the same name because this would result in ambiguous implicits due toadaptError
having originally been included in theMonadError
API and syntax. - def ap10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9]): F[Z]
- Definition Classes
- ApplyArityFunctions
- def ap11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[Z]
- Definition Classes
- ApplyArityFunctions
- def ap12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[Z]
- Definition Classes
- ApplyArityFunctions
- def ap13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[Z]
- Definition Classes
- ApplyArityFunctions
- def ap14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[Z]
- Definition Classes
- ApplyArityFunctions
- def ap15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[Z]
- Definition Classes
- ApplyArityFunctions
- def ap16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[Z]
- Definition Classes
- ApplyArityFunctions
- def ap17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[Z]
- Definition Classes
- ApplyArityFunctions
- def ap18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[Z]
- Definition Classes
- ApplyArityFunctions
- def ap19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[Z]
- Definition Classes
- ApplyArityFunctions
- def ap2[A, B, Z](ff: F[(A, B) => Z])(fa: F[A], fb: F[B]): F[Z]
ap2 is a binary version of ap, defined in terms of ap.
ap2 is a binary version of ap, defined in terms of ap.
- Definition Classes
- Apply
- def ap20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19]): F[Z]
- Definition Classes
- ApplyArityFunctions
- def ap21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[Z]
- Definition Classes
- ApplyArityFunctions
- def ap22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[Z]
- Definition Classes
- ApplyArityFunctions
- def ap3[A0, A1, A2, Z](f: F[(A0, A1, A2) => Z])(f0: F[A0], f1: F[A1], f2: F[A2]): F[Z]
- Definition Classes
- ApplyArityFunctions
- def ap4[A0, A1, A2, A3, Z](f: F[(A0, A1, A2, A3) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[Z]
- Definition Classes
- ApplyArityFunctions
- def ap5[A0, A1, A2, A3, A4, Z](f: F[(A0, A1, A2, A3, A4) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[Z]
- Definition Classes
- ApplyArityFunctions
- def ap6[A0, A1, A2, A3, A4, A5, Z](f: F[(A0, A1, A2, A3, A4, A5) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[Z]
- Definition Classes
- ApplyArityFunctions
- def ap7[A0, A1, A2, A3, A4, A5, A6, Z](f: F[(A0, A1, A2, A3, A4, A5, A6) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[Z]
- Definition Classes
- ApplyArityFunctions
- def ap8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[Z]
- Definition Classes
- ApplyArityFunctions
- def ap9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[Z]
- Definition Classes
- ApplyArityFunctions
- def as[A, B](fa: F[A], b: B): F[B]
Replaces the
A
value inF[A]
with the supplied value.Replaces the
A
value inF[A]
with the supplied value.Example:
scala> import cats.Functor scala> import cats.implicits.catsStdInstancesForList scala> Functor[List].as(List(1,2,3), "hello") res0: List[String] = List(hello, hello, hello)
- Definition Classes
- Functor
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def attempt[A](fa: F[A]): F[Either[E, A]]
Handle errors by turning them into scala.util.Either values.
Handle errors by turning them into scala.util.Either values.
If there is no error, then an
scala.util.Right
value will be returned instead.All non-fatal errors should be handled by this method.
- def attemptNarrow[EE <: Throwable, A](fa: F[A])(implicit tag: ClassTag[EE], ev: <:<[EE, E]): F[Either[EE, A]]
Similar to attempt, but it only handles errors of type
EE
. - def attemptT[A](fa: F[A]): EitherT[F, E, A]
Similar to attempt, but wraps the result in a cats.data.EitherT for convenience.
- def catchNonFatal[A](a: => A)(implicit ev: <:<[Throwable, E]): F[A]
Often E is Throwable.
Often E is Throwable. Here we try to call pure or catch and raise.
- def catchNonFatalEval[A](a: Eval[A])(implicit ev: <:<[Throwable, E]): F[A]
Often E is Throwable.
Often E is Throwable. Here we try to call pure or catch and raise
- def catchOnly[T >: Null <: Throwable]: CatchOnlyPartiallyApplied[T, F, E]
Evaluates the specified block, catching exceptions of the specified type.
Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def compose[G[_]](implicit arg0: Applicative[G]): Applicative[[α]F[G[α]]]
Compose an
Applicative[F]
and anApplicative[G]
into anApplicative[λ[α => F[G[α]]]]
.Compose an
Applicative[F]
and anApplicative[G]
into anApplicative[λ[α => F[G[α]]]]
.Example:
scala> import cats.implicits._ scala> val alo = Applicative[List].compose[Option] scala> alo.pure(3) res0: List[Option[Int]] = List(Some(3)) scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None)) res1: List[Option[(Boolean, Int)]] = List(None, None, Some((true,2)), None, Some((false,2)), None)
- Definition Classes
- Applicative
- def compose[G[_]](implicit arg0: Apply[G]): Apply[[α]F[G[α]]]
Compose an
Apply[F]
and anApply[G]
into anApply[λ[α => F[G[α]]]]
.Compose an
Apply[F]
and anApply[G]
into anApply[λ[α => F[G[α]]]]
.Example:
scala> import cats.implicits._ scala> val alo = Apply[List].compose[Option] scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None)) res1: List[Option[(Boolean, Int)]] = List(None, None, Some((true,2)), None, Some((false,2)), None)
- Definition Classes
- Apply
- def compose[G[_]](implicit arg0: Functor[G]): Functor[[α]F[G[α]]]
- Definition Classes
- Functor
- def compose[G[_]](implicit arg0: Invariant[G]): Invariant[[α]F[G[α]]]
Compose Invariant
F[_]
andG[_]
then produceInvariant[F[G[_]]]
using theirimap
.Compose Invariant
F[_]
andG[_]
then produceInvariant[F[G[_]]]
using theirimap
.Example:
scala> import cats.implicits._ scala> import scala.concurrent.duration._ scala> val durSemigroupList: Semigroup[List[FiniteDuration]] = | Invariant[Semigroup].compose[List].imap(Semigroup[List[Long]])(Duration.fromNanos)(_.toNanos) scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds)) res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
- Definition Classes
- Invariant
- def composeApply[G[_]](implicit arg0: Apply[G]): InvariantSemigroupal[[α]F[G[α]]]
- Definition Classes
- InvariantSemigroupal
- def composeContravariant[G[_]](implicit arg0: Contravariant[G]): Contravariant[[α]F[G[α]]]
Compose Invariant
F[_]
and ContravariantG[_]
then produceInvariant[F[G[_]]]
using F'simap
and G'scontramap
.Compose Invariant
F[_]
and ContravariantG[_]
then produceInvariant[F[G[_]]]
using F'simap
and G'scontramap
.Example:
scala> import cats.implicits._ scala> import scala.concurrent.duration._ scala> type ToInt[T] = T => Int scala> val durSemigroupToInt: Semigroup[ToInt[FiniteDuration]] = | Invariant[Semigroup] | .composeContravariant[ToInt] | .imap(Semigroup[ToInt[Long]])(Duration.fromNanos)(_.toNanos) // semantically equal to (2.seconds.toSeconds.toInt + 1) + (2.seconds.toSeconds.toInt * 2) = 7 scala> durSemigroupToInt.combine(_.toSeconds.toInt + 1, _.toSeconds.toInt * 2)(2.seconds) res1: Int = 7
- def composeContravariantMonoidal[G[_]](implicit arg0: ContravariantMonoidal[G]): ContravariantMonoidal[[α]F[G[α]]]
Compose an
Applicative[F]
and aContravariantMonoidal[G]
into aContravariantMonoidal[λ[α => F[G[α]]]]
.Compose an
Applicative[F]
and aContravariantMonoidal[G]
into aContravariantMonoidal[λ[α => F[G[α]]]]
.Example:
scala> import cats.kernel.Comparison scala> import cats.implicits._ // compares strings by alphabetical order scala> val alpha: Order[String] = Order[String] // compares strings by their length scala> val strLength: Order[String] = Order.by[String, Int](_.length) scala> val stringOrders: List[Order[String]] = List(alpha, strLength) // first comparison is with alpha order, second is with string length scala> stringOrders.map(o => o.comparison("abc", "de")) res0: List[Comparison] = List(LessThan, GreaterThan) scala> val le = Applicative[List].composeContravariantMonoidal[Order] // create Int orders that convert ints to strings and then use the string orders scala> val intOrders: List[Order[Int]] = le.contramap(stringOrders)(_.toString) // first comparison is with alpha order, second is with string length scala> intOrders.map(o => o.comparison(12, 3)) res1: List[Comparison] = List(LessThan, GreaterThan) // create the `product` of the string order list and the int order list // `p` contains a list of the following orders: // 1. (alpha comparison on strings followed by alpha comparison on ints) // 2. (alpha comparison on strings followed by length comparison on ints) // 3. (length comparison on strings followed by alpha comparison on ints) // 4. (length comparison on strings followed by length comparison on ints) scala> val p: List[Order[(String, Int)]] = le.product(stringOrders, intOrders) scala> p.map(o => o.comparison(("abc", 12), ("def", 3))) res2: List[Comparison] = List(LessThan, LessThan, LessThan, GreaterThan)
- Definition Classes
- Applicative
- def composeFunctor[G[_]](implicit arg0: Functor[G]): Invariant[[α]F[G[α]]]
Compose Invariant
F[_]
and FunctorG[_]
then produceInvariant[F[G[_]]]
using F'simap
and G'smap
.Compose Invariant
F[_]
and FunctorG[_]
then produceInvariant[F[G[_]]]
using F'simap
and G'smap
.Example:
scala> import cats.implicits._ scala> import scala.concurrent.duration._ scala> val durSemigroupList: Semigroup[List[FiniteDuration]] = | Invariant[Semigroup] | .composeFunctor[List] | .imap(Semigroup[List[Long]])(Duration.fromNanos)(_.toNanos) scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds)) res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
- Definition Classes
- Invariant
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- final def fmap[A, B](fa: F[A])(f: (A) => B): F[B]
Alias for map, since map can't be injected as syntax if the implementing type already had a built-in
.map
method.Alias for map, since map can't be injected as syntax if the implementing type already had a built-in
.map
method.Example:
scala> import cats.implicits._ scala> val m: Map[Int, String] = Map(1 -> "hi", 2 -> "there", 3 -> "you") scala> m.fmap(_ ++ "!") res0: Map[Int,String] = Map(1 -> hi!, 2 -> there!, 3 -> you!)
- Definition Classes
- Functor
- def fproduct[A, B](fa: F[A])(f: (A) => B): F[(A, B)]
Tuple the values in fa with the result of applying a function with the value
Tuple the values in fa with the result of applying a function with the value
Example:
scala> import cats.Functor scala> import cats.implicits.catsStdInstancesForOption scala> Functor[Option].fproduct(Option(42))(_.toString) res0: Option[(Int, String)] = Some((42,42))
- Definition Classes
- Functor
- def fproductLeft[A, B](fa: F[A])(f: (A) => B): F[(B, A)]
Pair the result of function application with
A
.Pair the result of function application with
A
.Example:
scala> import cats.Functor scala> import cats.implicits.catsStdInstancesForOption scala> Functor[Option].fproductLeft(Option(42))(_.toString) res0: Option[(String, Int)] = Some((42,42))
- Definition Classes
- Functor
- def fromEither[A](x: Either[E, A]): F[A]
Convert from scala.Either
Convert from scala.Either
Example:
scala> import cats.ApplicativeError scala> import cats.instances.option._ scala> ApplicativeError[Option, Unit].fromEither(Right(1)) res0: scala.Option[Int] = Some(1) scala> ApplicativeError[Option, Unit].fromEither(Left(())) res1: scala.Option[Nothing] = None
- def fromOption[A](oa: Option[A], ifEmpty: => E): F[A]
Convert from scala.Option
Convert from scala.Option
Example:
scala> import cats.implicits._ scala> import cats.ApplicativeError scala> val F = ApplicativeError[Either[String, *], String] scala> F.fromOption(Some(1), "Empty") res0: scala.Either[String, Int] = Right(1) scala> F.fromOption(Option.empty[Int], "Empty") res1: scala.Either[String, Int] = Left(Empty)
- def fromTry[A](t: Try[A])(implicit ev: <:<[Throwable, E]): F[A]
If the error type is Throwable, we can convert from a scala.util.Try
- def fromValidated[A](x: Validated[E, A]): F[A]
Convert from cats.data.Validated
Convert from cats.data.Validated
Example:
scala> import cats.implicits._ scala> import cats.ApplicativeError scala> ApplicativeError[Option, Unit].fromValidated(1.valid[Unit]) res0: scala.Option[Int] = Some(1) scala> ApplicativeError[Option, Unit].fromValidated(().invalid[Int]) res1: scala.Option[Int] = None
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def handleError[A](fa: F[A])(f: (E) => A): F[A]
Handle any error, by mapping it to an
A
value.Handle any error, by mapping it to an
A
value.- See also
handleErrorWith to map to an
F[A]
value instead of simply anA
value.recover to only recover from certain errors.
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def ifF[A](fb: F[Boolean])(ifTrue: => A, ifFalse: => A): F[A]
Lifts
if
to FunctorLifts
if
to FunctorExample:
scala> import cats.Functor scala> import cats.implicits.catsStdInstancesForList scala> Functor[List].ifF(List(true, false, false))(1, 0) res0: List[Int] = List(1, 0, 0)
- Definition Classes
- Functor
- def imap[A, B](fa: F[A])(f: (A) => B)(g: (B) => A): F[B]
Transform an
F[A]
into anF[B]
by providing a transformation fromA
toB
and one fromB
toA
.Transform an
F[A]
into anF[B]
by providing a transformation fromA
toB
and one fromB
toA
.Example:
scala> import cats.implicits._ scala> import scala.concurrent.duration._ scala> val durSemigroup: Semigroup[FiniteDuration] = | Invariant[Semigroup].imap(Semigroup[Long])(Duration.fromNanos)(_.toNanos) scala> durSemigroup.combine(2.seconds, 3.seconds) res1: FiniteDuration = 5 seconds
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def lift[A, B](f: (A) => B): (F[A]) => F[B]
Lift a function f to operate on Functors
Lift a function f to operate on Functors
Example:
scala> import cats.Functor scala> import cats.implicits.catsStdInstancesForOption scala> val o = Option(42) scala> Functor[Option].lift((x: Int) => x + 10)(o) res0: Option[Int] = Some(52)
- Definition Classes
- Functor
- def map[A, B](fa: F[A])(f: (A) => B): F[B]
- Definition Classes
- Applicative → Functor
- def map10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z): F[Z]
- Definition Classes
- ApplyArityFunctions
- def map11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z): F[Z]
- Definition Classes
- ApplyArityFunctions
- def map12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z): F[Z]
- Definition Classes
- ApplyArityFunctions
- def map13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z): F[Z]
- Definition Classes
- ApplyArityFunctions
- def map14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z): F[Z]
- Definition Classes
- ApplyArityFunctions
- def map15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z): F[Z]
- Definition Classes
- ApplyArityFunctions
- def map16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z): F[Z]
- Definition Classes
- ApplyArityFunctions
- def map17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z): F[Z]
- Definition Classes
- ApplyArityFunctions
- def map18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z): F[Z]
- Definition Classes
- ApplyArityFunctions
- def map19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z): F[Z]
- Definition Classes
- ApplyArityFunctions
- def map2[A, B, Z](fa: F[A], fb: F[B])(f: (A, B) => Z): F[Z]
Applies the pure (binary) function f to the effectful values fa and fb.
Applies the pure (binary) function f to the effectful values fa and fb.
map2 can be seen as a binary version of cats.Functor#map.
Example:
scala> import cats.implicits._ scala> val someInt: Option[Int] = Some(3) scala> val noneInt: Option[Int] = None scala> val someLong: Option[Long] = Some(4L) scala> val noneLong: Option[Long] = None scala> Apply[Option].map2(someInt, someLong)((i, l) => i.toString + l.toString) res0: Option[String] = Some(34) scala> Apply[Option].map2(someInt, noneLong)((i, l) => i.toString + l.toString) res0: Option[String] = None scala> Apply[Option].map2(noneInt, noneLong)((i, l) => i.toString + l.toString) res0: Option[String] = None scala> Apply[Option].map2(noneInt, someLong)((i, l) => i.toString + l.toString) res0: Option[String] = None
- Definition Classes
- Apply
- def map20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z): F[Z]
- Definition Classes
- ApplyArityFunctions
- def map21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z): F[Z]
- Definition Classes
- ApplyArityFunctions
- def map22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z): F[Z]
- Definition Classes
- ApplyArityFunctions
- def map2Eval[A, B, Z](fa: F[A], fb: Eval[F[B]])(f: (A, B) => Z): Eval[F[Z]]
Similar to map2 but uses Eval to allow for laziness in the
F[B]
argument.Similar to map2 but uses Eval to allow for laziness in the
F[B]
argument. This can allow for "short-circuiting" of computations.NOTE: the default implementation of
map2Eval
does not short-circuit computations. For data structures that can benefit from laziness, Apply instances should override this method.In the following example,
x.map2(bomb)(_ + _)
would result in an error, butmap2Eval
"short-circuits" the computation.x
isNone
and thus the result ofbomb
doesn't even need to be evaluated in order to determine that the result ofmap2Eval
should beNone
.scala> import cats.{Eval, Later} scala> import cats.implicits._ scala> val bomb: Eval[Option[Int]] = Later(sys.error("boom")) scala> val x: Option[Int] = None scala> x.map2Eval(bomb)(_ + _).value res0: Option[Int] = None
- Definition Classes
- Apply
- def map3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2])(f: (A0, A1, A2) => Z): F[Z]
- Definition Classes
- ApplyArityFunctions
- def map4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3])(f: (A0, A1, A2, A3) => Z): F[Z]
- Definition Classes
- ApplyArityFunctions
- def map5[A0, A1, A2, A3, A4, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4])(f: (A0, A1, A2, A3, A4) => Z): F[Z]
- Definition Classes
- ApplyArityFunctions
- def map6[A0, A1, A2, A3, A4, A5, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5])(f: (A0, A1, A2, A3, A4, A5) => Z): F[Z]
- Definition Classes
- ApplyArityFunctions
- def map7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6])(f: (A0, A1, A2, A3, A4, A5, A6) => Z): F[Z]
- Definition Classes
- ApplyArityFunctions
- def map8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7])(f: (A0, A1, A2, A3, A4, A5, A6, A7) => Z): F[Z]
- Definition Classes
- ApplyArityFunctions
- def map9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z): F[Z]
- Definition Classes
- ApplyArityFunctions
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def onError[A](fa: F[A])(pf: PartialFunction[E, F[Unit]]): F[A]
Execute a callback on certain errors, then rethrow them.
Execute a callback on certain errors, then rethrow them. Any non matching error is rethrown as well.
In the following example, only one of the errors is logged, but they are both rethrown, to be possibly handled by another layer of the program:
scala> import cats._, data._, implicits._ scala> case class Err(msg: String) scala> type F[A] = EitherT[State[String, *], Err, A] scala> val action: PartialFunction[Err, F[Unit]] = { | case Err("one") => EitherT.liftF(State.set("one")) | } scala> val prog1: F[Int] = (Err("one")).raiseError[F, Int] scala> val prog2: F[Int] = (Err("two")).raiseError[F, Int] scala> prog1.onError(action).value.run("").value res0: (String, Either[Err,Int]) = (one,Left(Err(one))) scala> prog2.onError(action).value.run("").value res1: (String, Either[Err,Int]) = ("",Left(Err(two)))
- def point[A](a: A): F[A]
point
lifts any value into a Monoidal Functor.point
lifts any value into a Monoidal Functor.Example:
scala> import cats.implicits._ scala> InvariantMonoidal[Option].point(10) res0: Option[Int] = Some(10)
- Definition Classes
- InvariantMonoidal
- def product[A, B](fa: F[A], fb: F[B]): F[(A, B)]
Combine an
F[A]
and anF[B]
into anF[(A, B)]
that maintains the effects of bothfa
andfb
.Combine an
F[A]
and anF[B]
into anF[(A, B)]
that maintains the effects of bothfa
andfb
.Example:
scala> import cats.implicits._ scala> val noneInt: Option[Int] = None scala> val some3: Option[Int] = Some(3) scala> val noneString: Option[String] = None scala> val someFoo: Option[String] = Some("foo") scala> Semigroupal[Option].product(noneInt, noneString) res0: Option[(Int, String)] = None scala> Semigroupal[Option].product(noneInt, someFoo) res1: Option[(Int, String)] = None scala> Semigroupal[Option].product(some3, noneString) res2: Option[(Int, String)] = None scala> Semigroupal[Option].product(some3, someFoo) res3: Option[(Int, String)] = Some((3,foo))
- Definition Classes
- Apply → Semigroupal
- def productL[A, B](fa: F[A])(fb: F[B]): F[A]
Compose two actions, discarding any value produced by the second.
Compose two actions, discarding any value produced by the second.
- Definition Classes
- Apply
- See also
productR to discard the value of the first instead. Example:
scala> import cats.implicits._ scala> import cats.data.Validated scala> import Validated.{Valid, Invalid} scala> type ErrOr[A] = Validated[String, A] scala> val validInt: ErrOr[Int] = Valid(3) scala> val validBool: ErrOr[Boolean] = Valid(true) scala> val invalidInt: ErrOr[Int] = Invalid("Invalid int.") scala> val invalidBool: ErrOr[Boolean] = Invalid("Invalid boolean.") scala> Apply[ErrOr].productL(validInt)(validBool) res0: ErrOr[Int] = Valid(3) scala> Apply[ErrOr].productL(invalidInt)(validBool) res1: ErrOr[Int] = Invalid(Invalid int.) scala> Apply[ErrOr].productL(validInt)(invalidBool) res2: ErrOr[Int] = Invalid(Invalid boolean.) scala> Apply[ErrOr].productL(invalidInt)(invalidBool) res3: ErrOr[Int] = Invalid(Invalid int.Invalid boolean.)
- def productR[A, B](fa: F[A])(fb: F[B]): F[B]
Compose two actions, discarding any value produced by the first.
Compose two actions, discarding any value produced by the first.
- Definition Classes
- Apply
- See also
productL to discard the value of the second instead. Example:
scala> import cats.implicits._ scala> import cats.data.Validated scala> import Validated.{Valid, Invalid} scala> type ErrOr[A] = Validated[String, A] scala> val validInt: ErrOr[Int] = Valid(3) scala> val validBool: ErrOr[Boolean] = Valid(true) scala> val invalidInt: ErrOr[Int] = Invalid("Invalid int.") scala> val invalidBool: ErrOr[Boolean] = Invalid("Invalid boolean.") scala> Apply[ErrOr].productR(validInt)(validBool) res0: ErrOr[Boolean] = Valid(true) scala> Apply[ErrOr].productR(invalidInt)(validBool) res1: ErrOr[Boolean] = Invalid(Invalid int.) scala> Apply[ErrOr].productR(validInt)(invalidBool) res2: ErrOr[Boolean] = Invalid(Invalid boolean.) scala> Apply[ErrOr].productR(invalidInt)(invalidBool) res3: ErrOr[Boolean] = Invalid(Invalid int.Invalid boolean.)
- def raiseUnless(cond: Boolean)(e: => E): F[Unit]
Returns
raiseError
whencond
is false, otherwiseF.unit
Returns
raiseError
whencond
is false, otherwiseF.unit
val tooMany = 5 val x: Int = ??? F.raiseUnless(x < tooMany)(new IllegalArgumentException("Too many"))
Example: - def raiseWhen(cond: Boolean)(e: => E): F[Unit]
Returns
raiseError
when thecond
is true, otherwiseF.unit
Returns
raiseError
when thecond
is true, otherwiseF.unit
val tooMany = 5 val x: Int = ??? F.raiseWhen(x >= tooMany)(new IllegalArgumentException("Too many"))
Example: - def recover[A](fa: F[A])(pf: PartialFunction[E, A]): F[A]
Recover from certain errors by mapping them to an
A
value.Recover from certain errors by mapping them to an
A
value.- See also
handleError to handle any/all errors.
recoverWith to recover from certain errors by mapping them to
F[A]
values.
- def recoverWith[A](fa: F[A])(pf: PartialFunction[E, F[A]]): F[A]
Recover from certain errors by mapping them to an
F[A]
value.Recover from certain errors by mapping them to an
F[A]
value.- See also
handleErrorWith to handle any/all errors.
recover to recover from certain errors by mapping them to
A
values.
- def redeem[A, B](fa: F[A])(recover: (E) => B, f: (A) => B): F[B]
Returns a new value that transforms the result of the source, given the
recover
ormap
functions, which get executed depending on whether the result is successful or if it ends in error.Returns a new value that transforms the result of the source, given the
recover
ormap
functions, which get executed depending on whether the result is successful or if it ends in error.This is an optimization on usage of attempt and map, this equivalence being available:
fa.redeem(fe, fs) <-> fa.attempt.map(_.fold(fe, fs))
Usage of
redeem
subsumes handleError because:fa.redeem(fe, id) <-> fa.handleError(fe)
Implementations are free to override it in order to optimize error recovery.
- fa
is the source whose result is going to get transformed
- recover
is the function that gets called to recover the source in case of error
- See also
- def replicateA[A](n: Int, fa: F[A]): F[List[A]]
Given
fa
andn
, applyfa
n
times to construct anF[List[A]]
value.Given
fa
andn
, applyfa
n
times to construct anF[List[A]]
value.Example:
scala> import cats.data.State scala> type Counter[A] = State[Int, A] scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) } scala> val getAndIncrement5: Counter[List[Int]] = | Applicative[Counter].replicateA(5, getAndIncrement) scala> getAndIncrement5.run(0).value res0: (Int, List[Int]) = (5,List(0, 1, 2, 3, 4))
- Definition Classes
- Applicative
- def replicateA_[A](n: Int, fa: F[A]): F[Unit]
Given
fa
andn
, applyfa
n
times discarding results to return F[Unit].Given
fa
andn
, applyfa
n
times discarding results to return F[Unit].Example:
scala> import cats.data.State scala> type Counter[A] = State[Int, A] scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) } scala> val getAndIncrement5: Counter[Unit] = | Applicative[Counter].replicateA_(5, getAndIncrement) scala> getAndIncrement5.run(0).value res0: (Int, Unit) = (5,())
- Definition Classes
- Applicative
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- def tuple10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)]
- Definition Classes
- ApplyArityFunctions
- def tuple11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)]
- Definition Classes
- ApplyArityFunctions
- def tuple12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)]
- Definition Classes
- ApplyArityFunctions
- def tuple13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)]
- Definition Classes
- ApplyArityFunctions
- def tuple14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)]
- Definition Classes
- ApplyArityFunctions
- def tuple15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)]
- Definition Classes
- ApplyArityFunctions
- def tuple16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)]
- Definition Classes
- ApplyArityFunctions
- def tuple17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)]
- Definition Classes
- ApplyArityFunctions
- def tuple18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)]
- Definition Classes
- ApplyArityFunctions
- def tuple19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)]
- Definition Classes
- ApplyArityFunctions
- def tuple2[A, B](f1: F[A], f2: F[B]): F[(A, B)]
- Definition Classes
- ApplyArityFunctions
- def tuple20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)]
- Definition Classes
- ApplyArityFunctions
- def tuple21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)]
- Definition Classes
- ApplyArityFunctions
- def tuple22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)]
- Definition Classes
- ApplyArityFunctions
- def tuple3[A0, A1, A2](f0: F[A0], f1: F[A1], f2: F[A2]): F[(A0, A1, A2)]
- Definition Classes
- ApplyArityFunctions
- def tuple4[A0, A1, A2, A3](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[(A0, A1, A2, A3)]
- Definition Classes
- ApplyArityFunctions
- def tuple5[A0, A1, A2, A3, A4](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[(A0, A1, A2, A3, A4)]
- Definition Classes
- ApplyArityFunctions
- def tuple6[A0, A1, A2, A3, A4, A5](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[(A0, A1, A2, A3, A4, A5)]
- Definition Classes
- ApplyArityFunctions
- def tuple7[A0, A1, A2, A3, A4, A5, A6](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[(A0, A1, A2, A3, A4, A5, A6)]
- Definition Classes
- ApplyArityFunctions
- def tuple8[A0, A1, A2, A3, A4, A5, A6, A7](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[(A0, A1, A2, A3, A4, A5, A6, A7)]
- Definition Classes
- ApplyArityFunctions
- def tuple9[A0, A1, A2, A3, A4, A5, A6, A7, A8](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8)]
- Definition Classes
- ApplyArityFunctions
- def tupleLeft[A, B](fa: F[A], b: B): F[(B, A)]
Tuples the
A
value inF[A]
with the suppliedB
value, with theB
value on the left.Tuples the
A
value inF[A]
with the suppliedB
value, with theB
value on the left.Example:
scala> import scala.collection.immutable.Queue scala> import cats.Functor scala> import cats.implicits.catsStdInstancesForQueue scala> Functor[Queue].tupleLeft(Queue("hello", "world"), 42) res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))
- Definition Classes
- Functor
- def tupleRight[A, B](fa: F[A], b: B): F[(A, B)]
Tuples the
A
value inF[A]
with the suppliedB
value, with theB
value on the right.Tuples the
A
value inF[A]
with the suppliedB
value, with theB
value on the right.Example:
scala> import scala.collection.immutable.Queue scala> import cats.Functor scala> import cats.implicits.catsStdInstancesForQueue scala> Functor[Queue].tupleRight(Queue("hello", "world"), 42) res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))
- Definition Classes
- Functor
- def unit: F[Unit]
Returns an
F[Unit]
value, equivalent withpure(())
.Returns an
F[Unit]
value, equivalent withpure(())
.A useful shorthand, also allowing implementations to optimize the returned reference (e.g. it can be a
val
).Example:
scala> import cats.implicits._ scala> Applicative[Option].unit res0: Option[Unit] = Some(())
- Definition Classes
- Applicative → InvariantMonoidal
- def unlessA[A](cond: Boolean)(f: => F[A]): F[Unit]
Returns the given argument (mapped to Unit) if
cond
isfalse
, otherwise, unit lifted into F.Returns the given argument (mapped to Unit) if
cond
isfalse
, otherwise, unit lifted into F.Example:
scala> import cats.implicits._ scala> Applicative[List].unlessA(true)(List(1, 2, 3)) res0: List[Unit] = List(()) scala> Applicative[List].unlessA(false)(List(1, 2, 3)) res1: List[Unit] = List((), (), ()) scala> Applicative[List].unlessA(true)(List.empty[Int]) res2: List[Unit] = List(()) scala> Applicative[List].unlessA(false)(List.empty[Int]) res3: List[Unit] = List()
- Definition Classes
- Applicative
- def unzip[A, B](fab: F[(A, B)]): (F[A], F[B])
Un-zips an
F[(A, B)]
consisting of element pairs or Tuple2 into two separate F's tupled.Un-zips an
F[(A, B)]
consisting of element pairs or Tuple2 into two separate F's tupled.NOTE: Check for effect duplication, possibly memoize before
scala> import cats.Functor scala> import cats.implicits.catsStdInstancesForList scala> Functor[List].unzip(List((1,2), (3, 4))) res0: (List[Int], List[Int]) = (List(1, 3),List(2, 4))
- Definition Classes
- Functor
- def void[A](fa: F[A]): F[Unit]
Empty the fa of the values, preserving the structure
Empty the fa of the values, preserving the structure
Example:
scala> import cats.Functor scala> import cats.implicits.catsStdInstancesForList scala> Functor[List].void(List(1,2,3)) res0: List[Unit] = List((), (), ())
- Definition Classes
- Functor
- 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
- @throws(classOf[java.lang.InterruptedException]) @native()
- def whenA[A](cond: Boolean)(f: => F[A]): F[Unit]
Returns the given argument (mapped to Unit) if
cond
istrue
, otherwise, unit lifted into F.Returns the given argument (mapped to Unit) if
cond
istrue
, otherwise, unit lifted into F.Example:
scala> import cats.implicits._ scala> Applicative[List].whenA(true)(List(1, 2, 3)) res0: List[Unit] = List((), (), ()) scala> Applicative[List].whenA(false)(List(1, 2, 3)) res1: List[Unit] = List(()) scala> Applicative[List].whenA(true)(List.empty[Int]) res2: List[Unit] = List() scala> Applicative[List].whenA(false)(List.empty[Int]) res3: List[Unit] = List(())
- Definition Classes
- Applicative
- def widen[A, B >: A](fa: F[A]): F[B]
Lifts natural subtyping covariance of covariant Functors.
Lifts natural subtyping covariance of covariant Functors.
NOTE: In certain (perhaps contrived) situations that rely on universal equality this can result in a
ClassCastException
, because it is implemented as a type cast. It could be implemented asmap(identity)
, but according to the functor laws, that should be equal tofa
, and a type cast is often much more performant. See this example ofwiden
creating aClassCastException
.Example:
scala> import cats.Functor scala> import cats.implicits.catsStdInstancesForOption scala> val s = Some(42) scala> Functor[Option].widen(s) res0: Option[Int] = Some(42)
- Definition Classes
- Functor
Inherited from Applicative[F]
Inherited from InvariantMonoidal[F]
Inherited from Apply[F]
Inherited from ApplyArityFunctions[F]
Inherited from InvariantSemigroupal[F]
Inherited from Semigroupal[F]
Inherited from Functor[F]
Inherited from Invariant[F]
Inherited from Serializable
Inherited from AnyRef
Inherited from Any
Ungrouped
ap arity
Higher-arity ap methods
map arity
Higher-arity map methods
tuple arity
Higher-arity tuple methods