p

cats

package cats

Symbolic aliases for various types are defined here.

Source
package.scala
Linear Supertypes
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. cats
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. type :<:[F[_], G[_]] = InjectK[F, G]

    cats.InjectK[F, G]

  2. type :≺:[F[_], G[_]] = InjectK[F, G]

    cats.InjectK[F, G]

  3. trait Alternative[F[_]] extends Applicative[F] with MonoidK[F] with Serializable
  4. 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.

  5. trait Applicative[F[_]] extends Apply[F] with InvariantMonoidal[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.

  6. 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.

  7. trait Apply[F[_]] extends Functor[F] with InvariantSemigroupal[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.

  8. trait ApplyArityFunctions[F[_]] extends AnyRef

  9. trait Bifoldable[F[_, _]] extends Serializable

    A type class abstracting over types that give rise to two independent cats.Foldables.

  10. trait Bifunctor[F[_, _]] extends Serializable

    A type class of types which give rise to two independent, covariant functors.

  11. trait Bimonad[F[_]] extends Monad[F] with Comonad[F] with Serializable
  12. 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.

  13. trait CoflatMap[F[_]] extends Functor[F] with Serializable

    CoflatMap is the dual of FlatMap.

    CoflatMap is the dual of FlatMap.

    Must obey the laws in cats.laws.CoflatMapLaws

  14. trait CommutativeApplicative[F[_]] extends Applicative[F] with CommutativeApply[F] with Serializable

    Commutative Applicative.

    Commutative Applicative.

    Further than an Applicative, which just allows composition of independent effectful functions, in a Commutative Applicative those functions can be composed in any order, which guarantees that their effects do not interfere.

    Must obey the laws defined in cats.laws.CommutativeApplicativeLaws.

  15. trait CommutativeApply[F[_]] extends Apply[F] with Serializable

    Commutative Apply.

    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.

  16. trait CommutativeFlatMap[F[_]] extends FlatMap[F] with CommutativeApply[F] with Serializable

    Commutative FlatMap.

    Commutative FlatMap.

    Further than a FlatMap, which just allows composition of dependent effectful functions, in a Commutative FlatMap those functions can be composed in any order, which guarantees that their effects do not interfere.

    Must obey the laws defined in cats.laws.CommutativeFlatMapLaws.

  17. trait CommutativeMonad[F[_]] extends Monad[F] with CommutativeFlatMap[F] with CommutativeApplicative[F] with Serializable

    Commutative Monad.

    Commutative Monad.

    Further than a Monad, which just allows composition of dependent effectful functions, in a Commutative Monad those functions can be composed in any order, which guarantees that their effects do not interfere.

    Must obey the laws defined in cats.laws.CommutativeMonadLaws.

  18. 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.

  19. type Comparison = cats.kernel.Comparison
  20. trait Contravariant[F[_]] extends Invariant[F] with Serializable

    Must obey the laws defined in cats.laws.ContravariantLaws.

  21. trait ContravariantMonoidal[F[_]] extends ContravariantSemigroupal[F] with InvariantMonoidal[F] with Serializable

    ContravariantMonoidal functors are functors that supply a unit along the diagonal map for the contramap2 operation.

    ContravariantMonoidal functors are functors that supply a unit along the diagonal map for the contramap2 operation.

    Must obey the laws defined in cats.laws.ContravariantMonoidalLaws.

    Based on ekmett's contravariant library: https://hackage.haskell.org/package/contravariant-1.4/docs/Data-Functor-Contravariant-Divisible.html

  22. trait ContravariantSemigroupal[F[_]] extends InvariantSemigroupal[F] with Contravariant[F] with Serializable

    ContravariantSemigroupal is nothing more than something both contravariant and Semigroupal.

    ContravariantSemigroupal is nothing more than something both contravariant and Semigroupal. It comes up enough to be useful, and composes well

  23. trait Distributive[F[_]] extends Functor[F] with Serializable
  24. type Endo[A] = (A) ⇒ A
  25. type Eq[A] = cats.kernel.Eq[A]
  26. 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.

  27. trait EvalGroup[A] extends Group[Eval[A]] with EvalMonoid[A]
  28. trait EvalMonoid[A] extends Monoid[Eval[A]] with EvalSemigroup[A]
  29. trait EvalSemigroup[A] extends Semigroup[Eval[A]]
  30. 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.

  31. trait Foldable[F[_]] extends UnorderedFoldable[F] with 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 or Vector), 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.

    Instances of Foldable should be ordered collections to allow for consistent folding. Use the UnorderedFoldable type class if you want to fold over unordered collections.

    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

  32. 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.

  33. type Group[A] = cats.kernel.Group[A]
  34. type Hash[A] = cats.kernel.Hash[A]
  35. 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 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.

  36. abstract class Inject[A, B] extends AnyRef

    Inject is a type class providing an injection from type A into type B.

    Inject is a type class providing an injection from type A into type B. An injection is a function inj which does not destroy any information: for every b: B there is at most one a: A such that inj(a) = b.

    Because of this all injections admit partial inverses prj which pair a value b: B back with a single value a: A.

    Since

    1.0

    Note

    Prior to cats 1.0, Inject handled injection for type constructors. For injection of type constructors, use InjectK.

    See also

    InjectK for injection for cats.data.EitherK

  37. abstract class InjectK[F[_], G[_]] extends AnyRef

    InjectK is a type class providing an injection from type constructor F into type constructor G.

    InjectK is a type class providing an injection from type constructor F into type constructor G. An injection is a functor transformation inj which does not destroy any information: for every ga: G[A] there is at most one fa: F[A] such that inj(fa) = ga.

    Because of this all injections admit partial inverses prj which pair a value ga: G[A] back with a single value fa: F[A].

    The behavior of the default instances for the InjectK type class are described thoroughly in "Data types a la carte" (Swierstra 2008).

    Note

    Prior to cats 1.0, InjectK was known as Inject.

    See also

    Inject for injection for Either

    http://www.staff.science.uu.nl/~swier004/publications/2008-jfp.pdf

  38. trait Invariant[F[_]] extends Serializable

    Must obey the laws defined in cats.laws.InvariantLaws.

  39. trait InvariantMonoidal[F[_]] extends InvariantSemigroupal[F] with Serializable

    Invariant version of a Monoidal.

    Invariant version of a Monoidal.

    Must obey the laws defined in cats.laws.InvariantMonoidalLaws.

  40. trait InvariantSemigroupal[F[_]] extends Semigroupal[F] with Invariant[F] with Serializable

    InvariantSemigroupal is nothing more than something both invariant and Semigroupal.

    InvariantSemigroupal is nothing more than something both invariant and Semigroupal. It comes up enough to be useful, and composes well

  41. 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.

  42. 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.

  43. 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.

  44. type Monoid[A] = cats.kernel.Monoid[A]
  45. 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. parametrized 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.
  46. trait NonEmptyParallel[M[_], F[_]] extends Serializable

    Some types that form a FlatMap, are also capable of forming an Apply that supports parallel composition.

    Some types that form a FlatMap, are also capable of forming an Apply that supports parallel composition. The NonEmptyParallel type class allows us to represent this relationship.

  47. abstract class NonEmptyReducible[F[_], G[_]] extends Reducible[F]

    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.

  48. trait NonEmptyTraverse[F[_]] extends Traverse[F] with Reducible[F] with Serializable

    NonEmptyTraverse, also known as Traversable1.

    NonEmptyTraverse, also known as Traversable1.

    NonEmptyTraverse is like a non-empty Traverse. In addition to the traverse and sequence methods it provides nonEmptyTraverse and nonEmptySequence methods which require an Apply instance instead of Applicative.

  49. sealed trait NotNull[A] extends AnyRef

    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.

    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 a Nothing type.

  50. 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.

  51. type Order[A] = cats.kernel.Order[A]
  52. trait Parallel[M[_], F[_]] extends NonEmptyParallel[M, F]

    Some types that form a Monad, are also capable of forming an Applicative that supports parallel composition.

    Some types that form a Monad, are also capable of forming an Applicative that supports parallel composition. The Parallel type class allows us to represent this relationship.

  53. trait ParallelArityFunctions extends AnyRef

  54. abstract class ParallelArityFunctions2 extends ParallelArityFunctions

  55. type PartialOrder[A] = cats.kernel.PartialOrder[A]
  56. 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-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 function
    • reduceRightTo(fa)(f)(g) lazily reduces with an additional mapping function
  57. type Semigroup[A] = cats.kernel.Semigroup[A]
  58. 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. parametrized 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.
  59. trait Semigroupal[F[_]] extends Serializable

    Semigroupal captures the idea of composing independent effectful values.

    Semigroupal 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 Semigroupal and Functor to illustrate this.

  60. trait SemigroupalArityFunctions extends AnyRef

  61. trait Show[T] extends ContravariantShow[T]

    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.

  62. trait StackSafeMonad[F[_]] extends Monad[F]

    A mix-in for inheriting tailRecM on monads which define a stack-safe flatMap.

    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.

  63. trait Traverse[F[_]] extends Functor[F] with Foldable[F] with UnorderedTraverse[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.

    See: The Essence of the Iterator Pattern

  64. trait UnorderedFoldable[F[_]] extends Serializable

    UnorderedFoldable is like a Foldable for unordered containers.

  65. trait UnorderedTraverse[F[_]] extends UnorderedFoldable[F] with Serializable

    UnorderedTraverse is like a Traverse for unordered containers.

  66. type ~>[F[_], G[_]] = FunctionK[F, G]
  67. type = Any
  68. type = Nothing
  69. type Cartesian[F[_]] = Semigroupal[F]
    Annotations
    @deprecated
    Deprecated

    (Since version 1.0.0-RC1) renamed to Semigroupal

Value Members

  1. val Comparison: cats.kernel.Comparison.type
  2. val Eq: cats.kernel.Eq.type
  3. val Group: cats.kernel.Group.type
  4. val Hash: cats.kernel.Hash.type
  5. val Monoid: cats.kernel.Monoid.type
  6. val Order: cats.kernel.Order.type
  7. val PartialOrder: cats.kernel.PartialOrder.type
  8. val Semigroup: cats.kernel.Semigroup.type
  9. implicit val catsInstancesForId: Bimonad[Id] with CommutativeMonad[Id] with Comonad[Id] with NonEmptyTraverse[Id] with Distributive[Id]
  10. implicit val catsParallelForId: Parallel[Id, Id]
  11. object Alternative extends Serializable
  12. object Always extends Serializable
  13. object Applicative extends Serializable
  14. object ApplicativeError extends Serializable
  15. object Apply extends Serializable
  16. object Bifoldable extends Serializable
  17. object Bifunctor extends Serializable
  18. object Bimonad extends Serializable
  19. object Bitraverse extends Serializable
  20. object CoflatMap extends Serializable
  21. object CommutativeApplicative extends Serializable
  22. object CommutativeApply extends Serializable
  23. object CommutativeFlatMap extends Serializable
  24. object CommutativeMonad extends Serializable
  25. object Comonad extends Serializable
  26. object Contravariant extends Serializable
  27. object ContravariantMonoidal extends SemigroupalArityFunctions with Serializable
  28. object ContravariantSemigroupal extends SemigroupalArityFunctions with Serializable
  29. object Distributive extends Serializable
  30. object Eval extends EvalInstances with Serializable
  31. object FlatMap extends Serializable
  32. object Foldable extends Serializable
  33. object Functor extends Serializable
  34. object Inject extends InjectInstances
  35. object InjectK extends InjectKInstances
  36. object Invariant extends Serializable
  37. object InvariantMonoidal extends Serializable
  38. object InvariantSemigroupal extends SemigroupalArityFunctions with Serializable
  39. object Later extends Serializable
  40. object Monad extends Serializable
  41. object MonadError extends Serializable
  42. object MonoidK extends Serializable
  43. object NonEmptyParallel extends Serializable
  44. object NonEmptyTraverse extends Serializable
  45. object NotNull
  46. object Parallel extends ParallelArityFunctions2 with Serializable
  47. object Reducible extends Serializable
  48. object SemigroupK extends Serializable
  49. object Semigroupal extends SemigroupalArityFunctions with Serializable
  50. object Show extends Serializable

    Hand rolling the type class boilerplate due to scala/bug#6260 and scala/bug#10458

  51. object Traverse extends Serializable
  52. object UnorderedFoldable extends Serializable
  53. object UnorderedTraverse extends Serializable
  54. object implicits extends AllSyntax with AllSyntaxBinCompat0 with AllInstances

Inherited from AnyRef

Inherited from Any

Ungrouped