Packages

p

cats

data

package data

Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. data
  2. ScalaVersionSpecificPackage
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. sealed abstract class AndThen[-T, +R] extends (T) ⇒ R with Product with Serializable

    A function type of a single input that can do function composition (via andThen and compose) in constant stack space with amortized linear time application (in the number of constituent functions).

    A function type of a single input that can do function composition (via andThen and compose) in constant stack space with amortized linear time application (in the number of constituent functions).

    Example:

    val seed = AndThen((x: Int) => x + 1)
    val f = (0 until 10000).foldLeft(seed)((acc, _) => acc.andThen(_ + 1))
    
    // This should not trigger stack overflow ;-)
    f(0)

    This can be used to build stack safe data structures that make use of lambdas. The perfect candidates for usage with AndThen are the data structures using a signature like this (where F[_] is a monadic type):

    A => F[B]

    As an example, if we described this data structure, the naive solution for that map is stack unsafe:

    case class Resource[F[_], A, B](
      acquire: F[A],
      use: A => F[B],
      release: A => F[Unit]) {
    
      def flatMap[C](f: B => C)(implicit F: Functor[F]): Resource[F, A, C] = {
        Resource(
          ra.acquire,
          // Stack Unsafe!
          a => ra.use(a).map(f),
          ra.release)
      }
    }

    To describe a flatMap operation for this data type, AndThen can save the day:

    def flatMap[C](f: B => C)(implicit F: Functor[F]): Resource[F, A, C] = {
      Resource(
        ra.acquire,
        AndThen(ra.use).andThen(_.map(f)),
        ra.release)
    }
  2. sealed abstract class AppFunc[F[_], A, B] extends Func[F, A, B]

    An implementation of Func that's specialized to Applicative.

  3. final case class Binested[F[_, _], G[_], H[_], A, B](value: F[G[A], H[B]]) extends Product with Serializable

    Compose a two-slot type constructor F[_, _] with two single-slot type constructors G[_] and H[_], resulting in a two-slot type constructor with respect to the inner types.

    Compose a two-slot type constructor F[_, _] with two single-slot type constructors G[_] and H[_], resulting in a two-slot type constructor with respect to the inner types. For example, List and Option both have Functor instances, and Either has a Bifunctor instance. Therefore, Binested[Either, List, Option, *, *] has a Bifunctor instance as well:

    scala> import cats.Bifunctor
    scala> import cats.data.Binested
    scala> import cats.implicits._
    scala> val eitherListOption: Either[List[Int], Option[String]] = Right(Some("cats"))
    scala> val f: Int => String = _.toString
    scala> val g: String => String = _ + "-bifunctor"
    scala> val binested = Binested(eitherListOption)
    scala> val bimapped = Bifunctor[Binested[Either, List, Option, *, *]].bimap(binested)(f, g).value
    res0: Either[List[String], Option[String]] = Right(Some("cats-bifunctor"))
  4. sealed abstract class BinestedBifoldable[F[_, _], G[_], H[_]] extends Bifoldable[[δ$12$, ε$13$]Binested[F, G, H, δ$12$, ε$13$]]
  5. sealed abstract class BinestedBitraverse[F[_, _], G[_], H[_]] extends BinestedBifoldable[F, G, H] with Bitraverse[[δ$14$, ε$15$]Binested[F, G, H, δ$14$, ε$15$]]
  6. trait BinestedInstances extends BinestedInstances0
  7. sealed abstract class Chain[+A] extends AnyRef

    Trivial catenable sequence.

    Trivial catenable sequence. Supports O(1) append, and (amortized) O(1) uncons, such that walking the sequence via N successive uncons steps takes O(N).

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

    Represents a function F[A] => B.

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

  10. type Cont[A, B] = ContT[Eval, A, B]
  11. sealed abstract class ContT[M[_], A, +B] extends Serializable

    This is a continuation transformer based on the ContT in the Haskell package Control.Monad.Cont

    This is a continuation transformer based on the ContT in the Haskell package Control.Monad.Cont

    This is reasonably straight-forward except that to make a tailRecM implementation we leverage the Defer type class to obtain stack-safety.

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

  13. type EitherNec[+E, +A] = Either[NonEmptyChain[E], A]
  14. type EitherNel[+E, +A] = Either[NonEmptyList[E], A]
  15. type EitherNes[E, +A] = Either[NonEmptySet[E], A]
  16. 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.

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

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

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

  20. 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].

  21. type IndexedState[S1, S2, A] = IndexedStateT[Eval, S1, S2, A]
  22. 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.

  23. 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:

    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.

  24. type IorNec[+B, +A] = Ior[NonEmptyChain[B], A]
  25. type IorNel[+B, +A] = Ior[NonEmptyList[B], A]
  26. type IorNes[B, +A] = Ior[NonEmptySet[B], A]
  27. final case class IorT[F[_], A, B](value: F[Ior[A, B]]) extends Product with Serializable
  28. final case class Kleisli[F[_], -A, B](run: (A) ⇒ F[B]) extends Product with Serializable

    Represents a function A => F[B].

  29. final class KleisliFromFunctionPartiallyApplied[M[_], R] extends AnyRef
  30. 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)
  31. type NonEmptyChain[+A] = Type[A]
  32. final class NonEmptyChainOps[A] extends AnyVal with NonEmptyCollection[A, Chain, NonEmptyChain]
  33. final case class NonEmptyList[+A](head: A, tail: List[A]) extends NonEmptyCollection[A, List, NonEmptyList] with Product with Serializable

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

  34. type NonEmptyMap[K, +A] = data.NonEmptyMapImpl.Type[K, A]
  35. sealed class NonEmptyMapOps[K, A] extends AnyRef
  36. final class NonEmptySeq[+A] extends AnyVal with NonEmptyCollection[A, Seq, NonEmptySeq]

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

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

  37. type NonEmptySet[A] = data.NonEmptySetImpl.Type[A]
  38. sealed class NonEmptySetOps[A] extends AnyRef
    Annotations
    @suppressUnusedImportWarningForScalaVersionSpecific()
  39. type NonEmptyStream[A] = OneAnd[Stream, A]
    Definition Classes
    ScalaVersionSpecificPackage
  40. final class NonEmptyVector[+A] extends AnyVal with NonEmptyCollection[A, Vector, NonEmptyVector]

    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.

  41. 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]
  42. final case class Op[Arr[_, _], A, B](run: Arr[B, A]) extends Product with Serializable

    The dual category of some other category, Arr.

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

  44. type RWS[E, L, S, A] = IndexedReaderWriterStateT[Eval, E, L, S, S, A]
  45. type RWST[F[_], E, L, S, A] = IndexedReaderWriterStateT[F, E, L, S, S, A]
  46. type Reader[-A, B] = Kleisli[Id, A, B]
  47. type ReaderT[F[_], -A, B] = Kleisli[F, A, B]
  48. type ReaderWriterState[E, L, S, A] = IndexedReaderWriterStateT[Eval, E, L, S, S, A]
  49. 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.

  50. final case class RepresentableStore[F[_], S, A](fa: F[A], index: S)(implicit R: Aux[F, S]) extends Product with Serializable

    A generalization of StoreT, where the underlying functor F has a Representable instance.

    A generalization of StoreT, where the underlying functor F has a Representable instance. Store is the dual of State

  51. final case class RepresentableStoreT[W[_], F[_], S, A](runF: W[F[A]], index: S)(implicit F: Aux[F, S]) extends Product with Serializable
  52. trait RepresentableStoreTInstances1 extends RepresentableStoreTInstances2
  53. trait RepresentableStoreTInstances2 extends AnyRef
  54. type State[S, A] = IndexedStateT[Eval, S, S, A]
  55. 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.

  56. type Store[S, A] = RepresentableStore[[β$0$](S) ⇒ β$0$, S, A]
  57. type StoreT[W[_], S, A] = RepresentableStoreT[W, [β$2$](S) ⇒ β$2$, S, A]
  58. 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

  59. sealed abstract class Validated[+E, +A] extends Product with Serializable
  60. type ValidatedNec[+E, +A] = Validated[NonEmptyChain[E], A]
  61. type ValidatedNel[+E, +A] = Validated[NonEmptyList[E], A]
  62. type Writer[L, V] = WriterT[Id, L, V]
  63. final case class WriterT[F[_], L, V](run: F[(L, V)]) extends Product with Serializable
  64. final class ZipList[A] extends AnyVal
  65. final class ZipSeq[A] extends AnyVal
  66. final class ZipStream[A] extends AnyVal
  67. final class ZipVector[A] extends AnyVal

Value Members

  1. val IRWST: IndexedReaderWriterStateT.type
  2. val NonEmptyChain: NonEmptyChainImpl.type
  3. val NonEmptyMap: NonEmptyMapImpl.type
  4. val NonEmptySet: NonEmptySetImpl.type
  5. def NonEmptyStream[A](head: A, tail: A*): NonEmptyStream[A]
    Definition Classes
    ScalaVersionSpecificPackage
  6. def NonEmptyStream[A](head: A, tail: Stream[A] = Stream.empty): NonEmptyStream[A]
    Definition Classes
    ScalaVersionSpecificPackage
  7. val RWS: ReaderWriterState.type
  8. val RWST: ReaderWriterStateT.type
  9. val ReaderT: Kleisli.type
  10. object AndThen extends AndThenInstances0 with Serializable
  11. object AppFunc extends AppFuncInstances
  12. object Binested extends BinestedInstances with Serializable
  13. object Chain extends ChainInstances
  14. object Cokleisli extends CokleisliInstances with Serializable
  15. object Const extends ConstInstances with Serializable
  16. object Cont
  17. object ContT extends Serializable
  18. object EitherK extends EitherKInstances with Serializable
  19. object EitherT extends EitherTInstances with Serializable
  20. object Func extends FuncInstances
  21. object IdT extends IdTInstances with Serializable
  22. object IndexedReaderWriterStateT extends IRWSTInstances with CommonIRWSTConstructors with Serializable
  23. object IndexedState extends IndexedStateFunctions
  24. object IndexedStateT extends IndexedStateTInstances with CommonStateTConstructors0 with Serializable
  25. object Ior extends IorInstances with IorFunctions with IorFunctions2 with Serializable
  26. object IorT extends IorTInstances with Serializable
  27. object Kleisli extends KleisliInstances with KleisliFunctions with KleisliFunctionsBinCompat with KleisliExplicitInstances with Serializable
  28. object Nested extends NestedInstances with Serializable
  29. object NonEmptyList extends NonEmptyListInstances with Serializable
  30. object NonEmptySeq extends NonEmptySeqInstances with Serializable
  31. object NonEmptyVector extends NonEmptyVectorInstances with Serializable
  32. object OneAnd extends OneAndInstances with Serializable
  33. object Op extends OpInstances with Serializable
  34. object OptionT extends OptionTInstances with Serializable
  35. object Reader
  36. object ReaderWriterState extends RWSFunctions
  37. object ReaderWriterStateT extends RWSTFunctions
  38. object RepresentableStore extends Serializable
  39. object RepresentableStoreT extends RepresentableStoreTInstances1 with Serializable
  40. object State extends StateFunctions
  41. object StateT extends StateTFunctions with CommonStateTConstructors0
  42. object Store
  43. object StoreT
  44. object Tuple2K extends Tuple2KInstances with Serializable
  45. object Validated extends ValidatedInstances with ValidatedFunctions with ValidatedFunctionsBinCompat0 with Serializable
  46. object Writer
  47. object WriterT extends WriterTInstances with WriterTFunctions with WriterTFunctions0 with Serializable
  48. object ZipList
    Annotations
    @suppressUnusedImportWarningForScalaVersionSpecific()
  49. object ZipSeq
    Annotations
    @suppressUnusedImportWarningForScalaVersionSpecific()
  50. object ZipStream
  51. object ZipVector
    Annotations
    @suppressUnusedImportWarningForScalaVersionSpecific()

Inherited from ScalaVersionSpecificPackage

Inherited from AnyRef

Inherited from Any

Ungrouped