Type Members

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

   A left disjunction

   A left disjunction

   Often used to represent the failure case of a result

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

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

   scalaz.Inject[F, G]

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

   scalaz.Inject[F, G]

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

   A scalaz.NaturalTransformation[G, F].

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

7.  type =?>[E, A] = Kleisli[Option, E, A]
8.  type @>[A, B] = LensFamily[A, A, B, B]
   See also

   scalaz.Lens

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

   scalaz.PLens

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

    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

    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
13.  trait Align [F[_]] extends Functor[F]

14.  sealed abstract class Alpha extends Product with Serializable

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

15.  sealed abstract class AlphaInstances extends AnyRef
16.  type Alternative[F[_]] = ApplicativePlus[F]
17.  trait Applicative [F[_]] extends Apply[F] with ApplicativeParent[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

18.  trait ApplicativeParent [F[_]] extends AnyRef
19.  trait ApplicativePlus [F[_]] extends Applicative[F] with PlusEmpty[F]

    scalaz.Applicative combined with scalaz.PlusEmpty.

20.  trait Apply [F[_]] extends Functor[F] with ApplyParent[F]

    scalaz.Applicative without point.

    scalaz.Applicative without point.

    See also

    scalaz.Apply.ApplyLaw

21.  trait ApplyParent [F[_]] extends AnyRef
22.  trait Arrow [=>:[_, _]] extends Split[=>:] with Strong[=>:] with Category[=>:] with ArrowParent[=>:]

    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.

23.  trait ArrowParent [=>:[_, _]] extends AnyRef
24.  trait Associative [=>:[_, _]] extends AnyRef

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

    A constrained transformation natural in both sides of a bifunctor

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

    A function universally quantified over two parameters.

27.  trait Bifoldable [F[_, _]] extends AnyRef

    A type giving rise to two unrelated scalaz.Foldables.

28.  trait Bifunctor [F[_, _]] extends BifunctorParent[F]

    A type giving rise to two unrelated scalaz.Functors.

29.  trait BifunctorParent [F[_, _]] extends AnyRef
30.  final class BijectionT [F[_], G[_], A, B] extends AnyRef
31.  sealed abstract class BijectionTInstances extends BijectionTInstances0
32.  sealed abstract class BijectionTInstances0 extends AnyRef
33.  trait Bind [F[_]] extends Apply[F] with BindParent[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

34.  trait BindParent [F[_]] extends AnyRef
35.  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.

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

    A type giving rise to two unrelated scalaz.Traverses.

37.  sealed abstract class CaseInsensitive [A] extends AnyRef
38.  sealed abstract class CaseInsensitiveInstances extends AnyRef
39.  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.

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

    scalaz.Compose with identity.

    scalaz.Compose with identity.

    See also

    scalaz.Category.CategoryLaw

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

42.  trait Cobind [F[_]] extends Functor[F]

43.  abstract class Codensity [F[_], A] extends AnyRef
44.  sealed abstract class CodensityInstances extends AnyRef
45.  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.

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

57.  trait ComonadStore [F[_], S] extends Comonad[F]

58.  trait ComonadTrans [F[_[_], _]] extends AnyRef
59.  trait Compose [=>:[_, _]] extends AnyRef

60.  final case class Const [A, B](getConst: A) extends Product with Serializable
61.  sealed abstract class ConstInstances extends ConstInstances0
62.  sealed abstract class ConstInstances0 extends ConstInstances1
63.  sealed abstract class ConstInstances1 extends AnyRef
64.  trait ConstrainedNaturalTransformation [F[_], G[_], E[_]] extends AnyRef

    A constrained natural transformation

65.  type Cont[R, A] = IndexedContsT[scalaz.Id.Id, scalaz.Id.Id, R, R, A]
66.  type ContT[M[_], R, A] = IndexedContsT[scalaz.Id.Id, M, R, R, A]
67.  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

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

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

69.  sealed abstract class ContravariantCoyonedaInstances extends AnyRef
70.  type Conts[W[_], R, A] = IndexedContsT[W, scalaz.Id.Id, R, R, A]
71.  type ContsT[W[_], M[_], R, A] = IndexedContsT[W, M, R, R, A]
72.  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.\/.

73.  sealed abstract class CoproductInstances extends CoproductInstances0
74.  sealed abstract class CoproductInstances0 extends CoproductInstances1
75.  sealed abstract class CoproductInstances1 extends CoproductInstances2
76.  sealed abstract class CoproductInstances2 extends CoproductInstances3
77.  sealed abstract class CoproductInstances3 extends AnyRef
78.  final case class Cord (self: FingerTree[Int, String]) extends Product with Serializable

    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.

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

80.  sealed abstract class CorecursiveListInstances extends AnyRef
81.  abstract class Corepresentable [F[_], X] extends AnyRef

    Corepresentable functors

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

83.  sealed abstract class CoyonedaInstances extends CoyonedaInstances0
84.  sealed abstract class CoyonedaInstances0 extends CoyonedaInstances1
85.  sealed abstract class CoyonedaInstances1 extends CoyonedaInstances2
86.  sealed abstract class CoyonedaInstances10 extends AnyRef
87.  sealed abstract class CoyonedaInstances2 extends CoyonedaInstances3
88.  sealed abstract class CoyonedaInstances3 extends CoyonedaInstances4
89.  sealed abstract class CoyonedaInstances4 extends CoyonedaInstances5
90.  sealed abstract class CoyonedaInstances5 extends CoyonedaInstances6
91.  sealed abstract class CoyonedaInstances6 extends CoyonedaInstances7
92.  sealed abstract class CoyonedaInstances7 extends CoyonedaInstances8
93.  sealed abstract class CoyonedaInstances8 extends CoyonedaInstances9
94.  sealed abstract class CoyonedaInstances9 extends CoyonedaInstances10
95.  trait Cozip [F[_]] extends AnyRef

96.  type DLeft[+A] = -\/[A]
97.  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.

98.  sealed abstract class DListInstances extends AnyRef
99.  type DRight[+B] = \/-[B]
100.  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

101.  sealed abstract class DequeueInstances extends AnyRef
102.  trait DiNaturalTransformation [F[_, _], G[_, _]] extends AnyRef
103.  sealed abstract class Diev [A] extends AnyRef

     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.

104.  trait DievImplementation extends AnyRef
105.  sealed abstract class DievInstances extends DievImplementation
106.  sealed abstract class Digit extends Product with Serializable

     An algebraic data type representing the digits 0 - 9

107.  sealed abstract class DigitInstances extends AnyRef
108.  type Disjunction[+A, +B] = \/[A, B]
109.  sealed abstract class DisjunctionInstances extends DisjunctionInstances0
110.  sealed abstract class DisjunctionInstances0 extends DisjunctionInstances1
111.  sealed abstract class DisjunctionInstances1 extends DisjunctionInstances2
112.  sealed abstract class DisjunctionInstances2 extends AnyRef
113.  type DisjunctionT[F[_], A, B] = EitherT[F, A, B]
114.  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.

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

116.  trait Divisible [F[_]] extends Divide[F]

     Divisible is the contravariant analogue of scalaz.Applicative

     Divisible is the contravariant analogue of scalaz.Applicative

     See also

     ZuriHac 2015 - Discrimination is Wrong: Improving Productivity

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

117.  sealed abstract class DualInstances extends DualInstances0
118.  sealed abstract class DualInstances0 extends AnyRef
119.  sealed abstract class Either3 [+A, +B, +C] extends Product with Serializable
120.  final case class EitherT [F[_], A, 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))

121.  sealed abstract class EitherTInstances extends EitherTInstances0
122.  sealed abstract class EitherTInstances0 extends EitherTInstances1
123.  sealed abstract class EitherTInstances1 extends EitherTInstances2
124.  sealed abstract class EitherTInstances2 extends EitherTInstances3
125.  sealed abstract class EitherTInstances3 extends EitherTInstances4
126.  sealed abstract class EitherTInstances4 extends AnyRef
127.  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.

128.  sealed abstract class EndoInstances extends AnyRef
129.  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]

130.  sealed abstract class EndomorphicInstances extends EndomorphicInstances0
131.  sealed abstract class EndomorphicInstances0 extends EndomorphicInstances1
132.  sealed abstract class EndomorphicInstances1 extends EndomorphicInstances2
133.  sealed abstract class EndomorphicInstances2 extends AnyRef
134.  trait Enum [F] extends Order[F]

     An scalaz.Orderable with discrete values.

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

136.  sealed abstract class EphemeralStreamInstances extends AnyRef
137.  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

138.  final case class Failure [E](e: E) extends Validation[E, Nothing] with Product with Serializable
139.  sealed abstract class Finger [V, A] extends AnyRef
140.  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

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

     Finger trees: a simple general-purpose data structure

141.  sealed abstract class FingerTreeInstances extends AnyRef
142.  type FirstMaybe[A] = AnyRef { ... /* 2 definitions in type refinement */ }
143.  type FirstOf[A] = AnyRef { ... /* 2 definitions in type refinement */ }
144.  type FirstOption[A] = AnyRef { ... /* 2 definitions in type refinement */ }
145.  trait FoldCase [A] extends AnyRef
146.  sealed abstract class FoldCaseInstances extends AnyRef
147.  trait Foldable [F[_]] extends FoldableParent[F]

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

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

149.  trait FoldableParent [F[_]] extends AnyRef
150.  trait Forall [P[_]] extends AnyRef

     A universally quantified value

151.  trait Foralls extends AnyRef
152.  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
153.  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.

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

155.  sealed abstract class FreeInstances extends FreeInstances0 with TrampolineInstances with SinkInstances with SourceInstances
156.  sealed abstract class FreeInstances0 extends FreeInstances1
157.  sealed abstract class FreeInstances1 extends FreeInstances2
158.  sealed abstract class FreeInstances2 extends FreeInstances3
159.  sealed abstract class FreeInstances3 extends AnyRef
160.  sealed abstract class FreeT [S[_], M[_], A] extends AnyRef
161.  sealed abstract class FreeTInstances extends FreeTInstances0
162.  sealed abstract class FreeTInstances0 extends FreeTInstances1
163.  sealed abstract class FreeTInstances1 extends FreeTInstances2
164.  sealed abstract class FreeTInstances2 extends FreeTInstances3
165.  sealed abstract class FreeTInstances3 extends FreeTInstances4
166.  sealed abstract class FreeTInstances4 extends FreeTInstances5
167.  sealed abstract class FreeTInstances5 extends FreeTInstances6
168.  sealed abstract class FreeTInstances6 extends AnyRef
169.  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

170.  trait Generator [C[_]] extends AnyRef

     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.

171.  trait Generators extends AnyRef
172.  type GlorifiedTuple[+A, +B] = \/[A, B]
173.  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

174.  sealed abstract class HeapInstances extends AnyRef
175.  trait Hoist [F[_[_], _]] extends MonadTrans[F]
176.  final case class ICons [A](head: A, tail: IList[A]) extends IList[A] with Product with Serializable
177.  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.

178.  sealed abstract class IListInstance0 extends AnyRef
179.  sealed abstract class IListInstances extends IListInstance0
180.  type IMap[A, B] = ==>>[A, B]
181.  final case class INil [A]() extends IList[A] with Product with Serializable
182.  type IRWS[-R, W, -S1, S2, A] = IndexedReaderWriterStateT[scalaz.Id.Id, R, W, S1, S2, A]
183.  type IRWST[F[_], -R, W, -S1, S2, A] = IndexedReaderWriterStateT[F, R, W, S1, S2, A]
184.  sealed abstract class ISet [A] extends AnyRef
     See also

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

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

185.  sealed abstract class ISetInstances extends AnyRef
186.  trait IdInstances extends AnyRef

     Mixed into object Id in the package object scalaz.

187.  final case class IdT [F[_], A](run: F[A]) extends Product with Serializable
188.  sealed abstract class IdTInstances extends IdTInstances0
189.  sealed abstract class IdTInstances0 extends IdTInstances1
190.  sealed abstract class IdTInstances1 extends IdTInstances2
191.  sealed abstract class IdTInstances2 extends IdTInstances3
192.  sealed abstract class IdTInstances3 extends IdTInstances4
193.  sealed abstract class IdTInstances4 extends AnyRef
194.  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

195.  sealed abstract class ImmutableArrayInstances extends AnyRef
196.  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).

197.  sealed abstract class IndSeqInstances extends AnyRef
198.  type IndexedCont[R, O, A] = IndexedContsT[scalaz.Id.Id, scalaz.Id.Id, R, O, A]
199.  type IndexedContT[M[_], R, O, A] = IndexedContsT[scalaz.Id.Id, M, R, O, A]
200.  type IndexedConts[W[_], R, O, A] = IndexedContsT[W, scalaz.Id.Id, R, O, A]
201.  final class IndexedContsT [W[_], M[_], R, O, A] extends AnyRef
202.  trait IndexedContsTFunctions extends AnyRef
203.  abstract class IndexedContsTInstances extends IndexedContsTInstances0
204.  sealed abstract class IndexedContsTInstances0 extends IndexedContsTInstances1
205.  sealed abstract class IndexedContsTInstances1 extends IndexedContsTInstances2
206.  sealed abstract class IndexedContsTInstances2 extends AnyRef
207.  type IndexedReaderWriterState[-R, W, -S1, S2, A] = IndexedReaderWriterStateT[scalaz.Id.Id, R, W, S1, S2, A]
208.  sealed abstract class IndexedReaderWriterStateT [F[_], -R, W, -S1, S2, A] extends AnyRef

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

209.  sealed abstract class IndexedReaderWriterStateTInstances extends IndexedReaderWriterStateTInstances0
210.  sealed abstract class IndexedReaderWriterStateTInstances0 extends IndexedReaderWriterStateTInstances1
211.  sealed abstract class IndexedReaderWriterStateTInstances1 extends AnyRef
212.  type IndexedState[-S1, S2, A] = IndexedStateT[scalaz.Id.Id, S1, S2, A]
213.  trait IndexedStateFunctions extends AnyRef
214.  sealed abstract class IndexedStateT [F[_], -S1, S2, A] extends AnyRef
215.  trait IndexedStateTFunctions extends AnyRef
216.  sealed abstract class IndexedStateTInstances extends IndexedStateTInstances0
217.  sealed abstract class IndexedStateTInstances0 extends IndexedStateTInstances1
218.  sealed abstract class IndexedStateTInstances1 extends IndexedStateTInstances2
219.  sealed abstract class IndexedStateTInstances2 extends AnyRef
220.  type IndexedStore[I, A, B] = IndexedStoreT[scalaz.Id.Id, I, A, B]
221.  final case class IndexedStoreT [F[_], +I, A, B](run: (F[(A) ⇒ B], I)) extends Product with Serializable
     See also

     scalaz.Lens

222.  trait IndexedStoreTFunctions extends AnyRef
223.  sealed abstract class IndexedStoreTInstances extends IndexedStoreTInstances0
224.  sealed abstract class IndexedStoreTInstances0 extends IndexedStoreTInstances1
225.  sealed abstract class IndexedStoreTInstances1 extends IndexedStoreTInstances2
226.  sealed abstract class IndexedStoreTInstances2 extends AnyRef
227.  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

228.  sealed abstract class InjectInstances extends AnyRef
229.  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.

230.  case class Injective2 [T[_, _]]() extends Product with Serializable
231.  case class Injective3 [T[_, _, _]]() extends Product with Serializable
232.  case class Injective4 [T[_, _, _, _]]() extends Product with Serializable
233.  case class Injective5 [T[_, _, _, _, _]]() extends Product with Serializable
234.  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

     scalaz.InvariantFunctor.InvariantFunctorLaw

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

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

235.  trait IsEmpty [F[_]] extends PlusEmpty[F]

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

236.  trait IsomorphismAlign [F[_], G[_]] extends Align[F] with IsomorphismFunctor[F, G]
237.  trait IsomorphismApplicative [F[_], G[_]] extends Applicative[F] with IsomorphismApply[F, G]
238.  trait IsomorphismApplicativePlus [F[_], G[_]] extends ApplicativePlus[F] with IsomorphismEmpty[F, G] with IsomorphismApplicative[F, G]
239.  trait IsomorphismApply [F[_], G[_]] extends Apply[F] with IsomorphismFunctor[F, G]
240.  trait IsomorphismArrow [F[_, _], G[_, _]] extends Arrow[F] with IsomorphismSplit[F, G] with IsomorphismStrong[F, G] with IsomorphismCategory[F, G]
241.  trait IsomorphismAssociative [F[_, _], G[_, _]] extends Associative[F]
242.  trait IsomorphismBifoldable [F[_, _], G[_, _]] extends Bifoldable[F]
243.  trait IsomorphismBifunctor [F[_, _], G[_, _]] extends Bifunctor[F]
244.  trait IsomorphismBind [F[_], G[_]] extends Bind[F] with IsomorphismApply[F, G]
245.  trait IsomorphismBindRec [F[_], G[_]] extends BindRec[F] with IsomorphismBind[F, G]
246.  trait IsomorphismBitraverse [F[_, _], G[_, _]] extends Bitraverse[F] with IsomorphismBifunctor[F, G] with IsomorphismBifoldable[F, G]
247.  trait IsomorphismCatchable [F[_], G[_]] extends Catchable[F]
248.  trait IsomorphismCategory [F[_, _], G[_, _]] extends Category[F] with IsomorphismCompose[F, G]
249.  trait IsomorphismChoice [F[_, _], G[_, _]] extends Choice[F] with IsomorphismCategory[F, G]
250.  trait IsomorphismCobind [F[_], G[_]] extends Cobind[F] with IsomorphismFunctor[F, G]
251.  trait IsomorphismComonad [F[_], G[_]] extends Comonad[F] with IsomorphismCobind[F, G]
252.  trait IsomorphismComonadStore [F[_], G[_], S] extends ComonadStore[F, S] with IsomorphismComonad[F, G]
253.  trait IsomorphismCompose [F[_, _], G[_, _]] extends Compose[F]
254.  trait IsomorphismContravariant [F[_], G[_]] extends Contravariant[F]
255.  trait IsomorphismCozip [F[_], G[_]] extends Cozip[F]
256.  trait IsomorphismDivide [F[_], G[_]] extends Divide[F] with IsomorphismContravariant[F, G]
257.  trait IsomorphismDivisible [F[_], G[_]] extends Divisible[F] with IsomorphismDivide[F, G]
258.  trait IsomorphismEmpty [F[_], G[_]] extends PlusEmpty[F] with IsomorphismPlus[F, G]
259.  trait IsomorphismEnum [F, G] extends Enum[F]
260.  trait IsomorphismEqual [F, G] extends Equal[F]
261.  trait IsomorphismFoldable [F[_], G[_]] extends Foldable[F]
262.  trait IsomorphismFoldable1 [F[_], G[_]] extends Foldable1[F] with IsomorphismFoldable[F, G]
263.  trait IsomorphismFunctor [F[_], G[_]] extends Functor[F]
264.  trait IsomorphismInvariantFunctor [F[_], G[_]] extends InvariantFunctor[F]
265.  trait IsomorphismIsEmpty [F[_], G[_]] extends IsEmpty[F] with IsomorphismEmpty[F, G]
266.  trait IsomorphismMonad [F[_], G[_]] extends Monad[F] with IsomorphismApplicative[F, G] with IsomorphismBind[F, G]
267.  trait IsomorphismMonadError [F[_], G[_], S] extends MonadError[F, S] with IsomorphismMonad[F, G]
268.  trait IsomorphismMonadPlus [F[_], G[_]] extends MonadPlus[F] with IsomorphismEmpty[F, G] with IsomorphismMonad[F, G]
269.  trait IsomorphismMonadReader [F[_], G[_], E] extends MonadReader[F, E] with IsomorphismMonad[F, G]
270.  trait IsomorphismMonadState [F[_], G[_], S] extends MonadState[F, S] with IsomorphismMonad[F, G]
271.  trait IsomorphismMonadTell [F[_], G[_], S] extends MonadTell[F, S] with IsomorphismMonad[F, G]
272.  trait IsomorphismMonoid [F, G] extends Monoid[F] with IsomorphismSemigroup[F, G]
273.  trait IsomorphismNondeterminism [F[_], G[_]] extends Nondeterminism[F] with IsomorphismMonad[F, G]
274.  trait IsomorphismOptional [F[_], G[_]] extends Optional[F]
275.  trait IsomorphismOrder [F, G] extends Order[F]
276.  trait IsomorphismPlus [F[_], G[_]] extends Plus[F]
277.  trait IsomorphismProChoice [F[_, _], G[_, _]] extends ProChoice[F] with IsomorphismProfunctor[F, G]
278.  trait IsomorphismProfunctor [F[_, _], G[_, _]] extends Profunctor[F]
279.  trait IsomorphismSemigroup [F, G] extends Semigroup[F]
280.  trait IsomorphismShow [F, G] extends Show[F]
281.  trait IsomorphismSplit [F[_, _], G[_, _]] extends Split[F] with IsomorphismCompose[F, G]
282.  trait IsomorphismStrong [F[_, _], G[_, _]] extends Strong[F] with IsomorphismProfunctor[F, G]
283.  trait IsomorphismTraverse [F[_], G[_]] extends Traverse[F] with IsomorphismFoldable[F, G] with IsomorphismFunctor[F, G]
284.  trait IsomorphismTraverse1 [F[_], G[_]] extends Traverse1[F] with IsomorphismTraverse[F, G] with IsomorphismFoldable1[F, G]
285.  trait IsomorphismUnzip [F[_], G[_]] extends Unzip[F]
286.  trait IsomorphismZip [F[_], G[_]] extends Zip[F]
287.  sealed abstract class Isomorphisms extends IsomorphismsLow0
288.  sealed abstract class IsomorphismsLow0 extends IsomorphismsLow1
289.  sealed abstract class IsomorphismsLow1 extends AnyRef
290.  final case class Kleisli [M[_], A, B](run: (A) ⇒ M[B]) extends Product with Serializable

     Represents a function A => M[B].

291.  abstract class KleisliInstances extends KleisliInstances0
292.  sealed abstract class KleisliInstances0 extends KleisliInstances1
293.  sealed abstract class KleisliInstances1 extends KleisliInstances2
294.  sealed abstract class KleisliInstances10 extends KleisliInstances11
295.  sealed abstract class KleisliInstances11 extends KleisliInstances12
296.  sealed abstract class KleisliInstances12 extends KleisliInstances13
297.  sealed abstract class KleisliInstances13 extends AnyRef
298.  sealed abstract class KleisliInstances2 extends KleisliInstances3
299.  sealed abstract class KleisliInstances3 extends KleisliInstances4
300.  sealed abstract class KleisliInstances4 extends KleisliInstances5
301.  sealed abstract class KleisliInstances5 extends KleisliInstances6
302.  sealed abstract class KleisliInstances6 extends KleisliInstances7
303.  sealed abstract class KleisliInstances7 extends KleisliInstances8
304.  sealed abstract class KleisliInstances8 extends KleisliInstances9
305.  sealed abstract class KleisliInstances9 extends KleisliInstances10
306.  trait Konst [A] extends AnyRef
307.  trait Lan [G[_], H[_], A] extends AnyRef

     The left Kan extension of H along G

308.  sealed abstract class LanInstances extends LanInstances0
309.  sealed abstract class LanInstances0 extends AnyRef
310.  type LastMaybe[A] = AnyRef { ... /* 2 definitions in type refinement */ }
311.  type LastOf[A] = AnyRef { ... /* 2 definitions in type refinement */ }
312.  type LastOption[A] = AnyRef { ... /* 2 definitions in type refinement */ }
313.  sealed abstract class LazyEither [+A, +B] extends AnyRef

     scala.Either, but with a value by name.

314.  sealed abstract class LazyEitherInstances extends AnyRef
315.  final case class LazyEitherT [F[_], A, B](run: F[LazyEither[A, B]]) extends Product with Serializable
316.  sealed abstract class LazyEitherTInstances extends LazyEitherTInstances0
317.  sealed abstract class LazyEitherTInstances0 extends LazyEitherTInstances1
318.  sealed abstract class LazyEitherTInstances1 extends AnyRef
319.  sealed abstract class LazyOption [+A] extends Product with Serializable

     scala.Option, but with a value by name.

320.  sealed abstract class LazyOptionInstances extends AnyRef
321.  final case class LazyOptionT [F[_], A](run: F[LazyOption[A]]) extends Product with Serializable
322.  sealed abstract class LazyOptionTInstances extends LazyOptionTInstances0
323.  sealed abstract class LazyOptionTInstances0 extends LazyOptionTInstances1
324.  sealed abstract class LazyOptionTInstances1 extends AnyRef
325.  sealed abstract class LazyTuple2 [A, B] extends AnyRef

     scala.Tuple2, but with values by name.

326.  sealed abstract class LazyTuple2Instances extends LazyTuple2Instances0
327.  sealed abstract class LazyTuple2Instances0 extends AnyRef
328.  sealed abstract class LazyTuple3 [A, B, C] extends AnyRef

     scala.Tuple3, but with values by name.

329.  sealed abstract class LazyTuple3Instances extends LazyTuple3Instances0
330.  sealed abstract class LazyTuple3Instances0 extends AnyRef
331.  sealed abstract class LazyTuple4 [A, B, C, D] extends AnyRef

     scala.Tuple4, but with values by name.

332.  sealed abstract class LazyTuple4Instances extends LazyTuple4Instances0
333.  sealed abstract class LazyTuple4Instances0 extends AnyRef
334.  final case class Left3 [+A, +B, +C](a: A) extends Either3[A, B, C] with Product with Serializable
335.  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.

336.  sealed abstract class LeibnizInstances extends AnyRef
337.  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.@>

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

339.  trait LensFamilyFunctions extends AnyRef
340.  trait LensFunctions extends LensFamilyFunctions
341.  abstract class LensInstances extends LensInstances0
342.  sealed abstract class LensInstances0 extends AnyRef
343.  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.)

344.  sealed abstract class LiskovInstances extends AnyRef
345.  final case class ListT [M[_], A](run: M[List[A]]) extends Product with Serializable

     ListT monad transformer.

346.  sealed abstract class ListTInstances extends ListTInstances1
347.  sealed abstract class ListTInstances1 extends ListTInstances2
348.  sealed abstract class ListTInstances2 extends AnyRef
349.  sealed abstract class MapInstances extends MapInstances0
350.  sealed abstract class MapInstances0 extends AnyRef
351.  type MaxMaybe[A] = AnyRef { ... /* 2 definitions in type refinement */ }
352.  type MaxOf[A] = AnyRef { ... /* 2 definitions in type refinement */ }
353.  type MaxOption[A] = AnyRef { ... /* 2 definitions in type refinement */ }
354.  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).

355.  sealed abstract class MaybeInstances extends AnyRef
356.  final case class MaybeT [F[_], A](run: F[Maybe[A]]) extends Product with Serializable

     monad transformer for Maybe

357.  sealed abstract class MaybeTInstances extends MaybeTInstances0
358.  sealed abstract class MaybeTInstances0 extends MaybeTInstances1
359.  sealed abstract class MaybeTInstances1 extends MaybeTInstances2
360.  sealed abstract class MaybeTInstances2 extends MaybeTInstances3
361.  sealed abstract class MaybeTInstances3 extends AnyRef
362.  sealed abstract class Memo [K, V] extends AnyRef

     A function memoization strategy.

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

363.  sealed abstract class MemoInstances extends AnyRef
364.  final case class Middle3 [+A, +B, +C](b: B) extends Either3[A, B, C] with Product with Serializable
365.  type MinMaybe[A] = AnyRef { ... /* 2 definitions in type refinement */ }
366.  type MinOf[A] = AnyRef { ... /* 2 definitions in type refinement */ }
367.  type MinOption[A] = AnyRef { ... /* 2 definitions in type refinement */ }
368.  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

369.  trait MonadError [F[_], S] extends Monad[F]

370.  trait MonadListen [F[_], W] extends MonadTell[F, W]
371.  trait MonadPartialOrder [G[_], F[_]] extends NaturalTransformation[F, G]

     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.

372.  sealed abstract class MonadPartialOrderFunctions extends MonadPartialOrderFunctions1
373.  sealed abstract class MonadPartialOrderFunctions1 extends AnyRef
374.  trait MonadPlus [F[_]] extends Monad[F] with ApplicativePlus[F] with MonadPlusParent[F]
     See also

     scalaz.PlusEmpty

     scalaz.Monad

375.  trait MonadPlusParent [F[_]] extends AnyRef
376.  trait MonadReader [F[_], S] extends Monad[F]

377.  trait MonadState [F[_], S] extends Monad[F]

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

378.  trait MonadTell [F[_], S] extends Monad[F]

     The class of monads supporting write operations

379.  trait MonadTrans [F[_[_], _]] extends AnyRef

     Class of monad transformers.

380.  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:

     • http://mathworld.wolfram.com/Monoid.html

     See also

     scalaz.Monoid.MonoidLaw

     scalaz.syntax.MonoidOps

381.  sealed abstract class Name [+A] extends AnyRef

     Call by name

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

383.  trait NaturalTransformations extends AnyRef
384.  sealed abstract class Need [+A] extends Name[A]

     Call by need

385.  sealed abstract class Node [V, A] extends AnyRef
386.  type NonEmptyIList[A] = OneAnd[IList, A]
387.  final class NonEmptyList [A] extends AnyRef

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

388.  sealed abstract class NonEmptyListInstances extends NonEmptyListInstances0
389.  sealed abstract class NonEmptyListInstances0 extends AnyRef
390.  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

391.  sealed trait NotNothing [A] extends AnyRef
392.  final class NullArgument [A, B] extends AnyRef
393.  sealed abstract class NullArgumentInstances extends NullArgumentInstances0
394.  sealed abstract class NullArgumentInstances0 extends AnyRef
395.  final class NullResult [A, B] extends AnyRef
396.  sealed abstract class NullResultInstances extends NullResultInstances0
397.  sealed abstract class NullResultInstances0 extends AnyRef
398.  case class One [V, A](v: V, a1: A)(implicit r: Reducer[A, V]) extends Finger[V, A] with Product with Serializable
399.  final case class OneAnd [F[_], A](head: A, tail: F[A]) extends Product with Serializable

     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

400.  sealed abstract class OneAndInstances extends OneAndInstances0
401.  sealed abstract class OneAndInstances0 extends OneAndInstances1
402.  sealed abstract class OneAndInstances1 extends OneAndInstances2
403.  sealed abstract class OneAndInstances2 extends OneAndInstances3
404.  sealed abstract class OneAndInstances3 extends OneAndInstances4
405.  sealed abstract class OneAndInstances4 extends OneAndInstances5
406.  sealed abstract class OneAndInstances5 extends AnyRef
407.  final case class OneOr [F[_], A](run: \/[F[A], A]) extends Product with Serializable
     Since

     7.0.3

408.  sealed abstract class OneOrInstances extends OneOrInstances0
409.  sealed abstract class OneOrInstances0 extends OneOrInstances1
410.  sealed abstract class OneOrInstances1 extends OneOrInstances2
411.  sealed abstract class OneOrInstances2 extends OneOrInstances3
412.  sealed abstract class OneOrInstances3 extends OneOrInstances4
413.  sealed abstract class OneOrInstances4 extends OneOrInstances5
414.  sealed abstract class OneOrInstances5 extends OneOrInstances6
415.  sealed abstract class OneOrInstances6 extends AnyRef
416.  final case class OptionT [F[_], A](run: F[Option[A]]) extends Product with Serializable

     OptionT monad transformer.

417.  sealed abstract class OptionTInstances extends OptionTInstances0
418.  sealed abstract class OptionTInstances0 extends OptionTInstances1
419.  sealed abstract class OptionTInstances1 extends OptionTInstances2
420.  sealed abstract class OptionTInstances2 extends OptionTInstances3
421.  sealed abstract class OptionTInstances3 extends AnyRef
422.  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

423.  sealed abstract class OrdSeq [A] extends Ops[FingerTree[LastOption[A], 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 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.

424.  trait Order [F] extends Equal[F]

     Safer version of scala.math.Ordering.

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

426.  sealed abstract class OrderingInstances extends AnyRef
427.  type PIndexedState[-S1, S2, A] = IndexedStateT[scalaz.Id.Id, S1, S2, Option[A]]
428.  type PIndexedStateT[F[_], -S1, S2, A] = IndexedStateT[F, S1, S2, Option[A]]
429.  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.@?>

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

431.  trait PLensFamilyFunctions extends PLensInstances
432.  trait PLensFunctions extends PLensInstances with PLensFamilyFunctions
433.  abstract class PLensInstances extends AnyRef
434.  type PState[S, A] = IndexedStateT[scalaz.Id.Id, S, S, Option[A]]
435.  type PStateT[F[_], S, A] = IndexedStateT[F, S, S, Option[A]]
436.  trait Plus [F[_]] extends AnyRef

     Universally quantified scalaz.Semigroup.

437.  trait PlusEmpty [F[_]] extends Plus[F]

     Universally quantified scalaz.Monoid.

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

     Strength on a coproduct.

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

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

440.  type RWS[-R, W, S, A] = IndexedReaderWriterStateT[scalaz.Id.Id, R, W, S, S, A]
441.  type RWST[F[_], -R, W, S, A] = IndexedReaderWriterStateT[F, R, W, S, S, A]
442.  trait Ran [G[_], H[_], A] extends AnyRef

     The right Kan extension of H along G

443.  case class Ranked [A](rank: Int, value: A) extends Product with Serializable
444.  type Reader[E, A] = Kleisli[scalaz.Id.Id, E, A]
445.  type ReaderT[F[_], E, A] = Kleisli[F, E, A]
446.  type ReaderWriterState[-R, W, S, A] = IndexedReaderWriterStateT[scalaz.Id.Id, R, W, S, S, A]
447.  type ReaderWriterStateT[F[_], -R, W, S, A] = IndexedReaderWriterStateT[F, R, W, S, S, A]
448.  trait ReaderWriterStateTFunctions extends AnyRef
449.  abstract class ReaderWriterStateTInstances extends ReaderWriterStateTInstances0
450.  sealed abstract class ReaderWriterStateTInstances0 extends IndexedReaderWriterStateTInstances
451.  sealed abstract class Reducer [C, M] extends AnyRef

     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

452.  sealed abstract class ReducerInstances extends AnyRef
453.  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.

454.  sealed abstract class RepresentableInstances extends AnyRef
455.  final case class Right3 [+A, +B, +C](c: C) extends Either3[A, B, C] with Product with Serializable
456.  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

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

     scalaz.syntax.SemigroupOps

     scalaz.Semigroup.SemigroupLaw

457.  trait Show [F] extends AnyRef

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

458.  sealed trait SinkInstances extends AnyRef
459.  sealed trait SourceInstances extends AnyRef
460.  trait Split [=>:[_, _]] extends Compose[=>:]

     A scalaz.Compose (semigroupoid) permitting products.

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

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

462.  trait StateFunctions extends IndexedStateFunctions
463.  type StateT[F[_], S, A] = IndexedStateT[F, S, S, A]
464.  trait StateTFunctions extends IndexedStateTFunctions
465.  abstract class StateTInstances extends StateTInstances0
466.  sealed abstract class StateTInstances0 extends StateTInstances1
467.  sealed abstract class StateTInstances1 extends StateTInstances2
468.  sealed abstract class StateTInstances2 extends StateTInstances3
469.  sealed abstract class StateTInstances3 extends IndexedStateTInstances
470.  type Store[A, B] = IndexedStoreT[scalaz.Id.Id, A, A, B]
471.  type StoreT[F[_], A, B] = IndexedStoreT[F, A, A, B]
472.  trait StoreTFunctions extends IndexedStoreTFunctions
473.  abstract class StoreTInstances extends StoreTInstances0
474.  sealed abstract class StoreTInstances0 extends StoreTInstances1
475.  sealed abstract class StoreTInstances1 extends StoreTInstances2
476.  sealed abstract class StoreTInstances2 extends IndexedStoreTInstances
477.  sealed class StreamT [M[_], A] extends AnyRef

     StreamT monad transformer.

478.  sealed abstract class StreamTInstances extends StreamTInstances0
479.  sealed abstract class StreamTInstances0 extends AnyRef
480.  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.

481.  sealed abstract class StrictTreeInstances extends AnyRef
482.  final class StrictTreeUnzip [A1, A2] extends AnyVal
483.  trait Strong [=>:[_, _]] extends Profunctor[=>:]

     Strength on a product.

484.  final case class Success [A](a: A) extends Validation[Nothing, A] with Product with Serializable
485.  sealed abstract class TheseInstances extends TheseInstances0
486.  sealed abstract class TheseInstances0 extends TheseInstances1
487.  sealed abstract class TheseInstances1 extends AnyRef
488.  final case class TheseT [F[_], A, B](run: F[\&/[A, B]]) extends Product with Serializable
489.  sealed abstract class TheseTInstances extends TheseTInstances0
490.  sealed abstract class TheseTInstances0 extends TheseTInstances1
491.  sealed abstract class TheseTInstances1 extends AnyRef
492.  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
493.  type Traced[A, B] = TracedT[scalaz.Id.Id, A, B]
494.  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

495.  sealed abstract class TracedTInstances extends TracedTInstances0
496.  sealed abstract class TracedTInstances0 extends TracedTInstances1
497.  sealed abstract class TracedTInstances1 extends TracedTInstances2
498.  sealed abstract class TracedTInstances2 extends TracedTInstances3
499.  sealed abstract class TracedTInstances3 extends TracedTInstances4
500.  sealed abstract class TracedTInstances4 extends TracedTInstances5
501.  sealed abstract class TracedTInstances5 extends AnyRef
502.  sealed trait TrampolineInstances extends AnyRef
503.  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

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

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

506.  sealed abstract class TreeInstances extends AnyRef
507.  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.

508.  sealed abstract class TreeLocInstances extends AnyRef
509.  case class Two [V, A](v: V, a1: A, a2: A)(implicit r: Reducer[A, V]) extends Finger[V, A] with Product with Serializable
510.  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( ... )

511.  trait Unapply2 [TC[_[_, _]], MAB] extends AnyRef
512.  trait Unapply21 [TC[_[_, _], _], MAB] extends AnyRef
513.  sealed abstract class Unapply2_0 extends AnyRef
514.  trait UnapplyProduct [TC[_[_]], MA, MB] extends AnyRef
515.  sealed abstract class Unapply_0 extends Unapply_1
516.  sealed abstract class Unapply_1 extends Unapply_2
517.  sealed abstract class Unapply_2 extends Unapply_3
518.  sealed abstract class Unapply_3 extends Unapply_4
519.  sealed abstract class Unapply_4 extends Unapply_5
520.  sealed abstract class Unapply_5 extends AnyRef
521.  sealed abstract class UnitReducer [C, M] extends Reducer[C, M]
522.  type Unwriter[W, A] = UnwriterT[scalaz.Id.Id, W, A]
523.  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_-.

524.  trait UnwriterTFunctions extends AnyRef
525.  sealed abstract class UnwriterTInstances extends UnwriterTInstances0
526.  sealed abstract class UnwriterTInstances0 extends UnwriterTInstances1
527.  sealed abstract class UnwriterTInstances1 extends UnwriterTInstances2
528.  sealed abstract class UnwriterTInstances2 extends AnyRef
529.  trait Unzip [F[_]] extends AnyRef

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

531.  final class ValidationFlatMap [E, A] extends AnyVal
532.  sealed abstract class ValidationInstances extends ValidationInstances0
533.  sealed abstract class ValidationInstances0 extends ValidationInstances1
534.  sealed abstract class ValidationInstances1 extends ValidationInstances2
535.  sealed abstract class ValidationInstances2 extends ValidationInstances3
536.  sealed abstract class ValidationInstances3 extends AnyRef
537.  type ValidationNel[E, +X] = Validation[NonEmptyList[E], X]

     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.

538.  final case class Value [+A](value: A) extends Need[A] with Product with Serializable

     Call by value

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

     View of the left end of a sequence.

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

     View of the right end of a sequence.

541.  type Writer[W, A] = WriterT[scalaz.Id.Id, W, A]
542.  final case class WriterT [F[_], W, A](run: F[(W, A)]) extends Product with Serializable
543.  trait WriterTFunctions extends AnyRef
544.  sealed abstract class WriterTInstance5 extends WriterTInstances6
545.  sealed abstract class WriterTInstances extends WriterTInstances0
546.  sealed abstract class WriterTInstances0 extends WriterTInstances1
547.  sealed abstract class WriterTInstances1 extends WriterTInstances2
548.  sealed abstract class WriterTInstances10 extends WriterTInstances11
549.  sealed abstract class WriterTInstances11 extends WriterTInstances12
550.  sealed abstract class WriterTInstances12 extends WriterTInstances13
551.  sealed abstract class WriterTInstances13 extends WriterTInstances14
552.  sealed abstract class WriterTInstances14 extends WriterTInstances15
553.  sealed abstract class WriterTInstances15 extends AnyRef
554.  sealed abstract class WriterTInstances2 extends WriterTInstances3
555.  sealed abstract class WriterTInstances3 extends WriterTInstances4
556.  sealed abstract class WriterTInstances4 extends WriterTInstance5
557.  sealed abstract class WriterTInstances6 extends WriterTInstances7
558.  sealed abstract class WriterTInstances7 extends WriterTInstances8
559.  sealed abstract class WriterTInstances8 extends WriterTInstances9
560.  sealed abstract class WriterTInstances9 extends WriterTInstances10
561.  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.

562.  trait Zap [F[_], G[_]] extends AnyRef

     Functors that annihilate each other.

563.  sealed abstract class ZapInstances extends AnyRef
564.  trait Zip [F[_]] extends AnyRef

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

566.  sealed abstract class ZipperInstances extends AnyRef
567.  sealed abstract class \&/ [+A, +B] extends Product with Serializable
     Since

     7.0.3

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

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

     A right disjunction

     A right disjunction

     Often used to represent the success case of a result

570.  type |-->[A, B] = IndexedStoreT[scalaz.Id.Id, B, B, A]
571.  type |>=|[G[_], F[_]] = MonadPartialOrder[G, F]
572.  type ~>[-F[_], +G[_]] = NaturalTransformation[F, G]

     A scalaz.NaturalTransformation[F, G].

573.  type ~~>[-F[_, _], +G[_, _]] = BiNaturalTransformation[F, G]
574.  type ∨[A, B] = \/[A, B]
575.  type ⊤ = Any
576.  type ⊥ = Nothing