Package

scalaz

Permalink

package scalaz

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

This package, scalaz, contains:

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
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](a: A) extends \/[A, Nothing] with Product with Serializable

    Permalink

    A left disjunction

    A left disjunction

    Often used to represent the failure case of a result

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

    Permalink

    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.

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

    Permalink

    scalaz.Inject[F, G]

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

    Permalink

    scalaz.Inject[F, G]

  5. type <~[+F[_], -G[_]] = NaturalTransformation[G, F]

    Permalink

    A scalaz.NaturalTransformation[G, F].

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

    Permalink

    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

  7. type =?>[E, A] = Kleisli[Option, E, A]

    Permalink
  8. type @>[A, B] = LensFamily[A, A, B, B]

    Permalink

    See also

    scalaz.Lens

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

    Permalink

    See also

    scalaz.PLens

  10. type @@[T, Tag] = AnyRef { ... /* 2 definitions in type refinement */ }

    Permalink

    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.

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

    Permalink

    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 defition is either (unit, counit) or (leftAdjunct, rightAdjunct)

  12. sealed abstract class AdjunctionInstances extends AnyRef

    Permalink
  13. trait Align[F[_]] extends Functor[F]

    Permalink

  14. sealed abstract class Alpha extends Product with Serializable

    Permalink

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

  15. sealed abstract class AlphaInstances extends AnyRef

    Permalink
  16. type Alternative[F[_]] = ApplicativePlus[F]

    Permalink
  17. trait Applicative[F[_]] extends Apply[F]

    Permalink

    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

  18. trait ApplicativePlus[F[_]] extends Applicative[F] with PlusEmpty[F]

    Permalink

    scalaz.Applicative combined with scalaz.PlusEmpty.

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

    Permalink

    scalaz.Applicative without point.

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

    Permalink

    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.

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

    Permalink

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

    Permalink

    A constrained transformation natural in both sides of a bifunctor

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

    Permalink

    A function universally quantified over two parameters.

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

    Permalink

    A type giving rise to two unrelated scalaz.Foldables.

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

    Permalink

    A type giving rise to two unrelated scalaz.Functors.

  26. final class BijectionT[F[_], G[_], A, B] extends AnyRef

    Permalink
  27. sealed abstract class BijectionTInstances extends BijectionTInstances0

    Permalink
  28. sealed abstract class BijectionTInstances0 extends AnyRef

    Permalink
  29. trait Bind[F[_]] extends Apply[F]

    Permalink

    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

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

    Permalink

    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.

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

    Permalink

    A type giving rise to two unrelated scalaz.Traverses.

  32. sealed abstract class CaseInsensitive[A] extends AnyRef

    Permalink
  33. sealed abstract class CaseInsensitiveInstances extends AnyRef

    Permalink
  34. trait Catchable[F[_]] extends AnyRef

    Permalink

    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.

  35. trait Category[=>:[_, _]] extends Compose[=>:]

    Permalink

    scalaz.Compose with identity.

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

    Permalink

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

    Permalink

  38. abstract class Codensity[F[_], A] extends AnyRef

    Permalink
  39. sealed abstract class CodensityInstances extends AnyRef

    Permalink
  40. sealed abstract class Cofree[S[_], A] extends AnyRef

    Permalink

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

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

  41. sealed abstract class CofreeInstances extends CofreeInstances0

    Permalink
  42. sealed abstract class CofreeInstances0 extends CofreeInstances1

    Permalink
  43. sealed abstract class CofreeInstances1 extends CofreeInstances2

    Permalink
  44. sealed abstract class CofreeInstances2 extends CofreeInstances3

    Permalink
  45. sealed abstract class CofreeInstances3 extends CofreeInstances4

    Permalink
  46. sealed abstract class CofreeInstances4 extends AnyRef

    Permalink
  47. trait Cohoist[F[_[_], _]] extends ComonadTrans[F]

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

    Permalink
  49. sealed abstract class CokleisliInstances extends CokleisliInstances0

    Permalink
  50. sealed abstract class CokleisliInstances0 extends AnyRef

    Permalink
  51. trait Comonad[F[_]] extends Cobind[F]

    Permalink

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

    Permalink

  53. trait ComonadTrans[F[_[_], _]] extends AnyRef

    Permalink
  54. trait Compose[=>:[_, _]] extends AnyRef

    Permalink

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

    Permalink
  56. sealed abstract class ConstInstances extends ConstInstances0

    Permalink
  57. sealed abstract class ConstInstances0 extends ConstInstances1

    Permalink
  58. sealed abstract class ConstInstances1 extends AnyRef

    Permalink
  59. trait ConstrainedNaturalTransformation[F[_], G[_], E[_]] extends AnyRef

    Permalink

    A constrained natural transformation

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

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

    Permalink
  62. trait Contravariant[F[_]] extends InvariantFunctor[F]

    Permalink

    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

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

    Permalink

    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

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

  64. sealed abstract class ContravariantCoyonedaInstances extends AnyRef

    Permalink
  65. type Conts[W[_], R, A] = IndexedContsT[W, scalaz.Id.Id, R, R, A]

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

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

    Permalink

    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.\/.

  68. sealed abstract class CoproductInstances extends CoproductInstances0

    Permalink
  69. sealed abstract class CoproductInstances0 extends CoproductInstances1

    Permalink
  70. sealed abstract class CoproductInstances1 extends CoproductInstances2

    Permalink
  71. sealed abstract class CoproductInstances2 extends CoproductInstances3

    Permalink
  72. sealed abstract class CoproductInstances3 extends AnyRef

    Permalink
  73. final case class Cord(self: FingerTree[Int, String]) extends Product with Serializable

    Permalink

    A Cord is a purely functional data structure for efficiently storing and manipulating Strings that are potentially very long.

    A Cord is a purely functional data structure for efficiently storing and manipulating Strings that are potentially very long. Very similar to Rope[Char], but with better constant factors and a simpler interface since it's specialized for Strings.

  74. abstract class Corepresentable[F[_], X] extends AnyRef

    Permalink

    Corepresentable functors

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

    Permalink

    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.

  76. sealed abstract class CoyonedaInstances extends CoyonedaInstances0

    Permalink
  77. sealed abstract class CoyonedaInstances0 extends CoyonedaInstances1

    Permalink
  78. sealed abstract class CoyonedaInstances1 extends CoyonedaInstances2

    Permalink
  79. sealed abstract class CoyonedaInstances10 extends AnyRef

    Permalink
  80. sealed abstract class CoyonedaInstances2 extends CoyonedaInstances3

    Permalink
  81. sealed abstract class CoyonedaInstances3 extends CoyonedaInstances4

    Permalink
  82. sealed abstract class CoyonedaInstances4 extends CoyonedaInstances5

    Permalink
  83. sealed abstract class CoyonedaInstances5 extends CoyonedaInstances6

    Permalink
  84. sealed abstract class CoyonedaInstances6 extends CoyonedaInstances7

    Permalink
  85. sealed abstract class CoyonedaInstances7 extends CoyonedaInstances8

    Permalink
  86. sealed abstract class CoyonedaInstances8 extends CoyonedaInstances9

    Permalink
  87. sealed abstract class CoyonedaInstances9 extends CoyonedaInstances10

    Permalink
  88. trait Cozip[F[_]] extends AnyRef

    Permalink

  89. type DLeft[+A] = -\/[A]

    Permalink
  90. final class DList[A] extends AnyRef

    Permalink

    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.

  91. sealed abstract class DListInstances extends AnyRef

    Permalink
  92. type DRight[+B] = \/-[B]

    Permalink
  93. sealed abstract class Dequeue[A] extends AnyRef

    Permalink

    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

  94. sealed abstract class DequeueInstances extends AnyRef

    Permalink
  95. trait DiNaturalTransformation[F[_, _], G[_, _]] extends AnyRef

    Permalink
  96. sealed abstract class Diev[A] extends AnyRef

    Permalink

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

  97. trait DievImplementation extends AnyRef

    Permalink
  98. sealed abstract class DievInstances extends DievImplementation

    Permalink
  99. sealed abstract class Digit extends Product with Serializable

    Permalink

    An algebraic data type representing the digits 0 - 9

  100. sealed abstract class DigitInstances extends AnyRef

    Permalink
  101. type Disjunction[+A, +B] = \/[A, B]

    Permalink
  102. sealed abstract class DisjunctionInstances extends DisjunctionInstances0

    Permalink
  103. sealed abstract class DisjunctionInstances0 extends DisjunctionInstances1

    Permalink
  104. sealed abstract class DisjunctionInstances1 extends DisjunctionInstances2

    Permalink
  105. sealed abstract class DisjunctionInstances2 extends AnyRef

    Permalink
  106. type DisjunctionT[F[_], A, B] = EitherT[F, A, B]

    Permalink
  107. trait Distributive[F[_]] extends Functor[F]

    Permalink

    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.

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

    Permalink

    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

  109. trait Divisible[F[_]] extends Divide[F]

    Permalink

    Divisible is the contravariant analogue of scalaz.Applicative

  110. sealed abstract class DualInstances extends DualInstances0

    Permalink
  111. sealed abstract class DualInstances0 extends AnyRef

    Permalink
  112. sealed abstract class Either3[+A, +B, +C] extends Product with Serializable

    Permalink
  113. final case class EitherT[F[_], A, B](run: F[\/[A, B]]) extends Product with Serializable

    Permalink

    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))
  114. sealed abstract class EitherTInstances extends EitherTInstances0

    Permalink
  115. sealed abstract class EitherTInstances0 extends EitherTInstances1

    Permalink
  116. sealed abstract class EitherTInstances1 extends EitherTInstances2

    Permalink
  117. sealed abstract class EitherTInstances2 extends EitherTInstances3

    Permalink
  118. sealed abstract class EitherTInstances3 extends EitherTInstances4

    Permalink
  119. sealed abstract class EitherTInstances4 extends AnyRef

    Permalink
  120. final case class Endo[A](run: (A) ⇒ A) extends Product with Serializable

    Permalink

    Endomorphisms.

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

    run

    The captured function.

  121. sealed abstract class EndoInstances extends AnyRef

    Permalink
  122. final case class Endomorphic[=>:[_, _], A](run: =>:[A, A]) extends Product with Serializable

    Permalink

    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]

  123. sealed abstract class EndomorphicInstances extends EndomorphicInstances0

    Permalink
  124. sealed abstract class EndomorphicInstances0 extends EndomorphicInstances1

    Permalink
  125. sealed abstract class EndomorphicInstances1 extends EndomorphicInstances2

    Permalink
  126. sealed abstract class EndomorphicInstances2 extends AnyRef

    Permalink
  127. trait Enum[F] extends Order[F]

    Permalink

    An scalaz.Orderable with discrete values.

  128. sealed abstract class EphemeralStream[A] extends AnyRef

    Permalink

    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.

  129. sealed abstract class EphemeralStreamInstances extends AnyRef

    Permalink
  130. trait Equal[F] extends AnyRef

    Permalink

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

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

    See also

    scalaz.Equal.EqualLaw

  131. final case class Failure[E](e: E) extends Validation[E, Nothing] with Product with Serializable

    Permalink
  132. sealed abstract class Finger[V, A] extends AnyRef

    Permalink
  133. sealed abstract class FingerTree[V, A] extends AnyRef

    Permalink

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

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

    Finger trees: a simple general-purpose data structure

  134. sealed abstract class FingerTreeInstances extends AnyRef

    Permalink
  135. type FirstMaybe[A] = AnyRef { ... /* 2 definitions in type refinement */ }

    Permalink
  136. type FirstOf[A] = AnyRef { ... /* 2 definitions in type refinement */ }

    Permalink
  137. type FirstOption[A] = AnyRef { ... /* 2 definitions in type refinement */ }

    Permalink
  138. trait FoldCase[A] extends AnyRef

    Permalink
  139. sealed abstract class FoldCaseInstances extends AnyRef

    Permalink
  140. trait Foldable[F[_]] extends AnyRef

    Permalink

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

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

    Permalink

    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.

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

    Permalink

    A universally quantified value

  143. trait Foralls extends AnyRef

    Permalink
  144. case class Four[V, A](v: V, a1: A, a2: A, a3: A, a4: A)(implicit r: Reducer[A, V]) extends Finger[V, A] with Product with Serializable

    Permalink
  145. sealed abstract class Free[S[_], A] extends AnyRef

    Permalink

    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.

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

    Permalink

    Free applicative functors.

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

  147. sealed abstract class FreeInstances extends FreeInstances0 with TrampolineInstances with SinkInstances with SourceInstances

    Permalink
  148. sealed abstract class FreeInstances0 extends FreeInstances1

    Permalink
  149. sealed abstract class FreeInstances1 extends FreeInstances2

    Permalink
  150. sealed abstract class FreeInstances2 extends FreeInstances3

    Permalink
  151. sealed abstract class FreeInstances3 extends AnyRef

    Permalink
  152. sealed abstract class FreeT[S[_], M[_], A] extends AnyRef

    Permalink
  153. sealed abstract class FreeTInstances extends FreeTInstances0

    Permalink
  154. sealed abstract class FreeTInstances0 extends FreeTInstances1

    Permalink
  155. sealed abstract class FreeTInstances1 extends FreeTInstances2

    Permalink
  156. sealed abstract class FreeTInstances2 extends FreeTInstances3

    Permalink
  157. sealed abstract class FreeTInstances3 extends FreeTInstances4

    Permalink
  158. sealed abstract class FreeTInstances4 extends FreeTInstances5

    Permalink
  159. sealed abstract class FreeTInstances5 extends FreeTInstances6

    Permalink
  160. sealed abstract class FreeTInstances6 extends AnyRef

    Permalink
  161. trait Functor[F[_]] extends InvariantFunctor[F]

    Permalink

    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

  162. trait Generator[C[_]] extends AnyRef

    Permalink

    A Generator[C] is a container of elements, and which knows how to efficiently apply a scalaz.Reducer to extract an answer by combining elements.

    A Generator[C] is a container of elements, and which 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.

  163. trait Generators extends AnyRef

    Permalink
  164. type GlorifiedTuple[+A, +B] = \/[A, B]

    Permalink
  165. sealed abstract class Heap[A] extends AnyRef

    Permalink

    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

  166. sealed abstract class HeapInstances extends AnyRef

    Permalink
  167. trait Hoist[F[_[_], _]] extends MonadTrans[F]

    Permalink
  168. final case class ICons[A](head: A, tail: IList[A]) extends IList[A] with Product with Serializable

    Permalink
  169. sealed abstract class IList[A] extends Product with Serializable

    Permalink

    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.

  170. sealed abstract class IListInstance0 extends AnyRef

    Permalink
  171. sealed abstract class IListInstances extends IListInstance0

    Permalink
  172. type IMap[A, B] = ==>>[A, B]

    Permalink
  173. final case class INil[A]() extends IList[A] with Product with Serializable

    Permalink
  174. type IRWS[-R, W, -S1, S2, A] = IndexedReaderWriterStateT[scalaz.Id.Id, R, W, S1, S2, A]

    Permalink
  175. type IRWST[F[_], -R, W, -S1, S2, A] = IndexedReaderWriterStateT[F, R, W, S1, S2, A]

    Permalink
  176. sealed abstract class ISet[A] extends AnyRef

    Permalink

  177. sealed abstract class ISetInstances extends AnyRef

    Permalink
  178. trait IdInstances extends AnyRef

    Permalink

    Mixed into object Id in the package object scalaz.

  179. final case class IdT[F[_], A](run: F[A]) extends Product with Serializable

    Permalink
  180. sealed abstract class IdTInstances extends IdTInstances0

    Permalink
  181. sealed abstract class IdTInstances0 extends IdTInstances1

    Permalink
  182. sealed abstract class IdTInstances1 extends IdTInstances2

    Permalink
  183. sealed abstract class IdTInstances2 extends IdTInstances3

    Permalink
  184. sealed abstract class IdTInstances3 extends IdTInstances4

    Permalink
  185. sealed abstract class IdTInstances4 extends AnyRef

    Permalink
  186. sealed abstract class ImmutableArray[+A] extends AnyRef

    Permalink

    An immutable wrapper for arrays

    An immutable wrapper for arrays

    A

    type of the elements of the array

  187. sealed abstract class ImmutableArrayInstances extends AnyRef

    Permalink
  188. final class IndSeq[A] extends AnyRef

    Permalink

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

  189. sealed abstract class IndSeqInstances extends AnyRef

    Permalink
  190. type IndexedCont[R, O, A] = IndexedContsT[scalaz.Id.Id, scalaz.Id.Id, R, O, A]

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

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

    Permalink
  193. final class IndexedContsT[W[_], M[_], R, O, A] extends AnyRef

    Permalink
  194. trait IndexedContsTFunctions extends AnyRef

    Permalink
  195. abstract class IndexedContsTInstances extends IndexedContsTInstances0

    Permalink
  196. sealed abstract class IndexedContsTInstances0 extends IndexedContsTInstances1

    Permalink
  197. sealed abstract class IndexedContsTInstances1 extends IndexedContsTInstances2

    Permalink
  198. sealed abstract class IndexedContsTInstances2 extends AnyRef

    Permalink
  199. type IndexedReaderWriterState[-R, W, -S1, S2, A] = IndexedReaderWriterStateT[scalaz.Id.Id, R, W, S1, S2, A]

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

    Permalink

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

  201. sealed abstract class IndexedReaderWriterStateTInstances extends IndexedReaderWriterStateTInstances0

    Permalink
  202. sealed abstract class IndexedReaderWriterStateTInstances0 extends IndexedReaderWriterStateTInstances1

    Permalink
  203. sealed abstract class IndexedReaderWriterStateTInstances1 extends AnyRef

    Permalink
  204. type IndexedState[-S1, S2, A] = IndexedStateT[scalaz.Id.Id, S1, S2, A]

    Permalink
  205. trait IndexedStateFunctions extends AnyRef

    Permalink
  206. sealed abstract class IndexedStateT[F[_], -S1, S2, A] extends AnyRef

    Permalink
  207. trait IndexedStateTFunctions extends AnyRef

    Permalink
  208. sealed abstract class IndexedStateTInstances extends IndexedStateTInstances0

    Permalink
  209. sealed abstract class IndexedStateTInstances0 extends IndexedStateTInstances1

    Permalink
  210. sealed abstract class IndexedStateTInstances1 extends IndexedStateTInstances2

    Permalink
  211. sealed abstract class IndexedStateTInstances2 extends AnyRef

    Permalink
  212. type IndexedStore[I, A, B] = IndexedStoreT[scalaz.Id.Id, I, A, B]

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

    Permalink

    See also

    scalaz.Lens

  214. trait IndexedStoreTFunctions extends AnyRef

    Permalink
  215. sealed abstract class IndexedStoreTInstances extends IndexedStoreTInstances0

    Permalink
  216. sealed abstract class IndexedStoreTInstances0 extends IndexedStoreTInstances1

    Permalink
  217. sealed abstract class IndexedStoreTInstances1 extends IndexedStoreTInstances2

    Permalink
  218. sealed abstract class IndexedStoreTInstances2 extends AnyRef

    Permalink
  219. sealed abstract class Inject[F[_], G[_]] extends ~>[F, G]

    Permalink

    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

  220. sealed abstract class InjectInstances extends AnyRef

    Permalink
  221. case class Injective[T[_]]() extends Product with Serializable

    Permalink

    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.

  222. case class Injective2[T[_, _]]() extends Product with Serializable

    Permalink
  223. case class Injective3[T[_, _, _]]() extends Product with Serializable

    Permalink
  224. case class Injective4[T[_, _, _, _]]() extends Product with Serializable

    Permalink
  225. case class Injective5[T[_, _, _, _, _]]() extends Product with Serializable

    Permalink
  226. trait InvariantFunctor[F[_]] extends AnyRef

    Permalink

    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

    scalaz.InvariantFunctor.InvariantFunctorLaw

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

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

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

    Permalink

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

  228. trait IsomorphismApplicative[F[_], G[_]] extends Applicative[F] with IsomorphismApply[F, G]

    Permalink
  229. trait IsomorphismApplicativePlus[F[_], G[_]] extends ApplicativePlus[F] with IsomorphismEmpty[F, G] with IsomorphismApplicative[F, G]

    Permalink
  230. trait IsomorphismApply[F[_], G[_]] extends Apply[F] with IsomorphismFunctor[F, G]

    Permalink
  231. trait IsomorphismBifoldable[F[_, _], G[_, _]] extends Bifoldable[F]

    Permalink
  232. trait IsomorphismBifunctor[F[_, _], G[_, _]] extends Bifunctor[F]

    Permalink
  233. trait IsomorphismBind[F[_], G[_]] extends Bind[F] with IsomorphismApply[F, G]

    Permalink
  234. trait IsomorphismBindRec[F[_], G[_]] extends BindRec[F] with IsomorphismBind[F, G]

    Permalink
  235. trait IsomorphismBitraverse[F[_, _], G[_, _]] extends Bitraverse[F] with IsomorphismBifunctor[F, G] with IsomorphismBifoldable[F, G]

    Permalink
  236. trait IsomorphismCobind[F[_], G[_]] extends Cobind[F] with IsomorphismFunctor[F, G]

    Permalink
  237. trait IsomorphismComonad[F[_], G[_]] extends Comonad[F] with IsomorphismCobind[F, G]

    Permalink
  238. trait IsomorphismContravariant[F[_], G[_]] extends Contravariant[F]

    Permalink
  239. trait IsomorphismEmpty[F[_], G[_]] extends PlusEmpty[F] with IsomorphismPlus[F, G]

    Permalink
  240. trait IsomorphismEqual[F, G] extends Equal[F]

    Permalink
  241. trait IsomorphismFoldable[F[_], G[_]] extends Foldable[F]

    Permalink
  242. trait IsomorphismFoldable1[F[_], G[_]] extends Foldable1[F] with IsomorphismFoldable[F, G]

    Permalink
  243. trait IsomorphismFunctor[F[_], G[_]] extends Functor[F]

    Permalink
  244. trait IsomorphismMonad[F[_], G[_]] extends Monad[F] with IsomorphismApplicative[F, G] with IsomorphismBind[F, G]

    Permalink
  245. trait IsomorphismMonadPlus[F[_], G[_]] extends MonadPlus[F] with IsomorphismEmpty[F, G] with IsomorphismMonad[F, G]

    Permalink
  246. trait IsomorphismMonoid[F, G] extends Monoid[F] with IsomorphismSemigroup[F, G]

    Permalink
  247. trait IsomorphismOptional[F[_], G[_]] extends Optional[F]

    Permalink
  248. trait IsomorphismOrder[F, G] extends Order[F]

    Permalink
  249. trait IsomorphismPlus[F[_], G[_]] extends Plus[F]

    Permalink
  250. trait IsomorphismSemigroup[F, G] extends Semigroup[F]

    Permalink
  251. trait IsomorphismShow[F, G] extends Show[F]

    Permalink
  252. trait IsomorphismTraverse[F[_], G[_]] extends Traverse[F] with IsomorphismFoldable[F, G] with IsomorphismFunctor[F, G]

    Permalink
  253. trait IsomorphismTraverse1[F[_], G[_]] extends Traverse1[F] with IsomorphismTraverse[F, G] with IsomorphismFoldable1[F, G]

    Permalink
  254. sealed abstract class Isomorphisms extends IsomorphismsLow0

    Permalink
  255. sealed abstract class IsomorphismsLow0 extends IsomorphismsLow1

    Permalink
  256. sealed abstract class IsomorphismsLow1 extends AnyRef

    Permalink
  257. final case class Kleisli[M[_], A, B](run: (A) ⇒ M[B]) extends Product with Serializable

    Permalink

    Represents a function A => M[B].

  258. abstract class KleisliInstances extends KleisliInstances0

    Permalink
  259. sealed abstract class KleisliInstances0 extends KleisliInstances1

    Permalink
  260. sealed abstract class KleisliInstances1 extends KleisliInstances2

    Permalink
  261. sealed abstract class KleisliInstances10 extends KleisliInstances11

    Permalink
  262. sealed abstract class KleisliInstances11 extends KleisliInstances12

    Permalink
  263. sealed abstract class KleisliInstances12 extends KleisliInstances13

    Permalink
  264. sealed abstract class KleisliInstances13 extends AnyRef

    Permalink
  265. sealed abstract class KleisliInstances2 extends KleisliInstances3

    Permalink
  266. sealed abstract class KleisliInstances3 extends KleisliInstances4

    Permalink
  267. sealed abstract class KleisliInstances4 extends KleisliInstances5

    Permalink
  268. sealed abstract class KleisliInstances5 extends KleisliInstances6

    Permalink
  269. sealed abstract class KleisliInstances6 extends KleisliInstances7

    Permalink
  270. sealed abstract class KleisliInstances7 extends KleisliInstances8

    Permalink
  271. sealed abstract class KleisliInstances8 extends KleisliInstances9

    Permalink
  272. sealed abstract class KleisliInstances9 extends KleisliInstances10

    Permalink
  273. trait Konst[A] extends AnyRef

    Permalink
  274. trait Lan[G[_], H[_], A] extends AnyRef

    Permalink

    The left Kan extension of H along G

  275. sealed abstract class LanInstances extends LanInstances0

    Permalink
  276. sealed abstract class LanInstances0 extends AnyRef

    Permalink
  277. type LastMaybe[A] = AnyRef { ... /* 2 definitions in type refinement */ }

    Permalink
  278. type LastOf[A] = AnyRef { ... /* 2 definitions in type refinement */ }

    Permalink
  279. type LastOption[A] = AnyRef { ... /* 2 definitions in type refinement */ }

    Permalink
  280. sealed abstract class LazyEither[+A, +B] extends AnyRef

    Permalink

    scala.Either, but with a value by name.

  281. sealed abstract class LazyEitherInstances extends AnyRef

    Permalink
  282. final case class LazyEitherT[F[_], A, B](run: F[LazyEither[A, B]]) extends Product with Serializable

    Permalink
  283. sealed abstract class LazyEitherTInstances extends LazyEitherTInstances0

    Permalink
  284. sealed abstract class LazyEitherTInstances0 extends LazyEitherTInstances1

    Permalink
  285. sealed abstract class LazyEitherTInstances1 extends AnyRef

    Permalink
  286. sealed abstract class LazyOption[+A] extends Product with Serializable

    Permalink

    scala.Option, but with a value by name.

  287. sealed abstract class LazyOptionInstances extends AnyRef

    Permalink
  288. final case class LazyOptionT[F[_], A](run: F[LazyOption[A]]) extends Product with Serializable

    Permalink
  289. sealed abstract class LazyOptionTInstances extends LazyOptionTInstances0

    Permalink
  290. sealed abstract class LazyOptionTInstances0 extends LazyOptionTInstances1

    Permalink
  291. sealed abstract class LazyOptionTInstances1 extends AnyRef

    Permalink
  292. sealed abstract class LazyTuple2[A, B] extends AnyRef

    Permalink

    scala.Tuple2, but with values by name.

  293. sealed abstract class LazyTuple2Instances extends LazyTuple2Instances0

    Permalink
  294. sealed abstract class LazyTuple2Instances0 extends AnyRef

    Permalink
  295. sealed abstract class LazyTuple3[A, B, C] extends AnyRef

    Permalink

    scala.Tuple3, but with values by name.

  296. sealed abstract class LazyTuple3Instances extends LazyTuple3Instances0

    Permalink
  297. sealed abstract class LazyTuple3Instances0 extends AnyRef

    Permalink
  298. sealed abstract class LazyTuple4[A, B, C, D] extends AnyRef

    Permalink

    scala.Tuple4, but with values by name.

  299. sealed abstract class LazyTuple4Instances extends LazyTuple4Instances0

    Permalink
  300. sealed abstract class LazyTuple4Instances0 extends AnyRef

    Permalink
  301. final case class Left3[+A, +B, +C](a: A) extends Either3[A, B, C] with Product with Serializable

    Permalink
  302. sealed abstract class Leibniz[-L, +H >: L, A >: L <: H, B >: L <: H] extends AnyRef

    Permalink

    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.

  303. sealed abstract class LeibnizInstances extends AnyRef

    Permalink
  304. type Lens[A, B] = LensFamily[A, A, B, B]

    Permalink

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

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

    Permalink

    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

  306. trait LensFamilyFunctions extends AnyRef

    Permalink
  307. trait LensFunctions extends LensFamilyFunctions

    Permalink
  308. abstract class LensInstances extends LensInstances0

    Permalink
  309. sealed abstract class LensInstances0 extends AnyRef

    Permalink
  310. sealed abstract class Liskov[-A, +B] extends AnyRef

    Permalink

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

  311. sealed abstract class LiskovInstances extends AnyRef

    Permalink
  312. final case class ListT[M[_], A](run: M[List[A]]) extends Product with Serializable

    Permalink

    ListT monad transformer.

  313. sealed abstract class ListTInstances extends ListTInstances1

    Permalink
  314. sealed abstract class ListTInstances1 extends ListTInstances2

    Permalink
  315. sealed abstract class ListTInstances2 extends AnyRef

    Permalink
  316. sealed abstract class MapInstances extends MapInstances0

    Permalink
  317. sealed abstract class MapInstances0 extends AnyRef

    Permalink
  318. type MaxMaybe[A] = AnyRef { ... /* 2 definitions in type refinement */ }

    Permalink
  319. type MaxOf[A] = AnyRef { ... /* 2 definitions in type refinement */ }

    Permalink
  320. type MaxOption[A] = AnyRef { ... /* 2 definitions in type refinement */ }

    Permalink
  321. sealed abstract class Maybe[A] extends AnyRef

    Permalink

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

  322. sealed abstract class MaybeInstances extends AnyRef

    Permalink
  323. final case class MaybeT[F[_], A](run: F[Maybe[A]]) extends Product with Serializable

    Permalink

    monad transformer for Maybe

  324. sealed abstract class MaybeTInstances extends MaybeTInstances0

    Permalink
  325. sealed abstract class MaybeTInstances0 extends MaybeTInstances1

    Permalink
  326. sealed abstract class MaybeTInstances1 extends MaybeTInstances2

    Permalink
  327. sealed abstract class MaybeTInstances2 extends MaybeTInstances3

    Permalink
  328. sealed abstract class MaybeTInstances3 extends AnyRef

    Permalink
  329. sealed abstract class Memo[K, V] extends AnyRef

    Permalink

    A function memoization strategy.

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

  330. sealed abstract class MemoInstances extends AnyRef

    Permalink
  331. final case class Middle3[+A, +B, +C](b: B) extends Either3[A, B, C] with Product with Serializable

    Permalink
  332. type MinMaybe[A] = AnyRef { ... /* 2 definitions in type refinement */ }

    Permalink
  333. type MinOf[A] = AnyRef { ... /* 2 definitions in type refinement */ }

    Permalink
  334. type MinOption[A] = AnyRef { ... /* 2 definitions in type refinement */ }

    Permalink
  335. trait Monad[F[_]] extends Applicative[F] with Bind[F]

    Permalink

    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

  336. trait MonadError[F[_], S] extends Monad[F]

    Permalink

  337. trait MonadListen[F[_], W] extends MonadTell[F, W]

    Permalink
  338. trait MonadPartialOrder[G[_], F[_]] extends NaturalTransformation[F, G]

    Permalink

    This trait establishes a partial order among monads.

    This trait establishes a partial order among monads. A "bigger" monad is one that does all of the effects of the "smaller" as part of its execution.

  339. sealed abstract class MonadPartialOrderFunctions extends MonadPartialOrderFunctions1

    Permalink
  340. sealed abstract class MonadPartialOrderFunctions1 extends AnyRef

    Permalink
  341. trait MonadPlus[F[_]] extends Monad[F] with ApplicativePlus[F]

    Permalink

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

    Permalink

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

    Permalink

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

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

    Permalink

    The class of monads supporting write operations

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

    Permalink

    Class of monad transformers.

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

    Permalink

    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.Monoid.MonoidLaw

    scalaz.syntax.MonoidOps

  347. sealed abstract class Name[+A] extends AnyRef

    Permalink

    Call by name

  348. trait NaturalTransformation[-F[_], +G[_]] extends AnyRef

    Permalink

    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.

  349. trait NaturalTransformations extends AnyRef

    Permalink
  350. final class Need[+A] extends Name[A]

    Permalink

    Call by need

  351. sealed abstract class Node[V, A] extends AnyRef

    Permalink
  352. type NonEmptyIList[A] = OneAnd[IList, A]

    Permalink
  353. final class NonEmptyList[A] extends AnyRef

    Permalink

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

  354. sealed abstract class NonEmptyListInstances extends NonEmptyListInstances0

    Permalink
  355. sealed abstract class NonEmptyListInstances0 extends AnyRef

    Permalink
  356. trait Nondeterminism[F[_]] extends Monad[F]

    Permalink

    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

  357. sealed trait NotNothing[A] extends AnyRef

    Permalink
  358. final class NullArgument[A, B] extends AnyRef

    Permalink
  359. sealed abstract class NullArgumentInstances extends NullArgumentInstances0

    Permalink
  360. sealed abstract class NullArgumentInstances0 extends AnyRef

    Permalink
  361. final class NullResult[A, B] extends AnyRef

    Permalink
  362. sealed abstract class NullResultInstances extends NullResultInstances0

    Permalink
  363. sealed abstract class NullResultInstances0 extends AnyRef

    Permalink
  364. case class One[V, A](v: V, a1: A)(implicit r: Reducer[A, V]) extends Finger[V, A] with Product with Serializable

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

    Permalink

    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

  366. sealed abstract class OneAndInstances extends OneAndInstances0

    Permalink
  367. sealed abstract class OneAndInstances0 extends OneAndInstances1

    Permalink
  368. sealed abstract class OneAndInstances1 extends OneAndInstances2

    Permalink
  369. sealed abstract class OneAndInstances2 extends OneAndInstances3

    Permalink
  370. sealed abstract class OneAndInstances3 extends OneAndInstances4

    Permalink
  371. sealed abstract class OneAndInstances4 extends OneAndInstances5

    Permalink
  372. sealed abstract class OneAndInstances5 extends AnyRef

    Permalink
  373. final case class OneOr[F[_], A](run: \/[F[A], A]) extends Product with Serializable

    Permalink

    Since

    7.0.3

  374. sealed abstract class OneOrInstances extends OneOrInstances0

    Permalink
  375. sealed abstract class OneOrInstances0 extends OneOrInstances1

    Permalink
  376. sealed abstract class OneOrInstances1 extends OneOrInstances2

    Permalink
  377. sealed abstract class OneOrInstances2 extends OneOrInstances3

    Permalink
  378. sealed abstract class OneOrInstances3 extends OneOrInstances4

    Permalink
  379. sealed abstract class OneOrInstances4 extends OneOrInstances5

    Permalink
  380. sealed abstract class OneOrInstances5 extends OneOrInstances6

    Permalink
  381. sealed abstract class OneOrInstances6 extends AnyRef

    Permalink
  382. final case class OptionT[F[_], A](run: F[Option[A]]) extends Product with Serializable

    Permalink

    OptionT monad transformer.

  383. sealed abstract class OptionTInstances extends OptionTInstances0

    Permalink
  384. sealed abstract class OptionTInstances0 extends OptionTInstances1

    Permalink
  385. sealed abstract class OptionTInstances1 extends OptionTInstances2

    Permalink
  386. sealed abstract class OptionTInstances2 extends OptionTInstances3

    Permalink
  387. sealed abstract class OptionTInstances3 extends AnyRef

    Permalink
  388. trait Optional[F[_]] extends AnyRef

    Permalink

    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

  389. sealed abstract class OrdSeq[A] extends Ops[FingerTree[LastOption[A], A]]

    Permalink

    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 Monoid[Option[A] @@ Last], whose append operation favours the first argument. Accordingly, the measuer of a node is the item with the highest priority contained recursively below that node.

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

    Permalink

    Safer version of scala.math.Ordering.

  391. sealed abstract class Ordering extends Product with Serializable

    Permalink

    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.

  392. sealed abstract class OrderingInstances extends AnyRef

    Permalink
  393. type PIndexedState[-S1, S2, A] = IndexedStateT[scalaz.Id.Id, S1, S2, Option[A]]

    Permalink
  394. type PIndexedStateT[F[_], -S1, S2, A] = IndexedStateT[F, S1, S2, Option[A]]

    Permalink
  395. type PLens[A, B] = PLensFamily[A, A, B, B]

    Permalink

    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.@?>

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

    Permalink

    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

  397. trait PLensFamilyFunctions extends PLensInstances

    Permalink
  398. trait PLensFunctions extends PLensInstances with PLensFamilyFunctions

    Permalink
  399. abstract class PLensInstances extends AnyRef

    Permalink
  400. type PState[S, A] = IndexedStateT[scalaz.Id.Id, S, S, Option[A]]

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

    Permalink
  402. trait Plus[F[_]] extends AnyRef

    Permalink

    Universally quantified scalaz.Semigroup.

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

    Permalink

    Universally quantified scalaz.Monoid.

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

    Permalink

    Strength on a coproduct.

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

    Permalink

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

  406. type RWS[-R, W, S, A] = IndexedReaderWriterStateT[scalaz.Id.Id, R, W, S, S, A]

    Permalink
  407. type RWST[F[_], -R, W, S, A] = IndexedReaderWriterStateT[F, R, W, S, S, A]

    Permalink
  408. trait Ran[G[_], H[_], A] extends AnyRef

    Permalink

    The right Kan extension of H along G

  409. case class Ranked[A](rank: Int, value: A) extends Product with Serializable

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

    Permalink
  411. type ReaderT[F[_], E, A] = Kleisli[F, E, A]

    Permalink
  412. type ReaderWriterState[-R, W, S, A] = IndexedReaderWriterStateT[scalaz.Id.Id, R, W, S, S, A]

    Permalink
  413. type ReaderWriterStateT[F[_], -R, W, S, A] = IndexedReaderWriterStateT[F, R, W, S, S, A]

    Permalink
  414. trait ReaderWriterStateTFunctions extends AnyRef

    Permalink
  415. abstract class ReaderWriterStateTInstances extends ReaderWriterStateTInstances0

    Permalink
  416. sealed abstract class ReaderWriterStateTInstances0 extends IndexedReaderWriterStateTInstances

    Permalink
  417. sealed abstract class Reducer[C, M] extends AnyRef

    Permalink

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

    A Reducer[C,M] is a scalaz.Monoid[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 Monoid 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 monoid.

    Minimal definition: unit or snoc

    Based on a Haskell library by Edward Kmett

  418. sealed abstract class ReducerInstances extends AnyRef

    Permalink
  419. abstract class Representable[F[_], X] extends AnyRef

    Permalink

    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.

  420. sealed abstract class RepresentableInstances extends AnyRef

    Permalink
  421. final case class Right3[+A, +B, +C](c: C) extends Either3[A, B, C] with Product with Serializable

    Permalink
  422. trait Semigroup[F] extends AnyRef

    Permalink

    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

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

    scalaz.syntax.SemigroupOps

    scalaz.Semigroup.SemigroupLaw

  423. trait Show[F] extends AnyRef

    Permalink

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

  424. sealed trait SinkInstances extends AnyRef

    Permalink
  425. sealed trait SourceInstances extends AnyRef

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

    Permalink

    A scalaz.Compose (semigroupoid) permitting products.

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

    Permalink

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

  428. trait StateFunctions extends IndexedStateFunctions

    Permalink
  429. type StateT[F[_], S, A] = IndexedStateT[F, S, S, A]

    Permalink
  430. trait StateTFunctions extends IndexedStateTFunctions

    Permalink
  431. abstract class StateTInstances extends StateTInstances0

    Permalink
  432. sealed abstract class StateTInstances0 extends StateTInstances1

    Permalink
  433. sealed abstract class StateTInstances1 extends StateTInstances2

    Permalink
  434. sealed abstract class StateTInstances2 extends StateTInstances3

    Permalink
  435. sealed abstract class StateTInstances3 extends IndexedStateTInstances

    Permalink
  436. type Store[A, B] = IndexedStoreT[scalaz.Id.Id, A, A, B]

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

    Permalink
  438. trait StoreTFunctions extends IndexedStoreTFunctions

    Permalink
  439. abstract class StoreTInstances extends StoreTInstances0

    Permalink
  440. sealed abstract class StoreTInstances0 extends StoreTInstances1

    Permalink
  441. sealed abstract class StoreTInstances1 extends StoreTInstances2

    Permalink
  442. sealed abstract class StoreTInstances2 extends IndexedStoreTInstances

    Permalink
  443. sealed class StreamT[M[_], A] extends AnyRef

    Permalink

    StreamT monad transformer.

  444. sealed abstract class StreamTInstances extends StreamTInstances0

    Permalink
  445. sealed abstract class StreamTInstances0 extends AnyRef

    Permalink
  446. case class StrictTree[A](rootLabel: A, subForest: Vector[StrictTree[A]]) extends Product with Serializable

    Permalink

    rootLabel

    The label at the root of this tree.

    subForest

    The child nodes of this tree.

  447. sealed abstract class StrictTreeInstances extends AnyRef

    Permalink
  448. final class StrictTreeUnzip[A1, A2] extends AnyVal

    Permalink
  449. trait Strong[=>:[_, _]] extends Profunctor[=>:]

    Permalink

    Strength on a product.

  450. final case class Success[A](a: A) extends Validation[Nothing, A] with Product with Serializable

    Permalink
  451. sealed abstract class TheseInstances extends TheseInstances0

    Permalink
  452. sealed abstract class TheseInstances0 extends TheseInstances1

    Permalink
  453. sealed abstract class TheseInstances1 extends AnyRef

    Permalink
  454. final case class TheseT[F[_], A, B](run: F[\&/[A, B]]) extends Product with Serializable

    Permalink
  455. sealed abstract class TheseTInstances extends TheseTInstances0

    Permalink
  456. sealed abstract class TheseTInstances0 extends TheseTInstances1

    Permalink
  457. sealed abstract class TheseTInstances1 extends AnyRef

    Permalink
  458. case class Three[V, A](v: V, a1: A, a2: A, a3: A)(implicit r: Reducer[A, V]) extends Finger[V, A] with Product with Serializable

    Permalink
  459. type Traced[A, B] = TracedT[scalaz.Id.Id, A, B]

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

    Permalink

  461. sealed abstract class TracedTInstances extends TracedTInstances0

    Permalink
  462. sealed abstract class TracedTInstances0 extends TracedTInstances1

    Permalink
  463. sealed abstract class TracedTInstances1 extends TracedTInstances2

    Permalink
  464. sealed abstract class TracedTInstances2 extends TracedTInstances3

    Permalink
  465. sealed abstract class TracedTInstances3 extends TracedTInstances4

    Permalink
  466. sealed abstract class TracedTInstances4 extends TracedTInstances5

    Permalink
  467. sealed abstract class TracedTInstances5 extends AnyRef

    Permalink
  468. sealed trait TrampolineInstances extends AnyRef

    Permalink
  469. trait Traverse[F[_]] extends Functor[F] with Foldable[F]

    Permalink

    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

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

    Permalink

    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.

  471. sealed abstract class Tree[A] extends AnyRef

    Permalink

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

  472. sealed abstract class TreeInstances extends AnyRef

    Permalink
  473. final case class TreeLoc[A](tree: Tree[A], lefts: TreeForest[A], rights: TreeForest[A], parents: Parents[A]) extends Product with Serializable

    Permalink

    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.

  474. sealed abstract class TreeLocInstances extends AnyRef

    Permalink
  475. case class Two[V, A](v: V, a1: A, a2: A)(implicit r: Reducer[A, V]) extends Finger[V, A] with Product with Serializable

    Permalink
  476. trait Unapply[TC[_[_]], MA] extends AnyRef

    Permalink

    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( ... )
  477. trait Unapply2[TC[_[_, _]], MAB] extends AnyRef

    Permalink
  478. trait Unapply21[TC[_[_, _], _], MAB] extends AnyRef

    Permalink
  479. sealed abstract class Unapply2_0 extends AnyRef

    Permalink
  480. trait UnapplyProduct[TC[_[_]], MA, MB] extends AnyRef

    Permalink
  481. sealed abstract class Unapply_0 extends Unapply_1

    Permalink
  482. sealed abstract class Unapply_1 extends Unapply_2

    Permalink
  483. sealed abstract class Unapply_2 extends Unapply_3

    Permalink
  484. sealed abstract class Unapply_3 extends Unapply_4

    Permalink
  485. sealed abstract class Unapply_4 extends Unapply_5

    Permalink
  486. sealed abstract class Unapply_5 extends AnyRef

    Permalink
  487. sealed abstract class UnitReducer[C, M] extends Reducer[C, M]

    Permalink
  488. type Unwriter[W, A] = UnwriterT[scalaz.Id.Id, W, A]

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

    Permalink

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

  490. trait UnwriterTFunctions extends AnyRef

    Permalink
  491. sealed abstract class UnwriterTInstances extends UnwriterTInstances0

    Permalink
  492. sealed abstract class UnwriterTInstances0 extends UnwriterTInstances1

    Permalink
  493. sealed abstract class UnwriterTInstances1 extends UnwriterTInstances2

    Permalink
  494. sealed abstract class UnwriterTInstances2 extends AnyRef

    Permalink
  495. trait Unzip[F[_]] extends AnyRef

    Permalink

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

    Permalink

    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

  497. final class ValidationFlatMap[E, A] extends AnyVal

    Permalink
  498. sealed abstract class ValidationInstances extends ValidationInstances0

    Permalink
  499. sealed abstract class ValidationInstances0 extends ValidationInstances1

    Permalink
  500. sealed abstract class ValidationInstances1 extends ValidationInstances2

    Permalink
  501. sealed abstract class ValidationInstances2 extends ValidationInstances3

    Permalink
  502. sealed abstract class ValidationInstances3 extends AnyRef

    Permalink
  503. type ValidationNel[E, +X] = Validation[NonEmptyList[E], X]

    Permalink

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

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

    Useful for accumulating errors through the corresponding scalaz.Applicative instance.

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

    Permalink

    Call by value

  505. sealed abstract class ViewL[S[_], A] extends AnyRef

    Permalink

    View of the left end of a sequence.

  506. sealed abstract class ViewR[S[_], A] extends AnyRef

    Permalink

    View of the right end of a sequence.

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

    Permalink
  508. final case class WriterT[F[_], W, A](run: F[(W, A)]) extends Product with Serializable

    Permalink
  509. trait WriterTFunctions extends AnyRef

    Permalink
  510. sealed abstract class WriterTInstance5 extends WriterTInstances6

    Permalink
  511. sealed abstract class WriterTInstances extends WriterTInstances0

    Permalink
  512. sealed abstract class WriterTInstances0 extends WriterTInstances1

    Permalink
  513. sealed abstract class WriterTInstances1 extends WriterTInstances2

    Permalink
  514. sealed abstract class WriterTInstances10 extends WriterTInstances11

    Permalink
  515. sealed abstract class WriterTInstances11 extends WriterTInstances12

    Permalink
  516. sealed abstract class WriterTInstances12 extends WriterTInstances13

    Permalink
  517. sealed abstract class WriterTInstances13 extends WriterTInstances14

    Permalink
  518. sealed abstract class WriterTInstances14 extends WriterTInstances15

    Permalink
  519. sealed abstract class WriterTInstances15 extends AnyRef

    Permalink
  520. sealed abstract class WriterTInstances2 extends WriterTInstances3

    Permalink
  521. sealed abstract class WriterTInstances3 extends WriterTInstances4

    Permalink
  522. sealed abstract class WriterTInstances4 extends WriterTInstance5

    Permalink
  523. sealed abstract class WriterTInstances6 extends WriterTInstances7

    Permalink
  524. sealed abstract class WriterTInstances7 extends WriterTInstances8

    Permalink
  525. sealed abstract class WriterTInstances8 extends WriterTInstances9

    Permalink
  526. sealed abstract class WriterTInstances9 extends WriterTInstances10

    Permalink
  527. abstract class Yoneda[F[_], A] extends AnyRef

    Permalink

    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.

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

    Permalink

    Functors that annihilate each other.

  529. sealed abstract class ZapInstances extends AnyRef

    Permalink
  530. trait Zip[F[_]] extends AnyRef

    Permalink

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

    Permalink

    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.

  532. sealed abstract class ZipperInstances extends AnyRef

    Permalink
  533. sealed abstract class \&/[+A, +B] extends Product with Serializable

    Permalink

    Since

    7.0.3

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

    Permalink

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

  535. final case class \/-[+B](b: B) extends \/[Nothing, B] with Product with Serializable

    Permalink

    A right disjunction

    A right disjunction

    Often used to represent the success case of a result

  536. type |-->[A, B] = IndexedStoreT[scalaz.Id.Id, B, B, A]

    Permalink
  537. type |>=|[G[_], F[_]] = MonadPartialOrder[G, F]

    Permalink
  538. type ~>[-F[_], +G[_]] = NaturalTransformation[F, G]

    Permalink

    A scalaz.NaturalTransformation[F, G].

  539. type ~~>[-F[_, _], +G[_, _]] = BiNaturalTransformation[F, G]

    Permalink
  540. type [A, B] = \/[A, B]

    Permalink
  541. type = Any

    Permalink
  542. type = Nothing

    Permalink

Value Members

  1. object :+:

    Permalink
  2. object ==>> extends MapInstances

    Permalink
  3. object Adjunction extends AdjunctionInstances

    Permalink
  4. object Align

    Permalink
  5. object Alpha extends AlphaInstances with Serializable

    Permalink
  6. object Applicative

    Permalink
  7. object ApplicativePlus

    Permalink
  8. object Apply

    Permalink
  9. object Arrow

    Permalink
  10. object Associative

    Permalink
  11. object Bifoldable

    Permalink
  12. object Bifunctor

    Permalink
  13. object BijectionT extends BijectionTInstances

    Permalink
  14. object Bind

    Permalink
  15. object BindRec

    Permalink
  16. object Bitraverse

    Permalink
  17. object CaseInsensitive extends CaseInsensitiveInstances

    Permalink
  18. object Catchable

    Permalink
  19. object Category

    Permalink
  20. object Choice

    Permalink
  21. object Cobind

    Permalink
  22. object Codensity extends CodensityInstances

    Permalink
  23. object Cofree extends CofreeInstances

    Permalink
  24. object Cohoist

    Permalink
  25. object Cokleisli extends CokleisliInstances with Serializable

    Permalink
  26. object Comonad

    Permalink
  27. object ComonadStore

    Permalink
  28. object ComonadTrans

    Permalink
  29. object Compose

    Permalink
  30. object Const extends ConstInstances with Serializable

    Permalink
  31. object Cont extends IndexedContsTInstances with IndexedContsTFunctions

    Permalink
  32. object ContT extends IndexedContsTInstances with IndexedContsTFunctions

    Permalink
  33. object Contravariant

    Permalink
  34. object ContravariantCoyoneda extends ContravariantCoyonedaInstances

    Permalink
  35. object Conts extends IndexedContsTInstances with IndexedContsTFunctions

    Permalink
  36. object ContsT extends IndexedContsTInstances with IndexedContsTFunctions

    Permalink
  37. object Coproduct extends CoproductInstances with Serializable

    Permalink
  38. object Cord extends Serializable

    Permalink
  39. object Coyoneda extends CoyonedaInstances

    Permalink
  40. object Cozip

    Permalink
  41. val DLeft: -\/.type

    Permalink
  42. object DList extends DListInstances

    Permalink
  43. val DRight: \/-.type

    Permalink
  44. object Dequeue extends DequeueInstances

    Permalink
  45. object Diev extends DievInstances

    Permalink
  46. object DievInterval

    Permalink
  47. object Digit extends DigitInstances with Serializable

    Permalink
  48. val Disjunction: \/.type

    Permalink
  49. val DisjunctionT: EitherT.type

    Permalink
  50. object Distributive

    Permalink
  51. object Divide

    Permalink
  52. object Divisible

    Permalink
  53. object Dual extends DualInstances

    Permalink
  54. object Either3 extends Serializable

    Permalink
  55. object EitherT extends EitherTInstances with Serializable

    Permalink
  56. object Endo extends EndoInstances with Serializable

    Permalink
  57. object Endomorphic extends EndomorphicInstances with Serializable

    Permalink
  58. object Enum

    Permalink
  59. object EphemeralStream extends EphemeralStreamInstances

    Permalink
  60. object Equal

    Permalink
  61. object FingerTree extends FingerTreeInstances

    Permalink
  62. object FoldCase extends FoldCaseInstances

    Permalink
  63. object Foldable

    Permalink
  64. object Foldable1

    Permalink
  65. object Forall extends Foralls

    Permalink
  66. object Free extends FreeInstances

    Permalink
  67. object FreeAp

    Permalink
  68. object FreeT extends FreeTInstances

    Permalink
  69. object Functor

    Permalink
  70. object Generator extends Generators

    Permalink
  71. object Heap extends HeapInstances

    Permalink
  72. object Hoist

    Permalink
  73. object IList extends IListInstances with Serializable

    Permalink
  74. val IMap: ==>>.type

    Permalink
  75. val IRWS: IndexedReaderWriterState.type

    Permalink
  76. val IRWST: IndexedReaderWriterStateT.type

    Permalink
  77. object ISet extends ISetInstances

    Permalink
  78. object Id extends IdInstances

    Permalink
  79. object IdT extends IdTInstances with Serializable

    Permalink
  80. object ImmutableArray extends ImmutableArrayInstances

    Permalink
  81. object IndSeq extends IndSeqInstances

    Permalink
  82. object IndexedCont extends IndexedContsTInstances with IndexedContsTFunctions

    Permalink
  83. object IndexedContT extends IndexedContsTInstances with IndexedContsTFunctions

    Permalink
  84. object IndexedConts extends IndexedContsTInstances with IndexedContsTFunctions

    Permalink
  85. object IndexedContsT extends IndexedContsTInstances with IndexedContsTFunctions

    Permalink
  86. object IndexedReaderWriterState extends ReaderWriterStateTInstances with ReaderWriterStateTFunctions

    Permalink
  87. object IndexedReaderWriterStateT extends ReaderWriterStateTInstances with ReaderWriterStateTFunctions

    Permalink
  88. object IndexedState extends StateFunctions

    Permalink
  89. object IndexedStateT extends StateTInstances with StateTFunctions

    Permalink
  90. object IndexedStore extends Serializable

    Permalink
  91. object IndexedStoreT extends StoreTInstances with StoreTFunctions with Serializable

    Permalink
  92. object Inject extends InjectInstances

    Permalink
  93. object Injectivity

    Permalink
  94. object InvariantFunctor

    Permalink
  95. object IsEmpty

    Permalink
  96. object Isomorphism extends Isomorphisms

    Permalink
  97. object Kleisli extends KleisliInstances with Serializable

    Permalink
  98. object Lan extends LanInstances

    Permalink
  99. object LazyEither extends LazyEitherInstances

    Permalink
  100. object LazyEitherT extends LazyEitherTInstances with Serializable

    Permalink
  101. object LazyOption extends LazyOptionInstances with Serializable

    Permalink
  102. object LazyOptionT extends LazyOptionTInstances with Serializable

    Permalink
  103. object LazyTuple

    Permalink
  104. object LazyTuple2 extends LazyTuple2Instances

    Permalink
  105. object LazyTuple3 extends LazyTuple3Instances

    Permalink
  106. object LazyTuple4 extends LazyTuple4Instances

    Permalink
  107. object Leibniz extends LeibnizInstances

    Permalink
  108. object Lens extends LensInstances with LensFunctions

    Permalink

    See also

    scalaz.Lens

  109. object LensFamily extends LensInstances with LensFunctions

    Permalink
  110. object Liskov extends LiskovInstances

    Permalink
  111. object ListT extends ListTInstances with Serializable

    Permalink
  112. object Maybe extends MaybeInstances

    Permalink
  113. object MaybeT extends MaybeTInstances with Serializable

    Permalink
  114. object Memo extends MemoInstances

    Permalink

  115. object Monad

    Permalink
  116. object MonadError

    Permalink
  117. object MonadListen

    Permalink
  118. object MonadPartialOrder extends MonadPartialOrderFunctions

    Permalink
  119. object MonadPlus

    Permalink
  120. object MonadReader

    Permalink
  121. object MonadState

    Permalink
  122. object MonadTell

    Permalink
  123. object MonadTrans

    Permalink
  124. object Monoid

    Permalink
  125. object Name

    Permalink
  126. object NaturalTransformation extends NaturalTransformations

    Permalink
  127. object Need

    Permalink
  128. object NonEmptyList extends NonEmptyListInstances

    Permalink
  129. object Nondeterminism

    Permalink
  130. object NotNothing

    Permalink
  131. object NullArgument extends NullArgumentInstances

    Permalink
  132. object NullResult extends NullResultInstances

    Permalink
  133. object OneAnd extends OneAndInstances with Serializable

    Permalink
  134. object OneOr extends OneOrInstances with Serializable

    Permalink
  135. object OptionT extends OptionTInstances with Serializable

    Permalink
  136. object Optional

    Permalink
  137. object OrdSeq

    Permalink
  138. object Order

    Permalink
  139. object Ordering extends OrderingInstances with Serializable

    Permalink
  140. object PLens extends PLensInstances with PLensFunctions

    Permalink

    See also

    scalaz.PLens

  141. object PLensFamily extends PLensInstances with PLensFunctions

    Permalink
  142. object Plus

    Permalink
  143. object PlusEmpty

    Permalink
  144. object ProChoice

    Permalink
  145. object Profunctor

    Permalink
  146. val RWS: ReaderWriterState.type

    Permalink
  147. val RWST: ReaderWriterStateT.type

    Permalink
  148. object Ran

    Permalink
  149. object Reader extends Serializable

    Permalink
  150. val ReaderT: Kleisli.type

    Permalink
  151. object ReaderWriterState extends ReaderWriterStateTInstances with ReaderWriterStateTFunctions

    Permalink
  152. object ReaderWriterStateT extends ReaderWriterStateTInstances with ReaderWriterStateTFunctions

    Permalink
  153. object Reducer extends ReducerInstances

    Permalink
  154. object Representable extends RepresentableInstances

    Permalink
  155. object Scalaz extends StateFunctions with ToTypeClassOps with ToDataOps with AllInstances with AllFunctions with ToAllStdOps with IdInstances

    Permalink
  156. object ScalazBuildInfo extends Product with Serializable

    Permalink

    This object was generated by sbt-buildinfo.

  157. object Semigroup

    Permalink
  158. object Show

    Permalink
  159. object Sink extends SinkInstances

    Permalink
  160. object Source extends SourceInstances

    Permalink
  161. object Split

    Permalink
  162. object State extends StateFunctions

    Permalink
  163. object StateT extends StateTInstances with StateTFunctions

    Permalink
  164. object Store extends Serializable

    Permalink
  165. object StoreT extends StoreTInstances with StoreTFunctions with Serializable

    Permalink
  166. object StreamT extends StreamTInstances

    Permalink
  167. object StrictTree extends StrictTreeInstances with Serializable

    Permalink
  168. object Strong

    Permalink
  169. object Tag

    Permalink
  170. object Tags

    Permalink

    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 .

  171. object TheseT extends TheseTInstances with Serializable

    Permalink
  172. def Traced[A, B](f: (A) ⇒ B): Traced[A, B]

    Permalink
  173. object TracedT extends TracedTInstances with Serializable

    Permalink
  174. object Trampoline extends TrampolineInstances

    Permalink
  175. object Traverse

    Permalink
  176. object Traverse1

    Permalink
  177. object Tree extends TreeInstances

    Permalink
  178. object TreeLoc extends TreeLocInstances with Serializable

    Permalink
  179. object Unapply extends Unapply_0

    Permalink
  180. object Unapply2 extends Unapply2_0

    Permalink
  181. object Unapply21

    Permalink
  182. object UnapplyProduct

    Permalink
  183. object UnitReducer

    Permalink
  184. object Unwriter extends Serializable

    Permalink
  185. object UnwriterT extends UnwriterTInstances with UnwriterTFunctions with Serializable

    Permalink
  186. object Unzip

    Permalink
  187. object Validation extends ValidationInstances with Serializable

    Permalink
  188. object Value extends Serializable

    Permalink
  189. object Writer extends Serializable

    Permalink
  190. object WriterT extends WriterTInstances with WriterTFunctions with Serializable

    Permalink
  191. object Yoneda

    Permalink
  192. object Zap extends ZapInstances

    Permalink
  193. object Zip

    Permalink
  194. object Zipper extends ZipperInstances with Serializable

    Permalink
  195. object \&/ extends TheseInstances with Serializable

    Permalink
  196. object \/ extends DisjunctionInstances with Serializable

    Permalink
  197. 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]

    Permalink
  198. package std

    Permalink

    Type Class instances for data structures in the Scala and Java standard libraries.

  199. package syntax

    Permalink

    Implicits to provide a convenient syntax to work with type classes and functions.

    Implicits to provide a convenient syntax to work with type classes and functions.

    Non-trivial code should *not* be defined in this package; instead delegate.

Inherited from AnyRef

Inherited from Any

Ungrouped