Packages

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
Known Subclasses
Ordering
  1. Grouped
  2. Alphabetic
  3. By Inheritance
Inherited
  1. ApplicativeError
  2. Applicative
  3. InvariantMonoidal
  4. Apply
  5. ApplyArityFunctions
  6. InvariantSemigroupal
  7. Semigroupal
  8. Functor
  9. Invariant
  10. Serializable
  11. Serializable
  12. AnyRef
  13. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Abstract Value Members

  1. 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
  2. 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 an F[A].

    recoverWith to recover from only certain errors.

  3. 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
  4. 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

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def *>[A, B](fa: F[A])(fb: F[B]): F[B]

    Alias for productR.

    Alias for productR.

    Definition Classes
    Apply
    Annotations
    @inline()
  4. final def <*[A, B](fa: F[A])(fb: F[B]): F[A]

    Alias for productL.

    Alias for productL.

    Definition Classes
    Apply
    Annotations
    @inline()
  5. final def <*>[A, B](ff: F[(A) ⇒ B])(fa: F[A]): F[B]

    Alias for ap.

    Alias for ap.

    Definition Classes
    Apply
    Annotations
    @inline()
  6. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  7. 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 as adaptErr - it cannot have the same name because this would result in ambiguous implicits due to adaptError having originally been included in the MonadError API and syntax.

  8. 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
  9. 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
  10. 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
  11. 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
  12. 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
  13. 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
  14. 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
  15. 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
  16. 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
  17. 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
  18. 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
  19. 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
  20. 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
  21. 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
  22. 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
  23. 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
  24. 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
  25. 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
  26. 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
  27. 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
  28. 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
  29. def as[A, B](fa: F[A], b: B): F[B]

    Replaces the A value in F[A] with the supplied value.

    Replaces the A value in F[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
  30. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  31. 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.

  32. 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.

  33. def attemptT[A](fa: F[A]): EitherT[F, E, A]

    Similar to attempt, but wraps the result in a cats.data.EitherT for convenience.

  34. 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.

  35. 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

  36. 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.

  37. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native() @IntrinsicCandidate()
  38. def compose[G[_]](implicit arg0: Applicative[G]): Applicative[[α]F[G[α]]]

    Compose an Applicative[F] and an Applicative[G] into an Applicative[λ[α => F[G[α]]]].

    Compose an Applicative[F] and an Applicative[G] into an Applicative[λ[α => 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
  39. def compose[G[_]](implicit arg0: Apply[G]): Apply[[α]F[G[α]]]

    Compose an Apply[F] and an Apply[G] into an Apply[λ[α => F[G[α]]]].

    Compose an Apply[F] and an Apply[G] into an Apply[λ[α => 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
  40. def compose[G[_]](implicit arg0: Functor[G]): Functor[[α]F[G[α]]]
    Definition Classes
    Functor
  41. def compose[G[_]](implicit arg0: Invariant[G]): Invariant[[α]F[G[α]]]

    Compose Invariant F[_] and G[_] then produce Invariant[F[G[_]]] using their imap.

    Compose Invariant F[_] and G[_] then produce Invariant[F[G[_]]] using their imap.

    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
  42. def composeApply[G[_]](implicit arg0: Apply[G]): InvariantSemigroupal[[α]F[G[α]]]
    Definition Classes
    InvariantSemigroupal
  43. def composeContravariant[G[_]](implicit arg0: Contravariant[G]): Contravariant[[α]F[G[α]]]

    Compose Invariant F[_] and Contravariant G[_] then produce Invariant[F[G[_]]] using F's imap and G's contramap.

    Compose Invariant F[_] and Contravariant G[_] then produce Invariant[F[G[_]]] using F's imap and G's contramap.

    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
    Definition Classes
    FunctorInvariant
  44. def composeContravariantMonoidal[G[_]](implicit arg0: ContravariantMonoidal[G]): ContravariantMonoidal[[α]F[G[α]]]

    Compose an Applicative[F] and a ContravariantMonoidal[G] into a ContravariantMonoidal[λ[α => F[G[α]]]].

    Compose an Applicative[F] and a ContravariantMonoidal[G] into a ContravariantMonoidal[λ[α => 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
  45. def composeFunctor[G[_]](implicit arg0: Functor[G]): Invariant[[α]F[G[α]]]

    Compose Invariant F[_] and Functor G[_] then produce Invariant[F[G[_]]] using F's imap and G's map.

    Compose Invariant F[_] and Functor G[_] then produce Invariant[F[G[_]]] using F's imap and G's map.

    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
  46. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  47. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  48. 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
  49. 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
  50. 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
  51. 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
  52. 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)
  53. 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

  54. 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
  55. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @IntrinsicCandidate()
  56. 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 an A value.

    recover to only recover from certain errors.

  57. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @IntrinsicCandidate()
  58. def ifF[A](fb: F[Boolean])(ifTrue: ⇒ A, ifFalse: ⇒ A): F[A]

    Lifts if to Functor

    Lifts if to Functor

    Example:

    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
    Annotations
    @noop()
  59. def imap[A, B](fa: F[A])(f: (A) ⇒ B)(g: (B) ⇒ A): F[B]

    Transform an F[A] into an F[B] by providing a transformation from A to B and one from B to A.

    Transform an F[A] into an F[B] by providing a transformation from A to B and one from B to A.

    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
    Definition Classes
    FunctorInvariant
  60. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  61. 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
  62. def map[A, B](fa: F[A])(f: (A) ⇒ B): F[B]
    Definition Classes
    ApplicativeFunctor
  63. 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
  64. 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
  65. 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
  66. 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
  67. 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
  68. 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
  69. 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
  70. 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
  71. 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
  72. 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
  73. 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
  74. 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
  75. 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
  76. 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
  77. 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, but map2Eval "short-circuits" the computation. x is None and thus the result of bomb doesn't even need to be evaluated in order to determine that the result of map2Eval should be None.

    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
  78. 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
  79. 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
  80. 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
  81. 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
  82. 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
  83. 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
  84. 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
  85. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  86. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @IntrinsicCandidate()
  87. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @IntrinsicCandidate()
  88. 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)))
  89. 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
  90. def product[A, B](fa: F[A], fb: F[B]): F[(A, B)]

    Combine an F[A] and an F[B] into an F[(A, B)] that maintains the effects of both fa and fb.

    Combine an F[A] and an F[B] into an F[(A, B)] that maintains the effects of both fa and fb.

    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
    ApplySemigroupal
  91. 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.)
  92. 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.)
  93. def raiseUnless(cond: Boolean)(e: ⇒ E): F[Unit]

    Returns raiseError when cond is false, otherwise F.unit

    Returns raiseError when cond is false, otherwise F.unit

    Example:
    1. val tooMany = 5
      val x: Int = ???
      F.raiseUnless(x < tooMany)(new IllegalArgumentException("Too many"))
  94. def raiseWhen(cond: Boolean)(e: ⇒ E): F[Unit]

    Returns raiseError when the cond is true, otherwise F.unit

    Returns raiseError when the cond is true, otherwise F.unit

    Example:
    1. val tooMany = 5
      val x: Int = ???
      F.raiseWhen(x >= tooMany)(new IllegalArgumentException("Too many"))
  95. 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.

  96. 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.

  97. 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 or map 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 or map 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

    MonadError.redeemWith, attempt and handleError

  98. def replicateA[A](n: Int, fa: F[A]): F[List[A]]

    Given fa and n, apply fa n times to construct an F[List[A]] value.

    Given fa and n, apply fa n times to construct an F[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
  99. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  100. def toString(): String
    Definition Classes
    AnyRef → Any
  101. def tuple10[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)]

    Definition Classes
    ApplyArityFunctions
  102. def tuple11[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)]

    Definition Classes
    ApplyArityFunctions
  103. def tuple12[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)]

    Definition Classes
    ApplyArityFunctions
  104. def tuple13[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)]

    Definition Classes
    ApplyArityFunctions
  105. def tuple14[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)]

    Definition Classes
    ApplyArityFunctions
  106. def tuple15[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)]

    Definition Classes
    ApplyArityFunctions
  107. def tuple16[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)]

    Definition Classes
    ApplyArityFunctions
  108. def tuple17[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)]

    Definition Classes
    ApplyArityFunctions
  109. def tuple18[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)]

    Definition Classes
    ApplyArityFunctions
  110. def tuple19[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)]

    Definition Classes
    ApplyArityFunctions
  111. def tuple2[A, B](f1: F[A], f2: F[B]): F[(A, B)]
    Definition Classes
    ApplyArityFunctions
  112. def tuple20[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)]

    Definition Classes
    ApplyArityFunctions
  113. def tuple21[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)]

    Definition Classes
    ApplyArityFunctions
  114. def tuple22[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)]

    Definition Classes
    ApplyArityFunctions
  115. def tuple3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2]): F[(A0, A1, A2)]

    Definition Classes
    ApplyArityFunctions
  116. def tuple4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[(A0, A1, A2, A3)]

    Definition Classes
    ApplyArityFunctions
  117. def tuple5[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)]

    Definition Classes
    ApplyArityFunctions
  118. def tuple6[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)]

    Definition Classes
    ApplyArityFunctions
  119. def tuple7[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)]

    Definition Classes
    ApplyArityFunctions
  120. def tuple8[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)]

    Definition Classes
    ApplyArityFunctions
  121. def tuple9[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)]

    Definition Classes
    ApplyArityFunctions
  122. def tupleLeft[A, B](fa: F[A], b: B): F[(B, A)]

    Tuples the A value in F[A] with the supplied B value, with the B value on the left.

    Tuples the A value in F[A] with the supplied B value, with the B 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
  123. def tupleRight[A, B](fa: F[A], b: B): F[(A, B)]

    Tuples the A value in F[A] with the supplied B value, with the B value on the right.

    Tuples the A value in F[A] with the supplied B value, with the B 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
  124. def unit: F[Unit]

    Returns an F[Unit] value, equivalent with pure(()).

    Returns an F[Unit] value, equivalent with pure(()).

    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
    ApplicativeInvariantMonoidal
  125. def unlessA[A](cond: Boolean)(f: ⇒ F[A]): F[Unit]

    Returns the given argument (mapped to Unit) if cond is false, otherwise, unit lifted into F.

    Returns the given argument (mapped to Unit) if cond is false, 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
  126. 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
    Annotations
    @noop()
  127. 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
  128. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  129. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  130. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  131. def whenA[A](cond: Boolean)(f: ⇒ F[A]): F[Unit]

    Returns the given argument (mapped to Unit) if cond is true, otherwise, unit lifted into F.

    Returns the given argument (mapped to Unit) if cond is true, 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
  132. 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 as map(identity), but according to the functor laws, that should be equal to fa, and a type cast is often much more performant. See this example of widen creating a ClassCastException.

    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

Deprecated Value Members

  1. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] ) @Deprecated
    Deprecated
  2. def ifA[A](fcond: F[Boolean])(ifTrue: F[A], ifFalse: F[A]): F[A]
    Definition Classes
    Apply
    Annotations
    @noop() @deprecated
    Deprecated

    (Since version 2.6.2) Dangerous method, use ifM (a flatMap) or ifF (a map) instead

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 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