prelude
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.
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.
A non-empty wrapper for the scala immutable map.
A non-empty wrapper for the scala immutable map. Note - this does not attempt to implement all features of map but what the author considers to be the "normal ones".
A non-empty wrapper for the scala immutable map.
A non-empty wrapper for the scala immutable map. Note - this does not attempt to implement all features of map but what the author considers to be the "normal ones".
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 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]
These is a data type representing a value that may either be a Left
with anA, a Right with a B, or a Both with an A and a B.
These is a data type representing a value that may either be a Left
with anA, a Right with a B, or a Both with an A and a B.
These can be useful to model certain domains where both values may be
present in addition to one or the other. For example, in streaming
applications we may want to consume values from two upstream producers
concurrently. Depending on the timing of the producers either one producer,
the other, or both producers may have values that are ready to be consumed.
Using These provides a convenient way to model all of these possibilities
in a single "flat" data type.
These can also be useful for representing computations that may produce
both a value and an error. For example, transferring money between two bank
accounts might either succeed, fail completely if there are not sufficient
funds, or succeed with some warnings if the sender's account balance would
be very low after the transfer or the receiver's account has not been
verified. These allows modeling these types of computations and preserving
information regarding all errors while still potentially returning a
successful computation.
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.