object arbitrary extends ArbitraryInstances0 with ArbitraryInstances
Arbitrary instances for cats.data
- Annotations
- @suppressUnusedImportWarningForScalaVersionSpecific()
- Source
- arbitrary.scala
- Alphabetic
- By Inheritance
- arbitrary
- ArbitraryInstances
- ArbitraryInstances0
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- implicit def arbNonEmptyMap[K, A](implicit arg0: Order[K], A: Arbitrary[A], K: Arbitrary[K]): Arbitrary[NonEmptyMap[K, A]]
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- implicit def catLawsCogenForTuple2K[F[_], G[_], A](implicit F: Cogen[F[A]], G: Cogen[G[A]]): Cogen[Tuple2K[F, G, A]]
- implicit def catsLawArbitraryForCokleisliId[A, B](implicit arg0: Arbitrary[A], arg1: Cogen[A], arg2: Arbitrary[B]): Arbitrary[Cokleisli[Id, A, B]]
- implicit def catsLawArbitraryForIndexedStateT[F[_], SA, SB, A](implicit F: Arbitrary[F[(SA) => F[(SB, A)]]]): Arbitrary[IndexedStateT[F, SA, SB, A]]
- Definition Classes
- ArbitraryInstances0
- implicit def catsLawArbitraryForReader[A, B](implicit arg0: Arbitrary[A], arg1: Cogen[A], arg2: Arbitrary[B]): Arbitrary[Reader[A, B]]
- implicit def catsLawArbitraryForState[S, A](implicit arg0: Arbitrary[S], arg1: Cogen[S], arg2: Arbitrary[A]): Arbitrary[State[S, A]]
- implicit def catsLawsArbitraryForAndThen[A, B](implicit F: Arbitrary[(A) => B]): Arbitrary[AndThen[A, B]]
- implicit def catsLawsArbitraryForAppFunc[F[_], A, B](implicit AA: Arbitrary[A], CA: Cogen[A], F: Arbitrary[F[B]], FF: Applicative[F]): Arbitrary[AppFunc[F, A, B]]
- implicit def catsLawsArbitraryForBinested[F[_, _], G[_], H[_], A, B](implicit F: Arbitrary[F[G[A], H[B]]]): Arbitrary[Binested[F, G, H, A, B]]
- implicit def catsLawsArbitraryForChain[A](implicit A: Arbitrary[A]): Arbitrary[Chain[A]]
- implicit def catsLawsArbitraryForCokleisli[F[_], A, B](implicit AFA: Arbitrary[F[A]], CFA: Cogen[F[A]], B: Arbitrary[B]): Arbitrary[Cokleisli[F, A, B]]
- Definition Classes
- ArbitraryInstances0
- implicit def catsLawsArbitraryForConst[A, B](implicit A: Arbitrary[A]): Arbitrary[Const[A, B]]
- implicit def catsLawsArbitraryForEitherK[F[_], G[_], A](implicit F: Arbitrary[F[A]], G: Arbitrary[G[A]]): Arbitrary[EitherK[F, G, A]]
- implicit def catsLawsArbitraryForEitherT[F[_], A, B](implicit F: Arbitrary[F[Either[A, B]]]): Arbitrary[EitherT[F, A, B]]
- implicit def catsLawsArbitraryForEq[A](implicit arg0: Arbitrary[A]): Arbitrary[Eq[A]]
- implicit def catsLawsArbitraryForEquiv[A](implicit arg0: Arbitrary[A]): Arbitrary[Equiv[A]]
- implicit def catsLawsArbitraryForEval[A](implicit arg0: Arbitrary[A]): Arbitrary[Eval[A]]
- implicit def catsLawsArbitraryForFn0[A](implicit arg0: Arbitrary[A]): Arbitrary[() => A]
- implicit def catsLawsArbitraryForFunc[F[_], A, B](implicit AA: Arbitrary[A], CA: Cogen[A], F: Arbitrary[F[B]]): Arbitrary[Func[F, A, B]]
- implicit def catsLawsArbitraryForHash[A](implicit arg0: Hash[A]): Arbitrary[Hash[A]]
- implicit def catsLawsArbitraryForIRWST[F[_], E, L, SA, SB, A](implicit arg0: Applicative[F], F: Arbitrary[(E, SA) => F[(L, SB, A)]]): Arbitrary[IndexedReaderWriterStateT[F, E, L, SA, SB, A]]
- implicit def catsLawsArbitraryForIdT[F[_], A](implicit F: Arbitrary[F[A]]): Arbitrary[IdT[F, A]]
- implicit def catsLawsArbitraryForIor[A, B](implicit A: Arbitrary[A], B: Arbitrary[B]): Arbitrary[Ior[A, B]]
- implicit def catsLawsArbitraryForIorT[F[_], A, B](implicit F: Arbitrary[F[Ior[A, B]]]): Arbitrary[IorT[F, A, B]]
- implicit def catsLawsArbitraryForKleisli[F[_], A, B](implicit AA: Arbitrary[A], CA: Cogen[A], F: Arbitrary[F[B]]): Arbitrary[Kleisli[F, A, B]]
- Definition Classes
- ArbitraryInstances0
- implicit val catsLawsArbitraryForMiniInt: Arbitrary[MiniInt]
- implicit def catsLawsArbitraryForNested[F[_], G[_], A](implicit FG: Arbitrary[F[G[A]]]): Arbitrary[Nested[F, G, A]]
- implicit def catsLawsArbitraryForNonEmptyChain[A](implicit A: Arbitrary[A]): Arbitrary[NonEmptyChain[A]]
- implicit def catsLawsArbitraryForNonEmptyLazyList[A](implicit A: Arbitrary[A]): Arbitrary[data.NonEmptyLazyList[A]]
- Definition Classes
- ArbitraryInstances
- implicit def catsLawsArbitraryForNonEmptyList[A](implicit A: Arbitrary[A]): Arbitrary[NonEmptyList[A]]
- implicit def catsLawsArbitraryForNonEmptySeq[A](implicit A: Arbitrary[A]): Arbitrary[NonEmptySeq[A]]
- implicit def catsLawsArbitraryForNonEmptySet[A](implicit arg0: Order[A], A: Arbitrary[A]): Arbitrary[NonEmptySet[A]]
- implicit def catsLawsArbitraryForNonEmptyVector[A](implicit A: Arbitrary[A]): Arbitrary[NonEmptyVector[A]]
- implicit def catsLawsArbitraryForOneAnd[F[_], A](implicit A: Arbitrary[A], F: Arbitrary[F[A]]): Arbitrary[OneAnd[F, A]]
- implicit def catsLawsArbitraryForOp[Arr[_, _], A, B](implicit Arr: Arbitrary[Arr[B, A]]): Arbitrary[Op[Arr, A, B]]
- implicit def catsLawsArbitraryForOptionT[F[_], A](implicit F: Arbitrary[F[Option[A]]]): Arbitrary[OptionT[F, A]]
- implicit def catsLawsArbitraryForOrder[A](implicit arg0: Arbitrary[A]): Arbitrary[Order[A]]
- implicit def catsLawsArbitraryForOrdering[A](implicit arg0: Arbitrary[A]): Arbitrary[Ordering[A]]
- implicit def catsLawsArbitraryForPartialFunction[A, B](implicit F: Arbitrary[(A) => Option[B]]): Arbitrary[PartialFunction[A, B]]
- implicit def catsLawsArbitraryForPartialOrder[A](implicit arg0: Arbitrary[A]): Arbitrary[PartialOrder[A]]
- implicit def catsLawsArbitraryForPartialOrdering[A](implicit arg0: Arbitrary[A]): Arbitrary[PartialOrdering[A]]
- implicit def catsLawsArbitraryForRepresentableStore[F[_], S, A](implicit R: Aux[F, S], ArbS: Arbitrary[S], ArbFA: Arbitrary[F[A]]): Arbitrary[RepresentableStore[F, S, A]]
- implicit def catsLawsArbitraryForRepresentableStoreT[W[_], F[_], S, A](implicit W: Arbitrary[W[F[A]]], S: Arbitrary[S], F: Aux[F, S]): Arbitrary[RepresentableStoreT[W, F, S, A]]
- implicit def catsLawsArbitraryForShow[A](implicit arg0: Arbitrary[A]): Arbitrary[Show[A]]
- implicit def catsLawsArbitraryForSortedMap[K, V](implicit arg0: Arbitrary[K], arg1: Order[K], arg2: Arbitrary[V]): Arbitrary[SortedMap[K, V]]
- implicit def catsLawsArbitraryForSortedSet[A](implicit arg0: Arbitrary[A], arg1: Order[A]): Arbitrary[SortedSet[A]]
- implicit def catsLawsArbitraryForTuple2K[F[_], G[_], A](implicit F: Arbitrary[F[A]], G: Arbitrary[G[A]]): Arbitrary[Tuple2K[F, G, A]]
- implicit def catsLawsArbitraryForValidated[A, B](implicit A: Arbitrary[A], B: Arbitrary[B]): Arbitrary[Validated[A, B]]
- implicit def catsLawsArbitraryForWriter[L, V](implicit arg0: Arbitrary[L], arg1: Arbitrary[V]): Arbitrary[Writer[L, V]]
- implicit def catsLawsArbitraryForWriterT[F[_], L, V](implicit F: Arbitrary[F[(L, V)]]): Arbitrary[WriterT[F, L, V]]
- Definition Classes
- ArbitraryInstances0
- implicit def catsLawsArbitraryForZipLazyList[A](implicit A: Arbitrary[A]): Arbitrary[ZipLazyList[A]]
- Definition Classes
- ArbitraryInstances
- implicit def catsLawsArbitraryForZipList[A](implicit A: Arbitrary[A]): Arbitrary[ZipList[A]]
- implicit def catsLawsArbitraryForZipNonEmptyList[A](implicit A: Arbitrary[A]): Arbitrary[ZipNonEmptyList[A]]
- implicit def catsLawsArbitraryForZipNonEmptyVector[A](implicit A: Arbitrary[A]): Arbitrary[ZipNonEmptyVector[A]]
- implicit def catsLawsArbitraryForZipSeq[A](implicit A: Arbitrary[A]): Arbitrary[ZipSeq[A]]
- implicit def catsLawsArbitraryForZipVector[A](implicit A: Arbitrary[A]): Arbitrary[ZipVector[A]]
- implicit def catsLawsCogenForAndThen[A, B](implicit F: Cogen[(A) => B]): Cogen[AndThen[A, B]]
- implicit def catsLawsCogenForChain[A](implicit A: Cogen[A]): Cogen[Chain[A]]
- implicit def catsLawsCogenForConst[A, B](implicit A: Cogen[A]): Cogen[Const[A, B]]
- implicit def catsLawsCogenForEitherK[F[_], G[_], A](implicit F: Cogen[F[A]], G: Cogen[G[A]]): Cogen[EitherK[F, G, A]]
- implicit def catsLawsCogenForEitherT[F[_], A, B](implicit F: Cogen[F[Either[A, B]]]): Cogen[EitherT[F, A, B]]
- implicit def catsLawsCogenForEval[A](implicit arg0: Cogen[A]): Cogen[Eval[A]]
- implicit def catsLawsCogenForFunction0[A](implicit A: Cogen[A]): Cogen[() => A]
- implicit def catsLawsCogenForIdT[F[_], A](implicit F: Cogen[F[A]]): Cogen[IdT[F, A]]
- implicit def catsLawsCogenForIor[A, B](implicit A: Cogen[A], B: Cogen[B]): Cogen[Ior[A, B]]
- implicit def catsLawsCogenForIorT[F[_], A, B](implicit F: Cogen[F[Ior[A, B]]]): Cogen[IorT[F, A, B]]
- implicit val catsLawsCogenForMiniInt: Cogen[MiniInt]
- implicit def catsLawsCogenForNonEmptyChain[A](implicit A: Cogen[A]): Cogen[NonEmptyChain[A]]
- implicit def catsLawsCogenForNonEmptyLazyList[A](implicit A: Cogen[A]): Cogen[data.NonEmptyLazyList[A]]
- Definition Classes
- ArbitraryInstances
- implicit def catsLawsCogenForNonEmptyList[A](implicit A: Cogen[A]): Cogen[NonEmptyList[A]]
- implicit def catsLawsCogenForNonEmptySeq[A](implicit A: Cogen[A]): Cogen[NonEmptySeq[A]]
- implicit def catsLawsCogenForNonEmptySet[A](implicit arg0: Order[A], arg1: Cogen[A]): Cogen[NonEmptySet[A]]
- implicit def catsLawsCogenForNonEmptyVector[A](implicit A: Cogen[A]): Cogen[NonEmptyVector[A]]
- implicit def catsLawsCogenForOneAnd[F[_], A](implicit A: Cogen[A], F: Cogen[F[A]]): Cogen[OneAnd[F, A]]
- implicit def catsLawsCogenForOp[Arr[_, _], A, B](implicit Arr: Cogen[Arr[B, A]]): Cogen[Op[Arr, A, B]]
- implicit def catsLawsCogenForOptionT[F[_], A](implicit F: Cogen[F[Option[A]]]): Cogen[OptionT[F, A]]
- implicit def catsLawsCogenForRepresentableStore[F[_], S, A](implicit arg0: Representable[F], CA: Cogen[A]): Cogen[RepresentableStore[F, S, A]]
- implicit def catsLawsCogenForRepresentableStoreT[W[_], F[_], S, A](implicit W: Cogen[W[F[A]]], S: Cogen[S]): Cogen[RepresentableStoreT[W, F, S, A]]
- implicit def catsLawsCogenForSortedMap[K, V](implicit arg0: Order[K], arg1: Cogen[K], arg2: Cogen[V]): Cogen[SortedMap[K, V]]
- implicit def catsLawsCogenForSortedSet[A](implicit arg0: Order[A], arg1: Cogen[A]): Cogen[SortedSet[A]]
- implicit val catsLawsCogenForThrowable: Cogen[Throwable]
- implicit def catsLawsCogenForTry[A](implicit A: Cogen[A]): Cogen[Try[A]]
- implicit def catsLawsCogenForValidated[A, B](implicit A: Cogen[A], B: Cogen[B]): Cogen[Validated[A, B]]
- implicit def catsLawsCogenForWriter[L, V](implicit arg0: Cogen[L], arg1: Cogen[V]): Cogen[Writer[L, V]]
- implicit def catsLawsCogenForWriterT[F[_], L, V](implicit F: Cogen[F[(L, V)]]): Cogen[WriterT[F, L, V]]
- Definition Classes
- ArbitraryInstances0
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- implicit def cogenNonEmptyMap[K, A](implicit arg0: Order[K], arg1: Cogen[K], arg2: Cogen[A]): Cogen[NonEmptyMap[K, A]]
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
Deprecated Value Members
- implicit def catsLawsArbitraryForZipStream[A](implicit A: Arbitrary[A]): Arbitrary[ZipStream[A]]
- Definition Classes
- ArbitraryInstances
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0-RC2) Use catsLawsArbitraryForZipLazyList
- def catsLawsCogenForSortedMap[K, V](kOrder: Order[K], kCogen: Cogen[K], vOrder: Order[V], vCogen: Cogen[V]): Cogen[SortedMap[K, V]]
- Annotations
- @deprecated
- Deprecated
(Since version 2.9.0) Preserved for bincompat
- def cogenNonEmptyMap[K, A](kOrder: Order[K], kCogen: Cogen[K], aOrder: Order[A], aCogen: Cogen[A]): Cogen[NonEmptyMap[K, A]]
- Annotations
- @deprecated
- Deprecated
(Since version 2.9.0) Preserved for bincompat