scalaz
Type members
Classlikes
A left disjunction
A left disjunction
Often used to represent the failure case of a result
- Companion
- object
Type-aligned pair. Isomorphic to
Type-aligned pair. Isomorphic to
(F[A], G[A]) forSome { type A }
but more robust with respect to type inference.
Notation is conjunction /\
blended with ~
, which is often used to
indicate higher kindedness.
- Companion
- object
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.
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.
- Companion
- object
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
- Companion
- object
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.
An adjunction formed by two functors F
and G
such that F
is left-adjoint to G
.
The composite functor GF is a monad and the composite functor FG is a comonad.
The minimal definition is either (unit, counit) or (leftAdjunct, rightAdjunct)
- Companion
- object
An algebraic data type representing the characters 'a' to 'z'
An algebraic data type representing the characters 'a' to 'z'
- Companion
- object
Derive a Semigroup or Monoid instance from a Plus or PlusEmpty.
Derive a Semigroup or Monoid instance from a Plus or PlusEmpty.
https://hackage.haskell.org/package/reducers-3.12.1/docs/Data-Semigroup-Alt.html#t:Alter
- Companion
- object
Derive a Semigroup or Monoid instance from an Apply or Applicative.
Derive a Semigroup or Monoid instance from an Apply or Applicative.
https://hackage.haskell.org/package/reducers-3.12.1/docs/Data-Semigroup-Applicative.html#t:Ap
- Companion
- object
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
- Companion
- object
scalaz.Applicative combined with scalaz.PlusEmpty.
scalaz.Applicative combined with scalaz.PlusEmpty.
- Companion
- object
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.
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.
- Companion
- object
scalaz.Semigroup which is also idempotent, i.e. appending a value with itself results in the same value.
scalaz.Semigroup which is also idempotent, i.e. appending a value with itself results in the same value.
- See also
- Companion
- object
A constrained transformation natural in both sides of a bifunctor
A constrained transformation natural in both sides of a bifunctor
A function universally quantified over two parameters.
A function universally quantified over two parameters.
A type giving rise to two unrelated scalaz.Foldables.
A type giving rise to two unrelated scalaz.Foldables.
- Companion
- object
A type giving rise to two unrelated scalaz.Functors.
A type giving rise to two unrelated scalaz.Functors.
- Companion
- object
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.
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
- Companion
- object
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.
- Companion
- object
A type giving rise to two unrelated scalaz.Traverses.
A type giving rise to two unrelated scalaz.Traverses.
- Companion
- object
A cofree comonad for some functor S
, i.e. an S
-branching stream.
A cofree comonad for some functor S
, i.e. an S
-branching stream.
- Companion
- object
Contravariant functors. For example, functions provide a scalaz.Functor in their result type, but a scalaz.Contravariant for each argument type.
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
- Companion
- object
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
- Companion
- object
F
on the left, and G
on the right, of scalaz.\/.
F
on the left, and G
on the right, of scalaz.\/.
- Value Params
- run
The underlying scalaz.\/.
- Companion
- object
A Cord
is a purely functional data structure for efficiently creating a
String
from smaller parts, useful for printing ADTs that must write out
their contents into a text format.
A Cord
is a purely functional data structure for efficiently creating a
String
from smaller parts, useful for printing ADTs that must write out
their contents into a text format.
A z
interpolator is available for building String
from literals, using
the Show
typeclass to populate each "hole", and a cord
interpolator
for building Cord
instances.
If a more efficient solution is required to write a large String
to a
network socket or file, consider https://github.com/scalaz/scalaz/issues/1797
If you require a general text manipulation data structure, consider using
FingerTree
or creating a custom structure to resemble that used by the
popular text editors:
- Companion
- object
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; 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.
- Companion
- object
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.
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.
- Companion
- object
Difference lists: a data structure for O(1)
append on lists.
Based on Data.DList
, a Haskell library by Don Stewart.
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.
- Companion
- object
Covariant Day Convolution
Covariant Day Convolution
Based on Edward Kmett implementation in Haskell: https://hackage.haskell.org/package/kan-extensions/docs/Data-Functor-Day.html
Day convolution is a special form of Functor multiplication. In monoidal category of endofunctors Applicative is a monoid object when Day covolution is used as tensor. If we use Functor composition as tensor then then monoid form a Monad instead of Applicative.
Can be seen as generalization of method apply2 from Apply:
def apply2(fa => F[A], fb => F[B])(f: (A, B) => C): F[C]
trait Day[F[_], G[_], A] { self =>
// ...
val fx: F[X]
val gy: G[Y]
def xya: (X, Y) => A
}
- See also
- Companion
- object
Density Comonad.
Density Comonad.
Density is Left Kan Extension where both Functors are the same.
Without any restrictions on F we can define Functor, Cobind, Comonad for Density[F]. Density is Comonad for free.
- See also
- Companion
- object
A Double-ended queue, based on the Bankers Double Ended Queue as described by C. Okasaki in "Purely Functional Data Structures"
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
- Companion
- object
Implementation of a Discrete Interval Encoding Tree https://web.engr.oregonstate.edu/~erwig/diet/ that is actually implemented using a Vector and is balanced at all times as a result.
Implementation of a Discrete Interval Encoding Tree https://web.engr.oregonstate.edu/~erwig/diet/ that is actually implemented using a Vector and is balanced at all times as a result.
- Companion
- object
An algebraic data type representing the digits 0 - 9
An algebraic data type representing the digits 0 - 9
- Companion
- object
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.
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.
- Companion
- object
Divide
is the contravariant analogue of scalaz.Apply
Divide
is the contravariant analogue of scalaz.Apply
- See also
- Companion
- object
Divisible
is the contravariant analogue of scalaz.Applicative
Divisible
is the contravariant analogue of scalaz.Applicative
- See also
- Companion
- object
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))
- Companion
- object
Endomorphisms. They have special properties among functions, so are captured in this newtype.
Endomorphisms. They have special properties among functions, so are captured in this newtype.
- Value Params
- run
The captured function.
- Companion
- object
Endomorphisms using by-name evaluation. They have special properties among functions, so are captured in this newtype.
Endomorphisms using by-name evaluation. They have special properties among functions, so are captured in this newtype.
- Value Params
- run
The captured function.
- Companion
- object
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]
- Companion
- object
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.
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.
- Companion
- object
A type safe alternative to universal equality (scala.Any#==
).
A type safe alternative to universal equality (scala.Any#==
).
- See also
- Companion
- object
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))
wherel1
andl2
are their sizes - Random access to an element at
n
isO(lg min(n, l - n))
, wherel
is the size of the tree. - Constructing a tree with n copies of a value is O(lg n).
- Type Params
- A
The type of the elements stored at the leaves
- V
The type of the annotations of the nodes (the '''measure''')
- See also
- Companion
- object
A type parameter implying the ability to extract zero or more values of that type.
A type parameter implying the ability to extract zero or more values of that type.
- Companion
- object
A scalaz.Foldable where foldMap
is total over semigroups.
That is, toList
cannot return an empty list.
A scalaz.Foldable where foldMap
is total over semigroups.
That is, toList
cannot return an empty list.
- Companion
- object
A free monad for a type constructor S
.
Binding is done using the heap instead of the stack, allowing tail-call elimination.
A free monad for a type constructor S
.
Binding is done using the heap instead of the stack, allowing tail-call elimination.
- Companion
- object
Free applicative functors. Less expressive than free monads, but more flexible to inspect and interpret.
Free applicative functors. Less expressive than free monads, but more flexible to inspect and interpret.
- Companion
- object
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.
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
- Companion
- object
Generator
a class of container of elements that knows how to efficiently apply a scalaz.Reducer
to extract an answer by combining elements. A Reducer
may supply efficient left-to-right and
right-to-left reduction strategies that a Generator
may avail itself of.
Generator
a class of container of elements that knows how to efficiently apply a scalaz.Reducer
to extract an answer by combining elements. A Reducer
may supply efficient left-to-right and
right-to-left reduction strategies that a Generator
may avail itself of.
- Companion
- object
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
- Companion
- object
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.
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.
- Companion
- object
A linked list with by-name head and tail, allowing some control over memory usage and evaluation of contents.
A linked list with by-name head and tail, allowing some control over memory usage and evaluation of contents.
This structure is a good choice when the contents are expensive to calculate and may not all need to be evaluated, at the cost of an overhead when the contents are calculated. Typeclass instances try to defer evaluation of contents, unless it would require a full traversal of the spine, preferring lazy semantics when an evaluation choice is to be made.
- Companion
- object
Mixed into object Id
in the package object scalaz.
Mixed into object Id
in the package object scalaz.
An immutable wrapper for arrays
An immutable wrapper for arrays
- Type Params
- A
type of the elements of the array
- Companion
- object
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)
.
- Companion
- object
A monad transformer stack yielding (R, S1) => F[(W, A, S2)]
.
A monad transformer stack yielding (R, S1) => F[(W, A, S2)]
.
- Companion
- object
- Companion
- class
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
- Companion
- object
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.
Invariant parent of Decidable and Alternative.
Invariant parent of Decidable and Alternative.
Used for typeclass derivation of products, coproducts and value types.
- Companion
- object
Invariant parent of Divisible and Applicative.
Invariant parent of Divisible and Applicative.
Used for typeclass derivation of products and value types.
- Companion
- object
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
- Companion
- object
Type constructors that are contravariant with respect to subtyping.
Type constructors that are contravariant with respect to subtyping.
A type constructor F[_]
admits an instance IsContravariant[F]
iff
F[B]
is a subtype of F[A]
whenever A
is a subtype of B
.
The Scala language represents this natively using the [-A]
notation on
type constructors. The factory scalaContravariant
provides an instance of this typeclass for any such type. However, type
constructors which behave contravariantly despite not being thus notated can also
implement this typeclass. The factory force constructs
an instance of IsContravariant
for any type, based on the programmer's
assertion that it is indeed contravariant.
Note the relationship between this typeclass and Contravariant: whereas Contravariant instances are contravariant functors in the "category" of Scala types and functions, instances of this typeclass are contravariant functors in the "category" of Scala types and subtyping relations.
- Companion
- object
Type constructors that are covariant with respect to subtyping.
Type constructors that are covariant with respect to subtyping.
A type constructor F[_]
admits an instance IsCovariant[F]
iff
F[A]
is a subtype of F[B]
whenever A
is a subtype of B
.
The Scala language represents this natively using the [+A]
notation on
type constructors. The factory scalaCovariant
provides an instance of this typeclass for any such type. However, type
constructors which behave covariantly despite not being thus notated can also
implement this typeclass. The factory force constructs
an instance of IsCovariant
for any type, based on the programmer's
assertion that it is indeed covariant.
Note the relationship between this typeclass and Functor: whereas Functor instances are covariant functors in the "category" of Scala types and functions, instances of this typeclass are covariant functors in the "category" of Scala types and subtyping relations.
- Companion
- object
Typeclass that permits testing whether some type with an empty representation is in fact empty.
Typeclass that permits testing whether some type with an empty representation is in fact empty.
- Companion
- object
scala.Either, but with a value by name.
scala.Either, but with a value by name.
- Companion
- object
scala.Option, but with a value by name.
scala.Option, but with a value by name.
- Companion
- object
scala.Tuple2, but with values by name.
scala.Tuple2, but with values by name.
- Companion
- object
scala.Tuple3, but with values by name.
scala.Tuple3, but with values by name.
- Companion
- object
scala.Tuple4, but with values by name.
scala.Tuple4, but with values by name.
- Companion
- object
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.
- Companion
- object
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
.
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
.
- Type Params
- 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
- Companion
- object
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
.)
- Companion
- object
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).
- Companion
- object
A function memoization strategy. See companion for various instances employing various strategies.
A function memoization strategy. See companion for various instances employing various strategies.
- Companion
- object
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
- Companion
- object
The class of monads supporting the operations of scalaz.State.
The class of monads supporting the operations of scalaz.State.
- Companion
- object
The class of monads supporting write operations
The class of monads supporting write operations
- Companion
- object
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
andappend
are0
andInt#+
respectivelyMonoid[List[A]]
:zero
andappend
areNil
andList#++
respectively
References:
- See also
- Companion
- object
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.
- Companion
- object
A singly-linked list that is guaranteed to be non-empty.
A singly-linked list that is guaranteed to be non-empty.
- Companion
- object
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'.
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
- Companion
- object
A generalization of NonEmptyList
to non-List
things. For
example, OneAnd[Vector, A]
is a non-empty Vector
of A
.
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 NonEmptyList
s 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
- Companion
- object
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.
- Type Params
- F
the container/context type
- See also
- Companion
- object
Ordered sequences, based on scalaz.FingerTree
Ordered sequences, based on scalaz.FingerTree
a
has a higher priority than b
if Order[A].greaterThan(a, b)
.
insert
and ++
maintains the ordering.
The measure is calculated with a Semigroup[A @@ LastVal]
, whose append
operation favours the first argument. Accordingly, the measure of a node is the
item with the highest priority contained recursively below that node.
- Companion
- object
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 theInt
s returned by scala.math.Ordering.- Companion
- object
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
.
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
.
- Type Params
- 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
- Companion
- object
Container whose elements have two different orders: by priority and by lookup key.
Container whose elements have two different orders: by priority and by lookup key.
Supports efficient implementation of the following operations:
- insertion (O(log n)),
- lookup by key (O(log n)),
- deletion by key (O(log n)),
- access to minimal-by-priority element (O(1)),
- deletion of minimal-by-priority element (O(log n)).
Implemented using FingerTree.
- Type Params
- A
element type
- K
lookup key. Unique—the queue holds at most one element with any given key.
- P
priority of an element. Multiple elements can have the same priority.
- Companion
- object
Profunctors are covariant on the right and contravariant on the left.
Profunctors are covariant on the right and contravariant on the left.
- Companion
- object
A Reducer[C,M]
is a scalaz.Semigroup[M]
that maps
values of type C
through unit
to values of type M
. A C-Reducer
may also
supply operations which tack on another C
to an existing Semigroup
M
on the left
or right. These specialized reductions may be more efficient in some scenarios
and are used when appropriate by a scalaz.Generator. The names cons
and snoc
work
by analogy to the synonymous operations in the list semigroup.
A Reducer[C,M]
is a scalaz.Semigroup[M]
that maps
values of type C
through unit
to values of type M
. A C-Reducer
may also
supply operations which tack on another C
to an existing Semigroup
M
on the left
or right. These specialized reductions may be more efficient in some scenarios
and are used when appropriate by a scalaz.Generator. The names cons
and snoc
work
by analogy to the synonymous operations in the list semigroup.
Minimal definition: unit
or snoc
Based on the Reducer Haskell library by Edward Kmett (https://hackage.haskell.org/package/reducers).
- Companion
- object
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
.
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
.
- Companion
- object
This object was generated by sbt-buildinfo.
This object was generated by sbt-buildinfo.
scalaz.Band which is also commutative, i.e. A + B == B + A
scalaz.Band which is also commutative, i.e. A + B == B + A
- See also
- Companion
- object
An associative binary operation, circumscribed by type and the semigroup laws. Unlike scalaz.Monoid, there is not necessarily a zero.
An associative binary operation, circumscribed by type and the semigroup laws. Unlike scalaz.Monoid, there is not necessarily a zero.
- See also
- Companion
- object
A typeclass for conversion to textual representation, done via scalaz.Cord for efficiency.
A typeclass for conversion to textual representation, done via scalaz.Cord for efficiency.
- Companion
- object
A scalaz.Compose (semigroupoid) permitting products.
A scalaz.Compose (semigroupoid) permitting products.
- Companion
- object
- Value Params
- rootLabel
The label at the root of this tree.
- subForest
The child nodes of this tree.
- Companion
- object
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 .
Composes a Functor on the outside of a Bifunctor.
Composes a Functor on the outside of a Bifunctor.
https://hackage.haskell.org/package/bifunctors-5.5/docs/Data-Bifunctor-Tannen.html#t:Tannen
- Companion
- object
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
- Companion
- object
A scalaz.Traverse where traverse
is total over
scalaz.Applys. That is, toList
cannot return an empty list.
A scalaz.Traverse where traverse
is total over
scalaz.Applys. That is, toList
cannot return an empty list.
- Companion
- object
A multi-way tree, also known as a rose tree. Also known as Cofree[Stream, A].
A multi-way tree, also known as a rose tree. Also known as Cofree[Stream, A].
- Companion
- object
A rose-tree zipper. Represents a scalaz.Tree together with a position in that tree. Provides navigation, persistent update, insertion, and deletes.
A rose-tree zipper. Represents a scalaz.Tree together with a position in that tree. Provides navigation, persistent update, insertion, and deletes.
- Value Params
- lefts
The left siblings of the current node.
- parents
The parent contexts of the current node.
- rights
The right siblings of the current node.
- tree
The currently selected node.
- Companion
- object
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.
- Companion
- object
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_-
.
- Companion
- object
Represents either:
Represents either:
Success(a)
, orFailure(e)
.
Isomorphic to scala.Either
and scalaz.\/
. The motivation for a Validation
is to provide the instance
Applicative[[a]Validation[E, a]]
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"))
- Type Params
- A
The type of the
Success
- E
The type of the
Failure
- Companion
- object
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
.
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
.
- Companion
- object
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.
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.
- Companion
- object
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.
- Companion
- object
A right disjunction
A right disjunction
Often used to represent the success case of a result
- Companion
- object
Mark an explicit or implicit parameter as known to be unused, as shorthand
for the longer form, useful in combination with
-Ywarn-unused:explicits,implicits
compiler options.
Mark an explicit or implicit parameter as known to be unused, as shorthand
for the longer form, useful in combination with
-Ywarn-unused:explicits,implicits
compiler options.
Deprecated classlikes
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.
- Companion
- object
- Deprecated
Types
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.
A lens that doesn't transform the type of the record.
A lens that doesn't transform the type of the record.
- See also
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
A state transition, representing a function S => (S, A)
.
A state transition, representing a function S => (S, A)
.
An scalaz.Validation with a scalaz.NonEmptyList as the failure type.
An scalaz.Validation with a scalaz.NonEmptyList as the failure type.