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 Coproduct [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.  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.

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

7.  final case class IdT [F[_], A](value: F[A]) extends Product with Serializable

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

8.  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 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.

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

   Represents a function A => F[B].

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

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

    Similar to cats.data.Prod, 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)

11.  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).

12.  type NonEmptyStream[A] = OneAnd[Stream, A]
13.  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.

14.  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 List which is guaranteed to not be empty:

    type NonEmptyList[A] = OneAnd[List, A]

15.  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.

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

    Prod is a product to two independent functor values.

    Prod is a product to two independent functor values.

    See: The Essence of the Iterator Pattern

17.  type Reader[A, B] = Kleisli[Id, A, B]
18.  type ReaderT[F[_], A, B] = Kleisli[F, A, B]
19.  type State[S, A] = StateT[Eval, S, A]
20.  final class StateT [F[_], S, A] extends Serializable

    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.

21.  sealed abstract class Validated [+E, +A] extends Product with Serializable
22.  type ValidatedNel[+E, +A] = Validated[NonEmptyList[E], A]
23.  type Writer[L, V] = WriterT[Id, L, V]
24.  final case class WriterT [F[_], L, V](run: F[(L, V)]) extends Product with Serializable