cats
package cats
Symbolic aliases for various types are defined here.
- Alphabetic
- By Inheritance
- cats
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
- trait Alternative [F[_]] extends Applicative[F] with MonoidK[F] with Serializable
-
final
class
Always
[A] extends Eval[A]
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.
-
trait
Applicative
[F[_]] extends Apply[F] with Serializable
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.
-
trait
ApplicativeError
[F[_], E] extends Applicative[F]
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.
-
trait
Apply
[F[_]] extends Functor[F] with Cartesian[F] with ApplyArityFunctions[F] with Serializable
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.
- trait ApplyArityFunctions [F[_]] extends AnyRef
-
trait
Bifoldable
[F[_, _]] extends Serializable
A type class abstracting over types that give rise to two independent cats.Foldables.
- trait Bimonad [F[_]] extends Monad[F] with Comonad[F] with Serializable
-
trait
Bitraverse
[F[_, _]] extends Bifoldable[F] with Bifunctor[F] with Serializable
A type class abstracting over types that give rise to two independent cats.Traverses.
-
trait
Cartesian
[F[_]] extends Serializable
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
withmap
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.
- trait CartesianArityFunctions extends AnyRef
-
trait
CoflatMap
[F[_]] extends Functor[F] with Serializable
CoflatMap
is the dual ofFlatMap
.CoflatMap
is the dual ofFlatMap
.Must obey the laws in cats.laws.CoflatMapLaws
-
trait
Comonad
[F[_]] extends CoflatMap[F] with Serializable
Comonad
Comonad
Comonad is the dual of Monad. Whereas Monads allow for the composition of effectful functions, Comonads allow for composition of functions that extract the value from their context.
Must obey the laws defined in cats.laws.ComonadLaws.
-
trait
ContravariantCartesian
[F[_]] extends Cartesian[F] with Contravariant[F] with Serializable
ContravariantCartesian is nothing more than something both contravariant and Cartesian.
ContravariantCartesian is nothing more than something both contravariant and Cartesian. It comes up enough to be useful, and composes well
- type Eq[A] = cats.kernel.Eq[A]
-
sealed abstract
class
Eval
[+A] extends Serializable
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:
- Now: evaluated immediately
- Later: evaluated once when value is needed
- Always: evaluated every time value is needed
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.
- trait EvalGroup [A] extends Group[Eval[A]] with EvalMonoid[A]
- trait EvalMonoid [A] extends Monoid[Eval[A]] with EvalSemigroup[A]
- trait EvalSemigroup [A] extends Semigroup[Eval[A]]
-
trait
FlatMap
[F[_]] extends Apply[F] with Serializable
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 also
See https://github.com/typelevel/cats/issues/3 for some discussion. Must obey the laws defined in cats.laws.FlatMapLaws.
-
trait
Foldable
[F[_]] extends Serializable
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
orSet
), these methods will fold together (combine) the values contained in the collection to produce a single result. Most collection types havefoldLeft
methods, which will usually be used by the associatedFoldable[_]
instance.Foldable[F] is implemented in terms of two basic methods:
foldLeft(fa, b)(f)
eagerly foldsfa
from left-to-right.foldRight(fa, b)(f)
lazily foldsfa
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
-
trait
Functor
[F[_]] extends Invariant[F] with Serializable
Functor.
Functor.
The name is short for "covariant functor".
Must obey the laws defined in cats.laws.FunctorLaws.
- trait FunctorFilter [F[_]] extends Functor[F] with Serializable
- type Group[A] = cats.kernel.Group[A]
-
type
Id[A] = A
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 functionA => B
to anId[A]
and get anId[B]
. However, anId[A]
is the same asA
, so all we're doing is applying a pure function of typeA => B
to a pure value of typeA
to get a pure value of typeB
. That is, the instance encodes pure unary function application. -
trait
InvariantMonoidal
[F[_]] extends Invariant[F] with Cartesian[F] with Serializable
Invariant version of a Monoidal.
Invariant version of a Monoidal.
Must obey the laws defined in cats.laws.InvariantMonoidalLaws.
-
final
class
Later
[A] extends Eval[A]
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.
-
trait
Monad
[F[_]] extends FlatMap[F] with Applicative[F] with Serializable
Monad.
Monad.
Allows composition of dependent effectful functions.
See: Monads for functional programming
Must obey the laws defined in cats.laws.MonadLaws.
-
trait
MonadCombine
[F[_]] extends MonadFilter[F] with Alternative[F] with Serializable
The combination of a Monad with a MonoidK
-
trait
MonadError
[F[_], E] extends ApplicativeError[F, E] with Monad[F]
A monad that also allows you to raise and or handle an error value.
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.
-
trait
MonadFilter
[F[_]] extends Monad[F] with FunctorFilter[F] with Serializable
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. -
trait
MonadReader
[F[_], R] extends Monad[F]
A monad that has the ability to read from an environment.
-
trait
MonadState
[F[_], S] extends Monad[F]
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
-
trait
MonadWriter
[F[_], W] extends Monad[F]
A monad that support monoidal accumulation (e.g.
A monad that support monoidal accumulation (e.g. logging List[String])
- type Monoid[A] = cats.kernel.Monoid[A]
-
trait
MonoidK
[F[_]] extends SemigroupK[F] with Serializable
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:
- Monoid[A] allows A values to be combined, and also means there is an "empty" A value that functions as an identity.
- MonoidK[F] allows two F[A] values to be combined, for any A. It also means that for any A, there is an "empty" F[A] value. The combination operation and empty value just depend on the structure of F, but not on the structure of A.
-
abstract
class
NonEmptyReducible
[F[_], G[_]] extends Reducible[F]
This class defines a
Reducible[F]
in terms of aFoldable[G]
together with asplit
method,F[A]
=>(A, G[A])
.This class defines a
Reducible[F]
in terms of aFoldable[G]
together with asplit
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. -
sealed
trait
NotNull
[A] extends AnyRef
An instance of
NotNull[A]
indicates thatA
does not have a static type ofNull
.An instance of
NotNull[A]
indicates thatA
does not have a static type ofNull
.This can be useful in preventing
Null
from being inferred when a type parameter is omitted.This trait is used along with ambiguous implicits to achieve the goal of preventing inference of
Null
. This ambiguous implicit trick has been used in the Scala community for some time. Here is an early example of such a trick being used in a similar way to prevent aNothing
type. -
final
case class
Now
[A](value: A) extends Eval[A] with Product with Serializable
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.
- type Order[A] = cats.kernel.Order[A]
- type PartialOrder[A] = cats.kernel.PartialOrder[A]
-
trait
Reducible
[F[_]] extends Foldable[F] with Serializable
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-emptyFoldable
. 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
- type Semigroup[A] = cats.kernel.Semigroup[A]
-
trait
SemigroupK
[F[_]] extends Serializable
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:
- Semigroup[A] allows two A values to be combined.
- SemigroupK[F] allows two F[A] values to be combined, for any A. The combination operation just depends on the structure of F, but not the structure of A.
-
trait
Show
[T] extends Serializable
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.
-
trait
TransLift
[MT[_[_], _]] extends AnyRef
A type class which abstracts over the ability to lift an M[A] into a MonadTransformer
-
trait
Traverse
[F[_]] extends Functor[F] with Foldable[F] with Serializable
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.
-
trait
TraverseFilter
[F[_]] extends Traverse[F] with FunctorFilter[F] with Serializable
TraverseFilter
, also known asWitherable
, represents list-like structures that can essentially have a traverse and a filter applied as a single combined operation (traverseFilter).TraverseFilter
, also known asWitherable
, represents list-like structures that can essentially have a traverse and a filter applied as a single combined operation (traverseFilter).Must obey the laws defined in cats.laws.TraverseFilterLaws.
Based on Haskell's Data.Witherable
-
sealed
trait
Trivial
extends AnyRef
The "Unit type class".
The "Unit type class". The only instance of
Trivial
is given byTrivial.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 type class instance for a type constructor, you should useTrivial.PH1
). -
trait
Unapply
[TC[_[_]], MA] extends Serializable
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.
- type ~>[F[_], G[_]] = FunctionK[F, G]
- type ⊤ = Any
- type ⊥ = Nothing
Value Members
- val Eq: cats.kernel.Eq.type
- val Group: cats.kernel.Group.type
- val Monoid: cats.kernel.Monoid.type
- val Order: cats.kernel.Order.type
- val PartialOrder: cats.kernel.PartialOrder.type
- val Semigroup: cats.kernel.Semigroup.type
- implicit val catsInstancesForId: Bimonad[Id] with Monad[Id] with Traverse[Id]
- object Alternative extends Serializable
- object Always extends Serializable
- object Applicative extends Serializable
- object ApplicativeError extends Serializable
- object Apply extends Serializable
- object Bifoldable extends Serializable
- object Bimonad extends Serializable
- object Bitraverse extends Serializable
- object Cartesian extends CartesianArityFunctions with KernelCartesianInstances with Serializable
- object CoflatMap extends Serializable
- object Comonad extends Serializable
- object ContravariantCartesian extends KernelContravariantCartesianInstances with Serializable
- object Eval extends EvalInstances with Serializable
- object FlatMap extends Serializable
- object Foldable extends Serializable
- object Functor extends Serializable
- object FunctorFilter extends Serializable
- object InvariantMonoidal extends KernelInvariantMonoidalInstances with Serializable
- object Later extends Serializable
- object Monad extends Serializable
- object MonadCombine extends Serializable
- object MonadError extends Serializable
- object MonadFilter extends Serializable
- object MonadReader extends Serializable
- object MonadState extends Serializable
- object MonadWriter extends Serializable
- object MonoidK extends Serializable
- object NotNull
- object Reducible extends Serializable
- object SemigroupK extends Serializable
- object Show extends Serializable
- object TransLift
- object Traverse extends Serializable
- object TraverseFilter extends Serializable
- object Trivial
- object Unapply extends Unapply2Instances with Serializable
- object implicits extends AllSyntax with AllInstances