Packages

trait MonadError[F[_], E] extends ApplicativeError[F, E] with Monad[F]

A monad that also allows you to raise and or handle an error value.

This type class allows one to abstract over error-handling monads.

Source
MonadError.scala
Ordering
  1. Grouped
  2. Alphabetic
  3. By Inheritance
Inherited
  1. MonadError
  2. Monad
  3. FlatMap
  4. ApplicativeError
  5. Applicative
  6. InvariantMonoidal
  7. Apply
  8. ApplyArityFunctions
  9. InvariantSemigroupal
  10. Semigroupal
  11. Functor
  12. Invariant
  13. Serializable
  14. Serializable
  15. AnyRef
  16. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Abstract Value Members

  1. abstract def flatMap[A, B](fa: F[A])(f: (A) ⇒ F[B]): F[B]
    Definition Classes
    FlatMap
  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.

    Definition Classes
    ApplicativeError
    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)
    Definition Classes
    ApplicativeError
  5. abstract def tailRecM[A, B](a: A)(f: (A) ⇒ F[Either[A, B]]): F[B]

    Keeps calling f until a scala.util.Right[B] is returned.

    Keeps calling f until a scala.util.Right[B] is returned.

    Based on Phil Freeman's Stack Safety for Free.

    Implementations of this method should use constant stack space relative to f.

    Definition Classes
    FlatMap

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.

    Definition Classes
    MonadErrorApplicativeError
  8. 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
    FlatMapApply
  9. 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
  10. 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
  11. 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
  12. 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
  13. 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
  14. 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
  15. 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
  16. 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
  17. 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
  18. 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
  19. 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
    FlatMapApply
  20. 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
  21. 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
  22. 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
  23. 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
  24. 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
  25. 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
  26. 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
  27. 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
  28. 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
  29. 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
  30. 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
  31. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  32. 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.

    Definition Classes
    ApplicativeError
  33. 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.

    Similar to attempt, but it only handles errors of type EE.

    Definition Classes
    ApplicativeError
  34. def attemptT[A](fa: F[A]): EitherT[F, E, A]

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

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

    Definition Classes
    ApplicativeError
  35. def attemptTap[A, B](fa: F[A])(f: (Either[E, A]) ⇒ F[B]): F[A]

    Reifies the value or error of the source and performs an effect on the result, then recovers the original value or error back into F.

    Reifies the value or error of the source and performs an effect on the result, then recovers the original value or error back into F.

    Note that if the effect returned by f fails, the resulting effect will fail too.

    Alias for fa.attempt.flatTap(f).rethrow for convenience.

    Example:

    scala> import cats.implicits._
    scala> import scala.util.{Try, Success, Failure}
    
    scala> def checkError(result: Either[Throwable, Int]): Try[String] = result.fold(_ => Failure(new java.lang.Exception), _ => Success("success"))
    
    scala> val a: Try[Int] = Failure(new Throwable("failed"))
    scala> a.attemptTap(checkError)
    res0: scala.util.Try[Int] = Failure(java.lang.Exception)
    
    scala> val b: Try[Int] = Success(1)
    scala> b.attemptTap(checkError)
    res1: scala.util.Try[Int] = Success(1)
  36. 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.

    Definition Classes
    ApplicativeError
  37. 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

    Definition Classes
    ApplicativeError
  38. 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.

    Definition Classes
    ApplicativeError
  39. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  40. 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
  41. 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
  42. def compose[G[_]](implicit arg0: Functor[G]): Functor[[α]F[G[α]]]
    Definition Classes
    Functor
  43. 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
  44. def composeApply[G[_]](implicit arg0: Apply[G]): InvariantSemigroupal[[α]F[G[α]]]
    Definition Classes
    InvariantSemigroupal
  45. 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
  46. 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
  47. 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
  48. def ensure[A](fa: F[A])(error: ⇒ E)(predicate: (A) ⇒ Boolean): F[A]

    Turns a successful value into an error if it does not satisfy a given predicate.

  49. def ensureOr[A](fa: F[A])(error: (A) ⇒ E)(predicate: (A) ⇒ Boolean): F[A]

    Turns a successful value into an error specified by the error function if it does not satisfy a given predicate.

  50. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  51. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  52. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  53. def flatTap[A, B](fa: F[A])(f: (A) ⇒ F[B]): F[A]

    Apply a monadic function and discard the result while keeping the effect.

    Apply a monadic function and discard the result while keeping the effect.

    scala> import cats._, implicits._
    scala> Option(1).flatTap(_ => None)
    res0: Option[Int] = None
    scala> Option(1).flatTap(_ => Some("123"))
    res1: Option[Int] = Some(1)
    scala> def nCats(n: Int) = List.fill(n)("cat")
    nCats: (n: Int)List[String]
    scala> List[Int](0).flatTap(nCats)
    res2: List[Int] = List()
    scala> List[Int](4).flatTap(nCats)
    res3: List[Int] = List(4, 4, 4, 4)
    Definition Classes
    FlatMap
  54. def flatten[A](ffa: F[F[A]]): F[A]

    "flatten" a nested F of F structure into a single-layer F structure.

    "flatten" a nested F of F structure into a single-layer F structure.

    This is also commonly called join.

    Example:

    scala> import cats.Eval
    scala> import cats.implicits._
    
    scala> val nested: Eval[Eval[Int]] = Eval.now(Eval.now(3))
    scala> val flattened: Eval[Int] = nested.flatten
    scala> flattened.value
    res0: Int = 3
    Definition Classes
    FlatMap
  55. 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
  56. def foreverM[A, B](fa: F[A]): F[B]

    Like an infinite loop of >> calls.

    Like an infinite loop of >> calls. This is most useful effect loops that you want to run forever in for instance a server.

    This will be an infinite loop, or it will return an F[Nothing].

    Be careful using this. For instance, a List of length k will produce a list of length k^n at iteration n. This means if k = 0, we return an empty list, if k = 1, we loop forever allocating single element lists, but if we have a k > 1, we will allocate exponentially increasing memory and very quickly OOM.

    Definition Classes
    FlatMap
    Annotations
    @noop()
  57. 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
  58. 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
  59. 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
    Definition Classes
    ApplicativeError
  60. 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)
    Definition Classes
    ApplicativeError
  61. 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

    If the error type is Throwable, we can convert from a scala.util.Try

    Definition Classes
    ApplicativeError
  62. 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
    Definition Classes
    ApplicativeError
  63. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  64. 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.

    Definition Classes
    ApplicativeError
    See also

    handleErrorWith to map to an F[A] value instead of simply an A value.

    recover to only recover from certain errors.

  65. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  66. def ifA[A](fcond: F[Boolean])(ifTrue: F[A], ifFalse: F[A]): F[A]

    An if-then-else lifted into the F context.

    An if-then-else lifted into the F context. This function combines the effects of the fcond condition and of the two branches, in the order in which they are given.

    The value of the result is, depending on the value of the condition, the value of the first argument, or the value of the second argument.

    Example:

    scala> import cats.implicits._
    
    scala> val b1: Option[Boolean] = Some(true)
    scala> val asInt1: Option[Int] = Apply[Option].ifA(b1)(Some(1), Some(0))
    scala> asInt1.get
    res0: Int = 1
    
    scala> val b2: Option[Boolean] = Some(false)
    scala> val asInt2: Option[Int] = Apply[Option].ifA(b2)(Some(1), Some(0))
    scala> asInt2.get
    res1: Int = 0
    
    scala> val b3: Option[Boolean] = Some(true)
    scala> val asInt3: Option[Int] = Apply[Option].ifA(b3)(Some(1), None)
    asInt2: Option[Int] = None
    Definition Classes
    Apply
    Annotations
    @noop()
  67. def ifElseM[A](branches: (F[Boolean], F[A])*)(els: F[A]): F[A]

    Simulates an if/else-if/else in the context of an F.

    Simulates an if/else-if/else in the context of an F. It evaluates conditions until one evaluates to true, and returns the associated F[A]. If no condition is true, returns els.

    scala> import cats._
    scala> Monad[Eval].ifElseM(Eval.later(false) -> Eval.later(1), Eval.later(true) -> Eval.later(2))(Eval.later(5)).value
    res0: Int = 2

    Based on a gist by Daniel Spiewak with a stack-safe implementation due to P. Oscar Boykin

    Definition Classes
    Monad
    Annotations
    @noop()
    See also

    See https://gitter.im/typelevel/cats-effect?at=5f297e4314c413356f56d230 for the discussion.

  68. 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()
  69. def ifM[B](fa: F[Boolean])(ifTrue: ⇒ F[B], ifFalse: ⇒ F[B]): F[B]

    if lifted into monad.

    if lifted into monad.

    Definition Classes
    FlatMap
    Annotations
    @noop()
  70. 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
  71. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  72. def iterateForeverM[A, B](a: A)(f: (A) ⇒ F[A]): F[B]

    iterateForeverM is almost exclusively useful for effect types.

    iterateForeverM is almost exclusively useful for effect types. For instance, A may be some state, we may take the current state, run some effect to get a new state and repeat.

    Definition Classes
    FlatMap
    Annotations
    @noop()
  73. def iterateUntil[A](f: F[A])(p: (A) ⇒ Boolean): F[A]

    Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.

    Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.

    Definition Classes
    Monad
  74. def iterateUntilM[A](init: A)(f: (A) ⇒ F[A])(p: (A) ⇒ Boolean): F[A]

    Apply a monadic function iteratively until its result satisfies the given predicate and return that result.

    Apply a monadic function iteratively until its result satisfies the given predicate and return that result.

    Definition Classes
    Monad
  75. def iterateWhile[A](f: F[A])(p: (A) ⇒ Boolean): F[A]

    Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.

    Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.

    Definition Classes
    Monad
  76. def iterateWhileM[A](init: A)(f: (A) ⇒ F[A])(p: (A) ⇒ Boolean): F[A]

    Apply a monadic function iteratively until its result fails to satisfy the given predicate and return that result.

    Apply a monadic function iteratively until its result fails to satisfy the given predicate and return that result.

    Definition Classes
    Monad
  77. 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
  78. def map[A, B](fa: F[A])(f: (A) ⇒ B): F[B]
    Definition Classes
    MonadApplicativeFunctor
  79. 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
  80. 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
  81. 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
  82. 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
  83. 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
  84. 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
  85. 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
  86. 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
  87. 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
  88. 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
  89. 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
    FlatMapApply
  90. 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
  91. 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
  92. 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
  93. 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
  94. 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
  95. 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
  96. 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
  97. 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
  98. 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
  99. 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
  100. 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
  101. def mproduct[A, B](fa: F[A])(f: (A) ⇒ F[B]): F[(A, B)]

    Pair A with the result of function application.

    Pair A with the result of function application.

    Example:

    scala> import cats.implicits._
    scala> List("12", "34", "56").mproduct(_.toList)
    res0: List[(String, Char)] = List((12,1), (12,2), (34,3), (34,4), (56,5), (56,6))
    Definition Classes
    FlatMap
  102. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  103. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  104. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  105. 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)))
    Definition Classes
    ApplicativeError
  106. 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
  107. 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
    FlatMapApplySemigroupal
  108. 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
    FlatMapApply
    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.)
  109. def productLEval[A, B](fa: F[A])(fb: Eval[F[B]]): F[A]

    Sequentially compose two actions, discarding any value produced by the second.

    Sequentially compose two actions, discarding any value produced by the second. This variant of productL also lets you define the evaluation strategy of the second action. For instance you can evaluate it only after the first action has finished:

    scala> import cats.Eval
    scala> import cats.implicits._
    scala> var count = 0
    scala> val fa: Option[Int] = Some(3)
    scala> def fb: Option[Unit] = Some(count += 1)
    scala> fa.productLEval(Eval.later(fb))
    res0: Option[Int] = Some(3)
    scala> assert(count == 1)
    scala> none[Int].productLEval(Eval.later(fb))
    res1: Option[Int] = None
    scala> assert(count == 1)
    Definition Classes
    FlatMap
  110. 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
    FlatMapApply
    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.)
  111. def productREval[A, B](fa: F[A])(fb: Eval[F[B]]): F[B]

    Sequentially compose two actions, discarding any value produced by the first.

    Sequentially compose two actions, discarding any value produced by the first. This variant of productR also lets you define the evaluation strategy of the second action. For instance you can evaluate it only after the first action has finished:

    scala> import cats.Eval
    scala> import cats.implicits._
    scala> val fa: Option[Int] = Some(3)
    scala> def fb: Option[String] = Some("foo")
    scala> fa.productREval(Eval.later(fb))
    res0: Option[String] = Some(foo)
    Definition Classes
    FlatMap
  112. 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.

    Definition Classes
    ApplicativeError
    See also

    handleError to handle any/all errors.

    recoverWith to recover from certain errors by mapping them to F[A] values.

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

    Definition Classes
    ApplicativeError
    See also

    handleErrorWith to handle any/all errors.

    recover to recover from certain errors by mapping them to A values.

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

    Definition Classes
    ApplicativeError
    See also

    MonadError.redeemWith, attempt and handleError

  115. def redeemWith[A, B](fa: F[A])(recover: (E) ⇒ F[B], bind: (A) ⇒ F[B]): F[B]

    Returns a new value that transforms the result of the source, given the recover or bind 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 bind 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 flatMap, this equivalence being available:

    fa.redeemWith(fe, fs) <-> fa.attempt.flatMap(_.fold(fe, fs))

    Usage of redeemWith subsumes handleErrorWith because:

    fa.redeemWith(fe, F.pure) <-> fa.handleErrorWith(fe)

    Usage of redeemWith also subsumes flatMap because:

    fa.redeemWith(F.raiseError, fs) <-> fa.flatMap(fs)

    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

    bind

    is the function that gets to transform the source in case of success

    See also

    redeem, attempt and handleErrorWith

  116. 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
  117. def rethrow[A, EE <: E](fa: F[Either[EE, A]]): F[A]

    Inverse of attempt

    Inverse of attempt

    Example:

    scala> import cats.implicits._
    scala> import scala.util.{Try, Success}
    
    scala> val a: Try[Either[Throwable, Int]] = Success(Left(new java.lang.Exception))
    scala> a.rethrow
    res0: scala.util.Try[Int] = Failure(java.lang.Exception)
    
    scala> val b: Try[Either[Throwable, Int]] = Success(Right(1))
    scala> b.rethrow
    res1: scala.util.Try[Int] = Success(1)
  118. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  119. def toString(): String
    Definition Classes
    AnyRef → Any
  120. 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
  121. 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
  122. 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
  123. 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
  124. 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
  125. 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
  126. 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
  127. 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
  128. 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
  129. 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
  130. def tuple2[A, B](f1: F[A], f2: F[B]): F[(A, B)]
    Definition Classes
    ApplyArityFunctions
  131. 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
  132. 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
  133. 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
  134. def tuple3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2]): F[(A0, A1, A2)]

    Definition Classes
    ApplyArityFunctions
  135. 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
  136. 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
  137. 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
  138. 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
  139. 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
  140. 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
  141. 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
  142. 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
  143. 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
  144. 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
  145. def untilDefinedM[A](foa: F[Option[A]]): F[A]

    This repeats an F until we get defined values.

    This repeats an F until we get defined values. This can be useful for polling type operations on State (or RNG) Monads, or in effect monads.

    Definition Classes
    FlatMap
    Annotations
    @noop()
  146. def untilM[G[_], A](f: F[A])(cond: ⇒ F[Boolean])(implicit G: Alternative[G]): F[G[A]]

    Execute an action repeatedly until the Boolean condition returns true.

    Execute an action repeatedly until the Boolean condition returns true. The condition is evaluated after the loop body. Collects results into an arbitrary Alternative value, such as a Vector. This implementation uses append on each evaluation result, so avoid data structures with non-constant append performance, e.g. List.

    Definition Classes
    Monad
  147. def untilM_[A](f: F[A])(cond: ⇒ F[Boolean]): F[Unit]

    Execute an action repeatedly until the Boolean condition returns true.

    Execute an action repeatedly until the Boolean condition returns true. The condition is evaluated after the loop body. Discards results.

    Definition Classes
    Monad
  148. 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()
  149. 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
  150. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  151. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  152. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  153. 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
  154. def whileM[G[_], A](p: F[Boolean])(body: ⇒ F[A])(implicit G: Alternative[G]): F[G[A]]

    Execute an action repeatedly as long as the given Boolean expression returns true.

    Execute an action repeatedly as long as the given Boolean expression returns true. The condition is evaluated before the loop body. Collects the results into an arbitrary Alternative value, such as a Vector. This implementation uses append on each evaluation result, so avoid data structures with non-constant append performance, e.g. List.

    Definition Classes
    Monad
    Annotations
    @noop()
  155. def whileM_[A](p: F[Boolean])(body: ⇒ F[A]): F[Unit]

    Execute an action repeatedly as long as the given Boolean expression returns true.

    Execute an action repeatedly as long as the given Boolean expression returns true. The condition is evaluated before the loop body. Discards results.

    Definition Classes
    Monad
    Annotations
    @noop()
  156. 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

Inherited from Monad[F]

Inherited from FlatMap[F]

Inherited from ApplicativeError[F, E]

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