The Associative[A]
type class describes an associative binary operator
for a type A
.
The Associative[A]
type class describes an associative binary operator
for a type A
. For example, addition for integers, and string
concatenation for strings.
Associative
is at the top of the hierarchy for abstracting over operations
to combine types because while there are some operations that are not
associative but do obey other laws, it is generally difficult to combine
more than two values in interesting ways with these operators, and thus to
build solutions to more complicated problems out of solutions to simpler
ones.
For example, the mean of two numbers is an operation that is commutative but not associative. However, the lack of associativity is an indication that we can't combine the means of multiple values in an interesting way with this definition. If we attempt to take the mean of three values we always place twice as much weight on one number as the others, which is rarely what we want.
If we instead define this operation using a StatsCounter
object then means
can be combined in ways that are associative, commutative, and have an
identity element, supporting much more interesting modes of composition.
An associative binary operator that combines two values of types F[A]
and F[B]
to produce an F[(A, B)]
.
An associative binary operator that combines two values of types F[A]
and F[B]
to produce an F[(A, B)]
.
Provides infix syntax for associative operations for contravariant types.
Provides infix syntax for associative operations for contravariant types.
Provides infix syntax for associative operations for covariant types.
Provides infix syntax for associative operations for covariant types.
Provides infix syntax for associative operations for invariant types.
Provides infix syntax for associative operations for invariant types.
An associative binary operator that combines two values of types F[A]
and F[B]
to produce an F[Either[A, B]]
.
An associative binary operator that combines two values of types F[A]
and F[B]
to produce an F[Either[A, B]]
.
Provides infix syntax for associative operations for contravariant types.
Provides infix syntax for associative operations for contravariant types.
Provides infix syntax for associative operations for covariant types.
Provides infix syntax for associative operations for covariant types.
Provides infix syntax for associative operations for invariant types.
Provides infix syntax for associative operations for invariant types.
AssociativeFlatten
describes a type that can be "flattened" in an
associative way.
AssociativeFlatten
describes a type that can be "flattened" in an
associative way. For example, if we have a list of lists of lists, we can
flatten it by either flattening the two inner lists and then flattening the
resulting lists, or flattening the two outer lists and then flattening that
resulting list. Because the operation is associative, the resulting list is
the same either way.
Provides infix syntax for flattening covariant types.
Provides infix syntax for flattening covariant types.
Provides infix syntax for flattening types.
Provides infix syntax for flattening types.
Provides infix syntax for combining two values with an associative operation.
Provides infix syntax for combining two values with an associative operation.
The Commutative
type class describes a binary operator for a type A
that
is both associative and commutative.
The Commutative
type class describes a binary operator for a type A
that
is both associative and commutative. This means that a1 <> a2
is equal to
a2 <> a1
for all values a1
and a2
. Examples of commutative operations
include addition for integers, but not concatenation for strings.
Commutative operators are useful because combining values with a commutative operation results in the same value regardless of the order in which values are combined, allowing us to combine values in the order that is most efficient and allowing us to return determinate values even when the order of original values is indeterminate.
A commutative binary operator that combines two values of types F[A]
and
F[B]
to produce an F[(A, B)]
.
A commutative binary operator that combines two values of types F[A]
and
F[B]
to produce an F[(A, B)]
.
Provides infix syntax for commutative operations for contravariant types.
Provides infix syntax for commutative operations for contravariant types.
Provides infix syntax for commutative operations for covariant types.
Provides infix syntax for commutative operations for covariant types.
Provides infix syntax for commutative operations for invariant types.
Provides infix syntax for commutative operations for invariant types.
A commutative binary operator that combines two values of types F[A]
and
F[B]
to produce an F[Either[A, B]]
.
A commutative binary operator that combines two values of types F[A]
and
F[B]
to produce an F[Either[A, B]]
.
Provides infix syntax for commutative operations for contravariant types.
Provides infix syntax for commutative operations for contravariant types.
Provides infix syntax for commutative operations for covariant types.
Provides infix syntax for commutative operations for covariant types.
Provides infix syntax for commutative operations for invariant types.
Provides infix syntax for commutative operations for invariant types.
Contravariant[F]
provides implicit evidence that F[-_]
is a
contravariant endofunctor in the category of Scala objects.
Contravariant[F]
provides implicit evidence that F[-_]
is a
contravariant endofunctor in the category of Scala objects.
Contravariant
instances of type F[A]
"consume" values of type A
in
some sense. For example, Equal[A]
takes two values of type A
as input
and returns a Boolean
indicating whether they are equal. Similarly, a
Ord[A]
takes two values of type A
as input and returns an Ordering
with the result of comparing them and Hash
takes an A
value and returns
an Int
.
Common examples of contravariant instances in ZIO include effects with regard to their environment types, sinks with regard to their input type, and polymorphic queues and references regarding their input types.
Contravariant
instances support a contramap
operation, which allows
transforming the input type given a function from the new input type to the
old input type. For example, if we have an Ord[Int]
that allows us to
compare two integers and we have a function String => Int
that returns
the length of a string, then we can construct an Ord[String]
that
compares strings by computing their lengths with the provided function and
comparing those.
Provides infix syntax for mapping over covariant values.
Provides infix syntax for mapping over covariant values.
Covariant[F]
provides implicit evidence that F[+_]
is a covariant
endofunctor in the category of Scala objects.
Covariant[F]
provides implicit evidence that F[+_]
is a covariant
endofunctor in the category of Scala objects.
Covariant instances of type F[A]
"produce" values of type A
in some
sense. In some cases, such as with a List[A]
, this means that they
contain values of type A
, in which case we can simply access the elements
of the collection. In other cases it means that output values of type A
which may not already exists, such as with a Function0[A]
that produces
A
values when invoked.
Common examples of covariant instances in ZIO includes effects with respect to their error and value types, sinks with respect to their error and output types, and queues and references with respect to their error and output types.
Covariant
instances support a map
operation which allows transforming
the output type given a function from the old output type to the new output
type. For example, if we have a List[String]
and a function
String => Int
that returns the length of a string, then we can construct
a List[Int]
with the length of each string.
Provides infix syntax for mapping over covariant values.
Provides infix syntax for mapping over covariant values.
Debug
is an abstraction that describes the ability to render a value of
type A
to a human readable format for debugging purposes.
Debug
is an abstraction that describes the ability to render a value of
type A
to a human readable format for debugging purposes.
Debug
captures this information in a structured data format called a
Repr
, or a "representation" of the data. This representation can then be
rendered to a human readable format using a Renderer
, which knows how to
render a representation to a specific human readable format. This two step
process preserves information when creating the representation and allows
rendering it in different ways. For example, we might want to render
it as a simple string representation using the Simple
renderer or as valid
Scala code that we could paste into a REPL with the Scala
renderer.
You can use Repr
to create structured representations of your own data
types and even implement your own Renderer
, for example to render
representations to JSON, though in most cases the built in renderers will
be all that you need.
Derive[F, Typeclass]
represents a universally quantified function from
Typeclass[A]
to Typeclass[F[A]]
for some F[_]
.
Derive[F, Typeclass]
represents a universally quantified function from
Typeclass[A]
to Typeclass[F[A]]
for some F[_]
. You can think of
Derive
as a "recipe" for building a Typeclass[F[A]]
instance given a
Typeclass[A]
.
For example, if we know how to compare values of type A
for equality then
we can compare lists with elements of type A
for equality by checking
that the length of the lists is the same and each pair of corresponding
elements are equal. And we can do this for any type A
as long as it has
an Equal
instance.
This is used by the library to derive typeclass instances for higher kinded types given typeclass instances for the type they are parameterized on.
Equal[A]
provides implicit evidence that two values of type A
can be
compared for equality.
Equal[A]
provides implicit evidence that two values of type A
can be
compared for equality.
Provides infix syntax for comparing two values for equality.
Provides infix syntax for comparing two values for equality.
An Equivalence[A, B]
defines an equivalence between two types A
and B
.
An Equivalence[A, B]
defines an equivalence between two types A
and B
.
These types represent different ways to store the same information.
For example, a List[Byte]
is equivalent to a Vector[Byte]
. Similarly, a
List[Char]
is equivalent to a String
.
Equivalences are symmetrical. So if A
is equivalent to B
, then B
is
equivalent to A
.
A function that converts an A
into a B
.
A function that converts a B
into an A
.
Provides infix syntax for flip1.
Provides infix syntax for flip1.
Provides infix syntax for flip.
Provides infix syntax for flip.
ForEach
is an abstraction that describes the ability to iterate over
a collection, performing an effect for each element in the collection and
returning a collection with the same shape in the context of the effect.
ForEach
is an abstraction that describes the ability to iterate over
a collection, performing an effect for each element in the collection and
returning a collection with the same shape in the context of the effect.
By choosing the appropriate effect type to traverse with a wide range of operations on collections can be described. In particular, by traversing with state we can describe folds which allow implementing a wide variety of collection operations that produce summaries from a collection of values.
Provides infix syntax for traversing collections.
Provides infix syntax for traversing collections.
Hash[A]
provides implicit evidence that a value of type A
can be hashed.
Hash[A]
provides implicit evidence that a value of type A
can be hashed.
Provides infix syntax for hashing a value.
Provides infix syntax for hashing a value.
The Idempotent
type class describes a binary operator for a type A
that
is both associative and produces the same value when combining two identical values.
The Idempotent
type class describes a binary operator for a type A
that
is both associative and produces the same value when combining two identical values.
This means that a <> a
is equal to a
for all values a
.
Example of idempotent operations is union of sets, but not addition of integers.
Idempotent operators are useful because combining the values with an idempotent operation results in the same value regardless of the number of values are combined, allowing us to optimize out unnecessary combinations of the same values.
The Identity
type class describes an associative binary operator for a
type A
that also has an identity element.
The Identity
type class describes an associative binary operator for a
type A
that also has an identity element. Combining any value with the
identity element on either the left or the right must return the original
value unchanged. For example, zero is an identity element for integer
addition and the empty string is an identity element for string
concatenation.
Operators with an identity element are useful because the identity element provides a sensible default value when combining values of a type and no values exist.
A binary operator that combines two values of types F[A]
and F[B]
to
produce an F[(A, B)]
with an identity.
A binary operator that combines two values of types F[A]
and F[B]
to
produce an F[(A, B)]
with an identity.
A binary operator that combines two values of types F[A]
and F[B]
to
produce an F[Either[A, B]]
with an identity value.
A binary operator that combines two values of types F[A]
and F[B]
to
produce an F[Either[A, B]]
with an identity value.
IdentityFlatten
described a type that can be "flattened" in an
associative way and has an identity element with respect to that operation.
IdentityFlatten
described a type that can be "flattened" in an
associative way and has an identity element with respect to that operation.
For example, with a list we can always vacuously add a layer by wrapping a
list in another list constructor and flattening the resulting list always
returns the original list unchanged.
Provides infix syntax for combining two values with an associative operation.
Provides infix syntax for combining two values with an associative operation.
Provides infix syntax for mapping over invariant values.
Provides infix syntax for mapping over invariant values.
The Inverse
type class describes an associative binary operator for a
type A
that has an identity element and an inverse binary operator.
The Inverse
type class describes an associative binary operator for a
type A
that has an identity element and an inverse binary operator.
Combining any value with itself with the inverse operator must return the
identity element. For example, for integer addition zero is an identty
element and subtraction is an inverse operation, because subtracting any
value from itself always returns zero.
Because Inverse
defines a binary rather than a unary operator it can be
used to describe inverse operations for types that do not have inverse
values. For example, the natural numbers do not have inverses because the
set of natural numbers does not include negative numbers. But we can still
define a subtraction operation that is the inverse of addition for the
natural numbers, since subtracting a number from itself always returns
zero.
Provides infix syntax for combining two values with an inverse operation.
Provides infix syntax for combining two values with an inverse operation.
The class of objects corresponding to newtypes.
The class of objects corresponding to newtypes. Users should implement an
object that extends this class to create their own newtypes, specifying
A
as the underlying type to wrap.
object Meter extends Newtype[Double] type Meter = Meter.Type
The class of objects corresponding to parameterized newtypes.
The class of objects corresponding to parameterized newtypes. Users should implement an object that extends this class to create their own parameterized newtypes
object Sum extends NewtypeF type Sum[A] = Sum.Type[A]
A NonEmptyForEach
describes a ForEach
that is guaranteed to
contain at least one element, such as a NonEmptyList
, a NonEmptyChunk
,
or certain tree like data structures.
A NonEmptyForEach
describes a ForEach
that is guaranteed to
contain at least one element, such as a NonEmptyList
, a NonEmptyChunk
,
or certain tree like data structures.
Because of the additional information that there is always at least one
element, certain operations are available on a NonEmptyForEach
that
are not available on a ForEach
. For example, if an ordering is
defined on the elements of a NonEmptyForEach
then min
and max
are
defined, whereas for a ForEach
only minOption
and maxOption
would
be, since the collection might not contain any elements at all.
Provides infix syntax for traversing collections.
Provides infix syntax for traversing collections.
A NonEmptyList[A]
is a list of one or more values of type A.
A NonEmptyList[A]
is a list of one or more values of type A. Unlike a
List
, a NonEmptyList
is guaranteed to contain at least one element.
This additional structure allows some operations to be defined on
NonEmptyList
that are not safe on List
, such as head
and reduceAll
.
For interoperability with Scala's collection library an implicit conversion
is provided from NonEmptyList
to the ::
case of List
. Operations that
cannot preserve the guarantee that the resulting collection must have at
least one element will return a List
instead.
Ord[A]
provides implicit evidence that values of type A
have a total
ordering.
Ord[A]
provides implicit evidence that values of type A
have a total
ordering.
Provides infix syntax for comparing two values with a total ordering.
Provides infix syntax for comparing two values with a total ordering.
An Ordering
is the result of comparing two values.
An Ordering
is the result of comparing two values. The result may be
LessThan
, Equals
, or GreaterThan
.
ParSeq
is a data type that represents some notion of "events" that can
take place in parallel or in sequence.
ParSeq
is a data type that represents some notion of "events" that can
take place in parallel or in sequence. For example, a ParSeq
parameterized on some error type could be used to model the potentially
multiple ways that an application can fail. On the other hand, a ParSeq
parameterized on some request type could be used to model a collection of
requests to external data sources, some of which could be executed in
parallel and some of which must be executed sequentially.
PartialOrd[A]
provides implicit evidence that values of type A
have a partial
ordering.
PartialOrd[A]
provides implicit evidence that values of type A
have a partial
ordering.
Provides infix syntax for comparing two values with a total ordering.
Provides infix syntax for comparing two values with a total ordering.
A SafeFunction
is a function that can be freely composed with the
guarantee that functions of arbitrary size can be evaluated in constant
stack space.
A SafeFunction
is a function that can be freely composed with the
guarantee that functions of arbitrary size can be evaluated in constant
stack space. It does this by maintaining each of the composed functions
internally in a data structure and evaluating them in a loop when the
function is called.
The class of objects corresponding to subtypes.
The class of objects corresponding to subtypes. Users should implement an
object that extends this class to create their own subtypes, specifying
A
as the underlying type to wrap.
object And extends Subtype[Boolean] type And = And.Type
The class of objects corresponding to parameterized subtypes.
The class of objects corresponding to parameterized subtypes. Users should implement an object that extends this class to create their own parameterized subtypes
object Sum extends SubtypeF type Sum[A] = Sum.Type[A]
Similar to ZSet
, a ZNonEmptySet[A, B]
is a guaranteed non-empty set of A
values where B
represents some notion of
"how many" A
values are included in the set.
Similar to ZSet
, a ZNonEmptySet[A, B]
is a guaranteed non-empty set of A
values where B
represents some notion of
"how many" A
values are included in the set. This can be the number of
times each element appears in the set if B
is a natural number, the
probability associated with an element in the set if B
is a rational
number, or even whether an element appears at all if B
is a boolean.
A ZSet[A, B]
is a set of A
values where B
represents some notion of
"how many" A
values are included in the set.
A ZSet[A, B]
is a set of A
values where B
represents some notion of
"how many" A
values are included in the set. This can be the number of
times each element appears in the set if B
is a natural number, the
probability associated with an element in the set if B
is a rational
number, or even whether an element appears at all if B
is a boolean.
ZValidation
represents either a success of type A
or a collection of one
or more errors of type E
along with in either case a log with entries of
type W
.
ZValidation
represents either a success of type A
or a collection of one
or more errors of type E
along with in either case a log with entries of
type W
. Unlike Either
, ZValidation
does not "short circuit" on
failures and instead allows accumulating multiple errors. This can be
particularly useful in validating data, where we want to attempt to validate
all of the data and retain information about all errors that arose, rather
than failing at the first error.
Abstract over type constructor with 3 parameters: on first as contravariant and on second and third as covariant.
This object was generated by sbt-buildinfo.