Type Members

1.  sealed abstract class AppFunc[F[_], A, B] extends Func[F, A, B]

   An implementation of Func that's specialized to Applicative.

2.  final case class Cokleisli[F[_], A, B](run: (F[A]) ⇒ B) extends Product with Serializable

   Represents a function F[A] => B.

3.  final case class Const[A, B](getConst: A) extends Product with Serializable

   Const is a phantom type, it does not contain a value of its second type parameter B Const can be seen as a type level version of Function.const[A, B]: A => B => A

4.  final case class EitherK[F[_], G[_], A](run: Either[F[A], G[A]]) extends Product with Serializable

   F on the left and G on the right of scala.util.Either.

   F on the left and G on the right of scala.util.Either.

   run

   The underlying scala.util.Either.

5.  type EitherNel[+E, +A] = Either[NonEmptyList[E], A]
6.  final case class EitherT[F[_], A, B](value: F[Either[A, B]]) extends Product with Serializable

   Transformer for Either, allowing the effect of an arbitrary type constructor F to be combined with the fail-fast effect of Either.

   Transformer for Either, allowing the effect of an arbitrary type constructor F to be combined with the fail-fast effect of Either.

   EitherT[F, A, B] wraps a value of type F[Either[A, B]]. An F[C] can be lifted in to EitherT[F, A, C] via EitherT.right, and lifted in to a EitherT[F, C, B] via EitherT.left.

7.  sealed abstract class Func[F[_], A, B] extends AnyRef

   Func is a function A => F[B].

   Func is a function A => F[B].

   See: The Essence of the Iterator Pattern

8.  type IRWST[F[_], E, L, SA, SB, A] = IndexedReaderWriterStateT[F, E, L, SA, SB, A]
9.  final case class IdT[F[_], A](value: F[A]) extends Product with Serializable

   IdT[F[_], A] is the identity monad transformer.

10.  final class IndexedReaderWriterStateT[F[_], E, L, SA, SB, A] extends Serializable

    Represents a stateful computation in a context F[_], from state SA to state SB, with an initial environment E, an accumulated log L and a result A.

    Represents a stateful computation in a context F[_], from state SA to state SB, with an initial environment E, an accumulated log L and a result A.

    In other words, it is a pre-baked stack of ReaderT[F, E, A], WriterT[F, L, A] and IndexedStateT[F, SA, SB, A].

11.  final class IndexedStateT[F[_], SA, SB, A] extends Serializable

    IndexedStateT[F, SA, SB, A] is a stateful computation in a context F yielding a value of type A.

    IndexedStateT[F, SA, SB, A] is a stateful computation in a context F yielding a value of type A. The state transitions from a value of type SA to a value of type SB.

    Note that for the SA != SB case, this is an indexed monad. Indexed monads are monadic type constructors annotated by an additional type for effect tracking purposes. In this case, the annotation tracks the initial state and the resulting state.

    Given IndexedStateT[F, S, S, A], this yields the StateT[F, S, A] monad.

12.  sealed abstract class Ior[+A, +B] extends Product with Serializable

    Represents a right-biased disjunction that is either an A, or a B, or both an A and a B.

    Represents a right-biased disjunction that is either an A, or a B, or both an A and a B.

    An instance of A Ior B is one of:

    • Left[A]
    • Right[B]
    • Both[A, B]

    A Ior B is similar to scala.util.Either[A, B], except that it can represent the simultaneous presence of an A and a B. It is right-biased so methods such as map and flatMap operate on the B value. Some methods, like flatMap, handle the presence of two Both values using a Semigroup[A], while other methods, like toEither, ignore the A value in a Both.

    A Ior B is isomorphic to Either[Either[A, B], (A, B)], but provides methods biased toward B values, regardless of whether the B values appear in a Right or a Both. The isomorphic scala.util.Either form can be accessed via the unwrap method.

13.  type IorNel[+B, +A] = Ior[NonEmptyList[B], A]
14.  final case class IorT[F[_], A, B](value: F[Ior[A, B]]) extends Product with Serializable
15.  final case class Kleisli[F[_], A, B](run: (A) ⇒ F[B]) extends Product with Serializable

    Represents a function A => F[B].

16.  final case class Nested[F[_], G[_], A](value: F[G[A]]) extends Product with Serializable

    Similar to cats.data.Tuple2K, but for nested composition.

    Similar to cats.data.Tuple2K, but for nested composition.

    For instance, since both List and Option have a Functor, then so does List[Option[_]]. This is represented by this data type via the instantiation Nested[List, Option, ?].

    scala> import cats.Functor
    scala> import cats.data.Nested
    scala> import cats.implicits._
    scala> val listOption: List[Option[Int]] = List(Some(1), None)
    scala> val f: Int => String = i => (i * 2).toString
    scala> Functor[List].map(listOption)(opt => opt.map(f))
    res0: List[Option[String]] = List(Some(2), None)
    scala> val nested: Nested[List, Option, Int] = Nested(listOption)
    scala> val result: Nested[List, Option, String] = Functor[Nested[List, Option, ?]].map(nested)(f)
    scala> result.value
    res1: List[Option[String]] = List(Some(2), None)

17.  final case class NonEmptyList[+A](head: A, tail: List[A]) extends Product with Serializable

    A data type which represents a non empty list of A, with single element (head) and optional structure (tail).

18.  type NonEmptyMap[K, +A] = data.NonEmptyMapImpl.Type[K, A]
19.  sealed class NonEmptyMapOps[K, A] extends AnyRef
20.  type NonEmptySet[A] = data.NonEmptySetImpl.Type[A]
21.  sealed class NonEmptySetOps[A] extends AnyRef
22.  type NonEmptyStream[A] = OneAnd[Stream, A]
23.  final class NonEmptyVector[+A] extends AnyVal

    A data type which represents a Vector guaranteed to contain at least one element.

    A data type which represents a Vector guaranteed to contain at least one element.
    Note that the constructor is private to prevent accidental construction of an empty NonEmptyVector. However, due to https://issues.scala-lang.org/browse/SI-6601, on Scala 2.10, this may be bypassed due to a compiler bug.

24.  final case class OneAnd[F[_], A](head: A, tail: F[A]) extends Product with Serializable

    A data type which represents a single element (head) and some other structure (tail).

    A data type which represents a single element (head) and some other structure (tail). As we have done in package.scala, this can be used to represent a Stream which is guaranteed to not be empty:

    type NonEmptyStream[A] = OneAnd[Stream, A]

25.  final case class OptionT[F[_], A](value: F[Option[A]]) extends Product with Serializable

    OptionT[F[_], A] is a light wrapper on an F[Option[A]] with some convenient methods for working with this nested structure.

    OptionT[F[_], A] is a light wrapper on an F[Option[A]] with some convenient methods for working with this nested structure.

    It may also be said that OptionT is a monad transformer for Option.

    For more information, see the documentation.

26.  type RWS[E, L, S, A] = IndexedReaderWriterStateT[Eval, E, L, S, S, A]
27.  type RWST[F[_], E, L, S, A] = IndexedReaderWriterStateT[F, E, L, S, S, A]
28.  type Reader[A, B] = Kleisli[Id, A, B]
29.  type ReaderT[F[_], A, B] = Kleisli[F, A, B]
30.  type ReaderWriterState[E, L, S, A] = IndexedReaderWriterStateT[Eval, E, L, S, S, A]
31.  type ReaderWriterStateT[F[_], E, L, S, A] = IndexedReaderWriterStateT[F, E, L, S, S, A]

    Represents a stateful computation in a context F[_], over state S, with an initial environment E, an accumulated log L and a result A.

32.  type State[S, A] = IndexedStateT[Eval, S, S, A]
33.  type StateT[F[_], S, A] = IndexedStateT[F, S, S, A]

    StateT[F, S, A] is similar to Kleisli[F, S, A] in that it takes an S argument and produces an A value wrapped in F.

    StateT[F, S, A] is similar to Kleisli[F, S, A] in that it takes an S argument and produces an A value wrapped in F. However, it also produces an S value representing the updated state (which is wrapped in the F context along with the A value.

34.  final case class Tuple2K[F[_], G[_], A](first: F[A], second: G[A]) extends Product with Serializable

    Tuple2K is a product to two independent functor values.

    Tuple2K is a product to two independent functor values.

    See: The Essence of the Iterator Pattern

35.  sealed abstract class Validated[+E, +A] extends Product with Serializable
36.  type ValidatedNel[+E, +A] = Validated[NonEmptyList[E], A]
37.  type Writer[L, V] = WriterT[Id, L, V]
38.  final case class WriterT[F[_], L, V](run: F[(L, V)]) extends Product with Serializable
39.  final class ZipList[A] extends AnyVal
40.  final class ZipStream[A] extends AnyVal
41.  final class ZipVector[A] extends AnyVal