cats
Construct a lazy Eval[A] instance.
Construct a lazy Eval[A] instance.
This type can be used for "lazy" values. In some sense it is equivalent to using a Function0 value.
This type will evaluate the computation every time the value is required. It should be avoided except when laziness is required and caching must be avoided. Generally, prefer Later.
Applicative functor.
Applicative functor.
Allows application of a function in an Applicative context to a value in an Applicative context
See: The Essence of the Iterator Pattern Also: Applicative programming with effects
Must obey the laws defined in cats.laws.ApplicativeLaws.
An applicative that also allows you to raise and or handle an error value.
An applicative that also allows you to raise and or handle an error value.
This type class allows one to abstract over error-handling applicatives.
Weaker version of Applicative[F]; has apply but not pure.
Weaker version of Applicative[F]; has apply but not pure.
Must obey the laws defined in cats.laws.ApplyLaws.
A type class abstracting over types that give rise to two independent cats.Foldables.
A type class abstracting over types that give rise to two independent cats.Traverses.
Cartesian captures the idea of composing independent effectful values.
Cartesian captures the idea of composing independent effectful values.
It is of particular interest when taken together with Functor - where Functor
captures the idea of applying a unary pure function to an effectful value,
calling product with map allows one to apply a function of arbitrary arity to multiple
independent effectful values.
That same idea is also manifested in the form of Apply, and indeed Apply extends both Cartesian and Functor to illustrate this.
Must obey the laws defined in cats.laws.CoflatMapLaws.
Must obey the laws defined in cats.laws.ComonadLaws.
Methods that apply to 2 nested Foldable instances
This class composes two Reducible instances to provide an
instance for the nested types.
This class composes two Reducible instances to provide an
instance for the nested types.
In other words, given a Reducible[F] instance (which can reduce
F[A]) and a Reducible[G] instance (which can reduce G[A]
values), this class is able to reduce F[G[A]] values.
Eval is a monad which controls evaluation.
Eval is a monad which controls evaluation.
This type wraps a value (or a computation that produces a value)
and can produce it on command via the .value method.
There are three basic evaluation strategies:
The Later and Always are both lazy strategies while Now is eager. Later and Always are distinguished from each other only by memoization: once evaluated Later will save the value to be returned immediately if it is needed again. Always will run its computation every time.
Eval supports stack-safe lazy computation via the .map and .flatMap methods, which use an internal trampoline to avoid stack overflows. Computation done within .map and .flatMap is always done lazily, even when applied to a Now instance.
It is not generally good style to pattern-match on Eval instances. Rather, use .map and .flatMap to chain computation, and use .value to get the result when needed. It is also not good style to create Eval instances whose computation involves calling .value on another Eval instance -- this can defeat the trampolining and lead to stack overflows.
FlatMap type class gives us flatMap, which allows us to have a value in a context (F[A]) and then feed that into a function that takes a normal value and returns a value in a context (A => F[B]).
FlatMap type class gives us flatMap, which allows us to have a value in a context (F[A]) and then feed that into a function that takes a normal value and returns a value in a context (A => F[B]).
One motivation for separating this out from Monad is that there are situations where we can implement flatMap but not pure. For example, we can implement map or flatMap that transforms the values of Map[K, ?], but we can't implement pure (because we wouldn't know what key to use when instantiating the new Map).
See https://github.com/typelevel/cats/issues/3 for some discussion. Must obey the laws defined in cats.laws.FlatMapLaws.
Data structures that can be folded to a summary value.
Data structures that can be folded to a summary value.
In the case of a collection (such as List or Set), these
methods will fold together (combine) the values contained in the
collection to produce a single result. Most collection types have
foldLeft methods, which will usually be used by the associated
Foldable[_] instance.
Foldable[F] is implemented in terms of two basic methods:
foldLeft(fa, b)(f) eagerly folds fa from left-to-right.foldRight(fa, b)(f) lazily folds fa from right-to-left.Beyond these it provides many other useful methods related to folding over F[A] values.
See: A tutorial on the universality and expressiveness of fold
Functor.
Functor.
The name is short for "covariant functor".
Must obey the laws defined in cats.laws.FunctorLaws.
Identity, encoded as type Id[A] = A, a convenient alias to make
identity instances well-kinded.
Identity, encoded as type Id[A] = A, a convenient alias to make
identity instances well-kinded.
The identity monad can be seen as the ambient monad that encodes
the effect of having no effect. It is ambient in the sense that
plain pure values are values of Id.
For instance, the cats.Functor instance for cats.Id
allows us to apply a function A => B to an Id[A] and get an
Id[B]. However, an Id[A] is the same as A, so all we're doing
is applying a pure function of type A => B to a pure value of
type A to get a pure value of type B. That is, the instance
encodes pure unary function application.
Construct a lazy Eval[A] instance.
Construct a lazy Eval[A] instance.
This type should be used for most "lazy" values. In some sense it is equivalent to using a lazy val.
When caching is not required or desired (e.g. if the value produced may be large) prefer Always. When there is no computation necessary, prefer Now.
Once Later has been evaluated, the closure (and any values captured by the closure) will not be retained, and will be available for garbage collection.
Monad.
Monad.
Allows composition of dependent effectful functions.
See: Monads for functional programming
Must obey the laws defined in cats.laws.MonadLaws.
The combination of a Monad with a MonoidK
A monad that also allows you to raise and or handle an error value.
A monad that also allows you to raise and or handle an error value.
This type class allows one to abstract over error-handling monads.
a Monad equipped with an additional method which allows us to create an "Empty" value for the Monad (for whatever "empty" makes sense for that particular monad).
a Monad equipped with an additional method which allows us to
create an "Empty" value for the Monad (for whatever "empty" makes
sense for that particular monad). This is of particular interest to
us since it allows us to add a filter method to a Monad, which is
used when pattern matching or using guards in for comprehensions.
A monad that has the ability to read from an environment.
A monad that can read, update, and pass along state (e.g.
A monad that can read, update, and pass along state (e.g. StateT).
A common use case for MonadState is for syntax, especially when
dealing with large monad transformer stacks. For instance:
val M = MonadState[StateT[List, Int, ?], Int] import M._ for { g <- get _ <- set(g + 1) r <- inspect(_ * 100) } yield r
A monad that support monoidal accumulation (e.g.
A monad that support monoidal accumulation (e.g. logging List[String])
MonoidK is a universal monoid which operates on kinds.
MonoidK is a universal monoid which operates on kinds.
This type class is useful when its type parameter F[_] has a structure that can be combined for any particular type, and which also has an "empty" representation. Thus, MonoidK is like a Monoid for kinds (i.e. parameterized types).
A MonoidK[F] can produce a Monoid[F[A]] for any type A.
Here's how to distinguish Monoid and MonoidK:
This class defines a Reducible[F] in terms of a Foldable[G]
together with a split method, F[A] => (A, G[A]).
This class defines a Reducible[F] in terms of a Foldable[G]
together with a split method, F[A] => (A, G[A]).
This class can be used on any type where the first value (A) and
the "rest" of the values (G[A]) can be easily found.
An instance of NotNull[A] indicates that A does not have a static type
of Null.
An instance of NotNull[A] indicates that A does not have a static type
of Null.
This can be useful in preventing Null from being inferred when a type
parameter is omitted.
Construct an eager Eval[A] instance.
Construct an eager Eval[A] instance.
In some sense it is equivalent to using a val.
This type should be used when an A value is already in hand, or when the computation to produce an A value is pure and very fast.
Data structures that can be reduced to a summary value.
Data structures that can be reduced to a summary value.
Reducible is like a non-empty Foldable. In addition to the fold
methods it provides reduce methods which do not require an initial
value.
In addition to the methods needed by Foldable, Reducible is
implemented in terms of two methods:
reduceLeftTo(fa)(f)(g) eagerly reduces with an additional mapping functionreduceRightTo(fa)(f)(g) lazily reduces with an additional mapping function
SemigroupK is a universal semigroup which operates on kinds.
SemigroupK is a universal semigroup which operates on kinds.
This type class is useful when its type parameter F[_] has a structure that can be combined for any particular type. Thus, SemigroupK is like a Semigroup for kinds (i.e. parameterized types).
A SemigroupK[F] can produce a Semigroup[F[A]] for any type A.
Here's how to distinguish Semigroup and SemigroupK:
A type class to provide textual representation.
A type class to provide textual representation. It is meant to be a better "toString". Whereas toString exists for any Object, regardless of whether or not the creator of the class explicitly made a toString method, a Show instance will only exist if someone explicitly provided one.
A typeclass which abstracts over the ability to lift an M[A] into a MonadTransformer
Traverse, also known as Traversable.
Traverse, also known as Traversable.
Traversal over a structure with an effect.
Traversing with the cats.Id effect is equivalent to cats.Functor#map. Traversing with the cats.data.Const effect where the first type parameter has a cats.Monoid instance is equivalent to cats.Foldable#fold.
The "Unit typeclass".
The "Unit typeclass". The only instance of Trivial is given by
Trivial.manifest, and this instance is guaranteed to be in the
implicit scope. Several convenience type aliases are provided in
companion object, covering a few common use cases and avoiding the
need for unnecessary lambdas (e.g. if you want a trivial typeclass
instance for a type constructor, you should use Trivial.PH1).
A type class that is used to help guide Scala's type inference to find type class instances for types which have shapes which differ from what their type classes are looking for.
A type class that is used to help guide Scala's type inference to find type class instances for types which have shapes which differ from what their type classes are looking for.
For example, Functor is defined for types in the shape F[_]. Scala has no problem finding instance of Functor which match this shape, such as Functor[Option], Functor[List], etc. There is also a functor defined for some types which have the Shape F[_,_] when one of the two 'holes' is fixed. For example. there is a Functor for Map[A,?] for any A, and for Either[A,?] for any A, however the Scala compiler will not find them without some coercing.
Symbolic aliases for various types are defined here.