CellDecoderInstances

object CellDecoderInstances extends MonadError[CellDecoder, DecoderError] with SemigroupK[CellDecoder]
trait SemigroupK[CellDecoder]
trait MonadError[CellDecoder, DecoderError]
trait Monad[CellDecoder]
trait FlatMap[CellDecoder]
trait FlatMapArityFunctions[CellDecoder]
trait ApplicativeError[CellDecoder, DecoderError]
trait Applicative[CellDecoder]
trait InvariantMonoidal[CellDecoder]
trait Apply[CellDecoder]
trait ApplyArityFunctions[CellDecoder]
trait InvariantSemigroupal[CellDecoder]
trait Semigroupal[CellDecoder]
trait Functor[CellDecoder]
trait Invariant[CellDecoder]
trait Serializable
class Object
trait Matchable
class Any

Value members

Concrete methods

override def combineK[A](x: CellDecoder[A], y: CellDecoder[A]): CellDecoder[A]

Combine two F[A] values.

Combine two F[A] values.

Example:

scala> import cats.implicits._
scala> SemigroupK[List].combineK(List(1, 2), List(3, 4))
res0: List[Int] = List(1, 2, 3, 4)
Definition Classes
SemigroupK
def flatMap[A, B](fa: CellDecoder[A])(f: A => CellDecoder[B]): CellDecoder[B]

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.

override def map[A, B](fa: CellDecoder[A])(f: A => B): CellDecoder[B]
Definition Classes
Monad -> Applicative -> Functor
def pure[A](x: A): CellDecoder[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)

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)
def tailRecM[A, B](a: A)(f: A => CellDecoder[Either[A, B]]): CellDecoder[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.

Inherited methods

final def *>[A, B](fa: CellDecoder[A])(fb: CellDecoder[B]): F[B]

Alias for productR.

Alias for productR.

Inherited from:
Apply
final def <*[A, B](fa: CellDecoder[A])(fb: CellDecoder[B]): F[A]

Alias for productL.

Alias for productL.

Inherited from:
Apply
final def <*>[A, B](ff: CellDecoder[A => B])(fa: CellDecoder[A]): F[B]

Alias for ap.

Alias for ap.

Inherited from:
Apply
override def adaptError[A](fa: CellDecoder[A])(pf: PartialFunction[DecoderError, DecoderError]): F[A]

Transform certain errors using pf and rethrow them. Non matching errors and successful values are not affected by this function.

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
MonadError -> ApplicativeError
Inherited from:
MonadError
def algebra[A]: Semigroup[F[A]]

Given a type A, create a concrete Semigroup[F[A]].

Given a type A, create a concrete Semigroup[F[A]].

Example:

scala> import cats.implicits._
scala> val s: Semigroup[List[Int]] = SemigroupK[List].algebra[Int]
Inherited from:
SemigroupK
override def ap[A, B](ff: CellDecoder[A => B])(fa: CellDecoder[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
FlatMap -> Apply
Inherited from:
FlatMap
def ap10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f: CellDecoder[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z])(f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9]): F[Z]
Inherited from:
ApplyArityFunctions
def ap11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f: CellDecoder[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z])(f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10]): F[Z]
Inherited from:
ApplyArityFunctions
def ap12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f: CellDecoder[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z])(f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11]): F[Z]
Inherited from:
ApplyArityFunctions
def ap13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f: CellDecoder[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z])(f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12]): F[Z]
Inherited from:
ApplyArityFunctions
def ap14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f: CellDecoder[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z])(f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13]): F[Z]
Inherited from:
ApplyArityFunctions
def ap15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f: CellDecoder[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z])(f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14]): F[Z]
Inherited from:
ApplyArityFunctions
def ap16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f: CellDecoder[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z])(f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14], f15: CellDecoder[A15]): F[Z]
Inherited from:
ApplyArityFunctions
def ap17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f: CellDecoder[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z])(f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14], f15: CellDecoder[A15], f16: CellDecoder[A16]): F[Z]
Inherited from:
ApplyArityFunctions
def ap18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f: CellDecoder[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z])(f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14], f15: CellDecoder[A15], f16: CellDecoder[A16], f17: CellDecoder[A17]): F[Z]
Inherited from:
ApplyArityFunctions
def ap19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f: CellDecoder[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z])(f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14], f15: CellDecoder[A15], f16: CellDecoder[A16], f17: CellDecoder[A17], f18: CellDecoder[A18]): F[Z]
Inherited from:
ApplyArityFunctions
override def ap2[A, B, Z](ff: CellDecoder[(A, B) => Z])(fa: CellDecoder[A], fb: CellDecoder[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
FlatMap -> Apply
Inherited from:
FlatMap
def ap20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f: CellDecoder[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z])(f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14], f15: CellDecoder[A15], f16: CellDecoder[A16], f17: CellDecoder[A17], f18: CellDecoder[A18], f19: CellDecoder[A19]): F[Z]
Inherited from:
ApplyArityFunctions
def ap21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f: CellDecoder[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z])(f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14], f15: CellDecoder[A15], f16: CellDecoder[A16], f17: CellDecoder[A17], f18: CellDecoder[A18], f19: CellDecoder[A19], f20: CellDecoder[A20]): F[Z]
Inherited from:
ApplyArityFunctions
def ap22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f: CellDecoder[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z])(f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14], f15: CellDecoder[A15], f16: CellDecoder[A16], f17: CellDecoder[A17], f18: CellDecoder[A18], f19: CellDecoder[A19], f20: CellDecoder[A20], f21: CellDecoder[A21]): F[Z]
Inherited from:
ApplyArityFunctions
def ap3[A0, A1, A2, Z](f: CellDecoder[(A0, A1, A2) => Z])(f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2]): F[Z]
Inherited from:
ApplyArityFunctions
def ap4[A0, A1, A2, A3, Z](f: CellDecoder[(A0, A1, A2, A3) => Z])(f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3]): F[Z]
Inherited from:
ApplyArityFunctions
def ap5[A0, A1, A2, A3, A4, Z](f: CellDecoder[(A0, A1, A2, A3, A4) => Z])(f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4]): F[Z]
Inherited from:
ApplyArityFunctions
def ap6[A0, A1, A2, A3, A4, A5, Z](f: CellDecoder[(A0, A1, A2, A3, A4, A5) => Z])(f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5]): F[Z]
Inherited from:
ApplyArityFunctions
def ap7[A0, A1, A2, A3, A4, A5, A6, Z](f: CellDecoder[(A0, A1, A2, A3, A4, A5, A6) => Z])(f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6]): F[Z]
Inherited from:
ApplyArityFunctions
def ap8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f: CellDecoder[(A0, A1, A2, A3, A4, A5, A6, A7) => Z])(f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7]): F[Z]
Inherited from:
ApplyArityFunctions
def ap9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f: CellDecoder[(A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z])(f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8]): F[Z]
Inherited from:
ApplyArityFunctions
def as[A, B](fa: CellDecoder[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)
Inherited from:
Functor
def attempt[A](fa: CellDecoder[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.

Inherited from:
ApplicativeError
def attemptNarrow[EE <: Throwable, A](fa: CellDecoder[A])(implicit tag: ClassTag[EE], ev: EE <:< DecoderError): 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.

Inherited from:
ApplicativeError
def attemptT[A](fa: CellDecoder[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.

Inherited from:
ApplicativeError
def attemptTap[A, B](fa: CellDecoder[A])(f: Either[DecoderError, A] => CellDecoder[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)
Inherited from:
MonadError
def catchNonFatal[A](a: => A)(implicit ev: Throwable <:< DecoderError): F[A]

Often E is Throwable. Here we try to call pure or catch and raise.

Often E is Throwable. Here we try to call pure or catch and raise.

Inherited from:
ApplicativeError
def catchNonFatalEval[A](a: Eval[A])(implicit ev: Throwable <:< DecoderError): F[A]

Often E is Throwable. Here we try to call pure or catch and raise

Often E is Throwable. Here we try to call pure or catch and raise

Inherited from:
ApplicativeError
def catchOnly[T >: Null <: Throwable]: CatchOnlyPartiallyApplied[T, F, E]

Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.

Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.

Inherited from:
ApplicativeError
def combineAllOptionK[A](as: IterableOnce[CellDecoder[A]]): Option[F[A]]

Given a sequence of as, combine them and return the total.

Given a sequence of as, combine them and return the total.

If the sequence is empty, returns None. Otherwise, returns Some(total).

Example:

scala> SemigroupK[List].combineAllOptionK(List(List("One"), List("Two"), List("Three")))
res0: Option[List[String]] = Some(List(One, Two, Three))

scala> SemigroupK[List].combineAllOptionK[String](List.empty)
res1: Option[List[String]] = None
Inherited from:
SemigroupK
def combineKEval[A](x: CellDecoder[A], y: Eval[CellDecoder[A]]): Eval[F[A]]

Similar to combineK but uses Eval to allow for laziness in the second argument. This can allow for "short-circuiting" of computations.

Similar to combineK but uses Eval to allow for laziness in the second argument. This can allow for "short-circuiting" of computations.

NOTE: the default implementation of combineKEval does not short-circuit computations. For data structures that can benefit from laziness, SemigroupK instances should override this method.

In the following example, x.combineK(bomb) would result in an error, but combineKEval "short-circuits" the computation. x is Some and thus the result of bomb doesn't even need to be evaluated in order to determine that the result of combineKEval should be x.

scala> import cats.{Eval, Later}
scala> import cats.implicits._
scala> val bomb: Eval[Option[Int]] = Later(sys.error("boom"))
scala> val x: Option[Int] = Some(42)
scala> x.combineKEval(bomb).value
res0: Option[Int] = Some(42)
Inherited from:
SemigroupK
def combineNK[A](a: CellDecoder[A], n: Int): F[A]

Return a combined with itself n times.

Return a combined with itself n times.

Example:

scala> SemigroupK[List].combineNK(List(1), 5)
res0: List[Int] = List(1, 1, 1, 1, 1)

Inherited from:
SemigroupK
def compose[G[_]]: SemigroupK[[α] =>> F[G[α]]]

"Compose" with a G[_] type to form a SemigroupK for λ[α => F[G[α]]]. Note that this universally works for any G, because the "inner" structure isn't considered when combining two instances.

"Compose" with a G[_] type to form a SemigroupK for λ[α => F[G[α]]]. Note that this universally works for any G, because the "inner" structure isn't considered when combining two instances.

Example:

scala> import cats.implicits._
scala> type ListOption[A] = List[Option[A]]
scala> val s: SemigroupK[ListOption] = SemigroupK[List].compose[Option]
scala> s.combineK(List(Some(1), None, Some(2)), List(Some(3), None))
res0: List[Option[Int]] = List(Some(1), None, Some(2), Some(3), None)
Inherited from:
SemigroupK
def compose[G[_] : Applicative]: 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)
Inherited from:
Applicative
def compose[G[_] : Invariant]: 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)
Inherited from:
Invariant
def compose[G[_] : Apply]: 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)
Inherited from:
Apply
def compose[G[_] : Functor]: Functor[[α] =>> F[G[α]]]
Inherited from:
Functor
def composeApply[G[_] : Apply]: InvariantSemigroupal[[α] =>> F[G[α]]]
Inherited from:
InvariantSemigroupal
override def composeContravariant[G[_] : Contravariant]: 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
Functor -> Invariant
Inherited from:
Functor
def composeContravariantMonoidal[G[_] : ContravariantMonoidal]: 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)
Inherited from:
Applicative
def composeFunctor[G[_] : Functor]: 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)
Inherited from:
Invariant
def ensure[A](fa: CellDecoder[A])(error: => DecoderError)(predicate: A => Boolean): F[A]

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

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

Inherited from:
MonadError
def ensureOr[A](fa: CellDecoder[A])(error: A => DecoderError)(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.

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

Inherited from:
MonadError
def flatMap10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => CellDecoder[Z]): F[Z]
Inherited from:
FlatMapArityFunctions
def flatMap11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => CellDecoder[Z]): F[Z]
Inherited from:
FlatMapArityFunctions
def flatMap12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => CellDecoder[Z]): F[Z]
Inherited from:
FlatMapArityFunctions
def flatMap13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => CellDecoder[Z]): F[Z]
Inherited from:
FlatMapArityFunctions
def flatMap14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => CellDecoder[Z]): F[Z]
Inherited from:
FlatMapArityFunctions
def flatMap15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => CellDecoder[Z]): F[Z]
Inherited from:
FlatMapArityFunctions
def flatMap16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14], f15: CellDecoder[A15])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => CellDecoder[Z]): F[Z]
Inherited from:
FlatMapArityFunctions
def flatMap17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14], f15: CellDecoder[A15], f16: CellDecoder[A16])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => CellDecoder[Z]): F[Z]
Inherited from:
FlatMapArityFunctions
def flatMap18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14], f15: CellDecoder[A15], f16: CellDecoder[A16], f17: CellDecoder[A17])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => CellDecoder[Z]): F[Z]
Inherited from:
FlatMapArityFunctions
def flatMap19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14], f15: CellDecoder[A15], f16: CellDecoder[A16], f17: CellDecoder[A17], f18: CellDecoder[A18])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => CellDecoder[Z]): F[Z]
Inherited from:
FlatMapArityFunctions
def flatMap2[A0, A1, Z](f0: CellDecoder[A0], f1: CellDecoder[A1])(f: (A0, A1) => CellDecoder[Z]): F[Z]
Inherited from:
FlatMapArityFunctions
def flatMap20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14], f15: CellDecoder[A15], f16: CellDecoder[A16], f17: CellDecoder[A17], f18: CellDecoder[A18], f19: CellDecoder[A19])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => CellDecoder[Z]): F[Z]
Inherited from:
FlatMapArityFunctions
def flatMap21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14], f15: CellDecoder[A15], f16: CellDecoder[A16], f17: CellDecoder[A17], f18: CellDecoder[A18], f19: CellDecoder[A19], f20: CellDecoder[A20])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => CellDecoder[Z]): F[Z]
Inherited from:
FlatMapArityFunctions
def flatMap22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14], f15: CellDecoder[A15], f16: CellDecoder[A16], f17: CellDecoder[A17], f18: CellDecoder[A18], f19: CellDecoder[A19], f20: CellDecoder[A20], f21: CellDecoder[A21])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => CellDecoder[Z]): F[Z]
Inherited from:
FlatMapArityFunctions
def flatMap3[A0, A1, A2, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2])(f: (A0, A1, A2) => CellDecoder[Z]): F[Z]
Inherited from:
FlatMapArityFunctions
def flatMap4[A0, A1, A2, A3, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3])(f: (A0, A1, A2, A3) => CellDecoder[Z]): F[Z]
Inherited from:
FlatMapArityFunctions
def flatMap5[A0, A1, A2, A3, A4, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4])(f: (A0, A1, A2, A3, A4) => CellDecoder[Z]): F[Z]
Inherited from:
FlatMapArityFunctions
def flatMap6[A0, A1, A2, A3, A4, A5, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5])(f: (A0, A1, A2, A3, A4, A5) => CellDecoder[Z]): F[Z]
Inherited from:
FlatMapArityFunctions
def flatMap7[A0, A1, A2, A3, A4, A5, A6, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6])(f: (A0, A1, A2, A3, A4, A5, A6) => CellDecoder[Z]): F[Z]
Inherited from:
FlatMapArityFunctions
def flatMap8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7])(f: (A0, A1, A2, A3, A4, A5, A6, A7) => CellDecoder[Z]): F[Z]
Inherited from:
FlatMapArityFunctions
def flatMap9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => CellDecoder[Z]): F[Z]
Inherited from:
FlatMapArityFunctions
def flatTap[A, B](fa: CellDecoder[A])(f: A => CellDecoder[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)
Inherited from:
FlatMap
def flatten[A](ffa: CellDecoder[CellDecoder[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
Inherited from:
FlatMap
final def fmap[A, B](fa: CellDecoder[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!)
Inherited from:
Functor
def foreverM[A, B](fa: CellDecoder[A]): F[B]

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

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.

Inherited from:
FlatMap
def fproduct[A, B](fa: CellDecoder[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))
Inherited from:
Functor
def fproductLeft[A, B](fa: CellDecoder[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))
Inherited from:
Functor
def fromEither[A](x: Either[DecoderError, 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
Inherited from:
ApplicativeError
def fromOption[A](oa: Option[A], ifEmpty: => DecoderError): 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)
Inherited from:
ApplicativeError
def fromTry[A](t: Try[A])(implicit ev: Throwable <:< DecoderError): 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

Inherited from:
ApplicativeError
def fromValidated[A](x: Validated[DecoderError, 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
Inherited from:
ApplicativeError
def handleError[A](fa: CellDecoder[A])(f: DecoderError => 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.

Inherited from:
ApplicativeError
def ifElseM[A](branches: (CellDecoder[Boolean], CellDecoder[A])*)(els: CellDecoder[A]): F[A]

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.

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

See also:
Inherited from:
Monad
def ifF[A](fb: CellDecoder[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)
Inherited from:
Functor
def ifM[B](fa: CellDecoder[Boolean])(ifTrue: => CellDecoder[B], ifFalse: => CellDecoder[B]): F[B]

if lifted into monad.

if lifted into monad.

Inherited from:
FlatMap
override def imap[A, B](fa: CellDecoder[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
Functor -> Invariant
Inherited from:
Functor
def iterateForeverM[A, B](a: A)(f: A => CellDecoder[A]): F[B]

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.

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.

Inherited from:
FlatMap
def iterateUntil[A](f: CellDecoder[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.

Inherited from:
Monad
def iterateUntilM[A](init: A)(f: A => CellDecoder[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.

Inherited from:
Monad
def iterateWhile[A](f: CellDecoder[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.

Inherited from:
Monad
def iterateWhileM[A](init: A)(f: A => CellDecoder[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.

Inherited from:
Monad
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)
Inherited from:
Functor
def map10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z): F[Z]
Inherited from:
ApplyArityFunctions
def map11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z): F[Z]
Inherited from:
ApplyArityFunctions
def map12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z): F[Z]
Inherited from:
ApplyArityFunctions
def map13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z): F[Z]
Inherited from:
ApplyArityFunctions
def map14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z): F[Z]
Inherited from:
ApplyArityFunctions
def map15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z): F[Z]
Inherited from:
ApplyArityFunctions
def map16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14], f15: CellDecoder[A15])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z): F[Z]
Inherited from:
ApplyArityFunctions
def map17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14], f15: CellDecoder[A15], f16: CellDecoder[A16])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z): F[Z]
Inherited from:
ApplyArityFunctions
def map18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14], f15: CellDecoder[A15], f16: CellDecoder[A16], f17: CellDecoder[A17])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z): F[Z]
Inherited from:
ApplyArityFunctions
def map19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14], f15: CellDecoder[A15], f16: CellDecoder[A16], f17: CellDecoder[A17], f18: CellDecoder[A18])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z): F[Z]
Inherited from:
ApplyArityFunctions
override def map2[A, B, Z](fa: CellDecoder[A], fb: CellDecoder[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
FlatMap -> Apply
Inherited from:
FlatMap
def map20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14], f15: CellDecoder[A15], f16: CellDecoder[A16], f17: CellDecoder[A17], f18: CellDecoder[A18], f19: CellDecoder[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]
Inherited from:
ApplyArityFunctions
def map21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14], f15: CellDecoder[A15], f16: CellDecoder[A16], f17: CellDecoder[A17], f18: CellDecoder[A18], f19: CellDecoder[A19], f20: CellDecoder[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]
Inherited from:
ApplyArityFunctions
def map22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14], f15: CellDecoder[A15], f16: CellDecoder[A16], f17: CellDecoder[A17], f18: CellDecoder[A18], f19: CellDecoder[A19], f20: CellDecoder[A20], f21: CellDecoder[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]
Inherited from:
ApplyArityFunctions
override def map2Eval[A, B, Z](fa: CellDecoder[A], fb: Eval[CellDecoder[B]])(f: (A, B) => Z): Eval[F[Z]]

Similar to map2 but uses Eval to allow for laziness in the F[B] argument. This can allow for "short-circuiting" of computations.

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
FlatMap -> Apply
Inherited from:
FlatMap
def map3[A0, A1, A2, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2])(f: (A0, A1, A2) => Z): F[Z]
Inherited from:
ApplyArityFunctions
def map4[A0, A1, A2, A3, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3])(f: (A0, A1, A2, A3) => Z): F[Z]
Inherited from:
ApplyArityFunctions
def map5[A0, A1, A2, A3, A4, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4])(f: (A0, A1, A2, A3, A4) => Z): F[Z]
Inherited from:
ApplyArityFunctions
def map6[A0, A1, A2, A3, A4, A5, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5])(f: (A0, A1, A2, A3, A4, A5) => Z): F[Z]
Inherited from:
ApplyArityFunctions
def map7[A0, A1, A2, A3, A4, A5, A6, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6])(f: (A0, A1, A2, A3, A4, A5, A6) => Z): F[Z]
Inherited from:
ApplyArityFunctions
def map8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7])(f: (A0, A1, A2, A3, A4, A5, A6, A7) => Z): F[Z]
Inherited from:
ApplyArityFunctions
def map9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z): F[Z]
Inherited from:
ApplyArityFunctions
def mproduct[A, B](fa: CellDecoder[A])(f: A => CellDecoder[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))
Inherited from:
FlatMap
def onError[A](fa: CellDecoder[A])(pf: PartialFunction[DecoderError, CellDecoder[Unit]]): F[A]

Execute a callback on certain errors, then rethrow them. Any non matching error is rethrown as well.

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)))
Inherited from:
ApplicativeError
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)
Inherited from:
InvariantMonoidal
override def product[A, B](fa: CellDecoder[A], fb: CellDecoder[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
FlatMap -> Apply -> Semigroupal
Inherited from:
FlatMap
override def productL[A, B](fa: CellDecoder[A])(fb: CellDecoder[B]): F[A]

Compose two actions, discarding any value produced by the second.

Compose two actions, discarding any value produced by the second.

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.)
Definition Classes
FlatMap -> Apply
Inherited from:
FlatMap
def productLEval[A, B](fa: CellDecoder[A])(fb: Eval[CellDecoder[B]]): F[A]

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:

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)
Inherited from:
FlatMap
override def productR[A, B](fa: CellDecoder[A])(fb: CellDecoder[B]): F[B]

Compose two actions, discarding any value produced by the first.

Compose two actions, discarding any value produced by the first.

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.)
Definition Classes
FlatMap -> Apply
Inherited from:
FlatMap
def productREval[A, B](fa: CellDecoder[A])(fb: Eval[CellDecoder[B]]): F[B]

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:

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)
Inherited from:
FlatMap
def raiseUnless(cond: Boolean)(e: => DecoderError): F[Unit]

Returns raiseError when cond is false, otherwise F.unit

Returns raiseError when cond is false, otherwise F.unit

Example:
val tooMany = 5
val x: Int = ???
F.raiseUnless(x < tooMany)(new IllegalArgumentException("Too many"))
Inherited from:
ApplicativeError
def raiseWhen(cond: Boolean)(e: => DecoderError): F[Unit]

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

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

Example:
val tooMany = 5
val x: Int = ???
F.raiseWhen(x >= tooMany)(new IllegalArgumentException("Too many"))
Inherited from:
ApplicativeError
def recover[A](fa: CellDecoder[A])(pf: PartialFunction[DecoderError, 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.

Inherited from:
ApplicativeError
def recoverWith[A](fa: CellDecoder[A])(pf: PartialFunction[DecoderError, CellDecoder[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.

Inherited from:
ApplicativeError
def redeem[A, B](fa: CellDecoder[A])(recover: DecoderError => 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.

Value parameters:
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

Inherited from:
ApplicativeError
def redeemWith[A, B](fa: CellDecoder[A])(recover: DecoderError => CellDecoder[B], bind: A => CellDecoder[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.

Value parameters:
bind

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

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:

redeem, attempt and handleErrorWith

Inherited from:
MonadError
def replicateA[A](n: Int, fa: CellDecoder[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))
Inherited from:
Applicative
def replicateA_[A](n: Int, fa: CellDecoder[A]): F[Unit]

Given fa and n, apply fa n times discarding results to return F[Unit].

Given fa and n, apply fa n times discarding results to return F[Unit].

Example:

scala> import cats.data.State

scala> type Counter[A] = State[Int, A]
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[Unit] =
    | Applicative[Counter].replicateA_(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, Unit) = (5,())
Inherited from:
Applicative
def rethrow[A, EE <: DecoderError](fa: CellDecoder[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)
Inherited from:
MonadError
def reverse: SemigroupK[F]

return a semigroupK that reverses the order so combineK(a, b) == reverse.combineK(b, a)

return a semigroupK that reverses the order so combineK(a, b) == reverse.combineK(b, a)

Inherited from:
SemigroupK
def sum[A, B](fa: CellDecoder[A], fb: CellDecoder[B])(implicit F: Functor[CellDecoder]): F[Either[A, B]]

Combines F[A] and F[B] into a F[Either[A,B]]].

Combines F[A] and F[B] into a F[Either[A,B]]].

Example:

scala> import cats.SemigroupK
scala> import cats.data.NonEmptyList
scala> SemigroupK[NonEmptyList].sum(NonEmptyList.one("abc"), NonEmptyList.one(2))
res0: NonEmptyList[Either[String,Int]] = NonEmptyList(Left(abc), Right(2))
Inherited from:
SemigroupK
def tuple10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)]
Inherited from:
ApplyArityFunctions
def tuple11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)]
Inherited from:
ApplyArityFunctions
def tuple12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)]
Inherited from:
ApplyArityFunctions
def tuple13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)]
Inherited from:
ApplyArityFunctions
def tuple14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)]
Inherited from:
ApplyArityFunctions
def tuple15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)]
Inherited from:
ApplyArityFunctions
def tuple16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14], f15: CellDecoder[A15]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)]
Inherited from:
ApplyArityFunctions
def tuple17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14], f15: CellDecoder[A15], f16: CellDecoder[A16]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)]
Inherited from:
ApplyArityFunctions
def tuple18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14], f15: CellDecoder[A15], f16: CellDecoder[A16], f17: CellDecoder[A17]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)]
Inherited from:
ApplyArityFunctions
def tuple19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14], f15: CellDecoder[A15], f16: CellDecoder[A16], f17: CellDecoder[A17], f18: CellDecoder[A18]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)]
Inherited from:
ApplyArityFunctions
def tuple2[A, B](f1: CellDecoder[A], f2: CellDecoder[B]): F[(A, B)]
Inherited from:
ApplyArityFunctions
def tuple20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14], f15: CellDecoder[A15], f16: CellDecoder[A16], f17: CellDecoder[A17], f18: CellDecoder[A18], f19: CellDecoder[A19]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)]
Inherited from:
ApplyArityFunctions
def tuple21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14], f15: CellDecoder[A15], f16: CellDecoder[A16], f17: CellDecoder[A17], f18: CellDecoder[A18], f19: CellDecoder[A19], f20: CellDecoder[A20]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)]
Inherited from:
ApplyArityFunctions
def tuple22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8], f9: CellDecoder[A9], f10: CellDecoder[A10], f11: CellDecoder[A11], f12: CellDecoder[A12], f13: CellDecoder[A13], f14: CellDecoder[A14], f15: CellDecoder[A15], f16: CellDecoder[A16], f17: CellDecoder[A17], f18: CellDecoder[A18], f19: CellDecoder[A19], f20: CellDecoder[A20], f21: CellDecoder[A21]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)]
Inherited from:
ApplyArityFunctions
def tuple3[A0, A1, A2](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2]): F[(A0, A1, A2)]
Inherited from:
ApplyArityFunctions
def tuple4[A0, A1, A2, A3](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3]): F[(A0, A1, A2, A3)]
Inherited from:
ApplyArityFunctions
def tuple5[A0, A1, A2, A3, A4](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4]): F[(A0, A1, A2, A3, A4)]
Inherited from:
ApplyArityFunctions
def tuple6[A0, A1, A2, A3, A4, A5](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5]): F[(A0, A1, A2, A3, A4, A5)]
Inherited from:
ApplyArityFunctions
def tuple7[A0, A1, A2, A3, A4, A5, A6](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6]): F[(A0, A1, A2, A3, A4, A5, A6)]
Inherited from:
ApplyArityFunctions
def tuple8[A0, A1, A2, A3, A4, A5, A6, A7](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7]): F[(A0, A1, A2, A3, A4, A5, A6, A7)]
Inherited from:
ApplyArityFunctions
def tuple9[A0, A1, A2, A3, A4, A5, A6, A7, A8](f0: CellDecoder[A0], f1: CellDecoder[A1], f2: CellDecoder[A2], f3: CellDecoder[A3], f4: CellDecoder[A4], f5: CellDecoder[A5], f6: CellDecoder[A6], f7: CellDecoder[A7], f8: CellDecoder[A8]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8)]
Inherited from:
ApplyArityFunctions
def tupleLeft[A, B](fa: CellDecoder[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))
Inherited from:
Functor
def tupleRight[A, B](fa: CellDecoder[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))
Inherited from:
Functor
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(())
Inherited from:
Applicative
def unlessA[A](cond: Boolean)(f: => CellDecoder[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()
Inherited from:
Applicative
def untilDefinedM[A](foa: CellDecoder[Option[A]]): F[A]

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.

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.

Inherited from:
FlatMap
def untilM[G[_], A](f: CellDecoder[A])(cond: => CellDecoder[Boolean])(implicit G: Alternative[G]): F[G[A]]

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.

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.

Inherited from:
Monad
def untilM_[A](f: CellDecoder[A])(cond: => CellDecoder[Boolean]): F[Unit]

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

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

Inherited from:
Monad
def unzip[A, B](fab: CellDecoder[(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))
Inherited from:
Functor
def void[A](fa: CellDecoder[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((), (), ())
Inherited from:
Functor
def whenA[A](cond: Boolean)(f: => CellDecoder[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(())
Inherited from:
Applicative
def whileM[G[_], A](p: CellDecoder[Boolean])(body: => CellDecoder[A])(implicit G: Alternative[G]): F[G[A]]

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.

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.

Inherited from:
Monad
def whileM_[A](p: CellDecoder[Boolean])(body: => CellDecoder[A]): F[Unit]

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

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

Inherited from:
Monad
def widen[A, B >: A](fa: CellDecoder[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)
Inherited from:
Functor

Deprecated and Inherited methods

def ifA[A](fcond: CellDecoder[Boolean])(ifTrue: CellDecoder[A], ifFalse: CellDecoder[A]): F[A]
Deprecated
Inherited from:
Apply