zio-prelude-docs
API
Generated with
zio-prelude-docs/zio.prelude

zio.prelude

package zio.prelude

Members list

Packages

package zio.prelude.coherent
package zio.prelude.data
package zio.prelude.experimental
package zio.prelude.fx
package zio.prelude.laws
package zio.prelude.newtypes
package zio.prelude.recursive
package zio.prelude.scalaparallelcollections

Type members

Classlikes

sealed trait AnyType[A]

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
object AnyType

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
AnyType.type
trait Associative[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.

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.

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait AssociativeEqual[A]
trait CommutativeEqual[A]
trait EqualIdempotent[A]
trait EqualIdentity[A]
trait EqualInverse[A]
trait Commutative[A]
trait Idempotent[A]
trait Identity[A]
trait PartialInverse[A]
trait Inverse[A]
Show all
Self type
object Associative extends AssociativeLowPriority

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
trait AssociativeBoth[F[_]]

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

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait CommutativeBoth[F]
trait IdentityBoth[F]
Show all
object AssociativeBoth extends AssociativeBothLowPriority

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
trait AssociativeBothLowPriority

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait AssociativeBothSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
trait AssociativeCompose[=>:[_, _]]

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait BothCompose[=>:]
trait ApplicationCompose[=>:]
trait EitherCompose[=>:]
trait IdentityCompose[=>:]
object AssociativeCompose

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
trait AssociativeComposeSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
trait AssociativeEither[F[_]]

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

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait IdentityEither[F]
object AssociativeEither

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
trait AssociativeEitherSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
trait AssociativeFlatten[F[_]]

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.

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.

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait IdentityFlatten[F]
object AssociativeFlatten

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
trait AssociativeFlattenSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
trait AssociativeLowPriority

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
object Associative
trait AssociativeSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
trait Bicovariant[<=>[_, _]] extends RightCovariant[<=>]

Attributes

Companion
object
Supertypes
trait RightCovariant[<=>]
class Object
trait Matchable
class Any
Self type
object Bicovariant

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
trait BicovariantSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
case object BuildInfo

This object was generated by sbt-buildinfo.

This object was generated by sbt-buildinfo.

Attributes

Supertypes
trait Singleton
trait Product
trait Mirror
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
Self type
BuildInfo.type
trait Commutative[A] extends Associative[A]

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.

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.

Attributes

Companion
object
Supertypes
trait Associative[A]
class Object
trait Matchable
class Any
Known subtypes
trait CommutativeEqual[A]
Self type
object Commutative

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
trait CommutativeBoth[F[_]] extends AssociativeBoth[F]

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

Attributes

Companion
object
Supertypes
trait AssociativeBoth[F]
class Object
trait Matchable
class Any
Known subtypes
object CommutativeBoth

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
trait CommutativeBothSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
trait CommutativeEither[F[_]] extends AssociativeEither[F]

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

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
object CommutativeEither

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
trait CommutativeEitherSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
sealed trait Comparison extends Product, Serializable

Attributes

Companion
object
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
Known subtypes
trait NotEqual
object GreaterThan
object LessThan
object Incomparable
object Equals
object Comparison

Attributes

Companion
trait
Supertypes
trait Sum
trait Mirror
class Object
trait Matchable
class Any
Self type
Comparison.type
trait ConstExports

Attributes

Supertypes
class Object
trait Matchable
class Any
trait Contravariant[F[_]] extends ContravariantSubset[F, AnyType], Invariant[F]

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.

Attributes

Companion
object
Supertypes
trait Invariant[F]
class Object
trait Matchable
class Any
Known subtypes
Self type
object Contravariant

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
trait ContravariantSubset[F[_], Subset[_]]

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait Contravariant[F]
trait ContravariantSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
trait Covariant[F[_]] extends CovariantSubset[F, AnyType], Invariant[F]

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.

Attributes

Companion
object
Supertypes
trait Invariant[F]
class Object
trait Matchable
class Any
Known subtypes
trait ForEach[F]
trait NonEmptyForEach[F]
Show all
Self type
object Covariant

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
Covariant.type
trait CovariantSubset[F[_], Subset[_]]

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait Covariant[F]
trait ForEach[F]
trait NonEmptyForEach[F]
Show all
trait CovariantSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
trait Debug[-A]

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.

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
object Debug extends DebugVersionSpecific

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
Debug.type
trait DebugSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
trait DebugVersionSpecific

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
object Debug
trait Derive[F[_], Typeclass[_]]

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

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.

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
object Derive

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
Derive.type
trait Divariant[=>:[_, _]] extends RightCovariant[=>:]

Attributes

Companion
object
Supertypes
trait RightCovariant[=>:]
class Object
trait Matchable
class Any
Self type
Divariant[=>:]
object Divariant

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
Divariant.type
trait DivariantSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
trait Equal[-A]

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.

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait AssociativeEqual[A]
trait CommutativeEqual[A]
trait EqualIdempotent[A]
trait EqualIdentity[A]
trait EqualInverse[A]
trait AbsorptionEqual[A]
trait InvolutionEqual[A]
trait Hash[A]
trait HashPartialOrd[A]
trait HashOrd[A]
trait PartialOrd[A]
trait Ord[A]
Show all
Self type
Equal[A]
object Equal extends EqualVersionSpecific

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
Equal.type
trait EqualSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
trait EqualVersionSpecific

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
object Equal
trait Equivalence[A, B] extends PartialEquivalence[A, B, Nothing, Nothing]

An Equivalence[A, B] defines an equivalence between two types A and B. These types represent different ways to store the same information.

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.

Value parameters

from

A function that converts a B into an A.

to

A function that converts an A into a B.

Attributes

Companion
object
Supertypes
trait PartialEquivalence[A, B, Nothing, Nothing]
class Object
trait Matchable
class Any
Self type
Equivalence[A, B]
object Equivalence

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
trait ForEach[F[_]] extends Covariant[F]

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.

Attributes

Companion
object
Supertypes
trait Covariant[F]
trait Invariant[F]
class Object
trait Matchable
class Any
Show all
Known subtypes
trait NonEmptyForEach[F]
Self type
ForEach[F]
object ForEach

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
ForEach.type
trait ForEachSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
trait Hash[-A] extends Equal[A]

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.

Attributes

Companion
object
Supertypes
trait Equal[A]
class Object
trait Matchable
class Any
Known subtypes
trait HashPartialOrd[A]
trait HashOrd[A]
Self type
Hash[A]
object Hash

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
Hash.type
trait HashSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
trait IdExports

Attributes

Supertypes
class Object
trait Matchable
class Any
trait Idempotent[A] extends Associative[A]

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.

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.

Attributes

Companion
object
Supertypes
trait Associative[A]
class Object
trait Matchable
class Any
Known subtypes
trait EqualIdempotent[A]
Self type
object Idempotent

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
Idempotent.type
trait Identity[A] extends Associative[A]

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.

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.

Attributes

Companion
object
Supertypes
trait Associative[A]
class Object
trait Matchable
class Any
Known subtypes
trait EqualIdentity[A]
trait EqualInverse[A]
trait PartialInverse[A]
trait Inverse[A]
Show all
object Identity

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
Identity.type
trait IdentityBoth[F[_]] extends AssociativeBoth[F]

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.

Attributes

Companion
object
Supertypes
trait AssociativeBoth[F]
class Object
trait Matchable
class Any
Known subtypes
object IdentityBoth

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
trait IdentityBothSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
trait IdentityCompose[=>:[_, _]] extends AssociativeCompose[=>:]

Attributes

Supertypes
trait AssociativeCompose[=>:]
class Object
trait Matchable
class Any
trait IdentityEither[F[_]] extends AssociativeEither[F]

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.

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
object IdentityEither

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
trait IdentityEitherSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
trait IdentityFlatten[F[_]] extends AssociativeFlatten[F]

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.

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.

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
Self type
object IdentityFlatten

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
trait IdentitySyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
trait Invariant[F[_]]
object Invariant extends LowPriorityInvariantImplicits, InvariantVersionSpecific

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
Invariant.type
trait InvariantSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
trait InvariantVersionSpecific

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
object Invariant
trait Inverse[A] extends PartialInverse[A]

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 identity element and subtraction is an inverse operation, because subtracting any value from itself always returns zero.

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

Attributes

Companion
object
Supertypes
trait PartialInverse[A]
trait Identity[A]
trait Associative[A]
class Object
trait Matchable
class Any
Show all
Known subtypes
trait EqualInverse[A]
object Inverse

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
Inverse.type
trait InverseSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
trait Liftables

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
object Macros
class Validator[A]
trait LowPriorityInvariantImplicits

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
object Invariant
trait LowPriorityNonEmptyListImplicits

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
object NonEmptyList
trait LowPriorityValidationImplicits

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
object ZValidation
trait LowPriorityZNonEmptySetImplicits

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
object ZNonEmptySet
trait LowPriorityZSetImplicits

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
object ZSet
object Macros extends Liftables

Attributes

Supertypes
trait Liftables
class Object
trait Matchable
class Any
Self type
Macros.type
abstract class Newtype[A] extends NewtypeCustom[A]

Attributes

Supertypes
class NewtypeCustom[A]
class Object
trait Matchable
class Any
Known subtypes
class Subtype[A]
object And
object Natural
object Or
abstract class NewtypeCustom[A]

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
class Newtype[A]
class Subtype[A]
object And
object Natural
object Or
class SubtypeCustom[A]
Show all
trait NewtypeFExports

Attributes

Supertypes
class Object
trait Matchable
class Any
trait NewtypeVersionSpecific

Attributes

Supertypes
class Object
trait Matchable
class Any
trait NonEmptyForEach[F[_]] extends ForEach[F]

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.

Attributes

Companion
object
Supertypes
trait ForEach[F]
trait Covariant[F]
trait Invariant[F]
class Object
trait Matchable
class Any
Show all
Known subtypes
object NonEmptyForEach

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
trait NonEmptyForEachSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
sealed trait NonEmptyList[+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.

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.

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
class Cons[A]
class Single[A]
Self type
object NonEmptyList extends LowPriorityNonEmptyListImplicits

Attributes

Companion
trait
Supertypes
trait Sum
trait Mirror
class Object
trait Matchable
class Any
Show all
Self type
trait NonEmptyListSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
final class NonEmptyMap[K, V]

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. Note - this does not attempt to implement all features of map but what the author considers to be the "normal ones".

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Self type
NonEmptyMap[K, V]
object NonEmptyMap

Attributes

Companion
class
Supertypes
class Object
trait Matchable
class Any
Self type
trait NonEmptyMapSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
final class NonEmptySet[A]

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Self type
object NonEmptySet

Attributes

Companion
class
Supertypes
class Object
trait Matchable
class Any
Self type
trait NonEmptySetSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
final class NonEmptySortedMap[K, V]

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. Note - this does not attempt to implement all features of map but what the author considers to be the "normal ones".

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Self type
object NonEmptySortedMap

Attributes

Companion
class
Supertypes
class Object
trait Matchable
class Any
Self type
trait NonEmptySortedMapSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
final class NonEmptySortedSet[A]

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Self type
object NonEmptySortedSet

Attributes

Companion
class
Supertypes
class Object
trait Matchable
class Any
Self type
trait NonEmptySortedSetSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
trait Ord[-A] extends PartialOrd[A]

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.

Attributes

Companion
object
Supertypes
trait PartialOrd[A]
trait Equal[A]
class Object
trait Matchable
class Any
Known subtypes
trait HashOrd[A]
Self type
Ord[A]
object Ord

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
Ord.type
trait OrdSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
sealed trait Ordering extends PartialOrdering

An Ordering is the result of comparing two values. The result may be LessThan, Equals, or GreaterThan.

An Ordering is the result of comparing two values. The result may be LessThan, Equals, or GreaterThan.

Attributes

Companion
object
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
Known subtypes
object Equals
object GreaterThan
object LessThan
Self type
object Ordering

Attributes

Companion
trait
Supertypes
trait Sum
trait Mirror
class Object
trait Matchable
class Any
Self type
Ordering.type
sealed trait ParSeq[+Z <: Unit, +A]

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.

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.

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
class Both[Z, A]
object Empty
class Single[A]
class Then[Z, A]
Self type
ParSeq[Z, A]
object ParSeq

Attributes

Companion
trait
Supertypes
trait Sum
trait Mirror
class Object
trait Matchable
class Any
Self type
ParSeq.type
trait PartialEquivalence[A, B, +E1, +E2]

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait Equivalence[A, B]
Self type
PartialEquivalence[A, B, E1, E2]
object PartialEquivalence

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
trait PartialInverse[A] extends Identity[A]

The PartialInverse 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. There may be an exception, where the result is not defined. For example, for multiplication of reals, one is an identity element and division is an inverse operation, because dividing any value by itself always returns one.

The PartialInverse 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. There may be an exception, where the result is not defined. For example, for multiplication of reals, one is an identity element and division is an inverse operation, because dividing any value by itself always returns one.

Because PartialInverse 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.

Attributes

Companion
object
Supertypes
trait Identity[A]
trait Associative[A]
class Object
trait Matchable
class Any
Known subtypes
trait EqualInverse[A]
trait Inverse[A]
object PartialInverse

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
trait PartialInverseSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
trait PartialOrd[-A] extends Equal[A]

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.

Attributes

Companion
object
Supertypes
trait Equal[A]
class Object
trait Matchable
class Any
Known subtypes
trait HashPartialOrd[A]
trait HashOrd[A]
trait Ord[A]
Self type
object PartialOrd

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
PartialOrd.type
trait PartialOrdSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
sealed trait PartialOrdering extends Product, Serializable

Attributes

Companion
object
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
Known subtypes
trait Ordering
object Equals
object GreaterThan
object LessThan
object Incomparable
Self type
object PartialOrdering

Attributes

Companion
trait
Supertypes
trait Sum
trait Mirror
class Object
trait Matchable
class Any
Self type
trait RightCovariant[<=>[_, _]]

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait Bicovariant[<=>]
trait Divariant[=>:]
final class SafeFunction[-In, +Out] extends In => Out

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.

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.

Attributes

Companion
object
Supertypes
trait In => Out
class Object
trait Matchable
class Any
Self type
SafeFunction[In, Out]
object SafeFunction

Attributes

Companion
class
Supertypes
class Object
trait Matchable
class Any
Self type
abstract class Subtype[A] extends Newtype[A]

Attributes

Supertypes
class Newtype[A]
class NewtypeCustom[A]
class Object
trait Matchable
class Any
Known subtypes
object And
object Natural
object Or
abstract class SubtypeCustom[A] extends NewtypeCustom[A]

Attributes

Supertypes
class NewtypeCustom[A]
class Object
trait Matchable
class Any
trait TestAssertions

Provides versions of assertions from ZIO Test that use Equal, Ord, and Validation.

Provides versions of assertions from ZIO Test that use Equal, Ord, and Validation.

Attributes

Supertypes
class Object
trait Matchable
class Any
sealed trait These[+A, +B] extends Product, Serializable

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.

Attributes

Companion
object
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
Known subtypes
class Both[A, B]
class Left[A]
class Right[B]
Self type
These[A, B]
object These

Attributes

Companion
trait
Supertypes
trait Sum
trait Mirror
class Object
trait Matchable
class Any
Self type
These.type
abstract class Validator[A](f: A => Either[AssertionError, Unit])(implicit evidence$1: FromExpr[A]) extends Liftables

Convience type that helps with defining a Newtype with a custom (so anything that is not expressable with an Assertion) predicate that should be checked during compile-time.

Convience type that helps with defining a Newtype with a custom (so anything that is not expressable with an Assertion) predicate that should be checked during compile-time.

Define this in a separate file then the Newtype itself!

File 1:

import zio.prelude.Validator

object PalindromeValidator extends Validator[String](str =>
 if (str.reverse == str) Right(()) else Left(AssertionError.failure("isPalindrome"))
)

File 2:

type Palindrome = Palindrome.type
object Palindrome extends NewtypeCustom[String] {
 protected def validate(value: Int) = PalindromeValidator.validate(value)

 protected inline def validateInline(inline value: Int) =
  ${ PalindromeValidator.validateInlineImpl('value) }
}

Attributes

Supertypes
trait Liftables
class Object
trait Matchable
class Any
final class ZNonEmptySet[+A, +B]

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.

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.

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Self type
ZNonEmptySet[A, B]
object ZNonEmptySet extends LowPriorityZNonEmptySetImplicits

Attributes

Companion
class
Supertypes
class Object
trait Matchable
class Any
Self type
trait ZNonEmptySetSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
final class ZSet[+A, +B]

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.

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.

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Self type
ZSet[A, B]
object ZSet extends LowPriorityZSetImplicits

Attributes

Companion
class
Supertypes
class Object
trait Matchable
class Any
Self type
ZSet.type
trait ZSetSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
sealed trait ZValidation[+W, +E, +A]

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.

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.

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
class Failure[W, E]
class Success[W, A]
Self type
ZValidation[W, E, A]
object ZValidation extends LowPriorityValidationImplicits

Attributes

Companion
trait
Supertypes
trait Sum
trait Mirror
class Object
trait Matchable
class Any
Show all
Self type
trait Zivariant[Z[_, _, _]]

Abstract over type constructor with 3 parameters: on first as contravariant and on second and third as covariant.

Abstract over type constructor with 3 parameters: on first as contravariant and on second and third as covariant.

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Self type
object Zivariant

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
Zivariant.type
trait ZivariantSyntax

Attributes

Supertypes
class Object
trait Matchable
class Any
object classic

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
classic.type

Inherited classlikes

implicit class AssociativeBothContravariantOps[F[_], A](fa: => F[A])

Provides infix syntax for associative operations for contravariant types.

Provides infix syntax for associative operations for contravariant types.

Attributes

Inherited from:
AssociativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeBothCovariantOps[F[_], A](fa: => F[A])

Provides infix syntax for associative operations for covariant types.

Provides infix syntax for associative operations for covariant types.

Attributes

Inherited from:
AssociativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeBothOps[F[_], A](fa: => F[A])

Provides infix syntax for associative operations for invariant types.

Provides infix syntax for associative operations for invariant types.

Attributes

Inherited from:
AssociativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeBothTuple10Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10]))

Attributes

Inherited from:
AssociativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeBothTuple11Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11]))

Attributes

Inherited from:
AssociativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeBothTuple12Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12]))

Attributes

Inherited from:
AssociativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeBothTuple13Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13]))

Attributes

Inherited from:
AssociativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeBothTuple14Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14]))

Attributes

Inherited from:
AssociativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeBothTuple15Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15]))

Attributes

Inherited from:
AssociativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeBothTuple16Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15], F[T16]))

Attributes

Inherited from:
AssociativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeBothTuple17Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15], F[T16], F[T17]))

Attributes

Inherited from:
AssociativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeBothTuple18Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15], F[T16], F[T17], F[T18]))

Attributes

Inherited from:
AssociativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeBothTuple19Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15], F[T16], F[T17], F[T18], F[T19]))

Attributes

Inherited from:
AssociativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeBothTuple20Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15], F[T16], F[T17], F[T18], F[T19], F[T20]))

Attributes

Inherited from:
AssociativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeBothTuple21Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15], F[T16], F[T17], F[T18], F[T19], F[T20], F[T21]))

Attributes

Inherited from:
AssociativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeBothTuple22Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15], F[T16], F[T17], F[T18], F[T19], F[T20], F[T21], F[T22]))

Attributes

Inherited from:
AssociativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeBothTuple2Ops[F[_], T1, T2](tf: => (F[T1], F[T2]))

Attributes

Inherited from:
AssociativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeBothTuple3Ops[F[_], T1, T2, T3](tf: => (F[T1], F[T2], F[T3]))

Attributes

Inherited from:
AssociativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeBothTuple4Ops[F[_], T1, T2, T3, T4](tf: => (F[T1], F[T2], F[T3], F[T4]))

Attributes

Inherited from:
AssociativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeBothTuple5Ops[F[_], T1, T2, T3, T4, T5](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5]))

Attributes

Inherited from:
AssociativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeBothTuple6Ops[F[_], T1, T2, T3, T4, T5, T6](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6]))

Attributes

Inherited from:
AssociativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeBothTuple7Ops[F[_], T1, T2, T3, T4, T5, T6, T7](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7]))

Attributes

Inherited from:
AssociativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeBothTuple8Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8]))

Attributes

Inherited from:
AssociativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeBothTuple9Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9]))

Attributes

Inherited from:
AssociativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeComposeOps[A, B, =>:[_, _]](ab: A =>: B)

Attributes

Inherited from:
AssociativeComposeSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeEitherContravariantOps[F[_], A](fa: => F[A])

Provides infix syntax for associative operations for contravariant types.

Provides infix syntax for associative operations for contravariant types.

Attributes

Inherited from:
AssociativeEitherSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeEitherCovariantOps[F[_], A](fa: => F[A])

Provides infix syntax for associative operations for covariant types.

Provides infix syntax for associative operations for covariant types.

Attributes

Inherited from:
AssociativeEitherSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeEitherOps[F[_], A](fa: => F[A])

Provides infix syntax for associative operations for invariant types.

Provides infix syntax for associative operations for invariant types.

Attributes

Inherited from:
AssociativeEitherSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeFlattenCovariantOps[F[_], A](fa: F[A])

Provides infix syntax for flattening covariant types.

Provides infix syntax for flattening covariant types.

Attributes

Inherited from:
AssociativeFlattenSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeFlattenOps[F[_], A](ffa: F[F[A]])

Provides infix syntax for flattening types.

Provides infix syntax for flattening types.

Attributes

Inherited from:
AssociativeFlattenSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class AssociativeOps[+A](l: A)

Provides infix syntax for combining two values with an associative operation.

Provides infix syntax for combining two values with an associative operation.

Attributes

Inherited from:
AssociativeSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class BicovariantOps[<=>[_, _], A, B](f: => A <=> B)

Attributes

Inherited from:
BicovariantSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class CommutativeBothContraVariantOps[F[_], A](fa: => F[A])

Provides infix syntax for commutative operations for contravariant types.

Provides infix syntax for commutative operations for contravariant types.

Attributes

Inherited from:
CommutativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class CommutativeBothCovariantOps[F[_], A](fa: => F[A])

Provides infix syntax for commutative operations for covariant types.

Provides infix syntax for commutative operations for covariant types.

Attributes

Inherited from:
CommutativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class CommutativeBothOps[F[_], A](fa: => F[A])

Provides infix syntax for commutative operations for invariant types.

Provides infix syntax for commutative operations for invariant types.

Attributes

Inherited from:
CommutativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class CommutativeBothTuple10Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10]))

Attributes

Inherited from:
CommutativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class CommutativeBothTuple11Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11]))

Attributes

Inherited from:
CommutativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class CommutativeBothTuple12Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12]))

Attributes

Inherited from:
CommutativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class CommutativeBothTuple13Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13]))

Attributes

Inherited from:
CommutativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class CommutativeBothTuple14Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14]))

Attributes

Inherited from:
CommutativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class CommutativeBothTuple15Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15]))

Attributes

Inherited from:
CommutativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class CommutativeBothTuple16Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15], F[T16]))

Attributes

Inherited from:
CommutativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class CommutativeBothTuple17Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15], F[T16], F[T17]))

Attributes

Inherited from:
CommutativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class CommutativeBothTuple18Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15], F[T16], F[T17], F[T18]))

Attributes

Inherited from:
CommutativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class CommutativeBothTuple19Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15], F[T16], F[T17], F[T18], F[T19]))

Attributes

Inherited from:
CommutativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class CommutativeBothTuple20Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15], F[T16], F[T17], F[T18], F[T19], F[T20]))

Attributes

Inherited from:
CommutativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class CommutativeBothTuple21Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15], F[T16], F[T17], F[T18], F[T19], F[T20], F[T21]))

Attributes

Inherited from:
CommutativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class CommutativeBothTuple22Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15], F[T16], F[T17], F[T18], F[T19], F[T20], F[T21], F[T22]))

Attributes

Inherited from:
CommutativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class CommutativeBothTuple2Ops[F[_], T1, T2](tf: => (F[T1], F[T2]))

Attributes

Inherited from:
CommutativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class CommutativeBothTuple3Ops[F[_], T1, T2, T3](tf: => (F[T1], F[T2], F[T3]))

Attributes

Inherited from:
CommutativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class CommutativeBothTuple4Ops[F[_], T1, T2, T3, T4](tf: => (F[T1], F[T2], F[T3], F[T4]))

Attributes

Inherited from:
CommutativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class CommutativeBothTuple5Ops[F[_], T1, T2, T3, T4, T5](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5]))

Attributes

Inherited from:
CommutativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class CommutativeBothTuple6Ops[F[_], T1, T2, T3, T4, T5, T6](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6]))

Attributes

Inherited from:
CommutativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class CommutativeBothTuple7Ops[F[_], T1, T2, T3, T4, T5, T6, T7](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7]))

Attributes

Inherited from:
CommutativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class CommutativeBothTuple8Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8]))

Attributes

Inherited from:
CommutativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class CommutativeBothTuple9Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9]))

Attributes

Inherited from:
CommutativeBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class CommutativeEitherContravariantOps[F[_], A](fa: => F[A])

Provides infix syntax for commutative operations for contravariant types.

Provides infix syntax for commutative operations for contravariant types.

Attributes

Inherited from:
CommutativeEitherSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class CommutativeEitherCovariantOps[F[_], A](fa: => F[A])

Provides infix syntax for commutative operations for covariant types.

Provides infix syntax for commutative operations for covariant types.

Attributes

Inherited from:
CommutativeEitherSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class CommutativeEitherOps[F[_], A](fa: => F[A])

Provides infix syntax for commutative operations for invariant types.

Provides infix syntax for commutative operations for invariant types.

Attributes

Inherited from:
CommutativeEitherSyntax
Supertypes
class Object
trait Matchable
class Any
object Const extends NewtypeF

Attributes

Inherited from:
ConstExports
Supertypes
class NewtypeF
trait instance.NewtypeF
class Object
trait Matchable
class Any
implicit class ContravariantOps[F[_], A](self: F[A])

Provides infix syntax for mapping over covariant values.

Provides infix syntax for mapping over covariant values.

Attributes

Inherited from:
ContravariantSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class CovariantOps[F[_], A](self: F[A])

Provides infix syntax for mapping over covariant values.

Provides infix syntax for mapping over covariant values.

Attributes

Inherited from:
CovariantSyntax
Supertypes
class Object
trait Matchable
class Any
final implicit class DebugInterpolator(_sc: StringContext)

Attributes

Inherited from:
DebugSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class DebugOps[A](self: A)

Attributes

Inherited from:
DebugSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class DivariantOps[=>:[_, _], A, B](f: => A =>: B)

Attributes

Inherited from:
DivariantSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class EqualOps[A](l: A)

Provides infix syntax for comparing two values for equality.

Provides infix syntax for comparing two values for equality.

Attributes

Inherited from:
EqualSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class Flip1Ops[F[_], G[_], A](self: F[G[A]])

Provides infix syntax for flip1.

Provides infix syntax for flip1.

Attributes

Inherited from:
NonEmptyForEachSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class FlipOps[F[_], G[_], A](self: F[G[A]])

Provides infix syntax for flip.

Provides infix syntax for flip.

Attributes

Inherited from:
ForEachSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class ForEachOps[F[_], A](self: F[A])

Provides infix syntax for traversing collections.

Provides infix syntax for traversing collections.

Attributes

Inherited from:
ForEachSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class HashOps[A](a: A)

Provides infix syntax for hashing a value.

Provides infix syntax for hashing a value.

Attributes

Inherited from:
HashSyntax
Supertypes
class Object
trait Matchable
class Any
object Id extends NewtypeF

Attributes

Inherited from:
IdExports
Supertypes
class NewtypeF
trait instance.NewtypeF
class Object
trait Matchable
class Any
implicit class IdentityBothAnyOps[A](a: => A)

Attributes

Inherited from:
IdentityBothSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class IdentityEitherAnyOps(a: Any)

Attributes

Inherited from:
IdentityEitherSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class IdentityOps[A](l: A)

Provides infix syntax for combining two values with an associative operation.

Provides infix syntax for combining two values with an associative operation.

Attributes

Inherited from:
IdentitySyntax
Supertypes
class Object
trait Matchable
class Any
implicit class InvariantOps[F[_], A](self: F[A])

Provides infix syntax for mapping over invariant values.

Provides infix syntax for mapping over invariant values.

Attributes

Inherited from:
InvariantSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class InverseOps[A](l: A)

Provides infix syntax for combining two values with an inverse operation.

Provides infix syntax for combining two values with an inverse operation.

Attributes

Inherited from:
InverseSyntax
Supertypes
class Object
trait Matchable
class Any
abstract class NewtypeF extends instance.NewtypeF

The class of objects corresponding to parameterized newtypes. Users should implement an object that extends this class to create their own 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]

Attributes

Inherited from:
NewtypeFExports
Supertypes
trait instance.NewtypeF
class Object
trait Matchable
class Any
Known subtypes
object Failure
object FailureIn
object FailureOut
object Const
object Id
implicit class NonEmptyForEachOps[F[_], A](self: F[A])

Provides infix syntax for traversing collections.

Provides infix syntax for traversing collections.

Attributes

Inherited from:
NonEmptyForEachSyntax
Supertypes
class Object
trait Matchable
class Any
final implicit class NonEmptyListConsOps[A](self: ::[A])

Attributes

Inherited from:
NonEmptyListSyntax
Supertypes
class Object
trait Matchable
class Any
final implicit class NonEmptyListListOps[A](self: List[A])

Attributes

Inherited from:
NonEmptyListSyntax
Supertypes
class Object
trait Matchable
class Any
final implicit class NonEmptySetIterableOps[A](iterable: Iterable[A])

Attributes

Inherited from:
NonEmptySetSyntax
Supertypes
class Object
trait Matchable
class Any
final implicit class NonEmptySetSetOps[A](self: Set[A])

Attributes

Inherited from:
NonEmptySetSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class OrdOps[A](val l: A)

Provides infix syntax for comparing two values with a total ordering.

Provides infix syntax for comparing two values with a total ordering.

Attributes

Inherited from:
OrdSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class PartialInverseOps[A](l: A)

Provides infix syntax for combining two values with an inverse operation.

Provides infix syntax for combining two values with an inverse operation.

Attributes

Inherited from:
PartialInverseSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class PartialOrdOps[A](val l: A)

Provides infix syntax for comparing two values with a total ordering.

Provides infix syntax for comparing two values with a total ordering.

Attributes

Inherited from:
PartialOrdSyntax
Supertypes
class Object
trait Matchable
class Any
abstract class SubtypeF extends instance.SubtypeF

The class of objects corresponding to parameterized subtypes. Users should implement an object that extends this class to create their own 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]

Attributes

Inherited from:
NewtypeFExports
Supertypes
trait instance.SubtypeF
trait instance.NewtypeF
class Object
trait Matchable
class Any
Known subtypes
object AndF
object AndThen
object Both
object First
object Last
object Max
object Min
object OrF
object Prod
object Sum
Show all
final implicit class ZNonEmptySetMapOps[+A](self: Map[A, Natural])

Attributes

Inherited from:
ZNonEmptySetSyntax
Supertypes
class Object
trait Matchable
class Any
final implicit class ZNonEmptySetNonEmptyMultiSetOps[+A](self: NonEmptyMultiSet[A])

Attributes

Inherited from:
ZNonEmptySetSyntax
Supertypes
class Object
trait Matchable
class Any
final implicit class ZSetMapOps[+A](self: Map[A, Natural])

Attributes

Inherited from:
ZSetSyntax
Supertypes
class Object
trait Matchable
class Any
final implicit class ZSetMultiSetOps[+A](self: MultiSet[A])

Attributes

Inherited from:
ZSetSyntax
Supertypes
class Object
trait Matchable
class Any
implicit class ZivariantOps[Z[_, _, _], R, E, A](f: => Z[R, E, A])

Attributes

Inherited from:
ZivariantSyntax
Supertypes
class Object
trait Matchable
class Any

Types

type <=>[A, B] = Equivalence[A, B]
type AnyF[_] = Any
type DeriveDebug[F[_]] = Derive[F, Debug]
type DeriveEqual[F[_]] = Derive[F, Equal]
type DeriveHash[F[_]] = Derive[F, Hash]
type DeriveInverse[F[_]] = Derive[F, Inverse]
type DeriveOrd[F[_]] = Derive[F, Ord]
type EReader[-R, +E, +A] = ZPure[Nothing, Unit, Unit, R, E, A]
type EState[S, +E, +A] = ZPure[Nothing, S, S, Any, E, A]
type EWriter[+W, +E, +A] = ZPure[W, Unit, Unit, Any, E, A]
type MultiSet[+A] = ZSet[A, Natural]
type Reader[-R, +A] = ZPure[Nothing, Unit, Unit, R, Nothing, A]
type State[S, +A] = ZPure[Nothing, S, S, Any, Nothing, A]
type Validation[+E, +A] = ZValidation[Nothing, E, A]
type Writer[+W, +A] = ZPure[W, Unit, Unit, Any, Nothing, A]

Inherited types

type Const[+A, +B] = newtypeF.Type[A]

Attributes

Inherited from:
ConstExports
type Id[+A] = newtypeF.Type[A]

Attributes

Inherited from:
IdExports

Value members

Concrete fields

val EReader: ZPure.type
val EState: ZPure.type
val EWriter: ZPure.type
val MultiSet: ZSet.type
val Reader: ZPure.type
val State: ZPure.type
val Writer: ZPure.type

Implicits

Inherited implicits

final implicit def AssociativeBothContravariantOps[F[_], A](fa: => F[A]): AssociativeBothContravariantOps[F, A]

Provides infix syntax for associative operations for contravariant types.

Provides infix syntax for associative operations for contravariant types.

Attributes

Inherited from:
AssociativeBothSyntax
final implicit def AssociativeBothCovariantOps[F[_], A](fa: => F[A]): AssociativeBothCovariantOps[F, A]

Provides infix syntax for associative operations for covariant types.

Provides infix syntax for associative operations for covariant types.

Attributes

Inherited from:
AssociativeBothSyntax
final implicit def AssociativeBothOps[F[_], A](fa: => F[A]): AssociativeBothOps[F, A]

Provides infix syntax for associative operations for invariant types.

Provides infix syntax for associative operations for invariant types.

Attributes

Inherited from:
AssociativeBothSyntax
final implicit def AssociativeBothTuple10Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10])): AssociativeBothTuple10Ops[F, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]

Attributes

Inherited from:
AssociativeBothSyntax
final implicit def AssociativeBothTuple11Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11])): AssociativeBothTuple11Ops[F, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]

Attributes

Inherited from:
AssociativeBothSyntax
final implicit def AssociativeBothTuple12Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12])): AssociativeBothTuple12Ops[F, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]

Attributes

Inherited from:
AssociativeBothSyntax
final implicit def AssociativeBothTuple13Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13])): AssociativeBothTuple13Ops[F, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]

Attributes

Inherited from:
AssociativeBothSyntax
final implicit def AssociativeBothTuple14Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14])): AssociativeBothTuple14Ops[F, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]

Attributes

Inherited from:
AssociativeBothSyntax
final implicit def AssociativeBothTuple15Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15])): AssociativeBothTuple15Ops[F, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]

Attributes

Inherited from:
AssociativeBothSyntax
final implicit def AssociativeBothTuple16Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15], F[T16])): AssociativeBothTuple16Ops[F, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]

Attributes

Inherited from:
AssociativeBothSyntax
final implicit def AssociativeBothTuple17Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15], F[T16], F[T17])): AssociativeBothTuple17Ops[F, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]

Attributes

Inherited from:
AssociativeBothSyntax
final implicit def AssociativeBothTuple18Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15], F[T16], F[T17], F[T18])): AssociativeBothTuple18Ops[F, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]

Attributes

Inherited from:
AssociativeBothSyntax
final implicit def AssociativeBothTuple19Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15], F[T16], F[T17], F[T18], F[T19])): AssociativeBothTuple19Ops[F, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]

Attributes

Inherited from:
AssociativeBothSyntax
final implicit def AssociativeBothTuple20Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15], F[T16], F[T17], F[T18], F[T19], F[T20])): AssociativeBothTuple20Ops[F, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]

Attributes

Inherited from:
AssociativeBothSyntax
final implicit def AssociativeBothTuple21Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15], F[T16], F[T17], F[T18], F[T19], F[T20], F[T21])): AssociativeBothTuple21Ops[F, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]

Attributes

Inherited from:
AssociativeBothSyntax
final implicit def AssociativeBothTuple22Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15], F[T16], F[T17], F[T18], F[T19], F[T20], F[T21], F[T22])): AssociativeBothTuple22Ops[F, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]

Attributes

Inherited from:
AssociativeBothSyntax
final implicit def AssociativeBothTuple2Ops[F[_], T1, T2](tf: => (F[T1], F[T2])): AssociativeBothTuple2Ops[F, T1, T2]

Attributes

Inherited from:
AssociativeBothSyntax
final implicit def AssociativeBothTuple3Ops[F[_], T1, T2, T3](tf: => (F[T1], F[T2], F[T3])): AssociativeBothTuple3Ops[F, T1, T2, T3]

Attributes

Inherited from:
AssociativeBothSyntax
final implicit def AssociativeBothTuple4Ops[F[_], T1, T2, T3, T4](tf: => (F[T1], F[T2], F[T3], F[T4])): AssociativeBothTuple4Ops[F, T1, T2, T3, T4]

Attributes

Inherited from:
AssociativeBothSyntax
final implicit def AssociativeBothTuple5Ops[F[_], T1, T2, T3, T4, T5](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5])): AssociativeBothTuple5Ops[F, T1, T2, T3, T4, T5]

Attributes

Inherited from:
AssociativeBothSyntax
final implicit def AssociativeBothTuple6Ops[F[_], T1, T2, T3, T4, T5, T6](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6])): AssociativeBothTuple6Ops[F, T1, T2, T3, T4, T5, T6]

Attributes

Inherited from:
AssociativeBothSyntax
final implicit def AssociativeBothTuple7Ops[F[_], T1, T2, T3, T4, T5, T6, T7](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7])): AssociativeBothTuple7Ops[F, T1, T2, T3, T4, T5, T6, T7]

Attributes

Inherited from:
AssociativeBothSyntax
final implicit def AssociativeBothTuple8Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8])): AssociativeBothTuple8Ops[F, T1, T2, T3, T4, T5, T6, T7, T8]

Attributes

Inherited from:
AssociativeBothSyntax
final implicit def AssociativeBothTuple9Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9])): AssociativeBothTuple9Ops[F, T1, T2, T3, T4, T5, T6, T7, T8, T9]

Attributes

Inherited from:
AssociativeBothSyntax
final implicit def AssociativeComposeOps[A, B, =>:[_, _]](ab: =>:[A, B]): AssociativeComposeOps[A, B, =>:]

Attributes

Inherited from:
AssociativeComposeSyntax
final implicit def AssociativeEitherContravariantOps[F[_], A](fa: => F[A]): AssociativeEitherContravariantOps[F, A]

Provides infix syntax for associative operations for contravariant types.

Provides infix syntax for associative operations for contravariant types.

Attributes

Inherited from:
AssociativeEitherSyntax
final implicit def AssociativeEitherCovariantOps[F[_], A](fa: => F[A]): AssociativeEitherCovariantOps[F, A]

Provides infix syntax for associative operations for covariant types.

Provides infix syntax for associative operations for covariant types.

Attributes

Inherited from:
AssociativeEitherSyntax
final implicit def AssociativeEitherOps[F[_], A](fa: => F[A]): AssociativeEitherOps[F, A]

Provides infix syntax for associative operations for invariant types.

Provides infix syntax for associative operations for invariant types.

Attributes

Inherited from:
AssociativeEitherSyntax
final implicit def AssociativeFlattenCovariantOps[F[_], A](fa: F[A]): AssociativeFlattenCovariantOps[F, A]

Provides infix syntax for flattening covariant types.

Provides infix syntax for flattening covariant types.

Attributes

Inherited from:
AssociativeFlattenSyntax
final implicit def AssociativeFlattenOps[F[_], A](ffa: F[F[A]]): AssociativeFlattenOps[F, A]

Provides infix syntax for flattening types.

Provides infix syntax for flattening types.

Attributes

Inherited from:
AssociativeFlattenSyntax
final implicit def AssociativeOps[A](l: A): AssociativeOps[A]

Provides infix syntax for combining two values with an associative operation.

Provides infix syntax for combining two values with an associative operation.

Attributes

Inherited from:
AssociativeSyntax
final implicit def BicovariantOps[<=>[_, _], A, B](f: => <=>[A, B]): BicovariantOps[<=>, A, B]

Attributes

Inherited from:
BicovariantSyntax
final implicit def CommutativeBothContraVariantOps[F[_], A](fa: => F[A]): CommutativeBothContraVariantOps[F, A]

Provides infix syntax for commutative operations for contravariant types.

Provides infix syntax for commutative operations for contravariant types.

Attributes

Inherited from:
CommutativeBothSyntax
final implicit def CommutativeBothCovariantOps[F[_], A](fa: => F[A]): CommutativeBothCovariantOps[F, A]

Provides infix syntax for commutative operations for covariant types.

Provides infix syntax for commutative operations for covariant types.

Attributes

Inherited from:
CommutativeBothSyntax
final implicit def CommutativeBothOps[F[_], A](fa: => F[A]): CommutativeBothOps[F, A]

Provides infix syntax for commutative operations for invariant types.

Provides infix syntax for commutative operations for invariant types.

Attributes

Inherited from:
CommutativeBothSyntax
final implicit def CommutativeBothTuple10Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10])): CommutativeBothTuple10Ops[F, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]

Attributes

Inherited from:
CommutativeBothSyntax
final implicit def CommutativeBothTuple11Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11])): CommutativeBothTuple11Ops[F, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]

Attributes

Inherited from:
CommutativeBothSyntax
final implicit def CommutativeBothTuple12Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12])): CommutativeBothTuple12Ops[F, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]

Attributes

Inherited from:
CommutativeBothSyntax
final implicit def CommutativeBothTuple13Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13])): CommutativeBothTuple13Ops[F, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]

Attributes

Inherited from:
CommutativeBothSyntax
final implicit def CommutativeBothTuple14Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14])): CommutativeBothTuple14Ops[F, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]

Attributes

Inherited from:
CommutativeBothSyntax
final implicit def CommutativeBothTuple15Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15])): CommutativeBothTuple15Ops[F, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]

Attributes

Inherited from:
CommutativeBothSyntax
final implicit def CommutativeBothTuple16Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15], F[T16])): CommutativeBothTuple16Ops[F, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]

Attributes

Inherited from:
CommutativeBothSyntax
final implicit def CommutativeBothTuple17Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15], F[T16], F[T17])): CommutativeBothTuple17Ops[F, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]

Attributes

Inherited from:
CommutativeBothSyntax
final implicit def CommutativeBothTuple18Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15], F[T16], F[T17], F[T18])): CommutativeBothTuple18Ops[F, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]

Attributes

Inherited from:
CommutativeBothSyntax
final implicit def CommutativeBothTuple19Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15], F[T16], F[T17], F[T18], F[T19])): CommutativeBothTuple19Ops[F, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]

Attributes

Inherited from:
CommutativeBothSyntax
final implicit def CommutativeBothTuple20Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15], F[T16], F[T17], F[T18], F[T19], F[T20])): CommutativeBothTuple20Ops[F, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]

Attributes

Inherited from:
CommutativeBothSyntax
final implicit def CommutativeBothTuple21Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15], F[T16], F[T17], F[T18], F[T19], F[T20], F[T21])): CommutativeBothTuple21Ops[F, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]

Attributes

Inherited from:
CommutativeBothSyntax
final implicit def CommutativeBothTuple22Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9], F[T10], F[T11], F[T12], F[T13], F[T14], F[T15], F[T16], F[T17], F[T18], F[T19], F[T20], F[T21], F[T22])): CommutativeBothTuple22Ops[F, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]

Attributes

Inherited from:
CommutativeBothSyntax
final implicit def CommutativeBothTuple2Ops[F[_], T1, T2](tf: => (F[T1], F[T2])): CommutativeBothTuple2Ops[F, T1, T2]

Attributes

Inherited from:
CommutativeBothSyntax
final implicit def CommutativeBothTuple3Ops[F[_], T1, T2, T3](tf: => (F[T1], F[T2], F[T3])): CommutativeBothTuple3Ops[F, T1, T2, T3]

Attributes

Inherited from:
CommutativeBothSyntax
final implicit def CommutativeBothTuple4Ops[F[_], T1, T2, T3, T4](tf: => (F[T1], F[T2], F[T3], F[T4])): CommutativeBothTuple4Ops[F, T1, T2, T3, T4]

Attributes

Inherited from:
CommutativeBothSyntax
final implicit def CommutativeBothTuple5Ops[F[_], T1, T2, T3, T4, T5](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5])): CommutativeBothTuple5Ops[F, T1, T2, T3, T4, T5]

Attributes

Inherited from:
CommutativeBothSyntax
final implicit def CommutativeBothTuple6Ops[F[_], T1, T2, T3, T4, T5, T6](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6])): CommutativeBothTuple6Ops[F, T1, T2, T3, T4, T5, T6]

Attributes

Inherited from:
CommutativeBothSyntax
final implicit def CommutativeBothTuple7Ops[F[_], T1, T2, T3, T4, T5, T6, T7](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7])): CommutativeBothTuple7Ops[F, T1, T2, T3, T4, T5, T6, T7]

Attributes

Inherited from:
CommutativeBothSyntax
final implicit def CommutativeBothTuple8Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8])): CommutativeBothTuple8Ops[F, T1, T2, T3, T4, T5, T6, T7, T8]

Attributes

Inherited from:
CommutativeBothSyntax
final implicit def CommutativeBothTuple9Ops[F[_], T1, T2, T3, T4, T5, T6, T7, T8, T9](tf: => (F[T1], F[T2], F[T3], F[T4], F[T5], F[T6], F[T7], F[T8], F[T9])): CommutativeBothTuple9Ops[F, T1, T2, T3, T4, T5, T6, T7, T8, T9]

Attributes

Inherited from:
CommutativeBothSyntax
final implicit def CommutativeEitherContravariantOps[F[_], A](fa: => F[A]): CommutativeEitherContravariantOps[F, A]

Provides infix syntax for commutative operations for contravariant types.

Provides infix syntax for commutative operations for contravariant types.

Attributes

Inherited from:
CommutativeEitherSyntax
final implicit def CommutativeEitherCovariantOps[F[_], A](fa: => F[A]): CommutativeEitherCovariantOps[F, A]

Provides infix syntax for commutative operations for covariant types.

Provides infix syntax for commutative operations for covariant types.

Attributes

Inherited from:
CommutativeEitherSyntax
final implicit def CommutativeEitherOps[F[_], A](fa: => F[A]): CommutativeEitherOps[F, A]

Provides infix syntax for commutative operations for invariant types.

Provides infix syntax for commutative operations for invariant types.

Attributes

Inherited from:
CommutativeEitherSyntax
final implicit def ContravariantOps[F[_], A](self: F[A]): ContravariantOps[F, A]

Provides infix syntax for mapping over covariant values.

Provides infix syntax for mapping over covariant values.

Attributes

Inherited from:
ContravariantSyntax
final implicit def CovariantOps[F[_], A](self: F[A]): CovariantOps[F, A]

Provides infix syntax for mapping over covariant values.

Provides infix syntax for mapping over covariant values.

Attributes

Inherited from:
CovariantSyntax
final implicit def DebugInterpolator(_sc: StringContext): DebugInterpolator

Attributes

Inherited from:
DebugSyntax
final implicit def DebugOps[A](self: A): DebugOps[A]

Attributes

Inherited from:
DebugSyntax
final implicit def DivariantOps[=>:[_, _], A, B](f: => =>:[A, B]): DivariantOps[=>:, A, B]

Attributes

Inherited from:
DivariantSyntax
final implicit def EqualOps[A](l: A): EqualOps[A]

Provides infix syntax for comparing two values for equality.

Provides infix syntax for comparing two values for equality.

Attributes

Inherited from:
EqualSyntax
final implicit def Flip1Ops[F[_], G[_], A](self: F[G[A]]): Flip1Ops[F, G, A]

Provides infix syntax for flip1.

Provides infix syntax for flip1.

Attributes

Inherited from:
NonEmptyForEachSyntax
final implicit def FlipOps[F[_], G[_], A](self: F[G[A]]): FlipOps[F, G, A]

Provides infix syntax for flip.

Provides infix syntax for flip.

Attributes

Inherited from:
ForEachSyntax
final implicit def ForEachOps[F[_], A](self: F[A]): ForEachOps[F, A]

Provides infix syntax for traversing collections.

Provides infix syntax for traversing collections.

Attributes

Inherited from:
ForEachSyntax
final implicit def HashOps[A](a: A): HashOps[A]

Provides infix syntax for hashing a value.

Provides infix syntax for hashing a value.

Attributes

Inherited from:
HashSyntax
final implicit def IdentityBothAnyOps[A](a: => A): IdentityBothAnyOps[A]

Attributes

Inherited from:
IdentityBothSyntax
final implicit def IdentityEitherAnyOps(a: Any): IdentityEitherAnyOps

Attributes

Inherited from:
IdentityEitherSyntax
final implicit def IdentityOps[A](l: A): IdentityOps[A]

Provides infix syntax for combining two values with an associative operation.

Provides infix syntax for combining two values with an associative operation.

Attributes

Inherited from:
IdentitySyntax
final implicit def InvariantOps[F[_], A](self: F[A]): InvariantOps[F, A]

Provides infix syntax for mapping over invariant values.

Provides infix syntax for mapping over invariant values.

Attributes

Inherited from:
InvariantSyntax
final implicit def InverseOps[A](l: A): InverseOps[A]

Provides infix syntax for combining two values with an inverse operation.

Provides infix syntax for combining two values with an inverse operation.

Attributes

Inherited from:
InverseSyntax
final implicit def NonEmptyForEachOps[F[_], A](self: F[A]): NonEmptyForEachOps[F, A]

Provides infix syntax for traversing collections.

Provides infix syntax for traversing collections.

Attributes

Inherited from:
NonEmptyForEachSyntax
final implicit def NonEmptyListConsOps[A](self: ::[A]): NonEmptyListConsOps[A]

Attributes

Inherited from:
NonEmptyListSyntax
final implicit def NonEmptyListListOps[A](self: List[A]): NonEmptyListListOps[A]

Attributes

Inherited from:
NonEmptyListSyntax
final implicit def NonEmptySetIterableOps[A](iterable: Iterable[A]): NonEmptySetIterableOps[A]

Attributes

Inherited from:
NonEmptySetSyntax
final implicit def NonEmptySetSetOps[A](self: Set[A]): NonEmptySetSetOps[A]

Attributes

Inherited from:
NonEmptySetSyntax
final implicit def OrdOps[A](l: A): OrdOps[A]

Provides infix syntax for comparing two values with a total ordering.

Provides infix syntax for comparing two values with a total ordering.

Attributes

Inherited from:
OrdSyntax
final implicit def PartialInverseOps[A](l: A): PartialInverseOps[A]

Provides infix syntax for combining two values with an inverse operation.

Provides infix syntax for combining two values with an inverse operation.

Attributes

Inherited from:
PartialInverseSyntax
final implicit def PartialOrdOps[A](l: A): PartialOrdOps[A]

Provides infix syntax for comparing two values with a total ordering.

Provides infix syntax for comparing two values with a total ordering.

Attributes

Inherited from:
PartialOrdSyntax
final implicit def ZNonEmptySetMapOps[A](self: Map[A, Natural]): ZNonEmptySetMapOps[A]

Attributes

Inherited from:
ZNonEmptySetSyntax
final implicit def ZSetMapOps[A](self: Map[A, Natural]): ZSetMapOps[A]

Attributes

Inherited from:
ZSetSyntax
final implicit def ZSetMultiSetOps[A](self: MultiSet[A]): ZSetMultiSetOps[A]

Attributes

Inherited from:
ZSetSyntax
final implicit def ZivariantOps[Z[_, _, _], R, E, A](f: => Z[R, E, A]): ZivariantOps[Z, R, E, A]

Attributes

Inherited from:
ZivariantSyntax
Generated with