Packages

p

scalaz

package scalaz

Scalaz: Type classes and pure functional data structures for Scala.

This package, scalaz, contains:

  • type class definitions
  • data structures
  • related functions

Type class instances and other functions related to the Scala and Java standard library are in scalaz.std

Implicit conversions and wrapper classes that provide a more convenient syntax for accessing the functionality of the library are in scalaz.syntax.

Type Classes Index

Data Structures Index

Source
package.scala
Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. scalaz
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. final case class -\/[A, B](a: A) extends \/[A, B] with Product with Serializable

    A left disjunction

    A left disjunction

    Often used to represent the failure case of a result

  2. sealed abstract class /~\[A[_], B[_]] extends AnyRef

    Type-aligned pair.

    Type-aligned pair. Isomorphic to

    (F[A], G[A]) forSome { type A }

    but more robust with respect to type inference.

    Notation is conjunction /\ blended with ~, which is often used to indicate higher kindedness.

  3. sealed class :+:[M, N] extends AnyRef

    The coproduct (or free product) of monoids M and N.

    The coproduct (or free product) of monoids M and N. Conceptually this is an alternating list of M and N values, with the identity as the empty list, and composition as list concatenation that combines adjacent elements when possible.

  4. type :<:[F[_], G[_]] = Inject[F, G]

    scalaz.Inject[F, G]

  5. type :≺:[F[_], G[_]] = Inject[F, G]

    scalaz.Inject[F, G]

  6. type <~[F[_], G[_]] = NaturalTransformation[G, F]

    A scalaz.NaturalTransformation[G, F].

  7. type ===[A, B] = Leibniz[⊥, ⊤, A, B]

    (A === B) is a supertype of Leibniz[L,H,A,B]

  8. sealed abstract class ==>>[A, B] extends AnyRef

    An immutable map of key/value pairs implemented as a balanced binary tree

    An immutable map of key/value pairs implemented as a balanced binary tree

    Based on Haskell's Data.Map

    Since

    7.0.3

  9. type =?>[E, A] = Kleisli[Option, E, A]
  10. type @>[A, B] = LensFamily[A, A, B, B]

    See also

    scalaz.Lens

  11. type @?>[A, B] = PLensFamily[A, A, B, B]

    See also

    scalaz.PLens

  12. type @@[T, Tag] = scalaz.TagKind.@@[T, Tag]

    Tag a type T with Tag.

    Tag a type T with Tag.

    The resulting type is used to discriminate between type class instances.

    See also

    scalaz.Tag and scalaz.Tags Credit to Miles Sabin for the idea.

  13. abstract class Adjunction[F[_], G[_]] extends AnyRef

    An adjunction formed by two functors F and G such that F is left-adjoint to G.

    An adjunction formed by two functors F and G such that F is left-adjoint to G. The composite functor GF is a monad and the composite functor FG is a comonad.

    The minimal definition is either (unit, counit) or (leftAdjunct, rightAdjunct)

  14. sealed abstract class AdjunctionInstances extends AnyRef
  15. trait Align[F[_]] extends Functor[F]

  16. sealed abstract class Alpha extends Product with Serializable

    An algebraic data type representing the characters 'a' to 'z'

  17. sealed abstract class AlphaInstances extends AnyRef
  18. trait Alt[F[_]] extends Applicative[F] with InvariantAlt[F]

    https://hackage.haskell.org/package/semigroupoids-5.2.2/docs/Data-Functor-Alt.html

  19. final case class Alter[F[_], A](f: F[A]) extends Product with Serializable

    Derive a Semigroup or Monoid instance from a Plus or PlusEmpty.

    Derive a Semigroup or Monoid instance from a Plus or PlusEmpty.

    https://hackage.haskell.org/package/reducers-3.12.1/docs/Data-Semigroup-Alt.html#t:Alter

  20. sealed abstract class AlterInstances extends AlterInstances0
  21. sealed abstract class AlterInstances0 extends AnyRef
  22. final case class Ap[F[_], A](f: F[A]) extends Product with Serializable

    Derive a Semigroup or Monoid instance from an Apply or Applicative.

    Derive a Semigroup or Monoid instance from an Apply or Applicative.

    https://hackage.haskell.org/package/reducers-3.12.1/docs/Data-Semigroup-Applicative.html#t:Ap

  23. sealed abstract class ApInstances extends ApInstances0
  24. sealed abstract class ApInstances0 extends AnyRef
  25. trait Applicative[F[_]] extends Apply[F] with InvariantApplicative[F]

    Applicative Functor, described in Applicative Programming with Effects

    Applicative Functor, described in Applicative Programming with Effects

    Whereas a scalaz.Functor allows application of a pure function to a value in a context, an Applicative also allows application of a function in a context to a value in a context (ap).

    It follows that a pure function can be applied to arguments in a context. (See apply2, apply3, ... )

    Applicative instances come in a few flavours:

    • All scalaz.Monads are also Applicative
    • Any scalaz.Monoid can be treated as an Applicative (see scalaz.Monoid#applicative)
    • Zipping together corresponding elements of Naperian data structures (those of of a fixed, possibly infinite shape)
    See also

    scalaz.Applicative.ApplicativeLaw

  26. trait ApplicativeError[F[_], S] extends Applicative[F]
  27. trait ApplicativePlus[F[_]] extends Applicative[F] with PlusEmpty[F]

    scalaz.Applicative combined with scalaz.PlusEmpty.

  28. trait Apply[F[_]] extends Functor[F]

    scalaz.Applicative without point.

    scalaz.Applicative without point.

    See also

    scalaz.Apply.ApplyLaw

  29. trait Arrow[=>:[_, _]] extends Split[=>:] with Strong[=>:] with Category[=>:]

    A scalaz.Category supporting all ordinary functions, as well as combining arrows product-wise.

    A scalaz.Category supporting all ordinary functions, as well as combining arrows product-wise. Every Arrow forms a scalaz.Contravariant in one type parameter, and a scalaz.Applicative in the other, just as with ordinary functions.

  30. trait Associative[=>:[_, _]] extends AnyRef

  31. trait Band[F] extends Semigroup[F]

    scalaz.Semigroup which is also idempotent, i.e.

    scalaz.Semigroup which is also idempotent, i.e. appending a value with itself results in the same value.

    See also

    scalaz.Band.BandLaw

  32. trait BiConstrainedNaturalTransformation[F[_, _], G[_, _], C[_], E[_]] extends AnyRef

    A constrained transformation natural in both sides of a bifunctor

  33. trait BiNaturalTransformation[-F[_, _], +G[_, _]] extends AnyRef

    A function universally quantified over two parameters.

  34. trait Bifoldable[F[_, _]] extends AnyRef

    A type giving rise to two unrelated scalaz.Foldables.

  35. trait Bifunctor[F[_, _]] extends AnyRef

    A type giving rise to two unrelated scalaz.Functors.

  36. final class BijectionT[F[_], G[_], A, B] extends AnyRef
  37. sealed abstract class BijectionTInstances extends BijectionTInstances0
  38. sealed abstract class BijectionTInstances0 extends AnyRef
  39. trait Bind[F[_]] extends Apply[F]

    An scalaz.Apply functor, where a lifted function can introduce new values _and_ new functor context to be incorporated into the lift context.

    An scalaz.Apply functor, where a lifted function can introduce new values _and_ new functor context to be incorporated into the lift context. The essential new operation of scalaz.Monads.

    See also

    scalaz.Bind.BindLaw

  40. trait BindRec[F[_]] extends Bind[F]

    scalaz.Bind capable of using constant stack space when doing recursive binds.

    scalaz.Bind capable of using constant stack space when doing recursive binds.

    Implementations of tailrecM should not make recursive calls without the @tailrec annotation.

    Based on Phil Freeman's work on stack safety in PureScript, described in Stack Safety for Free.

  41. trait Bitraverse[F[_, _]] extends Bifunctor[F] with Bifoldable[F]

    A type giving rise to two unrelated scalaz.Traverses.

  42. sealed abstract class CaseInsensitive[A] extends AnyRef
  43. sealed abstract class CaseInsensitiveInstances extends AnyRef
  44. trait Category[=>:[_, _]] extends Compose[=>:]

    scalaz.Compose with identity.

    scalaz.Compose with identity.

    See also

    scalaz.Category.CategoryLaw

  45. trait Choice[=>:[_, _]] extends Category[=>:]

  46. trait Cobind[F[_]] extends Functor[F]

  47. abstract class Codensity[F[_], A] extends AnyRef
  48. sealed abstract class CodensityInstances extends AnyRef
  49. sealed abstract class Cofree[S[_], A] extends AnyRef

    A cofree comonad for some functor S, i.e.

    A cofree comonad for some functor S, i.e. an S-branching stream.

  50. sealed abstract class CofreeInstances extends CofreeInstances0
  51. sealed abstract class CofreeInstances0 extends CofreeInstances1
  52. sealed abstract class CofreeInstances1 extends CofreeInstances2
  53. sealed abstract class CofreeInstances2 extends CofreeInstances3
  54. sealed abstract class CofreeInstances3 extends CofreeInstances4
  55. sealed abstract class CofreeInstances4 extends CofreeInstancesVersionSpecific
  56. abstract class CofreeInstancesVersionSpecific extends AnyRef
  57. trait Cohoist[F[_[_], _]] extends ComonadTrans[F]
  58. final case class Cokleisli[F[_], A, B](run: (F[A]) ⇒ B) extends Product with Serializable
  59. sealed abstract class CokleisliInstances extends CokleisliInstances0
  60. sealed abstract class CokleisliInstances0 extends AnyRef
  61. trait Comonad[F[_]] extends Cobind[F]

  62. trait ComonadStore[F[_], S] extends Comonad[F]

  63. trait ComonadTrans[F[_[_], _]] extends AnyRef
  64. trait Compose[=>:[_, _]] extends AnyRef

  65. final case class Const[A, B](getConst: A) extends Product with Serializable
  66. sealed abstract class ConstInstances extends ConstInstances0
  67. sealed abstract class ConstInstances0 extends ConstInstances1
  68. sealed abstract class ConstInstances1 extends AnyRef
  69. trait ConstrainedNaturalTransformation[F[_], G[_], E[_]] extends AnyRef

    A constrained natural transformation

  70. type Cont[R, A] = IndexedContsT[scalaz.Id.Id, R, R, scalaz.Id.Id, A]

  71. type ContT[R, M[_], A] = IndexedContsT[scalaz.Id.Id, R, R, M, A]

  72. trait Contravariant[F[_]] extends InvariantFunctor[F]

    Contravariant functors.

    Contravariant functors. For example, functions provide a scalaz.Functor in their result type, but a scalaz.Contravariant for each argument type.

    Note that the dual of a scalaz.Functor is just a scalaz.Functor itself.

    Providing an instance of this is a useful alternative to marking a type parameter with - in Scala.

    See also

    scalaz.Contravariant.ContravariantLaw

  73. sealed abstract class ContravariantCoyoneda[F[_], A] extends AnyRef

    Decomposition of fi.contramap(k) into its components, as it is frequently convenient to apply k separately from sorting or whatever process with fi, even when B is unknown, which is very common.

    Decomposition of fi.contramap(k) into its components, as it is frequently convenient to apply k separately from sorting or whatever process with fi, even when B is unknown, which is very common.

    This is isomorphic to F as long as F itself is a contravariant functor. The homomorphism from F[A] to ContravariantCoyoneda[F,A] exists even when F is not a contravariant functor.

    See ContravariantCoyonedaUsage.scala in the scalaz source tree for an interesting usage demonstration.

    As ContravariantCoyoneda(o)(identity).unlift = o, further factoring can occur as follows, for free:

    ContravariantCoyoneda(o contramap g)(f).unlift =
  ContravariantCoyoneda(o)(g compose f).unlift
    See also

    https://hackage.haskell.org/package/kan-extensions-4.0.1/docs/Data-Functor-Contravariant-Coyoneda.html

  74. sealed abstract class ContravariantCoyonedaInstances extends AnyRef
  75. type Conts[W[_], R, A] = IndexedContsT[W, R, R, scalaz.Id.Id, A]

  76. type ContsT[W[_], R, M[_], A] = IndexedContsT[W, R, R, M, A]

  77. final case class Coproduct[F[_], G[_], A](run: \/[F[A], G[A]]) extends Product with Serializable

    F on the left, and G on the right, of scalaz.\/.

    F on the left, and G on the right, of scalaz.\/.

    run

    The underlying scalaz.\/.

  78. sealed abstract class CoproductInstances extends CoproductInstances0
  79. sealed abstract class CoproductInstances0 extends CoproductInstances1
  80. sealed abstract class CoproductInstances1 extends CoproductInstances2
  81. sealed abstract class CoproductInstances2 extends CoproductInstances3
  82. sealed abstract class CoproductInstances3 extends AnyRef
  83. sealed abstract class Cord extends AnyRef

    A Cord is a purely functional data structure for efficiently creating a String from smaller parts, useful for printing ADTs that must write out their contents into a text format.

    A Cord is a purely functional data structure for efficiently creating a String from smaller parts, useful for printing ADTs that must write out their contents into a text format.

    A z interpolator is available for building String from literals, using the Show typeclass to populate each "hole", and a cord interpolator for building Cord instances.

    If a more efficient solution is required to write a large String to a network socket or file, consider https://github.com/scalaz/scalaz/issues/1797

    If you require a general text manipulation data structure, consider using FingerTree or creating a custom structure to resemble that used by the popular text editors:

    - https://ecc-comp.blogspot.co.uk/2015/05/a-brief-glance-at-how-5-text-editors.html - https://pavelfatin.com/typing-with-pleasure/

  84. sealed abstract class CorecursiveList[A] extends AnyRef

    The corecursive list; i.e.

    The corecursive list; i.e. the arguments to unfold saved off to a data structure. Generally does not have methods itself; as with scalaz.NonEmptyList, it provides typeclass instances instead, and you typically import typeclass syntax to get methods.

    The corecursive list can be a very efficient way to represent "listlike" things in some cases; because it is so unlike "normal" collections, though, it's important to understand how its operations are implemented and what their performance characteristics are going to be. For example, using cons iteratively to add a bunch of elements to the beginning of a scala.collection.immutable.List is very efficient; it's very inefficient for corecursive list.

    Operations are generally designed to preserve the isomorphism with scalaz.EphemeralStream; for example, ap could be a "zipping" ap, but instead is a less efficient "combination" style. This means that the scalaz.Monad has the same behavior as that of scalaz.EphemeralStream and more traditional strict list structures.

  85. sealed abstract class CorecursiveListInstances extends AnyRef
  86. abstract class Corepresentable[F[_], X] extends AnyRef

    Corepresentable functors

  87. sealed abstract class Coyoneda[F[_], A] extends AnyRef

    The dual view of the Yoneda lemma.

    The dual view of the Yoneda lemma. Also a free functor on F. This is isomorphic to F as long as F itself is a functor. The homomorphism from F[A] to Coyoneda[F,A] exists even when F is not a functor.

  88. sealed abstract class CoyonedaInstances extends CoyonedaInstances0
  89. sealed abstract class CoyonedaInstances0 extends CoyonedaInstances1
  90. sealed abstract class CoyonedaInstances1 extends CoyonedaInstances2
  91. sealed abstract class CoyonedaInstances10 extends AnyRef
  92. sealed abstract class CoyonedaInstances2 extends CoyonedaInstances3
  93. sealed abstract class CoyonedaInstances3 extends CoyonedaInstances4
  94. sealed abstract class CoyonedaInstances4 extends CoyonedaInstances5
  95. sealed abstract class CoyonedaInstances5 extends CoyonedaInstances6
  96. sealed abstract class CoyonedaInstances6 extends CoyonedaInstances7
  97. sealed abstract class CoyonedaInstances7 extends CoyonedaInstances8
  98. sealed abstract class CoyonedaInstances8 extends CoyonedaInstances9
  99. sealed abstract class CoyonedaInstances9 extends CoyonedaInstances10
  100. trait Cozip[F[_]] extends AnyRef

  101. type DLeft[A, B] = -\/[A, B]
  102. final class DList[A] extends AnyRef

    Difference lists: a data structure for O(1) append on lists.

    Difference lists: a data structure for O(1) append on lists. Based on Data.DList, a Haskell library by Don Stewart.

    A difference list is a function that given a list, returns the original contents of the difference list prepended at the given list.

    This structure supports O(1) append and snoc operations on lists, making it very useful for append-heavy uses, such as logging and pretty printing.

  103. sealed abstract class DListInstances extends AnyRef
  104. type DRight[A, B] = \/-[A, B]
  105. trait Day[F[_], G[_], A] extends AnyRef

    Covariant Day Convolution

    Covariant Day Convolution

    Based on Edward Kmett implementation in Haskell: https://hackage.haskell.org/package/kan-extensions/docs/Data-Functor-Day.html

    Day convolution is a special form of Functor multiplication. In monoidal category of endofunctors Applicative is a monoid object when Day covolution is used as tensor. If we use Functor composition as tensor then then monoid form a Monad instead of Applicative.

    Can be seen as generalization of method apply2 from Apply:

    def apply2(fa => F[A], fb => F[B])(f: (A, B) => C): F[C]

trait Day[F[_], G[_], A] { self =>
  // ...
  val fx: F[X]
  val gy: G[Y]
  def xya: (X, Y) => A
}
    See also

    Bartosz Milewski talk, derive Day from multiplying Functors and using Coyoneda

    Edward Kmett talk, explains Divisible and Decidable in context of contravariant Day

    Phil Freeman blog, connections between Day and Comonads, Comonads transformers, optics

    Discussion on Reddit with mention about usage for stream processing and intuition based on liftA2 from Applicative and Day

  106. sealed abstract class DayInstances extends DayInstances1
  107. sealed abstract class DayInstances1 extends DayInstances2
  108. sealed abstract class DayInstances2 extends DayInstances3
  109. sealed abstract class DayInstances3 extends DayInstances4
  110. sealed abstract class DayInstances4 extends AnyRef
  111. trait Decidable[F[_]] extends Divisible[F] with InvariantAlt[F]

    Coproduct analogue of Divide

    Coproduct analogue of Divide

    https://hackage.haskell.org/package/contravariant-1.4.1/docs/Data-Functor-Contravariant-Divisible.html#t:Decidable

  112. trait Density[F[_], Y] extends AnyRef

    Density Comonad.

    Density Comonad.

    Density is Left Kan Extension where both Functors are the same.

    Without any restrictions on F we can define Functor, Cobind, Comonad for Density[F]. Density is Comonad for free.

    See also

    https://hackage.haskell.org/package/kan-extensions/docs/Control-Comonad-Density.html

    http://comonad.com/reader/2011/a-product-of-an-imperfect-union/

  113. sealed abstract class DensityInstances extends DensityInstances0
  114. sealed abstract class DensityInstances0 extends AnyRef
  115. sealed abstract class Dequeue[A] extends AnyRef

    A Double-ended queue, based on the Bankers Double Ended Queue as described by C.

    A Double-ended queue, based on the Bankers Double Ended Queue as described by C. Okasaki in "Purely Functional Data Structures"

    A queue that allows items to be put onto either the front (cons) or the back (snoc) of the queue in constant time, and constant time access to the element at the very front or the very back of the queue. Dequeueing an element from either end is constant time when amortized over a number of dequeues.

    This queue maintains an invariant that whenever there are at least two elements in the queue, neither the front list nor back list are empty. In order to maintain this invariant, a dequeue from either side which would leave that side empty constructs the resulting queue by taking elements from the opposite side

  116. sealed abstract class DequeueInstances extends AnyRef
  117. trait DiNaturalTransformation[F[_, _], G[_, _]] extends AnyRef
  118. sealed abstract class Diev[A] extends AnyRef

    Implementation of a Discrete Interval Encoding Tree https://web.engr.oregonstate.edu/~erwig/diet/ that is actually implemented using a Vector and is balanced at all times as a result.

  119. trait DievImplementation extends AnyRef
  120. sealed abstract class DievInstances extends DievImplementation
  121. sealed abstract class Digit extends Product with Serializable

    An algebraic data type representing the digits 0 - 9

  122. sealed abstract class DigitInstances extends AnyRef
  123. type Disjunction[A, B] = \/[A, B]
  124. sealed abstract class DisjunctionInstances extends DisjunctionInstances0
  125. sealed abstract class DisjunctionInstances0 extends DisjunctionInstances1
  126. sealed abstract class DisjunctionInstances1 extends DisjunctionInstances2
  127. sealed abstract class DisjunctionInstances2 extends AnyRef
  128. type DisjunctionT[A, F[_], B] = EitherT[A, F, B]
  129. trait Distributive[F[_]] extends Functor[F]

    Dual of scalaz.Traverse.

    Dual of scalaz.Traverse. To transform F[G[B]] to G[F[B]], you may use Traverse[F] and Applicative[G], but alternatively Functor[F] and Distributive[G], which permits greater sharing and nonstrictness.

  130. trait Divide[F[_]] extends Contravariant[F]

    Divide is the contravariant analogue of scalaz.Apply

    Divide is the contravariant analogue of scalaz.Apply

    See also

    https://github.com/ekmett/contravariant/issues/18

  131. trait Divisible[F[_]] extends Divide[F] with InvariantApplicative[F]

    Divisible is the contravariant analogue of scalaz.Applicative

    Divisible is the contravariant analogue of scalaz.Applicative

    See also

    https://github.com/ekmett/contravariant/blob/v1.3.2/src/Data/Functor/Contravariant/Divisible.hs

    ZuriHac 2015 - Discrimination is Wrong: Improving Productivity

  132. sealed abstract class DualInstances extends DualInstances0
  133. sealed abstract class DualInstances0 extends AnyRef
  134. sealed abstract class Either3[A, B, C] extends Product with Serializable
  135. final case class EitherT[A, F[_], B](run: F[\/[A, B]]) extends Product with Serializable

    Represents a computation of type F[A \/ B].

    Represents a computation of type F[A \/ B].

    Example:

    val x: Option[String \/ Int] = Some(\/-(1))
EitherT(x).map(1+).run // Some(\/-(2))
  136. sealed abstract class EitherTInstances extends EitherTInstances0
  137. sealed abstract class EitherTInstances0 extends EitherTInstances1
  138. sealed abstract class EitherTInstances1 extends EitherTInstances2
  139. sealed abstract class EitherTInstances2 extends EitherTInstances3
  140. sealed abstract class EitherTInstances3 extends EitherTInstances4
  141. sealed abstract class EitherTInstances4 extends EitherTInstances5
  142. sealed abstract class EitherTInstances5 extends AnyRef
  143. final case class Endo[A](run: (A) ⇒ A) extends Product with Serializable

    Endomorphisms.

    Endomorphisms. They have special properties among functions, so are captured in this newtype.

    run

    The captured function.

  144. final case class EndoByName[A](run: (⇒ A) ⇒ A) extends Product with Serializable

    Endomorphisms using by-name evaluation.

    Endomorphisms using by-name evaluation. They have special properties among functions, so are captured in this newtype.

    run

    The captured function.

  145. sealed abstract class EndoByNameInstances extends AnyRef
  146. sealed abstract class EndoInstances extends AnyRef
  147. final case class Endomorphic[=>:[_, _], A](run: =>:[A, A]) extends Product with Serializable

    Endomorphisms have special properties among arrows, so are captured in this newtype.

    Endomorphisms have special properties among arrows, so are captured in this newtype.

    Endomorphic[Function1, A] is equivalent to Endo[A]

  148. sealed abstract class EndomorphicInstances extends EndomorphicInstances0
  149. sealed abstract class EndomorphicInstances0 extends EndomorphicInstances1
  150. sealed abstract class EndomorphicInstances1 extends EndomorphicInstances2
  151. sealed abstract class EndomorphicInstances2 extends AnyRef
  152. trait Enum[F] extends Order[F]

    An scalaz.Orderable with discrete values.

  153. sealed abstract class EphemeralStream[A] extends AnyRef

    Like scala.collection.immutable.Stream, but doesn't save computed values.

    Like scala.collection.immutable.Stream, but doesn't save computed values. As such, it can be used to represent similar things, but without the space leak problem frequently encountered using that type.

  154. sealed abstract class EphemeralStreamInstances extends AnyRef
  155. trait Equal[F] extends AnyRef

    A type safe alternative to universal equality (scala.Any#==).

    A type safe alternative to universal equality (scala.Any#==).

    See also

    scalaz.Equal.EqualLaw

  156. final case class Failure[E, A](e: E) extends Validation[E, A] with Product with Serializable
  157. sealed abstract class FingerTree[V, A] extends AnyRef

    Finger trees with leaves of type A and Nodes that are annotated with type V.

    Finger trees with leaves of type A and Nodes that are annotated with type V.

    Finger Trees provide a base for implementations of various collection types, as described in "Finger trees: a simple general-purpose data structure", by Ralf Hinze and Ross Paterson. A gentle introduction is presented in the blog post "Monoids and Finger Trees" by Heinrich Apfelmus.

    This is done by choosing a suitable type to annotate the nodes. For example, a binary tree can be implemented by annotating each node with the size of its subtree, while a priority queue can be implemented by labelling the nodes by the minimum priority of its children.

    The operations on FingerTree enforce the constraint measured (in the form of a Reducer instance).

    Finger Trees have excellent (amortized) asymptotic performance:

    • Access to the first and last elements is O(1)
    • Appending/prepending a single value is O(1)
    • Concatenating two trees is (O lg min(l1, l2)) where l1 and l2 are their sizes
    • Random access to an element at n is O(lg min(n, l - n)), where l is the size of the tree.
    • Constructing a tree with n copies of a value is O(lg n).
    V

    The type of the annotations of the nodes (the measure)

    A

    The type of the elements stored at the leaves

    See also

    Finger trees: a simple general-purpose data structure

    https://apfelmus.nfshost.com/articles/monoid-fingertree.html

  158. sealed abstract class FingerTreeInstances extends AnyRef
  159. type FirstMaybe[A] = scalaz.TagKind.@@[Maybe[A], First]
  160. type FirstOf[A] = scalaz.TagKind.@@[A, FirstVal]
  161. type FirstOption[A] = scalaz.TagKind.@@[Option[A], First]
  162. trait FoldCase[A] extends AnyRef
  163. sealed abstract class FoldCaseInstances extends AnyRef
  164. trait Foldable[F[_]] extends AnyRef

    A type parameter implying the ability to extract zero or more values of that type.

  165. trait Foldable1[F[_]] extends Foldable[F]

    A scalaz.Foldable where foldMap is total over semigroups.

    A scalaz.Foldable where foldMap is total over semigroups. That is, toList cannot return an empty list.

  166. trait Forall[P[_]] extends AnyRef

    A universally quantified value

  167. trait Foralls extends AnyRef
  168. sealed abstract class Free[S[_], A] extends AnyRef

    A free monad for a type constructor S.

    A free monad for a type constructor S. Binding is done using the heap instead of the stack, allowing tail-call elimination.

  169. sealed abstract class FreeAp[F[_], A] extends AnyRef

    Free applicative functors.

    Free applicative functors. Less expressive than free monads, but more flexible to inspect and interpret.

  170. sealed abstract class FreeInstances extends FreeInstances0
  171. sealed abstract class FreeInstances0 extends FreeInstances1
  172. sealed abstract class FreeInstances1 extends FreeInstances2
  173. sealed abstract class FreeInstances2 extends FreeInstances3
  174. sealed abstract class FreeInstances3 extends FreeInstances4
  175. sealed abstract class FreeInstances4 extends AnyRef
  176. sealed abstract class FreeT[S[_], M[_], A] extends AnyRef
  177. sealed abstract class FreeTInstances extends FreeTInstances0
  178. sealed abstract class FreeTInstances0 extends FreeTInstances1
  179. sealed abstract class FreeTInstances1 extends FreeTInstances2
  180. sealed abstract class FreeTInstances2 extends FreeTInstances3
  181. sealed abstract class FreeTInstances3 extends FreeTInstances4
  182. sealed abstract class FreeTInstances4 extends FreeTInstances5
  183. sealed abstract class FreeTInstances5 extends FreeTInstances6
  184. sealed abstract class FreeTInstances6 extends AnyRef
  185. trait Functor[F[_]] extends InvariantFunctor[F]

    Functors, covariant by nature if not by Scala type.

    Functors, covariant by nature if not by Scala type. Their key operation is map, whose behavior is constrained only by type and the functor laws.

    Many useful functors also have natural scalaz.Apply or scalaz.Bind operations. Many also support scalaz.Traverse.

    See also

    scalaz.Functor.FunctorLaw

  186. trait Generator[C, Elem] extends AnyRef

    Generator a class of container of elements that knows how to efficiently apply a scalaz.Reducer to extract an answer by combining elements.

    Generator a class of container of elements that knows how to efficiently apply a scalaz.Reducer to extract an answer by combining elements. A Reducer may supply efficient left-to-right and right-to-left reduction strategies that a Generator may avail itself of.

  187. trait Generators extends AnyRef
  188. sealed abstract class Heap[A] extends AnyRef

    An efficient, asymptotically optimal, implementation of priority queues extended with support for efficient size.

    An efficient, asymptotically optimal, implementation of priority queues extended with support for efficient size.

    The implementation of 'Heap' is based on bootstrapped skew binomial heaps as described by: G. Brodal and C. Okasaki , "Optimal Purely Functional Priority Queues", Journal of Functional Programming 6:839-857 (1996),

    Based on the heaps Haskell library by Edward Kmett

  189. sealed abstract class HeapInstances extends AnyRef
  190. trait Hoist[F[_[_], _]] extends MonadTrans[F]
  191. final case class ICons[A](head: A, tail: IList[A]) extends IList[A] with Product with Serializable
  192. sealed abstract class IList[A] extends Product with Serializable

    Safe, invariant alternative to stdlib List.

    Safe, invariant alternative to stdlib List. Most methods on List have a sensible equivalent here, either on the IList interface itself or via typeclass instances (which are the same as those defined for stdlib List). All methods are total and stack-safe.

  193. sealed abstract class IListInstance0 extends AnyRef
  194. sealed abstract class IListInstances extends IListInstance0
  195. type IMap[A, B] = ==>>[A, B]
  196. sealed case class INil[A] extends IList[A] with Product with Serializable
  197. type IRWS[R, W, S1, S2, A] = IndexedReaderWriterStateT[R, W, S1, S2, scalaz.Id.Id, A]
  198. type IRWST[R, W, S1, S2, F[_], A] = IndexedReaderWriterStateT[R, W, S1, S2, F, A]
  199. sealed abstract class ISet[A] extends AnyRef

    See also

    https://hackage.haskell.org/package/containers-0.5.7.1/docs/Data-Set.html

    https://github.com/haskell/containers/blob/v0.5.7.1/Data/Set/Base.hs

  200. sealed abstract class ISetInstances extends AnyRef
  201. sealed abstract class IStream[A] extends AnyRef

    A linked list with by-name head and tail, allowing some control over memory usage and evaluation of contents.

    A linked list with by-name head and tail, allowing some control over memory usage and evaluation of contents.

    This structure is a good choice when the contents are expensive to calculate and may not all need to be evaluated, at the cost of an overhead when the contents are calculated. Typeclass instances try to defer evaluation of contents, unless it would require a full traversal of the spine, preferring lazy semantics when an evaluation choice is to be made.

  202. trait IdInstances extends AnyRef

    Mixed into object Id in the package object scalaz.

  203. final case class IdT[F[_], A](run: F[A]) extends Product with Serializable
  204. sealed abstract class IdTInstances extends IdTInstances0
  205. sealed abstract class IdTInstances0 extends IdTInstances1
  206. sealed abstract class IdTInstances1 extends IdTInstances2
  207. sealed abstract class IdTInstances2 extends IdTInstances3
  208. sealed abstract class IdTInstances3 extends IdTInstances4
  209. sealed abstract class IdTInstances4 extends IdTInstances5
  210. sealed abstract class IdTInstances5 extends IdTInstances6
  211. sealed abstract class IdTInstances6 extends AnyRef
  212. sealed abstract class ImmutableArray[+A] extends AnyRef

    An immutable wrapper for arrays

    An immutable wrapper for arrays

    A

    type of the elements of the array

  213. sealed abstract class ImmutableArrayInstances extends AnyRef
  214. final class IndSeq[A] extends AnyRef

    Indexed sequences, based on scalaz.FingerTree

    Indexed sequences, based on scalaz.FingerTree

    The measure is the count of the preceding elements, provided by UnitReducer((e: Int) => 1).

  215. sealed abstract class IndSeqInstances extends AnyRef
  216. type IndexedCont[R, O, A] = IndexedContsT[scalaz.Id.Id, R, O, scalaz.Id.Id, A]

  217. type IndexedContT[R, O, M[_], A] = IndexedContsT[scalaz.Id.Id, R, O, M, A]

  218. type IndexedConts[W[_], R, O, A] = IndexedContsT[W, R, O, scalaz.Id.Id, A]

  219. final case class IndexedContsT[W[_], R, O, M[_], A](_run: (W[(A) ⇒ M[O]]) ⇒ M[R]) extends Product with Serializable
  220. trait IndexedContsTFunctions extends AnyRef
  221. abstract class IndexedContsTInstances extends IndexedContsTInstances0
  222. sealed abstract class IndexedContsTInstances0 extends IndexedContsTInstances1
  223. sealed abstract class IndexedContsTInstances1 extends IndexedContsTInstances2
  224. sealed abstract class IndexedContsTInstances2 extends AnyRef
  225. type IndexedReaderWriterState[R, W, S1, S2, A] = IndexedReaderWriterStateT[R, W, S1, S2, scalaz.Id.Id, A]

  226. sealed abstract class IndexedReaderWriterStateT[R, W, S1, S2, F[_], A] extends AnyRef

    A monad transformer stack yielding (R, S1) => F[(W, A, S2)].

  227. sealed abstract class IndexedReaderWriterStateTInstances extends IndexedReaderWriterStateTInstances0
  228. sealed abstract class IndexedReaderWriterStateTInstances0 extends IndexedReaderWriterStateTInstances1
  229. sealed abstract class IndexedReaderWriterStateTInstances1 extends AnyRef
  230. type IndexedState[S1, S2, A] = IndexedStateT[S1, S2, scalaz.Id.Id, A]

  231. trait IndexedStateFunctions extends AnyRef
  232. sealed abstract class IndexedStateT[S1, S2, F[_], A] extends AnyRef
  233. trait IndexedStateTFunctions extends AnyRef
  234. sealed abstract class IndexedStateTInstances extends IndexedStateTInstances0
  235. sealed abstract class IndexedStateTInstances0 extends IndexedStateTInstances1
  236. sealed abstract class IndexedStateTInstances1 extends IndexedStateTInstances2
  237. sealed abstract class IndexedStateTInstances2 extends IndexedStateTInstances3
  238. sealed abstract class IndexedStateTInstances3 extends AnyRef
  239. type IndexedStore[I, A, B] = IndexedStoreT[scalaz.Id.Id, I, A, B]

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

    See also

    scalaz.Lens

  241. trait IndexedStoreTFunctions extends AnyRef
  242. sealed abstract class IndexedStoreTInstances extends IndexedStoreTInstances0
  243. sealed abstract class IndexedStoreTInstances0 extends IndexedStoreTInstances1
  244. sealed abstract class IndexedStoreTInstances1 extends IndexedStoreTInstances2
  245. sealed abstract class IndexedStoreTInstances2 extends AnyRef
  246. sealed abstract class Inject[F[_], G[_]] extends ~>[F, G]

    Inject type class as described in "Data types a la carte" (Swierstra 2008).

    Inject type class as described in "Data types a la carte" (Swierstra 2008).

    See also

    http://www.staff.science.uu.nl/~swier004/Publications/DataTypesALaCarte.pdf

  247. sealed abstract class InjectInstances extends AnyRef
  248. case class Injective[T[_]]() extends Product with Serializable

    Given Injective[Foo]: If type Foo[A] = Foo[B] then A ~ B

    Given Injective[Foo]: If type Foo[A] = Foo[B] then A ~ B

    This represents an assertion that is used by other code that requires this condition.

  249. case class Injective2[T[_, _]]() extends Product with Serializable
  250. case class Injective3[T[_, _, _]]() extends Product with Serializable
  251. case class Injective4[T[_, _, _, _]]() extends Product with Serializable
  252. case class Injective5[T[_, _, _, _, _]]() extends Product with Serializable
  253. trait InvariantAlt[F[_]] extends InvariantApplicative[F]

    Invariant parent of Decidable and Alternative.

    Invariant parent of Decidable and Alternative.

    Used for typeclass derivation of products, coproducts and value types.

  254. trait InvariantApplicative[F[_]] extends InvariantFunctor[F]

    Invariant parent of Divisible and Applicative.

    Invariant parent of Divisible and Applicative.

    Used for typeclass derivation of products and value types.

  255. trait InvariantFunctor[F[_]] extends AnyRef

    Unary type constructor that supports an xmap operation that converts an F[A] to an F[B] given two functions, A => B and B => A.

    Unary type constructor that supports an xmap operation that converts an F[A] to an F[B] given two functions, A => B and B => A.

    An invariant functor must satisfy two laws:

    • identity - xmap(ma)(identity, identity) == ma
    • composite - xmap(xmap(ma, f1, g1), f2, g2) == xmap(ma, f2 compose f1, g1, compose g2)

    Also known as an exponential functor.

    See also

    https://hackage.haskell.org/packages/archive/invariant/latest/doc/html/Data-Functor-Invariant.html

    http://comonad.com/reader/2008/rotten-bananas/

    scalaz.InvariantFunctor.InvariantFunctorLaw

  256. trait IsContravariant[F[_]] extends AnyRef

    Type constructors that are contravariant with respect to subtyping.

    Type constructors that are contravariant with respect to subtyping.

    A type constructor F[_] admits an instance IsContravariant[F] iff F[B] is a subtype of F[A] whenever A is a subtype of B.

    The Scala language represents this natively using the [-A] notation on type constructors. The factory scalaContravariant provides an instance of this typeclass for any such type. However, type constructors which behave contravariantly despite not being thus notated can also implement this typeclass. The factory force constructs an instance of IsContravariant for any type, based on the programmer's assertion that it is indeed contravariant.

    Note the relationship between this typeclass and Contravariant: whereas Contravariant instances are contravariant functors in the "category" of Scala types and functions, instances of this typeclass are contravariant functors in the "category" of Scala types and subtyping relations.

  257. trait IsCovariant[F[_]] extends AnyRef

    Type constructors that are covariant with respect to subtyping.

    Type constructors that are covariant with respect to subtyping.

    A type constructor F[_] admits an instance IsCovariant[F] iff F[A] is a subtype of F[B] whenever A is a subtype of B.

    The Scala language represents this natively using the [+A] notation on type constructors. The factory scalaCovariant provides an instance of this typeclass for any such type. However, type constructors which behave covariantly despite not being thus notated can also implement this typeclass. The factory force constructs an instance of IsCovariant for any type, based on the programmer's assertion that it is indeed covariant.

    Note the relationship between this typeclass and Functor: whereas Functor instances are covariant functors in the "category" of Scala types and functions, instances of this typeclass are covariant functors in the "category" of Scala types and subtyping relations.

  258. trait IsEmpty[F[_]] extends PlusEmpty[F]

    Typeclass that permits testing whether some type with an empty representation is in fact empty.

  259. trait IsomorphismAlign[F[_], G[_]] extends Align[F] with IsomorphismFunctor[F, G]
  260. trait IsomorphismAlt[F[_], G[_]] extends Alt[F] with IsomorphismApplicative[F, G] with IsomorphismInvariantAlt[F, G]
  261. trait IsomorphismApplicative[F[_], G[_]] extends Applicative[F] with IsomorphismApply[F, G] with IsomorphismInvariantApplicative[F, G]
  262. trait IsomorphismApplicativeError[F[_], G[_], S] extends ApplicativeError[F, S] with IsomorphismApplicative[F, G]
  263. trait IsomorphismApplicativePlus[F[_], G[_]] extends ApplicativePlus[F] with IsomorphismApplicative[F, G] with IsomorphismPlusEmpty[F, G]
  264. trait IsomorphismApply[F[_], G[_]] extends Apply[F] with IsomorphismFunctor[F, G]
  265. trait IsomorphismArrow[F[_, _], G[_, _]] extends Arrow[F] with IsomorphismSplit[F, G] with IsomorphismStrong[F, G] with IsomorphismCategory[F, G]
  266. trait IsomorphismAssociative[F[_, _], G[_, _]] extends Associative[F]
  267. trait IsomorphismBand[F, G] extends Band[F] with IsomorphismSemigroup[F, G]
  268. trait IsomorphismBifoldable[F[_, _], G[_, _]] extends Bifoldable[F]
  269. trait IsomorphismBifunctor[F[_, _], G[_, _]] extends Bifunctor[F]
  270. trait IsomorphismBind[F[_], G[_]] extends Bind[F] with IsomorphismApply[F, G]
  271. trait IsomorphismBindRec[F[_], G[_]] extends BindRec[F] with IsomorphismBind[F, G]
  272. trait IsomorphismBitraverse[F[_, _], G[_, _]] extends Bitraverse[F] with IsomorphismBifunctor[F, G] with IsomorphismBifoldable[F, G]
  273. trait IsomorphismCatchable[F[_], G[_]] extends Catchable[F]
  274. trait IsomorphismCategory[F[_, _], G[_, _]] extends Category[F] with IsomorphismCompose[F, G]
  275. trait IsomorphismChoice[F[_, _], G[_, _]] extends Choice[F] with IsomorphismCategory[F, G]
  276. trait IsomorphismCobind[F[_], G[_]] extends Cobind[F] with IsomorphismFunctor[F, G]
  277. trait IsomorphismComonad[F[_], G[_]] extends Comonad[F] with IsomorphismCobind[F, G]
  278. trait IsomorphismComonadStore[F[_], G[_], S] extends ComonadStore[F, S] with IsomorphismComonad[F, G]
  279. trait IsomorphismCompose[F[_, _], G[_, _]] extends Compose[F]
  280. trait IsomorphismContravariant[F[_], G[_]] extends Contravariant[F] with IsomorphismInvariantFunctor[F, G]
  281. trait IsomorphismCozip[F[_], G[_]] extends Cozip[F]
  282. trait IsomorphismDecidable[F[_], G[_]] extends Decidable[F] with IsomorphismDivisible[F, G] with IsomorphismInvariantAlt[F, G]
  283. trait IsomorphismDistributive[F[_], G[_]] extends Distributive[F] with IsomorphismFunctor[F, G]
  284. trait IsomorphismDivide[F[_], G[_]] extends Divide[F] with IsomorphismContravariant[F, G]
  285. trait IsomorphismDivisible[F[_], G[_]] extends Divisible[F] with IsomorphismDivide[F, G] with IsomorphismInvariantApplicative[F, G]
  286. trait IsomorphismEnum[F, G] extends Enum[F] with IsomorphismOrder[F, G]
  287. trait IsomorphismEqual[F, G] extends Equal[F]
  288. trait IsomorphismFoldable[F[_], G[_]] extends Foldable[F]
  289. trait IsomorphismFoldable1[F[_], G[_]] extends Foldable1[F] with IsomorphismFoldable[F, G]
  290. trait IsomorphismFunctor[F[_], G[_]] extends Functor[F] with IsomorphismInvariantFunctor[F, G]
  291. trait IsomorphismInvariantAlt[F[_], G[_]] extends InvariantAlt[F] with IsomorphismInvariantApplicative[F, G]
  292. trait IsomorphismInvariantApplicative[F[_], G[_]] extends InvariantApplicative[F] with IsomorphismInvariantFunctor[F, G]
  293. trait IsomorphismInvariantFunctor[F[_], G[_]] extends InvariantFunctor[F]
  294. trait IsomorphismIsEmpty[F[_], G[_]] extends IsEmpty[F] with IsomorphismPlusEmpty[F, G]
  295. trait IsomorphismMonad[F[_], G[_]] extends Monad[F] with IsomorphismApplicative[F, G] with IsomorphismBind[F, G]
  296. trait IsomorphismMonadError[F[_], G[_], S] extends MonadError[F, S] with IsomorphismMonad[F, G] with IsomorphismApplicativeError[F, G, S]
  297. trait IsomorphismMonadPlus[F[_], G[_]] extends MonadPlus[F] with IsomorphismMonad[F, G] with IsomorphismApplicativePlus[F, G]
  298. trait IsomorphismMonadReader[F[_], G[_], S] extends MonadReader[F, S] with IsomorphismMonad[F, G]
  299. trait IsomorphismMonadState[F[_], G[_], S] extends MonadState[F, S] with IsomorphismMonad[F, G]
  300. trait IsomorphismMonadTell[F[_], G[_], S] extends MonadTell[F, S] with IsomorphismMonad[F, G]
  301. trait IsomorphismMonoid[F, G] extends Monoid[F] with IsomorphismSemigroup[F, G]
  302. trait IsomorphismNondeterminism[F[_], G[_]] extends Nondeterminism[F] with IsomorphismMonad[F, G]
  303. trait IsomorphismOptional[F[_], G[_]] extends Optional[F]
  304. trait IsomorphismOrder[F, G] extends Order[F] with IsomorphismEqual[F, G]
  305. trait IsomorphismPlus[F[_], G[_]] extends Plus[F]
  306. trait IsomorphismPlusEmpty[F[_], G[_]] extends PlusEmpty[F] with IsomorphismPlus[F, G]
  307. trait IsomorphismProChoice[F[_, _], G[_, _]] extends ProChoice[F] with IsomorphismProfunctor[F, G]
  308. trait IsomorphismProfunctor[F[_, _], G[_, _]] extends Profunctor[F]
  309. trait IsomorphismSemiLattice[F, G] extends SemiLattice[F] with IsomorphismBand[F, G]
  310. trait IsomorphismSemigroup[F, G] extends Semigroup[F]
  311. trait IsomorphismShow[F, G] extends Show[F]
  312. trait IsomorphismSplit[F[_, _], G[_, _]] extends Split[F] with IsomorphismCompose[F, G]
  313. trait IsomorphismStrong[F[_, _], G[_, _]] extends Strong[F] with IsomorphismProfunctor[F, G]
  314. trait IsomorphismTraverse[F[_], G[_]] extends Traverse[F] with IsomorphismFunctor[F, G] with IsomorphismFoldable[F, G]
  315. trait IsomorphismTraverse1[F[_], G[_]] extends Traverse1[F] with IsomorphismTraverse[F, G] with IsomorphismFoldable1[F, G]
  316. trait IsomorphismUnzip[F[_], G[_]] extends Unzip[F]
  317. trait IsomorphismZip[F[_], G[_]] extends Zip[F]
  318. sealed abstract class Isomorphisms extends AnyRef
  319. final case class Kleisli[M[_], A, B](run: (A) ⇒ M[B]) extends Product with Serializable

    Represents a function A => M[B].

  320. abstract class KleisliInstances extends KleisliInstances0
  321. sealed abstract class KleisliInstances0 extends KleisliInstances1
  322. sealed abstract class KleisliInstances1 extends KleisliInstances2
  323. sealed abstract class KleisliInstances10 extends KleisliInstances11
  324. sealed abstract class KleisliInstances11 extends KleisliInstances12
  325. sealed abstract class KleisliInstances12 extends KleisliInstances13
  326. sealed abstract class KleisliInstances13 extends KleisliInstances14
  327. sealed abstract class KleisliInstances14 extends KleisliInstances15
  328. sealed abstract class KleisliInstances15 extends AnyRef
  329. sealed abstract class KleisliInstances2 extends KleisliInstances3
  330. sealed abstract class KleisliInstances3 extends KleisliInstances4
  331. sealed abstract class KleisliInstances4 extends KleisliInstances5
  332. sealed abstract class KleisliInstances5 extends KleisliInstances6
  333. sealed abstract class KleisliInstances6 extends KleisliInstances7
  334. sealed abstract class KleisliInstances7 extends KleisliInstances8
  335. sealed abstract class KleisliInstances8 extends KleisliInstances9
  336. sealed abstract class KleisliInstances9 extends KleisliInstances10
  337. trait Konst[A] extends AnyRef
  338. trait Lan[G[_], H[_], A] extends AnyRef

    The left Kan extension of H along G

  339. sealed abstract class LanInstances extends LanInstances0
  340. sealed abstract class LanInstances0 extends AnyRef
  341. type LastMaybe[A] = scalaz.TagKind.@@[Maybe[A], Last]
  342. type LastOf[A] = scalaz.TagKind.@@[A, LastVal]
  343. type LastOption[A] = scalaz.TagKind.@@[Option[A], Last]
  344. sealed abstract class LazyEither[A, B] extends AnyRef

    scala.Either, but with a value by name.

  345. sealed abstract class LazyEitherInstances extends AnyRef
  346. final case class LazyEitherT[F[_], A, B](run: F[LazyEither[A, B]]) extends Product with Serializable
  347. sealed abstract class LazyEitherTInstances extends LazyEitherTInstances0
  348. sealed abstract class LazyEitherTInstances0 extends LazyEitherTInstances1
  349. sealed abstract class LazyEitherTInstances1 extends AnyRef
  350. sealed abstract class LazyOption[A] extends Product with Serializable

    scala.Option, but with a value by name.

  351. sealed abstract class LazyOptionInstances extends AnyRef
  352. final case class LazyOptionT[F[_], A](run: F[LazyOption[A]]) extends Product with Serializable
  353. sealed abstract class LazyOptionTInstances extends LazyOptionTInstances0
  354. sealed abstract class LazyOptionTInstances0 extends LazyOptionTInstances1
  355. sealed abstract class LazyOptionTInstances1 extends AnyRef
  356. sealed abstract class LazyTuple2[A, B] extends AnyRef

    scala.Tuple2, but with values by name.

  357. sealed abstract class LazyTuple2Instances extends LazyTuple2Instances0
  358. sealed abstract class LazyTuple2Instances0 extends AnyRef
  359. sealed abstract class LazyTuple3[A, B, C] extends AnyRef

    scala.Tuple3, but with values by name.

  360. sealed abstract class LazyTuple3Instances extends LazyTuple3Instances0
  361. sealed abstract class LazyTuple3Instances0 extends AnyRef
  362. sealed abstract class LazyTuple4[A, B, C, D] extends AnyRef

    scala.Tuple4, but with values by name.

  363. sealed abstract class LazyTuple4Instances extends LazyTuple4Instances0
  364. sealed abstract class LazyTuple4Instances0 extends AnyRef
  365. final case class Left3[A, B, C](a: A) extends Either3[A, B, C] with Product with Serializable
  366. sealed abstract class Leibniz[-L, +H >: L, A >: L <: H, B >: L <: H] extends AnyRef

    Leibnizian equality: a better =:=

    Leibnizian equality: a better =:=

    This technique was first used in Typing Dynamic Typing (Baars and Swierstra, ICFP 2002).

    It is generalized here to handle subtyping so that it can be used with constrained type constructors.

    Leibniz[L,H,A,B] says that A = B, and that both of its types are between L and H. Subtyping lets you loosen the bounds on L and H.

    If you just need a witness that A = B, then you can use A===B which is a supertype of any Leibniz[L,H,A,B]

    The more refined types are useful if you need to be able to substitute into restricted contexts.

  367. sealed abstract class LeibnizF[A[_], B[_]] extends AnyRef
  368. sealed abstract class LeibnizInstances extends AnyRef
  369. type Lens[A, B] = LensFamily[A, A, B, B]

    A lens that doesn't transform the type of the record.

    A lens that doesn't transform the type of the record.

    See also

    scalaz.@>

  370. sealed abstract class LensFamily[A1, A2, B1, B2] extends AnyRef

    A Lens Family, offering a purely functional means to access and retrieve a field transitioning from type B1 to type B2 in a record simultaneously transitioning from type A1 to type A2.

    A Lens Family, offering a purely functional means to access and retrieve a field transitioning from type B1 to type B2 in a record simultaneously transitioning from type A1 to type A2. scalaz.Lens is a convenient alias for when A1 === A2, and B1 === B2.

    The term field should not be interpreted restrictively to mean a member of a class. For example, a lens family can address membership of a Set.

    A1

    The initial type of the record

    A2

    The final type of the record

    B1

    The initial type of the field

    B2

    The final type of the field

    See also

    scalaz.PLens

  371. trait LensFamilyFunctions extends AnyRef
  372. trait LensFunctions extends LensFamilyFunctions
  373. abstract class LensInstances extends LensInstances0
  374. sealed abstract class LensInstances0 extends AnyRef
  375. sealed abstract class Liskov[-A, +B] extends AnyRef

    Liskov substitutability: A better <:<

    Liskov substitutability: A better <:<

    A <: B holds whenever A could be used in any negative context that expects a B. (e.g. if you could pass an A into any function that expects a B.)

  376. sealed abstract class LiskovF[-A[_], +B[_]] extends AnyRef
  377. sealed abstract class LiskovInstances extends AnyRef
  378. final case class ListT[M[_], A](run: M[IList[A]]) extends Product with Serializable

    ListT monad transformer.

  379. sealed abstract class ListTInstances extends ListTInstances1
  380. sealed abstract class ListTInstances1 extends ListTInstances2
  381. sealed abstract class ListTInstances2 extends AnyRef
  382. sealed abstract class MapInstances extends MapInstances0
  383. sealed abstract class MapInstances0 extends MapInstances1
  384. sealed abstract class MapInstances1 extends MapInstances2
  385. sealed abstract class MapInstances2 extends AnyRef
  386. type MaxMaybe[A] = scalaz.TagKind.@@[Maybe[A], Max]
  387. type MaxOf[A] = scalaz.TagKind.@@[A, MaxVal]
  388. type MaxOption[A] = scalaz.TagKind.@@[Option[A], Max]
  389. sealed abstract class Maybe[A] extends AnyRef

    An optional value

    An optional value

    A Maybe[A] will either be a wrapped A instance (Just[A]), or a lack of underlying A instance (Empty[A]).

    Maybe[A] is isomorphic to Option[A], however there are some differences between the two. Maybe is invariant in A while Option is covariant. Maybe[A] does not expose an unsafe get operation to access the underlying A value (that may not exist) like Option[A] does. Maybe[A] does not come with an implicit conversion to Iterable[A] (a trait with over a dozen super types).

  390. sealed abstract class MaybeInstances extends MaybeInstances0
  391. sealed abstract class MaybeInstances0 extends MaybeInstances1
  392. sealed abstract class MaybeInstances1 extends AnyRef
  393. final case class MaybeT[F[_], A](run: F[Maybe[A]]) extends Product with Serializable

    monad transformer for Maybe

  394. sealed abstract class MaybeTInstances extends MaybeTInstances0
  395. sealed abstract class MaybeTInstances0 extends MaybeTInstances1
  396. sealed abstract class MaybeTInstances1 extends MaybeTInstances2
  397. sealed abstract class MaybeTInstances2 extends MaybeTInstances3
  398. sealed abstract class MaybeTInstances3 extends AnyRef
  399. sealed abstract class Memo[K, V] extends AnyRef

    A function memoization strategy.

    A function memoization strategy. See companion for various instances employing various strategies.

  400. sealed abstract class MemoInstances extends AnyRef
  401. final case class Middle3[A, B, C](b: B) extends Either3[A, B, C] with Product with Serializable
  402. type MinMaybe[A] = scalaz.TagKind.@@[Maybe[A], Min]
  403. type MinOf[A] = scalaz.TagKind.@@[A, MinVal]
  404. type MinOption[A] = scalaz.TagKind.@@[Option[A], Min]
  405. trait Monad[F[_]] extends Applicative[F] with Bind[F]

    Monad, an scalaz.Applicative that also supports scalaz.Bind, circumscribed by the monad laws.

    Monad, an scalaz.Applicative that also supports scalaz.Bind, circumscribed by the monad laws.

    See also

    scalaz.Monad.MonadLaw

  406. trait MonadError[F[_], S] extends Monad[F] with ApplicativeError[F, S]

  407. trait MonadListen[F[_], W] extends MonadTell[F, W]
  408. trait MonadPlus[F[_]] extends Monad[F] with ApplicativePlus[F]

    See also

    scalaz.Monad

    scalaz.PlusEmpty

  409. trait MonadReader[F[_], S] extends Monad[F]

  410. trait MonadState[F[_], S] extends Monad[F]

    The class of monads supporting the operations of scalaz.State.

  411. trait MonadTell[F[_], S] extends Monad[F]

    The class of monads supporting write operations

  412. trait MonadTrans[F[_[_], _]] extends AnyRef

    Class of monad transformers.

  413. trait Monoid[F] extends Semigroup[F]

    Provides an identity element (zero) to the binary append operation in scalaz.Semigroup, subject to the monoid laws.

    Provides an identity element (zero) to the binary append operation in scalaz.Semigroup, subject to the monoid laws.

    Example instances:

    • Monoid[Int]: zero and append are 0 and Int#+ respectively
    • Monoid[List[A]]: zero and append are Nil and List#++ respectively

    References:

    See also

    scalaz.syntax.MonoidOps

    scalaz.Monoid.MonoidLaw

  414. sealed abstract class Name[A] extends AnyRef

    Call by name

  415. trait NaturalTransformation[F[_], G[_]] extends AnyRef

    A universally quantified function, usually written as F ~> G, for symmetry with A => B.

    A universally quantified function, usually written as F ~> G, for symmetry with A => B.

    Can be used to encode first-class functor transformations in the same way functions encode first-class concrete value morphisms; for example, sequence from scalaz.Traverse and cosequence from scalaz.Distributive give rise to ([a]T[A[a]]) ~> ([a]A[T[a]]), for varying A and T constraints.

  416. trait NaturalTransformations extends AnyRef
  417. final class Need[A] extends Name[A]

    Call by need

  418. final class NonEmptyList[A] extends AnyRef

    A singly-linked list that is guaranteed to be non-empty.

  419. sealed abstract class NonEmptyListInstances extends NonEmptyListInstances0
  420. sealed abstract class NonEmptyListInstances0 extends AnyRef
  421. trait Nondeterminism[F[_]] extends Monad[F]

    A context supporting nondeterministic choice.

    A context supporting nondeterministic choice. Unlike Monad.bind, which imposes a total order on the sequencing of effects throughout a computation, the choose and chooseAny operations let us partially order the sequencing of effects. Canonical instances are concurrent.Future and concurrent.Task, which run their arguments in parallel, returning whichever comes back 'first'.

    TODO - laws

  422. sealed trait NotNothing[A] extends AnyRef
  423. final class NullArgument[A, B] extends AnyRef
  424. sealed abstract class NullArgumentInstances extends NullArgumentInstances0
  425. sealed abstract class NullArgumentInstances0 extends AnyRef
  426. final class NullResult[A, B] extends AnyRef
  427. sealed abstract class NullResultInstances extends NullResultInstances0
  428. sealed abstract class NullResultInstances0 extends AnyRef
  429. final class OneAnd[F[_], A] extends AnyRef

    A generalization of NonEmptyList to non-List things.

    A generalization of NonEmptyList to non-List things. For example, OneAnd[Vector, A] is a non-empty Vector of A.

    Only head and tail are provided as direct methods, because there's little you can do with a OneAnd without knowing a bit about F. So useful functions are provided in the form of typeclass instances on OneAnd's companion; in combination with syntax extensions provided by scalaz.syntax, OneAnd has a large possible set of methods available by importing. For example, Applicative on this requires ApplicativePlus[F], and Traverse1 on this requires Traverse[F]. See the companion documentation for a complete list of instances.

    Additionally, unlike λ[α => (α, F[α])], the behavior of typeclass operations on OneAnd should be preserved across the natural transformation to scalaz.NonEmptyList where one exists. That is it should "be like" a nonempty structure. For example, ap-ing two OneAnd[Vector, *]s or NonEmptyLists of lengths *a* and *b* yields a sequence of same type of length *a*×*b*, but two λ[α => (α, Vector[α])]s of length *c* and *d* ap to one of length 1+(*c*–1)×(*d*–1). For another example, point of the former two yield a one-element sequence, but point of the latter yields a two-element sequence.

    Since

    7.0.3

  430. sealed abstract class OneAndInstances extends OneAndInstances0
  431. sealed abstract class OneAndInstances0 extends OneAndInstances1
  432. sealed abstract class OneAndInstances1 extends OneAndInstances2
  433. sealed abstract class OneAndInstances2 extends OneAndInstances3
  434. sealed abstract class OneAndInstances3 extends OneAndInstances4
  435. sealed abstract class OneAndInstances4 extends OneAndInstances5
  436. sealed abstract class OneAndInstances5 extends AnyRef
  437. final case class OneOr[F[_], A](run: \/[F[A], A]) extends Product with Serializable

    Since

    7.0.3

  438. sealed abstract class OneOrInstances extends OneOrInstances0
  439. sealed abstract class OneOrInstances0 extends OneOrInstances1
  440. sealed abstract class OneOrInstances1 extends OneOrInstances2
  441. sealed abstract class OneOrInstances2 extends OneOrInstances3
  442. sealed abstract class OneOrInstances3 extends OneOrInstances4
  443. sealed abstract class OneOrInstances4 extends OneOrInstances5
  444. sealed abstract class OneOrInstances5 extends OneOrInstances6
  445. sealed abstract class OneOrInstances6 extends AnyRef
  446. final case class OptionT[F[_], A](run: F[Option[A]]) extends Product with Serializable

    OptionT monad transformer.

  447. sealed abstract class OptionTInstances extends OptionTInstances0
  448. sealed abstract class OptionTInstances0 extends OptionTInstances1
  449. sealed abstract class OptionTInstances1 extends OptionTInstances2
  450. sealed abstract class OptionTInstances2 extends OptionTInstances3
  451. sealed abstract class OptionTInstances3 extends AnyRef
  452. trait Optional[F[_]] extends AnyRef

    Abstraction over a container/context which may or may not provide a value.

    Abstraction over a container/context which may or may not provide a value.

    F

    the container/context type

    See also

    syntax.OptionalOps

  453. sealed abstract class OrdSeq[A] extends Ops[FingerTree[@@[A, LastVal], A]]

    Ordered sequences, based on scalaz.FingerTree

    Ordered sequences, based on scalaz.FingerTree

    a has a higher priority than b if Order[A].greaterThan(a, b).

    insert and ++ maintains the ordering.

    The measure is calculated with a Semigroup[A @@ LastVal], whose append operation favours the first argument. Accordingly, the measure of a node is the item with the highest priority contained recursively below that node.

  454. trait Order[F] extends Equal[F]

    Safer version of scala.math.Ordering.

  455. sealed abstract class Ordering extends Product with Serializable

    A ternary marker of how two values relate in an ordering.

    A ternary marker of how two values relate in an ordering.

    Note

    scalaz calls its version of scala.math.Ordering, scalaz.Order. This Ordering is analogous to the Ints returned by scala.math.Ordering.

  456. sealed abstract class OrderingInstances extends AnyRef
  457. type PIndexedState[S1, S2, A] = IndexedStateT[S1, S2, scalaz.Id.Id, Option[A]]

  458. type PIndexedStateT[F[_], S1, S2, A] = IndexedStateT[S1, S2, F, Option[A]]

  459. type PLens[A, B] = PLensFamily[A, A, B, B]

    A partial lens that doesn't transform the type of the record.

    A partial lens that doesn't transform the type of the record.

    See also

    scalaz.@?>

  460. sealed abstract class PLensFamily[A1, A2, B1, B2] extends AnyRef

    Partial Lens Families, offering a purely functional means to access and retrieve an optional field transitioning from type B1 to type B2 in a record that is simultaneously transitioning from type A1 to type A2.

    Partial Lens Families, offering a purely functional means to access and retrieve an optional field transitioning from type B1 to type B2 in a record that is simultaneously transitioning from type A1 to type A2. scalaz.PLens is a convenient alias for when A1 === A2, and B1 === B2.

    The term field should not be interpreted restrictively to mean a member of a class. For example, a partial lens family can address the nth element of a List.

    A1

    The initial type of the record

    A2

    The final type of the record

    B1

    The initial type of the optional field

    B2

    The final type of the optional field

    See also

    scalaz.Lens

  461. trait PLensFamilyFunctions extends PLensInstances
  462. trait PLensFunctions extends PLensInstances with PLensFamilyFunctions
  463. abstract class PLensInstances extends AnyRef
  464. type PState[S, A] = IndexedStateT[S, S, scalaz.Id.Id, Option[A]]

  465. type PStateT[F[_], S, A] = IndexedStateT[S, S, F, Option[A]]

  466. type Pair[A] = (A, A)
  467. trait Plus[F[_]] extends AnyRef

    Universally quantified scalaz.Semigroup.

  468. trait PlusEmpty[F[_]] extends Plus[F]

    Universally quantified scalaz.Monoid.

  469. class PrioritySearchQueue[A, P, K] extends AnyRef

    Container whose elements have two different orders: by priority and by lookup key.

    Container whose elements have two different orders: by priority and by lookup key.

    Supports efficient implementation of the following operations: - insertion (O(log n)), - lookup by key (O(log n)), - deletion by key (O(log n)), - access to minimal-by-priority element (O(1)), - deletion of minimal-by-priority element (O(log n)).

    Implemented using FingerTree.

    A

    element type

    P

    priority of an element. Multiple elements can have the same priority.

    K

    lookup key. Unique—the queue holds at most one element with any given key.

  470. trait ProChoice[=>:[_, _]] extends Profunctor[=>:]

    Strength on a coproduct.

  471. trait Profunctor[=>:[_, _]] extends AnyRef

    Profunctors are covariant on the right and contravariant on the left.

  472. type RWS[R, W, S, A] = IndexedReaderWriterStateT[R, W, S, S, scalaz.Id.Id, A]
  473. type RWST[R, W, S, F[_], A] = IndexedReaderWriterStateT[R, W, S, S, F, A]
  474. trait Ran[G[_], H[_], A] extends AnyRef

    The right Kan extension of H along G

  475. type Reader[E, A] = Kleisli[scalaz.Id.Id, E, A]

  476. type ReaderT[E, F[_], A] = Kleisli[F, E, A]
  477. type ReaderWriterState[R, W, S, A] = IndexedReaderWriterStateT[R, W, S, S, scalaz.Id.Id, A]

  478. type ReaderWriterStateT[R, W, S, F[_], A] = IndexedReaderWriterStateT[R, W, S, S, F, A]

  479. trait ReaderWriterStateTFunctions extends AnyRef
  480. abstract class ReaderWriterStateTInstances extends ReaderWriterStateTInstances0
  481. sealed abstract class ReaderWriterStateTInstances0 extends IndexedReaderWriterStateTInstances
  482. trait Reducer[C, M] extends AnyRef

    A Reducer[C,M] is a scalaz.Semigroup[M] that maps values of type C through unit to values of type M.

    A Reducer[C,M] is a scalaz.Semigroup[M] that maps values of type C through unit to values of type M. A C-Reducer may also supply operations which tack on another C to an existing Semigroup M on the left or right. These specialized reductions may be more efficient in some scenarios and are used when appropriate by a scalaz.Generator. The names cons and snoc work by analogy to the synonymous operations in the list semigroup.

    Minimal definition: unit or snoc

    Based on the Reducer Haskell library by Edward Kmett (https://hackage.haskell.org/package/reducers).

  483. sealed abstract class ReducerInstances extends AnyRef
  484. abstract class Representable[F[_], X] extends AnyRef

    Representable functors, that is to say, those with isomorphisms to and from [a](X => a).

    Representable functors, that is to say, those with isomorphisms to and from [a](X => a). As such, all typeclasses and operations on [a](X => a), that is, fixed in X, can be trivially derived for F.

  485. sealed abstract class RepresentableInstances extends AnyRef
  486. final case class Right3[A, B, C](c: C) extends Either3[A, B, C] with Product with Serializable
  487. type Select[R, A] = SelectT[R, scalaz.Id.Id, A]

  488. final case class SelectT[R, M[_], A](run: ((A) ⇒ M[R]) ⇒ M[A]) extends Product with Serializable

    Selection monad transformer.

    Selection monad transformer.

    See also

    https://www.cs.bham.ac.uk/~mhe/papers/selection-escardo-oliva.pdf

    https://arxiv.org/pdf/1406.2058.pdf

    https://github.com/ghc/packages-transformers/blob/0_5_4_0/Control/Monad/Trans/Select.hs

  489. sealed abstract class SelectTInstances extends SelectTInstances1
  490. sealed abstract class SelectTInstances1 extends SelectTInstances2
  491. sealed abstract class SelectTInstances2 extends SelectTInstances3
  492. sealed abstract class SelectTInstances3 extends SelectTInstances4
  493. sealed abstract class SelectTInstances4 extends SelectTInstances5
  494. sealed abstract class SelectTInstances5 extends SelectTInstances6
  495. sealed abstract class SelectTInstances6 extends SelectTInstances7
  496. sealed abstract class SelectTInstances7 extends AnyRef
  497. trait SemiLattice[F] extends Band[F]

    scalaz.Band which is also commutative, i.e.

    scalaz.Band which is also commutative, i.e. A + B == B + A

    See also

    scalaz.SemiLattice.SemiLatticeLaw

  498. trait Semigroup[F] extends AnyRef

    An associative binary operation, circumscribed by type and the semigroup laws.

    An associative binary operation, circumscribed by type and the semigroup laws. Unlike scalaz.Monoid, there is not necessarily a zero.

    See also

    scalaz.Semigroup.SemigroupLaw

    scalaz.syntax.SemigroupOps

    http://mathworld.wolfram.com/Semigroup.html

  499. trait Show[F] extends AnyRef

    A typeclass for conversion to textual representation, done via scalaz.Cord for efficiency.

  500. trait Split[=>:[_, _]] extends Compose[=>:]

    A scalaz.Compose (semigroupoid) permitting products.

  501. type State[S, A] = IndexedStateT[S, S, scalaz.Id.Id, A]

    A state transition, representing a function S => (S, A).

  502. trait StateFunctions extends IndexedStateFunctions
  503. type StateT[S, F[_], A] = IndexedStateT[S, S, F, A]

  504. trait StateTFunctions extends IndexedStateTFunctions
  505. abstract class StateTInstances extends StateTInstances0
  506. sealed abstract class StateTInstances0 extends StateTInstances1
  507. sealed abstract class StateTInstances1 extends StateTInstances2
  508. sealed abstract class StateTInstances2 extends StateTInstances3
  509. sealed abstract class StateTInstances3 extends StateTInstances4
  510. sealed abstract class StateTInstances4 extends IndexedStateTInstances
  511. type Store[A, B] = IndexedStoreT[scalaz.Id.Id, A, A, B]

  512. type StoreT[F[_], A, B] = IndexedStoreT[F, A, A, B]

  513. trait StoreTFunctions extends IndexedStoreTFunctions
  514. abstract class StoreTInstances extends StoreTInstances0
  515. sealed abstract class StoreTInstances0 extends StoreTInstances1
  516. sealed abstract class StoreTInstances1 extends StoreTInstances2
  517. sealed abstract class StoreTInstances2 extends IndexedStoreTInstances
  518. sealed class StreamT[M[_], A] extends AnyRef

    StreamT monad transformer.

  519. sealed abstract class StreamTInstances extends StreamTInstances0
  520. sealed abstract class StreamTInstances0 extends AnyRef
  521. case class StrictTree[A](rootLabel: A, subForest: Vector[StrictTree[A]]) extends Product with Serializable

    rootLabel

    The label at the root of this tree.

    subForest

    The child nodes of this tree.

  522. sealed abstract class StrictTreeInstances extends AnyRef
  523. final class StrictTreeUnzip[A1, A2] extends AnyVal
  524. trait Strong[=>:[_, _]] extends Profunctor[=>:]

    Strength on a product.

  525. final case class Success[E, A](a: A) extends Validation[E, A] with Product with Serializable
  526. sealed abstract class TagKind extends AnyRef
  527. final case class Tannen[F[_], G[_, _], A, B](f: F[G[A, B]]) extends Product with Serializable

    Composes a Functor on the outside of a Bifunctor.

    Composes a Functor on the outside of a Bifunctor.

    https://hackage.haskell.org/package/bifunctors-5.5/docs/Data-Bifunctor-Tannen.html#t:Tannen

  528. sealed abstract class TannenInstances extends TannenInstances0
  529. sealed abstract class TannenInstances0 extends AnyRef
  530. sealed abstract class TheseInstances extends TheseInstances0
  531. sealed abstract class TheseInstances0 extends TheseInstances1
  532. sealed abstract class TheseInstances1 extends AnyRef
  533. final case class TheseT[F[_], A, B](run: F[\&/[A, B]]) extends Product with Serializable
  534. sealed abstract class TheseTInstances extends TheseTInstances0
  535. sealed abstract class TheseTInstances0 extends TheseTInstances1
  536. sealed abstract class TheseTInstances1 extends AnyRef
  537. type Traced[A, B] = TracedT[scalaz.Id.Id, A, B]

  538. final case class TracedT[W[_], A, B](run: W[(A) ⇒ B]) extends Product with Serializable

    See also

    https://github.com/ekmett/comonad/blob/v4.2.7.2/src/Control/Comonad/Trans/Traced.hs

  539. sealed abstract class TracedTInstances extends TracedTInstances0
  540. sealed abstract class TracedTInstances0 extends TracedTInstances1
  541. sealed abstract class TracedTInstances1 extends TracedTInstances2
  542. sealed abstract class TracedTInstances2 extends TracedTInstances3
  543. sealed abstract class TracedTInstances3 extends TracedTInstances4
  544. sealed abstract class TracedTInstances4 extends TracedTInstances5
  545. sealed abstract class TracedTInstances5 extends AnyRef
  546. trait Traverse[F[_]] extends Functor[F] with Foldable[F]

    Idiomatic traversal of a structure, as described in The Essence of the Iterator Pattern.

    Idiomatic traversal of a structure, as described in The Essence of the Iterator Pattern.

    See also

    scalaz.Traverse.TraverseLaw

  547. trait Traverse1[F[_]] extends Traverse[F] with Foldable1[F]

    A scalaz.Traverse where traverse is total over scalaz.Applys.

    A scalaz.Traverse where traverse is total over scalaz.Applys. That is, toList cannot return an empty list.

  548. sealed abstract class Tree[A] extends AnyRef

    A multi-way tree, also known as a rose tree.

    A multi-way tree, also known as a rose tree. Also known as Cofree[Stream, A].

  549. sealed abstract class TreeInstances extends AnyRef
  550. final case class TreeLoc[A](tree: Tree[A], lefts: TreeForest[A], rights: TreeForest[A], parents: Parents[A]) extends Product with Serializable

    A rose-tree zipper.

    A rose-tree zipper. Represents a scalaz.Tree together with a position in that tree. Provides navigation, persistent update, insertion, and deletes.

    tree

    The currently selected node.

    lefts

    The left siblings of the current node.

    rights

    The right siblings of the current node.

    parents

    The parent contexts of the current node.

  551. sealed abstract class TreeLocInstances extends AnyRef
  552. trait Unapply[TC[_[_]], MA] extends AnyRef

    Represents a type MA that has been destructured into as a type constructor M[_] applied to type A, along with a corresponding type class instance TC[M].

    Represents a type MA that has been destructured into as a type constructor M[_] applied to type A, along with a corresponding type class instance TC[M].

    The implicit conversions in the companion object provide a means to obtain type class instances for partially applied type constructors, in lieu of direct compiler support as described in SI-2712.

    // Directly depending on Applicative[G]
def traverse[G[_], B](f: A => G[B])(implicit G: Applicative[G]): G[F[B]] =
  G.traverse(self)(f)

// Indirect lookup of the Applicative instance
def traverseI[GB](f: A => GB)(implicit G: Unapply[Applicative, GB]): G.M[F[G.A]] /*G[F[B]*/ = {
  G.TC.traverse(self)(a => G(f(a)))
}

// Deforested version of traverseI
def traverseI2[GB](f: A => GB)(implicit G: Unapply[Applicative, GB]): G.M[F[G.A]] /*G[F[B]*/ = {
  G.TC.traverse(self)(G.leibniz.onF(f))
}

// Old usage
def stateTraverse1 {
  import scalaz._, Scalaz._
  import State.{State, stateMonad}
  val ls = List(1, 2, 3)
  val traverseOpt: Option[List[Int]] = ls.traverse(a => Some(a))
  val traverseState: State[Int, List[Int]] = ls.traverse[State[Int, *], Int](a => State((x: Int) => (x + 1, a)))
}

// New usage
def stateTraverse2 {
  import scalaz._, Scalaz._
  val ls = List(1, 2, 3)
  val traverseOpt: Option[List[Int]] = ls.traverseI(a => some(a))
  val traverseState = ls.traverseI(a => State((x: Int) => (x + 1, a)))
}

    Credits to Miles Sabin.

    Annotations
    @implicitNotFound( ... )
  553. trait Unapply2[TC[_[_, _]], MAB] extends AnyRef
  554. trait Unapply21[TC[_[_, _], _], MAB] extends AnyRef
  555. trait UnapplyProduct[TC[_[_]], MA, MB] extends AnyRef
  556. sealed abstract class Unapply_0 extends Unapply_2
  557. sealed abstract class Unapply_2 extends Unapply_3
  558. sealed abstract class Unapply_3 extends Unapply_4
  559. sealed abstract class Unapply_4 extends AnyRef
  560. sealed abstract class UnitReducer[C, M] extends Reducer[C, M]
  561. type Unwriter[W, A] = UnwriterT[scalaz.Id.Id, W, A]

  562. final case class UnwriterT[F[_], U, A](run: F[(U, A)]) extends Product with Serializable

    This data type is isomorphic to WriterT, however, it is NOT a monad.

    This data type is isomorphic to WriterT, however, it is NOT a monad.

    It implements flatMap+map and drops the write value. There is no Monoid or Semigroup required. There is no point operation. You can switch between WriterT and UnwriterT with unary_+ and unary_-.

  563. trait UnwriterTFunctions extends AnyRef
  564. sealed abstract class UnwriterTInstances extends UnwriterTInstances0
  565. sealed abstract class UnwriterTInstances0 extends UnwriterTInstances1
  566. sealed abstract class UnwriterTInstances1 extends UnwriterTInstances2
  567. sealed abstract class UnwriterTInstances2 extends AnyRef
  568. trait Unzip[F[_]] extends AnyRef

  569. sealed abstract class Validation[E, A] extends Product with Serializable

    Represents either:

    Represents either:

    • Success(a), or
    • Failure(e).

    Isomorphic to scala.Either and scalaz.\/. The motivation for a Validation is to provide the instance Applicativea that accumulate failures through a scalaz.Semigroup[E].

    scalaz.NonEmptyList is commonly chosen as a type constructor for the type E. As a convenience, an alias scalaz.ValidationNel[E] is provided as a shorthand for scalaz.Validation[NonEmptyList[E]], and a method Validation#toValidationNel converts Validation[E] to ValidationNel[E].

    Example:

    import scalaz._, std.AllInstances._

def parseInt(s: String): Validation[String, Int] =
  try { Success(s.toInt) } catch { case ex: NumberFormatException => Failure(ex.getMessage) }
val V = Applicative[ValidationNel[String, *]]

val x: ValidationNel[String, Int] =
  V.apply2(parseInt("1.x").toValidationNel, parseInt("1..0").toValidationNel)(_ * _)
  // Failure(NonEmptyList(For input string: "1..0", For input string: "1.x"))
    E

    The type of the Failure

    A

    The type of the Success

  570. final class ValidationFlatMap[E, A] extends AnyVal
  571. sealed abstract class ValidationInstances extends ValidationInstances0
  572. sealed abstract class ValidationInstances0 extends ValidationInstances1
  573. sealed abstract class ValidationInstances1 extends ValidationInstances2
  574. sealed abstract class ValidationInstances2 extends ValidationInstances3
  575. sealed abstract class ValidationInstances3 extends AnyRef
  576. type ValidationNel[E, X] = Validation[NonEmptyList[E], X]

    An scalaz.Validation with a scalaz.NonEmptyList as the failure type.

  577. final case class Value[A](value: A) extends Name[A] with Product with Serializable

    Call by value

  578. type Writer[W, A] = WriterT[W, scalaz.Id.Id, A]

  579. final case class WriterT[W, F[_], A](run: F[(W, A)]) extends Product with Serializable
  580. trait WriterTFunctions extends AnyRef
  581. sealed abstract class WriterTInstance5 extends WriterTInstances6
  582. sealed abstract class WriterTInstances extends WriterTInstances0
  583. sealed abstract class WriterTInstances0 extends WriterTInstances1
  584. sealed abstract class WriterTInstances1 extends WriterTInstances2
  585. sealed abstract class WriterTInstances10 extends WriterTInstances11
  586. sealed abstract class WriterTInstances11 extends WriterTInstances12
  587. sealed abstract class WriterTInstances12 extends WriterTInstances13
  588. sealed abstract class WriterTInstances13 extends WriterTInstances14
  589. sealed abstract class WriterTInstances14 extends WriterTInstances15
  590. sealed abstract class WriterTInstances15 extends WriterTInstances16
  591. sealed abstract class WriterTInstances16 extends AnyRef
  592. sealed abstract class WriterTInstances2 extends WriterTInstances3
  593. sealed abstract class WriterTInstances3 extends WriterTInstances4
  594. sealed abstract class WriterTInstances4 extends WriterTInstance5
  595. sealed abstract class WriterTInstances6 extends WriterTInstances7
  596. sealed abstract class WriterTInstances7 extends WriterTInstances8
  597. sealed abstract class WriterTInstances8 extends WriterTInstances9
  598. sealed abstract class WriterTInstances9 extends WriterTInstances10
  599. abstract class Yoneda[F[_], A] extends AnyRef

    The cofree functor generated by F.

    The cofree functor generated by F. The Yoneda lemma says that Yoneda[F,A] is isomorphic to F[A] for any functor F. The homomorphism from Yoneda[F,A] to F[A] exists even when we have forgotten that F is a functor. Can be seen as a partially applied map for the functor F.

  600. trait Zap[F[_], G[_]] extends AnyRef

    Functors that annihilate each other.

  601. sealed abstract class ZapInstances extends AnyRef
  602. trait Zip[F[_]] extends AnyRef

  603. final case class Zipper[A](lefts: Stream[A], focus: A, rights: Stream[A]) extends Product with Serializable

    Provides a pointed stream, which is a non-empty zipper-like stream structure that tracks an index (focus) position in a stream.

    Provides a pointed stream, which is a non-empty zipper-like stream structure that tracks an index (focus) position in a stream. Focus can be moved forward and backwards through the stream, elements can be inserted before or after the focused position, and the focused item can be deleted.

    Based on the pointedlist library by Jeff Wheeler.

  604. sealed abstract class ZipperInstances extends AnyRef
  605. sealed abstract class \&/[A, B] extends Product with Serializable

    Since

    7.0.3

  606. sealed abstract class \/[A, B] extends Product with Serializable

    Represents a disjunction: a result that is either an A or a B.

    Represents a disjunction: a result that is either an A or a B.

    An instance of A \/ B is either a -\/[A] (aka a "left") or a \/-[B] (aka a "right").

    A common use of a disjunction is to explicitly represent the possibility of failure in a result as opposed to throwing an exception. By convention, the left is used for errors and the right is reserved for successes. For example, a function that attempts to parse an integer from a string may have a return type of NumberFormatException \/ Int. However, since there is no need to actually throw an exception, the type (A) chosen for the "left" could be any type representing an error and has no need to actually extend Exception.

    A \/ B is isomorphic to scala.Either[A, B], but \/ is right-biased for all Scala versions, so methods such as map and flatMap apply only in the context of the "right" case. This right bias makes \/ more convenient to use than scala.Either in a monadic context in Scala versions <2.12. Methods such as swap, swapped, and leftMap provide functionality that scala.Either exposes through left projections.

    A \/ B is also isomorphic to Validation[A, B]. The subtle but important difference is that Applicative instances for Validation accumulates errors ("lefts") while Applicative instances for \/ fail fast on the first "left" they evaluate. This fail-fast behavior allows \/ to have lawful Monad instances that are consistent with their Applicative instances, while Validation cannot.

  607. final case class \/-[A, B](b: B) extends \/[A, B] with Product with Serializable

    A right disjunction

    A right disjunction

    Often used to represent the success case of a result

  608. class unused extends deprecated

    Mark an explicit or implicit parameter as known to be unused, as shorthand for the longer form, useful in combination with -Ywarn-unused:explicits,implicits compiler options.

  609. type |-->[A, B] = IndexedStoreT[scalaz.Id.Id, B, B, A]
  610. type ~>[F[_], G[_]] = NaturalTransformation[F, G]

    A scalaz.NaturalTransformation[F, G].

  611. type ~~>[F[_, _], G[_, _]] = BiNaturalTransformation[F, G]
  612. type ∨[A, B] = \/[A, B]
  613. type ⊤ = Any
  614. type ⊥ = Nothing
  615. trait Catchable[F[_]] extends AnyRef

    A context in which exceptions can be caught and thrown.

    A context in which exceptions can be caught and thrown.

    This class places no other class constraints on F, but it should be the case that exceptions raised via fail are caught by the nearest surrounding attempt and returned as a Left. In addition to catching explicitly raised exceptions via fail, we expect that attempt catch ambient exceptions that might occur when 'evaluating' an F.

    We can state the requirement that attempt catch all ambient exceptions by stipulating that for all total functions of the form g: forall A . F[Throwable \/ A] => B, g compose attempt is also total.

    Annotations
    @deprecated
    Deprecated

    (Since version 7.3.0) No laws, and Throwable is not referentially transparent. Prefer MonadError

Value Members

  1. val DLeft: -\/.type
  2. val DRight: \/-.type
  3. val Disjunction: \/.type
  4. val DisjunctionT: EitherT.type
  5. val IMap: ==>>.type
  6. val IRWS: IndexedReaderWriterState.type
  7. val IRWST: IndexedReaderWriterStateT.type
  8. val RWS: ReaderWriterState.type
  9. val RWST: ReaderWriterStateT.type
  10. def Traced[A, B](f: (A) ⇒ B): Traced[A, B]
  11. implicit val idInstance: Traverse1[scalaz.Id.Id] with Monad[scalaz.Id.Id] with BindRec[scalaz.Id.Id] with Comonad[scalaz.Id.Id] with Distributive[scalaz.Id.Id] with Zip[scalaz.Id.Id] with Unzip[scalaz.Id.Id] with Align[scalaz.Id.Id] with Cozip[scalaz.Id.Id] with Optional[scalaz.Id.Id]
  12. object -\/ extends Serializable
  13. object /~\
  14. object :+:
  15. object ==>> extends MapInstances
  16. object Adjunction extends AdjunctionInstances
  17. object Align
  18. object Alpha extends AlphaInstances with Serializable
  19. object Alt
  20. object Alter extends AlterInstances with Serializable
  21. object Ap extends ApInstances with Serializable
  22. object Applicative
  23. object ApplicativeError
  24. object ApplicativePlus
  25. object Apply
  26. object Arrow
  27. object Associative
  28. object Band
  29. object Bifoldable
  30. object Bifunctor
  31. object BijectionT extends BijectionTInstances
  32. object Bind
  33. object BindRec
  34. object Bitraverse
  35. object CaseInsensitive extends CaseInsensitiveInstances
  36. object Catchable
  37. object Category
  38. object Choice
  39. object Cobind
  40. object Codensity extends CodensityInstances
  41. object Cofree extends CofreeInstances
  42. object Cohoist
  43. object Cokleisli extends CokleisliInstances with Serializable
  44. object Comonad
  45. object ComonadStore
  46. object ComonadTrans
  47. object Compose
  48. object Const extends ConstInstances with Serializable
  49. object Cont extends IndexedContsTInstances with IndexedContsTFunctions
  50. object ContT extends IndexedContsTInstances with IndexedContsTFunctions
  51. object Contravariant
  52. object ContravariantCoyoneda extends ContravariantCoyonedaInstances
  53. object Conts extends IndexedContsTInstances with IndexedContsTFunctions
  54. object ContsT extends IndexedContsTInstances with IndexedContsTFunctions
  55. object Coproduct extends CoproductInstances with Serializable
  56. object Cord
  57. object CorecursiveList extends CorecursiveListInstances
  58. object Coyoneda extends CoyonedaInstances
  59. object Cozip
  60. object DList extends DListInstances
  61. object Day extends DayInstances
  62. object Decidable
  63. object Density extends DensityInstances
  64. object Dequeue extends DequeueInstances
  65. object Diev extends DievInstances
  66. object DievInterval
  67. object Digit extends DigitInstances with Serializable
  68. object Distributive
  69. object Divide
  70. object Divisible
  71. object Dual extends DualInstances
  72. object Either3 extends Serializable
  73. object EitherT extends EitherTInstances with Serializable
  74. object Endo extends EndoInstances with Serializable
  75. object EndoByName extends EndoByNameInstances with Serializable
  76. object Endomorphic extends EndomorphicInstances with Serializable
  77. object Enum
  78. object EphemeralStream extends EphemeralStreamInstances
  79. object Equal
  80. object FingerTree extends FingerTreeInstances
  81. object FoldCase extends FoldCaseInstances
  82. object Foldable
  83. object Foldable1
  84. object Forall extends Foralls
  85. object Free extends FreeInstances
  86. object FreeAp
  87. object FreeT extends FreeTInstances
  88. object Functor
  89. object Generator extends Generators
  90. object Heap extends HeapInstances
  91. object Hoist
  92. object IList extends IListInstances with Serializable
  93. object INil extends Serializable
  94. object ISet extends ISetInstances
  95. object IStream
  96. object Id extends IdInstances
  97. object IdT extends IdTInstances with Serializable
  98. object ImmutableArray extends ImmutableArrayInstances
  99. object IndSeq extends IndSeqInstances
  100. object IndexedCont extends IndexedContsTInstances with IndexedContsTFunctions
  101. object IndexedContT extends IndexedContsTInstances with IndexedContsTFunctions
  102. object IndexedConts extends IndexedContsTInstances with IndexedContsTFunctions
  103. object IndexedContsT extends IndexedContsTInstances with IndexedContsTFunctions with Serializable
  104. object IndexedReaderWriterState extends ReaderWriterStateTInstances with ReaderWriterStateTFunctions
  105. object IndexedReaderWriterStateT extends ReaderWriterStateTInstances with ReaderWriterStateTFunctions
  106. object IndexedState extends StateFunctions
  107. object IndexedStateT extends StateTInstances with StateTFunctions
  108. object IndexedStore
  109. object IndexedStoreT extends StoreTInstances with StoreTFunctions with Serializable
  110. object Inject extends InjectInstances
  111. object Injectivity
  112. object InvariantAlt
  113. object InvariantApplicative
  114. object InvariantFunctor
  115. object IsContravariant
  116. object IsCovariant
  117. object IsEmpty
  118. object Isomorphism extends Isomorphisms
  119. object Kleisli extends KleisliInstances with Serializable
  120. object Lan extends LanInstances
  121. object LazyEither extends LazyEitherInstances
  122. object LazyEitherT extends LazyEitherTInstances with Serializable
  123. object LazyOption extends LazyOptionInstances with Serializable
  124. object LazyOptionT extends LazyOptionTInstances with Serializable
  125. object LazyTuple
  126. object LazyTuple2 extends LazyTuple2Instances
  127. object LazyTuple3 extends LazyTuple3Instances
  128. object LazyTuple4 extends LazyTuple4Instances
  129. object Leibniz extends LeibnizInstances
  130. object LeibnizF
  131. object Lens extends LensInstances with LensFunctions

    See also

    scalaz.Lens

  132. object LensFamily extends LensInstances with LensFunctions
  133. object Liskov extends LiskovInstances
  134. object LiskovF
  135. object ListT extends ListTInstances with Serializable
  136. object Maybe extends MaybeInstances
  137. object MaybeT extends MaybeTInstances with Serializable
  138. object Memo extends MemoInstances

  139. object Monad
  140. object MonadError
  141. object MonadListen
  142. object MonadPlus
  143. object MonadReader
  144. object MonadState
  145. object MonadTell
  146. object MonadTrans
  147. object Monoid
  148. object Name
  149. object NaturalTransformation extends NaturalTransformations
  150. object Need
  151. object NonEmptyList extends NonEmptyListInstances
  152. object Nondeterminism
  153. object NotNothing
  154. object NullArgument extends NullArgumentInstances
  155. object NullResult extends NullResultInstances
  156. object OneAnd extends OneAndInstances
  157. object OneOr extends OneOrInstances with Serializable
  158. object OptionT extends OptionTInstances with Serializable
  159. object Optional
  160. object OrdSeq
  161. object Order
  162. object Ordering extends OrderingInstances with Serializable
  163. object PLens extends PLensInstances with PLensFunctions
  164. object PLensFamily extends PLensInstances with PLensFunctions
  165. object Plus
  166. object PlusEmpty
  167. object PrioritySearchQueue
  168. object ProChoice
  169. object Profunctor
  170. object Ran
  171. object Reader
  172. object ReaderT
  173. object ReaderWriterState extends ReaderWriterStateTInstances with ReaderWriterStateTFunctions
  174. object ReaderWriterStateT extends ReaderWriterStateTInstances with ReaderWriterStateTFunctions
  175. object Reducer extends ReducerInstances
  176. object Representable extends RepresentableInstances
  177. object Scalaz extends StateFunctions with ToTypeClassOps with ToDataOps with AllInstances with AllFunctions with ToAllStdOps with IdInstances
  178. object ScalazBuildInfo extends Product with Serializable

    This object was generated by sbt-buildinfo.

  179. object Select
  180. object SelectT extends SelectTInstances with Serializable
  181. object SemiLattice
  182. object Semigroup
  183. object Show
  184. object Split
  185. object State extends StateFunctions
  186. object StateT extends StateTInstances with StateTFunctions
  187. object Store
  188. object StoreT extends StoreTInstances with StoreTFunctions
  189. object StreamT extends StreamTInstances
  190. object StrictTree extends StrictTreeInstances with Serializable
  191. object Strong
  192. object Tag
  193. object Tags

    Type tags that are used to discriminate between alternative type class instances.

    Type tags that are used to discriminate between alternative type class instances.

    See also

    scalaz.Tag and, @@ in the package object scalaz .

  194. object Tannen extends TannenInstances with Serializable
  195. object TheseT extends TheseTInstances with Serializable
  196. object TracedT extends TracedTInstances with Serializable
  197. object Trampoline
  198. object Traverse
  199. object Traverse1
  200. object Tree extends TreeInstances
  201. object TreeLoc extends TreeLocInstances with Serializable
  202. object Unapply extends Unapply_0
  203. object Unapply2
  204. object Unapply21
  205. object UnapplyProduct
  206. object UnitReducer
  207. object Unwriter
  208. object UnwriterT extends UnwriterTInstances with UnwriterTFunctions with Serializable
  209. object Unzip
  210. object Validation extends ValidationInstances with Serializable
  211. object Value extends Serializable
  212. object Writer
  213. object WriterT extends WriterTInstances with WriterTFunctions with Serializable
  214. object Yoneda
  215. object Zap extends ZapInstances
  216. object Zip
  217. object Zipper extends ZipperInstances with Serializable
  218. object \&/ extends TheseInstances with Serializable
  219. object \/ extends DisjunctionInstances with Serializable
  220. object \/- extends Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped