Packages

p

zio

prelude

package prelude

Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. prelude
  2. ZivariantSyntax
  3. ZSetSyntax
  4. ZNonEmptySetSyntax
  5. ForEachSyntax
  6. PartialOrdSyntax
  7. OrdSyntax
  8. NonEmptyForEachSyntax
  9. NonEmptySetSyntax
  10. NonEmptyListSyntax
  11. NewtypeFExports
  12. NewtypeExports
  13. InverseSyntax
  14. InvariantSyntax
  15. IdentityEitherSyntax
  16. IdentityBothSyntax
  17. IdentitySyntax
  18. IdExports
  19. HashSyntax
  20. EqualSyntax
  21. DivariantSyntax
  22. DebugSyntax
  23. ContravariantSyntax
  24. CovariantSyntax
  25. ConstExports
  26. CommutativeEitherSyntax
  27. CommutativeBothSyntax
  28. BicovariantSyntax
  29. AssociativeFlattenSyntax
  30. AssociativeEitherSyntax
  31. AssociativeComposeSyntax
  32. AssociativeBothSyntax
  33. AssociativeSyntax
  34. Assertions
  35. AnyRef
  36. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Package Members

  1. package coherent
  2. package fx
  3. package newtypes
  4. package recursive

Type Members

  1. type <=>[A, B] = Equivalence[A, B]
  2. type AnyF[_] = Any
  3. implicit final class AnySyntax[A] extends AnyVal
  4. sealed trait AnyType[A] extends AnyRef
  5. trait AssertionF[-A[_]] extends AnyRef
  6. implicit final class AssertionSyntax[A] extends AnyVal

    Provides implicit syntax for assertions.

  7. trait Assertions extends AnyRef

    Provides versions of assertions from _ZIO Test_ that use Equal, Ord, and Validation.

  8. trait Associative[A] extends AnyRef

    The Associative[A] type class describes an associative binary operator for a type A.

    The Associative[A] type class describes an associative binary operator for a type A. For example, addition for integers, and string concatenation for strings.

    Associative is at the top of the hierarchy for abstracting over operations to combine types because while there are some operations that are not associative but do obey other laws, it is generally difficult to combine more than two values in interesting ways with these operators, and thus to build solutions to more complicated problems out of solutions to simpler ones.

    For example, the mean of two numbers is an operation that is commutative but not associative. However, the lack of associativity is an indication that we can't combine the means of multiple values in an interesting way with this definition. If we attempt to take the mean of three values we always place twice as much weight on one number as the others, which is rarely what we want.

    If we instead define this operation using a StatsCounter object then means can be combined in ways that are associative, commutative, and have an identity element, supporting much more interesting modes of composition.

  9. trait AssociativeBoth[F[_]] extends AnyRef

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

    Annotations
    @implicitNotFound("No implicit AssociativeBoth defined for ${F}.")
  10. trait AssociativeBothSyntax extends AnyRef
  11. implicit class AssociativeBothContravariantOps[F[-_], A] extends AnyRef

    Provides infix syntax for associative operations for contravariant types.

    Provides infix syntax for associative operations for contravariant types.

    Definition Classes
    AssociativeBothSyntax
  12. implicit class AssociativeBothCovariantOps[F[+_], A] extends AnyRef

    Provides infix syntax for associative operations for covariant types.

    Provides infix syntax for associative operations for covariant types.

    Definition Classes
    AssociativeBothSyntax
  13. implicit class AssociativeBothOps[F[_], A] extends AnyRef

    Provides infix syntax for associative operations for invariant types.

    Provides infix syntax for associative operations for invariant types.

    Definition Classes
    AssociativeBothSyntax
  14. implicit class AssociativeBothTuple10Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  15. implicit class AssociativeBothTuple11Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  16. implicit class AssociativeBothTuple12Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  17. implicit class AssociativeBothTuple13Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  18. implicit class AssociativeBothTuple14Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  19. implicit class AssociativeBothTuple15Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  20. implicit class AssociativeBothTuple16Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  21. implicit class AssociativeBothTuple17Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  22. implicit class AssociativeBothTuple18Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  23. implicit class AssociativeBothTuple19Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  24. implicit class AssociativeBothTuple20Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  25. 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] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  26. 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] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  27. implicit class AssociativeBothTuple2Ops[F[+_], T1, T2] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  28. implicit class AssociativeBothTuple3Ops[F[+_], T1, T2, T3] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  29. implicit class AssociativeBothTuple4Ops[F[+_], T1, T2, T3, T4] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  30. implicit class AssociativeBothTuple5Ops[F[+_], T1, T2, T3, T4, T5] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  31. implicit class AssociativeBothTuple6Ops[F[+_], T1, T2, T3, T4, T5, T6] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  32. implicit class AssociativeBothTuple7Ops[F[+_], T1, T2, T3, T4, T5, T6, T7] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  33. implicit class AssociativeBothTuple8Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  34. implicit class AssociativeBothTuple9Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  35. trait AssociativeCompose[=>:[-_, +_]] extends AnyRef
  36. trait AssociativeComposeSyntax extends AnyRef
  37. implicit class AssociativeComposeOps[A, B, =>:[-_, +_]] extends AnyRef
    Definition Classes
    AssociativeComposeSyntax
  38. trait AssociativeEither[F[_]] extends AnyRef

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

    Annotations
    @implicitNotFound("No implicit AssociativeEither defined for ${F}.")
  39. trait AssociativeEitherSyntax extends AnyRef
  40. implicit class AssociativeEitherContravariantOps[F[-_], A] extends AnyRef

    Provides infix syntax for associative operations for contravariant types.

    Provides infix syntax for associative operations for contravariant types.

    Definition Classes
    AssociativeEitherSyntax
  41. implicit class AssociativeEitherCovariantOps[F[+_], A] extends AnyRef

    Provides infix syntax for associative operations for covariant types.

    Provides infix syntax for associative operations for covariant types.

    Definition Classes
    AssociativeEitherSyntax
  42. implicit class AssociativeEitherOps[F[_], A] extends AnyRef

    Provides infix syntax for associative operations for invariant types.

    Provides infix syntax for associative operations for invariant types.

    Definition Classes
    AssociativeEitherSyntax
  43. trait AssociativeFlatten[F[+_]] extends AnyRef

    AssociativeFlatten describes a type that can be "flattened" in an associative way.

    AssociativeFlatten describes a type that can be "flattened" in an associative way. For example, if we have a list of lists of lists, we can flatten it by either flattening the two inner lists and then flattening the resulting lists, or flattening the two outer lists and then flattening that resulting list. Because the operation is associative, the resulting list is the same either way.

    Annotations
    @implicitNotFound("No implicit AssociativeFlatten defined for ${F}.")
  44. trait AssociativeFlattenSyntax extends AnyRef
  45. implicit class AssociativeFlattenCovariantOps[F[+_], A] extends AnyRef

    Provides infix syntax for flattening covariant types.

    Provides infix syntax for flattening covariant types.

    Definition Classes
    AssociativeFlattenSyntax
  46. implicit class AssociativeFlattenOps[F[+_], A] extends AnyRef

    Provides infix syntax for flattening types.

    Provides infix syntax for flattening types.

    Definition Classes
    AssociativeFlattenSyntax
  47. trait AssociativeLowPriority extends AnyRef
  48. trait AssociativeSyntax extends AnyRef
  49. implicit class AssociativeOps[A] extends AnyRef

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

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

    Definition Classes
    AssociativeSyntax
  50. trait Bicovariant[<=>[+_, +_]] extends RightCovariant[<=>]
  51. trait BicovariantSyntax extends AnyRef
  52. implicit class BicovariantOps[<=>[+_, +_], A, B] extends AnyRef
    Definition Classes
    BicovariantSyntax
  53. trait Commutative[A] extends Associative[A]

    The Commutative type class describes a binary operator for a type A that is both associative and commutative.

    The Commutative type class describes a binary operator for a type A that is both associative and commutative. This means that a1 <> a2 is equal to a2 <> a1 for all values a1 and a2. Examples of commutative operations include addition for integers, but not concatenation for strings.

    Commutative operators are useful because combining values with a commutative operation results in the same value regardless of the order in which values are combined, allowing us to combine values in the order that is most efficient and allowing us to return determinate values even when the order of original values is indeterminate.

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

    Annotations
    @implicitNotFound("No implicit CommutativeBoth defined for ${F}.")
  55. trait CommutativeBothSyntax extends AnyRef
  56. implicit class CommutativeBothContraVariantOps[F[-_], A] extends AnyRef

    Provides infix syntax for commutative operations for contravariant types.

    Provides infix syntax for commutative operations for contravariant types.

    Definition Classes
    CommutativeBothSyntax
  57. implicit class CommutativeBothCovariantOps[F[+_], A] extends AnyRef

    Provides infix syntax for commutative operations for covariant types.

    Provides infix syntax for commutative operations for covariant types.

    Definition Classes
    CommutativeBothSyntax
  58. implicit class CommutativeBothOps[F[_], A] extends AnyRef

    Provides infix syntax for commutative operations for invariant types.

    Provides infix syntax for commutative operations for invariant types.

    Definition Classes
    CommutativeBothSyntax
  59. implicit class CommutativeBothTuple10Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  60. implicit class CommutativeBothTuple11Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  61. implicit class CommutativeBothTuple12Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  62. implicit class CommutativeBothTuple13Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  63. implicit class CommutativeBothTuple14Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  64. implicit class CommutativeBothTuple15Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  65. implicit class CommutativeBothTuple16Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  66. implicit class CommutativeBothTuple17Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  67. implicit class CommutativeBothTuple18Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  68. implicit class CommutativeBothTuple19Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  69. implicit class CommutativeBothTuple20Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  70. 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] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  71. 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] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  72. implicit class CommutativeBothTuple2Ops[F[+_], T1, T2] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  73. implicit class CommutativeBothTuple3Ops[F[+_], T1, T2, T3] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  74. implicit class CommutativeBothTuple4Ops[F[+_], T1, T2, T3, T4] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  75. implicit class CommutativeBothTuple5Ops[F[+_], T1, T2, T3, T4, T5] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  76. implicit class CommutativeBothTuple6Ops[F[+_], T1, T2, T3, T4, T5, T6] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  77. implicit class CommutativeBothTuple7Ops[F[+_], T1, T2, T3, T4, T5, T6, T7] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  78. implicit class CommutativeBothTuple8Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  79. implicit class CommutativeBothTuple9Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  80. 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]].

    Annotations
    @implicitNotFound("No implicit CommutativeEither defined for ${F}.")
  81. trait CommutativeEitherSyntax extends AnyRef
  82. implicit class CommutativeEitherContravariantOps[F[-_], A] extends AnyRef

    Provides infix syntax for commutative operations for contravariant types.

    Provides infix syntax for commutative operations for contravariant types.

    Definition Classes
    CommutativeEitherSyntax
  83. implicit class CommutativeEitherCovariantOps[F[+_], A] extends AnyRef

    Provides infix syntax for commutative operations for covariant types.

    Provides infix syntax for commutative operations for covariant types.

    Definition Classes
    CommutativeEitherSyntax
  84. implicit class CommutativeEitherOps[F[_], A] extends AnyRef

    Provides infix syntax for commutative operations for invariant types.

    Provides infix syntax for commutative operations for invariant types.

    Definition Classes
    CommutativeEitherSyntax
  85. sealed trait Comparison extends Product with Serializable
  86. type Const[+A, +B] = Type[A]
    Definition Classes
    ConstExports
  87. trait ConstExports extends AnyRef
  88. trait Contravariant[F[-_]] extends ContravariantSubset[F, AnyType] with 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.

  89. trait ContravariantSubset[F[-_], Subset[_]] extends AnyRef
  90. trait ContravariantSyntax extends AnyRef
  91. implicit class ContravariantOps[F[-_], A] extends AnyRef

    Provides infix syntax for mapping over covariant values.

    Provides infix syntax for mapping over covariant values.

    Definition Classes
    ContravariantSyntax
  92. trait Covariant[F[+_]] extends CovariantSubset[F, AnyType] with 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.

  93. trait CovariantSubset[F[+_], Subset[_]] extends AnyRef
  94. trait CovariantSyntax extends AnyRef
  95. implicit class CovariantOps[F[+_], A] extends AnyRef

    Provides infix syntax for mapping over covariant values.

    Provides infix syntax for mapping over covariant values.

    Definition Classes
    CovariantSyntax
  96. trait Debug[-A] extends AnyRef
  97. trait DebugSyntax extends AnyRef
  98. implicit final class DebugInterpolator extends AnyRef
    Definition Classes
    DebugSyntax
  99. implicit class DebugOps[A] extends AnyRef
    Definition Classes
    DebugSyntax
  100. trait Derive[F[_], Typeclass[_]] extends AnyRef

    Derive[F, Typeclass] represents a universally quantified function from Typeclass[A] to Typeclass[F[A]] for some F[_].

    Derive[F, Typeclass] represents a universally quantified function from Typeclass[A] to Typeclass[F[A]] for some F[_]. You can think of Derive as a "recipe" for building a Typeclass[F[A]] instance given a Typeclass[A].

    For example, if we know how to compare values of type A for equality then we can compare lists with elements of type A for equality by checking that the length of the lists is the same and each pair of corresponding elements are equal. And we can do this for any type A as long as it has an Equal instance.

    This is used by the library to derive typeclass instances for higher kinded types given typeclass instances for the type they are parameterized on.

  101. type DeriveAssociative[F[_]] = Derive[F, Associative]
  102. type DeriveCommutative[F[_]] = Derive[F, Commutative]
  103. type DeriveDebug[F[_]] = Derive[F, Debug]
  104. type DeriveEqual[F[_]] = Derive[F, Equal]
  105. type DeriveHash[F[_]] = Derive[F, Hash]
  106. type DeriveIdentity[F[_]] = Derive[F, Identity]
  107. type DeriveInverse[F[_]] = Derive[F, Inverse]
  108. type DeriveOrd[F[_]] = Derive[F, Ord]
  109. trait Divariant[=>:[-_, +_]] extends RightCovariant[=>:]
  110. trait DivariantSyntax extends AnyRef
  111. implicit class DivariantOps[=>:[-_, +_], A, B] extends AnyRef
    Definition Classes
    DivariantSyntax
  112. type EReader[-R, +E, +A] = ZPure[Nothing, Unit, Unit, R, E, A]
  113. type EState[S, +E, +A] = ZPure[Nothing, S, S, Any, E, A]
  114. type EWriter[+W, +E, +A] = ZPure[W, Unit, Unit, Any, E, A]
  115. trait Equal[-A] extends AnyRef

    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.

    Annotations
    @implicitNotFound("No implicit Equal defined for ${A}.")
  116. trait EqualSyntax extends AnyRef
  117. implicit class EqualOps[A] extends AnyRef

    Provides infix syntax for comparing two values for equality.

    Provides infix syntax for comparing two values for equality.

    Definition Classes
    EqualSyntax
  118. final case class Equivalence[A, B](to: (A) => B, from: (B) => A) extends Product with Serializable

    An Equivalence[A, B] defines an equivalence between two types A and B.

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

    For example, a List[Byte] is equivalent to a Vector[Byte]. Similarly, a List[Char] is equivalent to a String.

    Equivalences are symmetrical. So if A is equivalent to B, then B is equivalent to A.

    to

    A function that converts an A into a B.

    from

    A function that converts a B into an A.

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

  120. trait ForEachSyntax extends AnyRef
  121. implicit class FlipOps[F[+_], G[+_], A] extends AnyRef

    Provides infix syntax for flip.

    Provides infix syntax for flip.

    Definition Classes
    ForEachSyntax
  122. implicit class ForEachOps[F[+_], A] extends AnyRef

    Provides infix syntax for traversing collections.

    Provides infix syntax for traversing collections.

    Definition Classes
    ForEachSyntax
  123. 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.

    Annotations
    @implicitNotFound("No implicit Hash defined for ${A}.")
  124. trait HashSyntax extends AnyRef
  125. implicit class HashOps[A] extends AnyRef

    Provides infix syntax for hashing a value.

    Provides infix syntax for hashing a value.

    Definition Classes
    HashSyntax
  126. type Id[+A] = Type[A]
    Definition Classes
    IdExports
  127. trait IdExports extends AnyRef
  128. 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.

    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.

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

    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.

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

    Annotations
    @implicitNotFound("No implicit IdentityBoth defined for ${F}.")
  131. trait IdentityBothSyntax extends AnyRef
  132. implicit class IdentityBothAnyOps[A] extends AnyRef
    Definition Classes
    IdentityBothSyntax
  133. trait IdentityCompose[=>:[-_, +_]] extends AssociativeCompose[=>:]
  134. 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.

    Annotations
    @implicitNotFound("No implicit IdentityEither defined for ${F}.")
  135. trait IdentityEitherSyntax extends AnyRef
  136. implicit class IdentityEitherAnyOps extends AnyRef
    Definition Classes
    IdentityEitherSyntax
  137. 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.

    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.

    Annotations
    @implicitNotFound("No implicit IdentityFlatten defined for ${F}.")
  138. trait IdentitySyntax extends AnyRef
  139. implicit class IdentityOps[A] extends AnyRef

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

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

    Definition Classes
    IdentitySyntax
  140. trait Invariant[F[_]] extends AnyRef
  141. trait InvariantSyntax extends AnyRef
  142. implicit class InvariantOps[F[_], A] extends AnyRef

    Provides infix syntax for mapping over invariant values.

    Provides infix syntax for mapping over invariant values.

    Definition Classes
    InvariantSyntax
  143. trait InvariantVersionSpecific extends AnyRef
  144. trait Inverse[A] extends Identity[A]

    The Inverse type class describes an associative binary operator for a type A that has an identity element and an inverse binary operator.

    The Inverse type class describes an associative binary operator for a type A that has an identity element and an inverse binary operator. Combining any value with itself with the inverse operator must return the identity element. For example, for integer addition zero is an identty element and subtraction is an inverse operation, because subtracting any value from itself always returns zero.

    Because Inverse defines a binary rather than a unary operator it can be used to describe inverse operations for types that do not have inverse values. For example, the natural numbers do not have inverses because the set of natural numbers does not include negative numbers. But we can still define a subtraction operation that is the inverse of addition for the natural numbers, since subtracting a number from itself always returns zero.

  145. trait InverseSyntax extends AnyRef
  146. implicit class InverseOps[A] extends AnyRef

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

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

    Definition Classes
    InverseSyntax
  147. trait LowPriorityInvariantImplicits extends AnyRef
  148. trait LowPriorityNonEmptyListImplicits extends AnyRef
  149. trait LowPriorityValidationImplicits extends AnyRef
  150. trait LowPriorityZNonEmptySetImplicits extends AnyRef
  151. trait LowPriorityZSetImplicits extends AnyRef
  152. implicit final class MapSyntax[K, V] extends AnyVal
  153. type MultiSet[+A] = ZSet[A, Natural]
  154. trait NewtypeExports extends AnyRef
  155. abstract class Newtype[A] extends NewtypeModule.Newtype[A]

    The class of objects corresponding to newtypes.

    The class of objects corresponding to newtypes. Users should implement an object that extends this class to create their own newtypes, specifying A as the underlying type to wrap.

    object Meter extends Newtype[Double]
type Meter = Meter.Type
    Definition Classes
    NewtypeExports
  156. abstract class NewtypeSmart[A] extends NewtypeModule.NewtypeSmart[A]

    The class of objects corresponding to newtypes with smart constructors where not all instances of the underlying type are valid instances of the newtype.

    The class of objects corresponding to newtypes with smart constructors where not all instances of the underlying type are valid instances of the newtype. Users should implement an object that extends this class to create their own newtypes, specifying A as the underlying type to wrap and an assertion that valid instances of the underlying type should satisfy.

    object Natural extends NewtypeSmart[Int](isGreaterThanEqualTo(0))
type Natural = Natural.Type
    Definition Classes
    NewtypeExports
  157. abstract class Subtype[A] extends NewtypeModule.Subtype[A]

    The class of objects corresponding to subtypes.

    The class of objects corresponding to subtypes. Users should implement an object that extends this class to create their own subtypes, specifying A as the underlying type to wrap.

    object And extends Subtype[Boolean]
type And = And.Type
    Definition Classes
    NewtypeExports
  158. abstract class SubtypeSmart[A] extends NewtypeModule.SubtypeSmart[A]

    The class of objects corresponding to subtypes with smart constructors where not all instances of the underlying type are valid instances of the subtype.

    The class of objects corresponding to subtypes with smart constructors where not all instances of the underlying type are valid instances of the subtype. Users should implement an object that extends this class to create their own subtypes, specifying A as the underlying type to wrap and an assertion that valid instances of the underlying type should satisfy.

    object Natural extends SubtypeSmart[Int](isGreaterThanEqualTo(0))
type Natural = Natural.Type
    Definition Classes
    NewtypeExports
  159. trait NewtypeFExports extends AnyRef
  160. abstract class NewtypeF extends NewtypeModuleF.NewtypeF

    The class of objects corresponding to parameterized newtypes.

    The class of objects corresponding to parameterized newtypes. Users should implement an object that extends this class to create their own parameterized newtypes

    object Sum extends NewtypeF
type Sum[A] = Sum.Type[A]
    Definition Classes
    NewtypeFExports
  161. abstract class NewtypeSmartF[A[_]] extends NewtypeModuleF.NewtypeSmartF[A]

    The class of objects corresponding to newtypes with smart constructors where not all instances of the underlying type are valid instances of the newtype.

    The class of objects corresponding to newtypes with smart constructors where not all instances of the underlying type are valid instances of the newtype. Users should implement an object that extends this class to create their own newtypes, specifying A as the underlying type to wrap and an assertion that valid instances of the underlying type should satisfy.

    object ShortList extends NewtypeSmart[List](isShorterThan(5))
type ShortList = ShortList.Type
    Definition Classes
    NewtypeFExports
  162. abstract class SubtypeF extends NewtypeModuleF.SubtypeF

    The class of objects corresponding to parameterized subtypes.

    The class of objects corresponding to parameterized subtypes. Users should implement an object that extends this class to create their own parameterized subtypes

    object Sum extends SubtypeF
type Sum[A] = Sum.Type[A]
    Definition Classes
    NewtypeFExports
  163. abstract class SubtypeSmartF[A[_]] extends NewtypeModuleF.SubtypeSmartF[A]

    The class of objects corresponding to subtypes with smart constructors where not all instances of the underlying type are valid instances of the subtype.

    The class of objects corresponding to subtypes with smart constructors where not all instances of the underlying type are valid instances of the subtype. Users should implement an object that extends this class to create their own subtypes, specifying A as the underlying type to wrap and an assertion that valid instances of the underlying type should satisfy.

    object ShortList extends SubtypeSmartF[List](isShorterThan(5))
type ShortList = ShortList.Type
    Definition Classes
    NewtypeFExports
  164. 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.

  165. trait NonEmptyForEachSyntax extends AnyRef
  166. implicit class Flip1Ops[F[+_], G[+_], A] extends AnyRef

    Provides infix syntax for flip1.

    Provides infix syntax for flip1.

    Definition Classes
    NonEmptyForEachSyntax
  167. implicit class NonEmptyForEachOps[F[+_], A] extends AnyRef

    Provides infix syntax for traversing collections.

    Provides infix syntax for traversing collections.

    Definition Classes
    NonEmptyForEachSyntax
  168. sealed trait NonEmptyList[+A] extends AnyRef

    A NonEmptyList[A] is a list of one or more values of type A.

    A NonEmptyList[A] is a list of one or more values of type A. Unlike a List, a NonEmptyList is guaranteed to contain at least one element. This additional structure allows some operations to be defined on NonEmptyList that are not safe on List, such as head and reduceAll.

    For interoperability with Scala's collection library an implicit conversion is provided from NonEmptyList to the :: case of List. Operations that cannot preserve the guarantee that the resulting collection must have at least one element will return a List instead.

  169. trait NonEmptyListSyntax extends AnyRef
  170. implicit final class NonEmptyListConsOps[A] extends AnyRef
    Definition Classes
    NonEmptyListSyntax
  171. implicit final class NonEmptyListListOps[A] extends AnyRef
    Definition Classes
    NonEmptyListSyntax
  172. type NonEmptyMultiSet[+A] = ZNonEmptySet[A, Natural]
  173. final class NonEmptySet[A] extends AnyRef
  174. trait NonEmptySetSyntax extends AnyRef
  175. implicit final class NonEmptySetIterableOps[A] extends AnyRef
    Definition Classes
    NonEmptySetSyntax
  176. implicit final class NonEmptySetSetOps[A] extends AnyRef
    Definition Classes
    NonEmptySetSyntax
  177. 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.

    Annotations
    @implicitNotFound("No implicit Ord defined for ${A}.")
  178. trait OrdSyntax extends AnyRef
  179. implicit class OrdOps[A] extends AnyRef

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

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

    Definition Classes
    OrdSyntax
  180. sealed trait Ordering extends PartialOrdering

    An Ordering is the result of comparing two values.

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

  181. sealed trait ParSeq[+Z <: Unit, +A] extends AnyRef

    ParSeq is a data type that represents some notion of "events" that can take place in parallel or in sequence.

    ParSeq is a data type that represents some notion of "events" that can take place in parallel or in sequence. For example, a ParSeq parameterized on some error type could be used to model the potentially multiple ways that an application can fail. On the other hand, a ParSeq parameterized on some request type could be used to model a collection of requests to external data sources, some of which could be executed in parallel and some of which must be executed sequentially.

  182. final case class PartialEquivalence[A, B, +E1, +E2](to: (A) => Either[E1, B], from: (B) => Either[E2, A]) extends Product with Serializable
    Annotations
    @silent("Unused import")
  183. 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.

    Annotations
    @implicitNotFound("No implicit PartialOrd defined for ${A}.")
  184. trait PartialOrdSyntax extends AnyRef
  185. implicit class PartialOrdOps[A] extends AnyRef

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

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

    Definition Classes
    PartialOrdSyntax
  186. sealed trait PartialOrdering extends Product with Serializable
  187. type Reader[-R, +A] = ZPure[Nothing, Unit, Unit, R, Nothing, A]
  188. trait RightCovariant[<=>[_, +_]] extends AnyRef
  189. 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.

    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.

  190. type State[S, +A] = ZPure[Nothing, S, S, Any, Nothing, A]
  191. sealed trait These[+A, +B] extends AnyRef
  192. type Validation[+E, +A] = ZValidation[Nothing, E, A]
  193. type Writer[+W, +A] = ZPure[W, Unit, Unit, Any, Nothing, A]
  194. final class ZNonEmptySet[+A, +B] extends AnyRef

    Similar to ZSet, a ZNonEmptySet[A, B] is a guaranteed non-empty set of A values where B represents some notion of "how many" A values are included in the set.

    Similar to ZSet, a ZNonEmptySet[A, B] is a guaranteed non-empty set of A values where B represents some notion of "how many" A values are included in the set. This can be the number of times each element appears in the set if B is a natural number, the probability associated with an element in the set if B is a rational number, or even whether an element appears at all if B is a boolean.

  195. trait ZNonEmptySetSyntax extends AnyRef
  196. implicit final class ZNonEmptySetMapOps[+A] extends AnyRef
    Definition Classes
    ZNonEmptySetSyntax
  197. implicit final class ZNonEmptySetNonEmptyMultiSetOps[+A] extends AnyRef
    Definition Classes
    ZNonEmptySetSyntax
  198. final class ZSet[+A, +B] extends AnyRef

    A ZSet[A, B] is a set of A values where B represents some notion of "how many" A values are included in the set.

    A ZSet[A, B] is a set of A values where B represents some notion of "how many" A values are included in the set. This can be the number of times each element appears in the set if B is a natural number, the probability associated with an element in the set if B is a rational number, or even whether an element appears at all if B is a boolean.

  199. trait ZSetSyntax extends AnyRef
  200. implicit final class ZSetMapOps[+A] extends AnyRef
    Definition Classes
    ZSetSyntax
  201. implicit final class ZSetMultiSetOps[+A] extends AnyRef
    Definition Classes
    ZSetSyntax
  202. sealed trait ZValidation[+W, +E, +A] extends AnyRef

    ZValidation represents either a success of type A or a collection of one or more errors of type E along with in either case a log with entries of type W.

    ZValidation represents either a success of type A or a collection of one or more errors of type E along with in either case a log with entries of type W. Unlike Either, ZValidation does not "short circuit" on failures and instead allows accumulating multiple errors. This can be particularly useful in validating data, where we want to attempt to validate all of the data and retain information about all errors that arose, rather than failing at the first error.

  203. trait Zivariant[Z[-_, +_, +_]] extends AnyRef

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

  204. trait ZivariantSyntax extends AnyRef
  205. implicit class ZivariantOps[Z[-_, +_, +_], R, E, A] extends AnyRef
    Definition Classes
    ZivariantSyntax

Value Members

  1. val EReader: ZPure.type
  2. val EState: ZPure.type
  3. val EWriter: ZPure.type
  4. val MultiSet: ZSet.type
  5. val NonEmptyMultiSet: ZNonEmptySet.type
  6. val Reader: ZPure.type
  7. val State: ZPure.type
  8. val Validation: ZValidation.type
  9. val Writer: ZPure.type
  10. val any: Any
  11. def equalTo[A](expected: A)(implicit arg0: Equal[A]): Assertion[A]

    Makes a new assertion that requires a value equal the specified value.

    Makes a new assertion that requires a value equal the specified value.

    Definition Classes
    Assertions
  12. def isFailureV[E](assertion: Assertion[NonEmptyChunk[E]]): Assertion[ZValidation[Any, E, Any]]

    Makes a new assertion that requires a validation failure satisfying a specified assertion.

    Makes a new assertion that requires a validation failure satisfying a specified assertion.

    Definition Classes
    Assertions
  13. def isGreaterThan[A](reference: A)(implicit ord: PartialOrd[A]): Assertion[A]

    Makes a new assertion that requires the value be greater than the specified reference value.

    Makes a new assertion that requires the value be greater than the specified reference value.

    Definition Classes
    Assertions
  14. def isGreaterThanEqualTo[A](reference: A)(implicit ord: PartialOrd[A]): Assertion[A]

    Makes a new assertion that requires the value be greater than or equal to the specified reference value.

    Makes a new assertion that requires the value be greater than or equal to the specified reference value.

    Definition Classes
    Assertions
  15. def isLessThan[A](reference: A)(implicit ord: PartialOrd[A]): Assertion[A]

    Makes a new assertion that requires the value be less than the specified reference value.

    Makes a new assertion that requires the value be less than the specified reference value.

    Definition Classes
    Assertions
  16. def isLessThanEqualTo[A](reference: A)(implicit ord: PartialOrd[A]): Assertion[A]

    Makes a new assertion that requires the value be less than or equal to the specified reference value.

    Makes a new assertion that requires the value be less than or equal to the specified reference value.

    Definition Classes
    Assertions
  17. def isSuccessV[A](assertion: Assertion[A]): Assertion[ZValidation[Any, Any, A]]

    Makes a new assertion that requires a validation failure satisfying a specified assertion.

    Makes a new assertion that requires a validation failure satisfying a specified assertion.

    Definition Classes
    Assertions
  18. object AnyType
  19. object Associative extends AssociativeLowPriority with Lawful[AssociativeEqual]
  20. object AssociativeBoth extends test.laws.LawfulF.Invariant[AssociativeBothDeriveEqualInvariant, Equal]
  21. object AssociativeCompose
  22. object AssociativeEither extends test.laws.LawfulF.Invariant[AssociativeEitherDeriveEqualInvariant, Equal]
  23. object AssociativeFlatten extends test.laws.LawfulF.Covariant[AssociativeFlattenCovariantDeriveEqual, Equal]
  24. object Bicovariant
  25. case object BuildInfo extends Product with Serializable

    This object was generated by sbt-buildinfo.

  26. object Commutative extends Lawful[CommutativeEqual]
  27. object CommutativeBoth extends test.laws.LawfulF.Invariant[CommutativeBothDeriveEqualInvariant, Equal]
  28. object CommutativeEither extends test.laws.LawfulF.Invariant[CommutativeEitherDeriveEqualInvariant, Equal]
  29. object Comparison extends Serializable
  30. object Const extends prelude.NewtypeF
    Definition Classes
    ConstExports
  31. object Contravariant extends test.laws.LawfulF.Contravariant[ContravariantDeriveEqual, Equal]
  32. object Covariant extends test.laws.LawfulF.Covariant[CovariantDeriveEqual, Equal]
  33. object Debug
  34. object Derive
  35. object Divariant
  36. object Equal extends Lawful[Equal]
  37. object Equivalence extends Lawful2[Equivalence, Equal, Equal] with Serializable
  38. object ForEach extends test.laws.LawfulF.Covariant[DeriveEqualForEach, Equal]
  39. object GenFs

    Provides higher kinded generators.

  40. object Gens

    Provides generators for data types from _ZIO Prelude_.

  41. object Hash extends Lawful[Hash]
  42. object Id extends prelude.NewtypeF
    Definition Classes
    IdExports
  43. object Idempotent extends Lawful[EqualIdempotent]
  44. object Identity extends Lawful[EqualIdentity]
  45. object IdentityBoth extends test.laws.LawfulF.Invariant[DeriveEqualIdentityBothInvariant, Equal]
    Annotations
    @silent("Unused import")
  46. object IdentityEither extends test.laws.LawfulF.Invariant[DeriveEqualIdentityEitherInvariant, Equal]
  47. object IdentityFlatten extends test.laws.LawfulF.Covariant[CovariantDeriveEqualIdentityFlatten, Equal]
  48. object Invariant extends LowPriorityInvariantImplicits with InvariantVersionSpecific
  49. object Inverse extends Lawful[EqualInverse]
  50. object NonEmptyForEach extends test.laws.LawfulF.Covariant[DeriveEqualNonEmptyForEach, Equal]
  51. object NonEmptyList extends LowPriorityNonEmptyListImplicits
  52. object NonEmptySet
  53. object Ord extends Lawful[Ord]
  54. object Ordering extends Serializable
  55. object ParSeq
  56. object PartialEquivalence extends Serializable
  57. object PartialOrd extends Lawful[PartialOrd]
  58. object PartialOrdering extends Serializable
  59. object SafeFunction
  60. object These
  61. object ZNonEmptySet extends LowPriorityZNonEmptySetImplicits
  62. object ZSet extends LowPriorityZSetImplicits
  63. object ZValidation extends LowPriorityValidationImplicits
  64. object Zivariant
  65. object classic

Inherited from ZivariantSyntax

Inherited from ZSetSyntax

Inherited from ZNonEmptySetSyntax

Inherited from ForEachSyntax

Inherited from PartialOrdSyntax

Inherited from OrdSyntax

Inherited from NonEmptyForEachSyntax

Inherited from NonEmptySetSyntax

Inherited from NonEmptyListSyntax

Inherited from NewtypeFExports

Inherited from NewtypeExports

Inherited from InverseSyntax

Inherited from InvariantSyntax

Inherited from IdentityEitherSyntax

Inherited from IdentityBothSyntax

Inherited from IdentitySyntax

Inherited from IdExports

Inherited from HashSyntax

Inherited from EqualSyntax

Inherited from DivariantSyntax

Inherited from DebugSyntax

Inherited from ContravariantSyntax

Inherited from CovariantSyntax

Inherited from ConstExports

Inherited from CommutativeEitherSyntax

Inherited from CommutativeBothSyntax

Inherited from BicovariantSyntax

Inherited from AssociativeFlattenSyntax

Inherited from AssociativeEitherSyntax

Inherited from AssociativeComposeSyntax

Inherited from AssociativeBothSyntax

Inherited from AssociativeSyntax

Inherited from Assertions

Inherited from AnyRef

Inherited from Any

Ungrouped