StackSafeMonad
Related Doc:
package cats
pure lifts any value into the Applicative Functor.
pure lifts any value into the Applicative Functor.
Applicative[Option].pure(10) = Some(10)
Alias for followedBy.
Alias for followedBy.
Alias for forEffect.
Alias for flatMap.
Given a value and a function in the Apply context, applies the function to the value.
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.
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)
"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
Compose two actions, discarding any value produced by the first.
Compose two actions, discarding any value produced by the first.
Sequentially compose two actions, discarding any value produced by the first.
Sequentially compose two actions, discarding any value produced by the first. This variant of followedBy 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.followedByEval(Eval.later(fb)) res0: Option[String] = Some(foo)
Compose two actions, discarding any value produced by the second.
Compose two actions, discarding any value produced by the second.
Sequentially compose two actions, discarding any value produced by the second.
Sequentially compose two actions, discarding any value produced by the second. This variant of forEffect 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.forEffectEval(Eval.later(fb)) res0: Option[Int] = Some(3) scala> assert(count == 1) scala> none[Int].forEffectEval(Eval.later(fb)) res1: Option[Int] = None scala> assert(count == 1)
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
if lifted into monad.
if lifted into monad.
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.
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.
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.
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.
Lift a function f to operate on Functors
Lift a function f to operate on Functors
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.
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
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))
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.
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.
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.
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.
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).
Returns the given argument if cond is false, otherwise, unit lifted into F.
Returns the given argument if cond is false, otherwise, unit lifted into F.
Execute an action repeatedly until the Boolean condition returns true.
Execute an action repeatedly until the Boolean condition returns true.
The condition is evaluated after the loop body. Collects results into an
arbitrary Alternative value, such as a Vector.
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g. List.
Execute an action repeatedly until the Boolean condition returns true.
Execute an action repeatedly until the Boolean condition returns true.
The condition is evaluated after the loop body. Discards results.
Empty the fa of the values, preserving the structure
Empty the fa of the values, preserving the structure
Returns the given argument if cond is true, otherwise, unit lifted into F.
Returns the given argument if cond is true, otherwise, unit lifted into F.
Execute an action repeatedly as long as the given Boolean expression
returns true.
Execute an action repeatedly as long as the given Boolean expression
returns true. The condition is evaluated before the loop body.
Collects the results into an arbitrary Alternative value, such as a Vector.
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g. List.
Execute an action repeatedly as long as the given Boolean expression
returns true.
Execute an action repeatedly as long as the given Boolean expression
returns true. The condition is evaluated before the loop body.
Discards results.
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.
A mix-in for inheriting tailRecM on monads which define a stack-safe flatMap. This is not an appropriate trait to use unless you are 100% certain your monad is stack-safe by definition! If your monad is not stack-safe, then the tailRecM implementation you will inherit will not be sound, and will result in unexpected stack overflows. This trait is only provided because a large number of monads do define a stack-safe flatMap, and so this particular implementation was being repeated over and over again.