cats
package cats
The cats
root package contains all the trait signatures of most Scala type classes.
Cats type classes are implemented using the approach from the Type classes as objects and implicits article.
For each type class, cats
provides three pieces:
 Its signature: a trait that is polymorphic on a type parameter.
Type class traits inherit from other type classes to indicate that any implementation of the lower type class (e.g. Applicative
)
can also serve as an instance for the higuer type class (e.g. Functor
).
 Type class 'instances, which are classes and objects that implement one or more type class signatures for some specific types.
Type class instances for several data types from the Java or Scala standard libraries are declared in the subpackage cats.instances
.
 Syntax extensions, each of which provides the methods of the type class defines as extension methods
(which in Scala 2 are encoded as implicit classes) for values of any type F
; given that an instance of the type class
for the receiver type (this
) is in the implicit scope.
Symtax extensions are declared in the cats.syntax
package.
 A set of laws, that are also generic on the type of the class, and are only defined on the operations of the type class.
The purpose of these laws is to declare some algebraic relations (equations) between Scala expressions involving the operations
of the type class, and test (but not verify) that implemented instances satisfy those equations.
Laws are defined in the catslaws
package.
Although most of cats type classes are declared in this package, some are declared in other packages:
 type classes that operate on base types (kind *
), and their implementations for standard library types,
are contained in cats.kernel
, which is a different SBT project. However, they are reexported from this package.
 type classes of kind F[_, _]
, such as cats.arrow.Profunctor" or cats.arrow.Arrow, which are relevant for
Functional Reactive Programming or optics, are declared in the cats.arrow
package.
 Also, those type classes that abstract over (pure or impure) functional runtime effects are declared
in the catseffect library.
 Some type classes for which no laws can be provided are left out of the main road, in a small and dirty alley.
These are the alleycats
.
 Source
 package.scala
 Alphabetic
 By Inheritance
 cats
 AnyRef
 Any
 Hide All
 Show All
 Public
 All
Type Members

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

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

trait
Align[F[_]] extends Serializable
Align
supports zipping together structures with different shapes, holding the results from either or both structures in anIor
.Align
supports zipping together structures with different shapes, holding the results from either or both structures in anIor
.Must obey the laws in cats.laws.AlignLaws
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )

trait
Alternative[F[_]] extends Applicative[F] with MonoidK[F]
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )

final
class
Always[A] extends Leaf[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 InvariantMonoidal[F]
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.
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )

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 errorhandling applicatives.

trait
Apply[F[_]] extends Functor[F] with InvariantSemigroupal[F] with ApplyArityFunctions[F]
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.
 Annotations
 @implicitNotFound( ... ) @typeclass( List("ApplyArityFunctions") , ... )
 trait ApplyArityFunctions[F[_]] extends AnyRef

trait
Bifoldable[F[_, _]] extends Serializable
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.Foldables.
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )

trait
Bifunctor[F[_, _]] extends Serializable
A type class of types which give rise to two independent, covariant functors.
A type class of types which give rise to two independent, covariant functors.
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )

trait
Bimonad[F[_]] extends Monad[F] with Comonad[F]
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )

trait
Bitraverse[F[_, _]] extends Bifoldable[F] with Bifunctor[F]
A type class abstracting over types that give rise to two independent cats.Traverses.
A type class abstracting over types that give rise to two independent cats.Traverses.
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )

trait
CoflatMap[F[_]] extends Functor[F]
CoflatMap
is the dual ofFlatMap
.CoflatMap
is the dual ofFlatMap
.Must obey the laws in cats.laws.CoflatMapLaws
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )

trait
CommutativeApplicative[F[_]] extends Applicative[F] with CommutativeApply[F]
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.
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )

trait
CommutativeApply[F[_]] extends Apply[F]
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.
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )

trait
CommutativeFlatMap[F[_]] extends FlatMap[F] with CommutativeApply[F]
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.
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )

trait
CommutativeMonad[F[_]] extends Monad[F] with CommutativeFlatMap[F] with CommutativeApplicative[F]
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.
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )

trait
Comonad[F[_]] extends CoflatMap[F]
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.
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )
 type Comparison = cats.kernel.Comparison

trait
Contravariant[F[_]] extends Invariant[F]
Must obey the laws defined in cats.laws.ContravariantLaws.
Must obey the laws defined in cats.laws.ContravariantLaws.
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )

trait
ContravariantMonoidal[F[_]] extends ContravariantSemigroupal[F] with InvariantMonoidal[F]
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/contravariant1.4/docs/DataFunctorContravariantDivisible.html
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )

trait
ContravariantSemigroupal[F[_]] extends InvariantSemigroupal[F] with Contravariant[F]
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
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )

trait
Defer[F[_]] extends Serializable
Defer is a type class that shows the ability to defer creation inside of the type constructor F[_].
Defer is a type class that shows the ability to defer creation inside of the type constructor F[_].
This comes up with F[_] types that are implemented with a trampoline or are based on function application.
The law is that defer(fa) is equivalent to fa, but not evaluated immediately, so
scala> import cats._ scala> import cats.implicits._ scala> var evaluated = false scala> val dfa = Defer[Eval].defer {  evaluated = true  Eval.now(21)  } scala> evaluated res0: Boolean = false scala> Eq[Eval[Int]].eqv(dfa, Eval.now(21)) res1: Boolean = true

trait
Distributive[F[_]] extends Functor[F]
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )
 type Endo[A] = (A) ⇒ A
 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 stacksafe 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 patternmatch 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]
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).
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )
 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 UnorderedFoldable[F]
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
orVector
), 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.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 foldsfa
from lefttoright.foldRight(fa, b)(f)
lazily foldsfa
from righttoleft.
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
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )

trait
Functor[F[_]] extends Invariant[F]
Functor.
Functor.
The name is short for "covariant functor".
Must obey the laws defined in cats.laws.FunctorLaws.
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )

trait
FunctorFilter[F[_]] extends Serializable
FunctorFilter[F]
allows you tomap
and filter out elements simultaneously.FunctorFilter[F]
allows you tomap
and filter out elements simultaneously. Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )
 trait FunctorFilterInstances0 extends AnyRef
 type Group[A] = cats.kernel.Group[A]
 type Hash[A] = cats.kernel.Hash[A]

type
Id[A] = A
Identity, encoded as
type Id[A] = A
, a convenient alias to make identity instances wellkinded.Identity, encoded as
type Id[A] = A
, a convenient alias to make identity instances wellkinded.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. 
abstract
class
Inject[A, B] extends AnyRef
Inject is a type class providing an injection from type
A
into typeB
.Inject is a type class providing an injection from type
A
into typeB
. An injection is a functioninj
which does not destroy any information: for everyb: B
there is at most onea: A
such thatinj(a) = b
.Because of this all injections admit partial inverses
prj
which pair a valueb: B
back with a single valuea: 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

abstract
class
InjectK[F[_], G[_]] extends AnyRef
InjectK is a type class providing an injection from type constructor
F
into type constructorG
.InjectK is a type class providing an injection from type constructor
F
into type constructorG
. An injection is a functor transformationinj
which does not destroy any information: for everyga: G[A]
there is at most onefa: F[A]
such thatinj(fa) = ga
.Because of this all injections admit partial inverses
prj
which pair a valuega: G[A]
back with a single valuefa: 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
http://www.staff.science.uu.nl/~swier004/publications/2008jfp.pdf
Inject for injection for
Either

trait
Invariant[F[_]] extends Serializable
Must obey the laws defined in cats.laws.InvariantLaws.
Must obey the laws defined in cats.laws.InvariantLaws.
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )

trait
InvariantMonoidal[F[_]] extends InvariantSemigroupal[F]
Invariant version of a Monoidal.
Invariant version of a Monoidal.
Must obey the laws defined in cats.laws.InvariantMonoidalLaws.
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )

trait
InvariantSemigroupal[F[_]] extends Semigroupal[F] with Invariant[F]
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
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )

final
class
Later[A] extends Leaf[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]
Monad.
Monad.
Allows composition of dependent effectful functions.
See: Monads for functional programming
Must obey the laws defined in cats.laws.MonadLaws.
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )

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 errorhandling monads.
 type Monoid[A] = cats.kernel.Monoid[A]

trait
MonoidK[F[_]] extends SemigroupK[F]
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.
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )

trait
NonEmptyParallel[M[_]] 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.

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.This class is only a helper, does not define a typeclass and should not be used outside of Cats. Also see the discussion: PR #3541 and issue #3069.

trait
NonEmptyTraverse[F[_]] extends Traverse[F] with Reducible[F]
NonEmptyTraverse, also known as Traversable1.
NonEmptyTraverse, also known as Traversable1.
NonEmptyTraverse
is like a nonemptyTraverse
. In addition to the traverse and sequence methods it provides nonEmptyTraverse and nonEmptySequence methods which require anApply
instance instead ofApplicative
. Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )

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 Leaf[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]

trait
Parallel[M[_]] extends NonEmptyParallel[M]
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.
 trait ParallelArityFunctions extends AnyRef
 abstract class ParallelArityFunctions2 extends ParallelArityFunctions
 type PartialOrder[A] = cats.kernel.PartialOrder[A]

trait
Reducible[F[_]] extends Foldable[F]
Data structures that can be reduced to a summary value.
Data structures that can be reduced to a summary value.
Reducible
is like a nonemptyFoldable
. 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
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )

trait
Representable[F[_]] extends Serializable
Representable.
Representable.
Is a witness to the isomorphism forall A. F[A] <> Representation => A
Must obey the laws defined in cats.laws.RepresentableLaws i.e. tabulate andThen index = identity index andThen tabulate = identity
Inspired by the Haskell representable package http://hackage.haskell.org/package/representablefunctors3.2.0.2/docs/DataFunctorRepresentable.html
 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. 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.
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )
 trait SemigroupKInstances0 extends AnyRef

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
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 Semigroupal and Functor to illustrate this.
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )
 trait SemigroupalArityFunctions extends AnyRef

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.

trait
StackSafeMonad[F[_]] extends Monad[F]
A mixin for inheriting tailRecM on monads which define a stacksafe flatMap.
A mixin for inheriting tailRecM on monads which define a stacksafe flatMap. This is not an appropriate trait to use unless you are 100% certain your monad is stacksafe by definition! If your monad is not stacksafe, 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 stacksafe flatMap, and so this particular implementation was being repeated over and over again.

trait
Traverse[F[_]] extends Functor[F] with Foldable[F] with UnorderedTraverse[F]
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.
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )

trait
TraverseFilter[F[_]] extends FunctorFilter[F]
TraverseFilter
, also known asWitherable
, represents listlike structures that can essentially have atraverse
and afilter
applied as a single combined operation (traverseFilter
).TraverseFilter
, also known asWitherable
, represents listlike structures that can essentially have atraverse
and afilter
applied as a single combined operation (traverseFilter
).Based on Haskell's Data.Witherable
 Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )

trait
UnorderedFoldable[F[_]] extends Serializable
UnorderedFoldable
is like aFoldable
for unordered containers.UnorderedFoldable
is like aFoldable
for unordered containers. Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )

trait
UnorderedTraverse[F[_]] extends UnorderedFoldable[F]
UnorderedTraverse
is like aTraverse
for unordered containers.UnorderedTraverse
is like aTraverse
for unordered containers. Annotations
 @implicitNotFound( ... ) @typeclass( ... , ... )
 type ~>[F[_], G[_]] = FunctionK[F, G]
 type ⊤ = Any
 type ⊥ = Nothing
Value Members
 val Comparison: cats.kernel.Comparison.type
 val Eq: cats.kernel.Eq.type
 val Group: cats.kernel.Group.type
 val Hash: cats.kernel.Hash.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 CommutativeMonad[Id] with Comonad[Id] with NonEmptyTraverse[Id] with Distributive[Id]
 implicit val catsParallelForId: Aux[Id, Id]

implicit
val
catsRepresentableForId: Aux[Id, Unit]
Witness for: Id[A] <> Unit => A
 object Align extends ScalaVersionSpecificAlignInstances with Serializable
 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 Bifunctor extends Serializable
 object Bimonad extends Serializable
 object Bitraverse extends Serializable
 object CoflatMap extends Serializable
 object CommutativeApplicative extends Serializable
 object CommutativeApply extends Serializable
 object CommutativeFlatMap extends Serializable
 object CommutativeMonad extends Serializable
 object Comonad extends Serializable
 object Contravariant extends Serializable
 object ContravariantMonoidal extends SemigroupalArityFunctions with Serializable
 object ContravariantSemigroupal extends SemigroupalArityFunctions with Serializable
 object Defer extends Serializable
 object Distributive extends Serializable
 object Eval extends EvalInstances with Serializable
 object FlatMap extends Serializable
 object Foldable extends Serializable
 object Functor extends Serializable
 object FunctorFilter extends ScalaVersionSpecificTraverseFilterInstances with FunctorFilterInstances0 with Serializable
 object Inject extends InjectInstances
 object InjectK extends InjectKInstances

object
Invariant extends ScalaVersionSpecificInvariantInstances with InvariantInstances0 with Serializable
 Annotations
 @suppressUnusedImportWarningForScalaVersionSpecific()
 object InvariantMonoidal extends Serializable
 object InvariantSemigroupal extends SemigroupalArityFunctions with Serializable
 object Later extends Serializable
 object Monad extends Serializable
 object MonadError extends Serializable
 object MonoidK extends Serializable
 object NonEmptyParallel extends ScalaVersionSpecificParallelInstances with Serializable
 object NonEmptyTraverse extends Serializable
 object NotNull
 object Parallel extends ParallelArityFunctions2 with Serializable
 object Reducible extends Serializable
 object Representable extends Serializable
 object SemigroupK extends ScalaVersionSpecificMonoidKInstances with SemigroupKInstances0 with Serializable
 object Semigroupal extends ScalaVersionSpecificSemigroupalInstances with SemigroupalArityFunctions with Serializable

object
Show extends ScalaVersionSpecificShowInstances with ShowInstances with Serializable
Hand rolling the type class boilerplate due to scala/bug#6260 and scala/bug#10458
 object Traverse extends Serializable
 object TraverseFilter extends Serializable
 object UnorderedFoldable extends ScalaVersionSpecificTraverseInstances with Serializable
 object UnorderedTraverse extends Serializable
 object implicits extends AllSyntax with AllSyntaxBinCompat0 with AllSyntaxBinCompat1 with AllSyntaxBinCompat2 with AllSyntaxBinCompat3 with AllSyntaxBinCompat4 with AllSyntaxBinCompat5 with AllSyntaxBinCompat6 with AllInstances with AllInstancesBinCompat0 with AllInstancesBinCompat1 with AllInstancesBinCompat2 with AllInstancesBinCompat3 with AllInstancesBinCompat4 with AllInstancesBinCompat5 with AllInstancesBinCompat6