Packages

p

zio

prelude

package prelude

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

Package Members

  1. package coherent
  2. package experimental
  3. package fx
  4. package newtypes
  5. 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 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.

  6. 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()
  7. trait AssociativeBothSyntax extends AnyRef
  8. 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
  9. 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
  10. 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
  11. implicit class AssociativeBothTuple10Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  12. implicit class AssociativeBothTuple11Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  13. implicit class AssociativeBothTuple12Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  14. implicit class AssociativeBothTuple13Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  15. implicit class AssociativeBothTuple14Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  16. implicit class AssociativeBothTuple15Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  17. 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
  18. 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
  19. 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
  20. 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
  21. 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
  22. 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
  23. 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
  24. implicit class AssociativeBothTuple2Ops[F[+_], T1, T2] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  25. implicit class AssociativeBothTuple3Ops[F[+_], T1, T2, T3] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  26. implicit class AssociativeBothTuple4Ops[F[+_], T1, T2, T3, T4] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  27. implicit class AssociativeBothTuple5Ops[F[+_], T1, T2, T3, T4, T5] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  28. implicit class AssociativeBothTuple6Ops[F[+_], T1, T2, T3, T4, T5, T6] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  29. implicit class AssociativeBothTuple7Ops[F[+_], T1, T2, T3, T4, T5, T6, T7] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  30. implicit class AssociativeBothTuple8Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  31. implicit class AssociativeBothTuple9Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9] extends AnyRef
    Definition Classes
    AssociativeBothSyntax
  32. trait AssociativeCompose[=>:[-_, +_]] extends AnyRef
  33. trait AssociativeComposeSyntax extends AnyRef
  34. implicit class AssociativeComposeOps[A, B, =>:[-_, +_]] extends AnyRef
    Definition Classes
    AssociativeComposeSyntax
  35. 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()
  36. trait AssociativeEitherSyntax extends AnyRef
  37. 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
  38. 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
  39. 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
  40. 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()
  41. trait AssociativeFlattenSyntax extends AnyRef
  42. implicit class AssociativeFlattenCovariantOps[F[+_], A] extends AnyRef

    Provides infix syntax for flattening covariant types.

    Provides infix syntax for flattening covariant types.

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

    Provides infix syntax for flattening types.

    Provides infix syntax for flattening types.

    Definition Classes
    AssociativeFlattenSyntax
  44. trait AssociativeLowPriority extends AnyRef
  45. trait AssociativeSyntax extends AnyRef
  46. 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
  47. trait Bicovariant[<=>[+_, +_]] extends RightCovariant[<=>]
  48. trait BicovariantSyntax extends AnyRef
  49. implicit class BicovariantOps[<=>[+_, +_], A, B] extends AnyRef
    Definition Classes
    BicovariantSyntax
  50. 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.

  51. 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()
  52. trait CommutativeBothSyntax extends AnyRef
  53. 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
  54. 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
  55. 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
  56. implicit class CommutativeBothTuple10Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  57. implicit class CommutativeBothTuple11Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  58. implicit class CommutativeBothTuple12Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  59. implicit class CommutativeBothTuple13Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  60. implicit class CommutativeBothTuple14Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  61. implicit class CommutativeBothTuple15Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  62. 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
  63. 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
  64. 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
  65. 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
  66. 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
  67. 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
  68. 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
  69. implicit class CommutativeBothTuple2Ops[F[+_], T1, T2] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  70. implicit class CommutativeBothTuple3Ops[F[+_], T1, T2, T3] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  71. implicit class CommutativeBothTuple4Ops[F[+_], T1, T2, T3, T4] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  72. implicit class CommutativeBothTuple5Ops[F[+_], T1, T2, T3, T4, T5] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  73. implicit class CommutativeBothTuple6Ops[F[+_], T1, T2, T3, T4, T5, T6] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  74. implicit class CommutativeBothTuple7Ops[F[+_], T1, T2, T3, T4, T5, T6, T7] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  75. implicit class CommutativeBothTuple8Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  76. implicit class CommutativeBothTuple9Ops[F[+_], T1, T2, T3, T4, T5, T6, T7, T8, T9] extends AnyRef
    Definition Classes
    CommutativeBothSyntax
  77. 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()
  78. trait CommutativeEitherSyntax extends AnyRef
  79. 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
  80. 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
  81. 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
  82. sealed trait Comparison extends Product with Serializable
  83. type Const[+A, +B] = Type[A]
    Definition Classes
    ConstExports
  84. trait ConstExports extends AnyRef
  85. 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.

  86. trait ContravariantSubset[F[-_], Subset[_]] extends AnyRef
  87. trait ContravariantSyntax extends AnyRef
  88. 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
  89. 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.

  90. trait CovariantSubset[F[+_], Subset[_]] extends AnyRef
  91. trait CovariantSyntax extends AnyRef
  92. 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
  93. trait CustomAssociativeBothSyntax[A] extends AnyRef

    Provides implicit evidence that a data type defines its own implementation of operators defined by AssociativeBothSyntax as extension methods and that the implementations provided by AssociativeBothSyntax should not be used.

  94. trait CustomAssociativeFlattenSyntax[A] extends AnyRef

    Provides implicit evidence that a data type defines its own implementation of operators defined by AssociativeFlattenSyntax as extension methods and that the implementations provided by AssociativeFlattenSyntax should not be used.

  95. trait CustomCovariantSyntax[A] extends AnyRef

    Provides implicit evidence that a data type defines its own implementation of operators defined by CovariantSyntax as extension methods and that the implementations provided by CovariantSyntax should not be used.

  96. trait Debug[-A] extends AnyRef

    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.

  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 DebugVersionSpecific extends AnyRef
  101. 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.

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

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

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

    Provides infix syntax for flip.

    Provides infix syntax for flip.

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

    Provides infix syntax for traversing collections.

    Provides infix syntax for traversing collections.

    Definition Classes
    ForEachSyntax
  124. 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()
  125. trait HashSyntax extends AnyRef
  126. implicit class HashOps[A] extends AnyRef

    Provides infix syntax for hashing a value.

    Provides infix syntax for hashing a value.

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

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

  131. 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()
  132. trait IdentityBothSyntax extends AnyRef
  133. implicit class IdentityBothAnyOps[A] extends AnyRef
    Definition Classes
    IdentityBothSyntax
  134. trait IdentityCompose[=>:[-_, +_]] extends AssociativeCompose[=>:]
  135. 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()
  136. trait IdentityEitherSyntax extends AnyRef
  137. implicit class IdentityEitherAnyOps extends AnyRef
    Definition Classes
    IdentityEitherSyntax
  138. 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()
  139. trait IdentitySyntax extends AnyRef
  140. 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
  141. trait Invariant[F[_]] extends AnyRef
  142. trait InvariantSyntax extends AnyRef
  143. 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
  144. trait InvariantVersionSpecific extends AnyRef
  145. 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.

  146. trait InverseSyntax extends AnyRef
  147. 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
  148. trait LowPriorityInvariantImplicits extends AnyRef
  149. trait LowPriorityNonEmptyListImplicits extends AnyRef
  150. trait LowPriorityValidationImplicits extends AnyRef
  151. trait LowPriorityZNonEmptySetImplicits extends AnyRef
  152. trait LowPriorityZSetImplicits extends AnyRef
  153. implicit final class MapSyntax[K, V] extends AnyVal
  154. type MultiSet[+A] = ZSet[A, Natural]
  155. trait NewtypeCompanionVersionSpecific extends AnyRef
  156. trait NewtypeExports extends AnyRef
  157. 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
  158. 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
  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 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
  162. trait NewtypeVersionSpecific[A] extends AnyRef
  163. 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.

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

    Provides infix syntax for flip1.

    Provides infix syntax for flip1.

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

    Provides infix syntax for traversing collections.

    Provides infix syntax for traversing collections.

    Definition Classes
    NonEmptyForEachSyntax
  167. 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.

  168. trait NonEmptyListSyntax extends AnyRef
  169. implicit final class NonEmptyListConsOps[A] extends AnyRef
    Definition Classes
    NonEmptyListSyntax
  170. implicit final class NonEmptyListListOps[A] extends AnyRef
    Definition Classes
    NonEmptyListSyntax
  171. type NonEmptyMultiSet[+A] = ZNonEmptySet[A, Natural]
  172. final class NonEmptySet[A] extends AnyRef
  173. trait NonEmptySetSyntax extends AnyRef
  174. implicit final class NonEmptySetIterableOps[A] extends AnyRef
    Definition Classes
    NonEmptySetSyntax
  175. implicit final class NonEmptySetSetOps[A] extends AnyRef
    Definition Classes
    NonEmptySetSyntax
  176. sealed trait Not[A] extends AnyRef

    Provides implicit evidence that an instance of A is not in implicit scope.

    Provides implicit evidence that an instance of A is not in implicit scope.

    Annotations
    @implicitAmbiguous()
  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()
  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()
  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. object AnyType
  12. object Associative extends AssociativeLowPriority
  13. object AssociativeBoth
  14. object AssociativeCompose
  15. object AssociativeEither
  16. object AssociativeFlatten
  17. object Bicovariant
  18. case object BuildInfo extends Product with Serializable

    This object was generated by sbt-buildinfo.

  19. object Commutative
  20. object CommutativeBoth
  21. object CommutativeEither
  22. object Comparison extends Serializable
  23. object Const extends prelude.NewtypeF
    Definition Classes
    ConstExports
  24. object Contravariant
  25. object Covariant
  26. object Debug extends DebugVersionSpecific
  27. object Derive
  28. object Divariant
  29. object Equal
  30. object Equivalence extends Serializable
  31. object ForEach
  32. object Hash
  33. object Id extends prelude.NewtypeF
    Definition Classes
    IdExports
  34. object Idempotent
  35. object Identity
  36. object IdentityBoth
    Annotations
    @silent("Unused import")
  37. object IdentityEither
  38. object IdentityFlatten
  39. object Invariant extends LowPriorityInvariantImplicits with InvariantVersionSpecific
  40. object Inverse
  41. object Newtype extends NewtypeCompanionVersionSpecific
    Definition Classes
    NewtypeExports
  42. object NonEmptyForEach
  43. object NonEmptyList extends LowPriorityNonEmptyListImplicits
  44. object NonEmptySet
  45. object Not
  46. object Ord
  47. object Ordering extends Serializable
  48. object ParSeq
  49. object PartialEquivalence extends Serializable
  50. object PartialOrd
  51. object PartialOrdering extends Serializable
  52. object SafeFunction
  53. object These
  54. object ZNonEmptySet extends LowPriorityZNonEmptySetImplicits
  55. object ZSet extends LowPriorityZSetImplicits
  56. object ZValidation extends LowPriorityValidationImplicits
  57. object Zivariant
  58. object classic

Inherited from ZivariantSyntax

Inherited from ZSetSyntax

Inherited from ZNonEmptySetSyntax

Inherited from PartialOrdSyntax

Inherited from OrdSyntax

Inherited from NonEmptySetSyntax

Inherited from NonEmptyListSyntax

Inherited from NonEmptyForEachSyntax

Inherited from NewtypeFExports

Inherited from NewtypeExports

Inherited from InverseSyntax

Inherited from InvariantSyntax

Inherited from IdentitySyntax

Inherited from IdentityEitherSyntax

Inherited from IdentityBothSyntax

Inherited from IdExports

Inherited from HashSyntax

Inherited from ForEachSyntax

Inherited from EqualSyntax

Inherited from DivariantSyntax

Inherited from DebugSyntax

Inherited from CovariantSyntax

Inherited from ContravariantSyntax

Inherited from ConstExports

Inherited from CommutativeBothSyntax

Inherited from BicovariantSyntax

Inherited from AssociativeBothSyntax

Inherited from AssociativeSyntax

Inherited from AnyRef

Inherited from Any

Ungrouped