data

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