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
Alias for productR.
Alias for productL.
Alias for ap.
ap2 is a binary version of ap, defined in terms of ap.
ap2 is a binary version of ap, defined in terms of ap.
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)
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)
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!)
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))
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
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)
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
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
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))
Compose two actions, discarding any value produced by the second.
Compose two actions, discarding any value produced by the second.
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.)
Compose two actions, discarding any value produced by the first.
Compose two actions, discarding any value produced by the first.
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.)
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))
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))
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((), (), ())
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)
Higher-arity ap methods
Higher-arity map methods
Higher-arity tuple methods
Commutative Apply.
Further than an Apply, which just allows composition of independent effectful functions, in a Commutative Apply those functions can be composed in any order, which guarantees that their effects do not interfere.
Must obey the laws defined in cats.laws.CommutativeApplyLaws.