scalaz-scalacheck-binding/scalaz.scalacheck/ScalazArbitrary

ScalazArbitrary

object ScalazArbitrary extends ScalazArbitraryPlatform

Instances of [[scalacheck.Arbitrary]] for many types in Scalaz.

class Object
trait Matchable
class Any

Value members

Concrete methods

def stateTArb[S, F[_], A](implicit A: Arbitrary[S => F[(S, A)]]): Arbitrary[StateT[S, F, A]]
def storeTArb[F[_], A, B](implicit A: Arbitrary[(F[A => B], A)]): Arbitrary[StoreT[F, A, B]]

Implicits

Implicits

implicit
val AlphaArbitrary: Arbitrary[Alpha]
implicit
def Arbitrary_==>>[A, B](implicit o: Order[A], A: Arbitrary[A], B: Arbitrary[B]): Arbitrary[A ==>> B]
Since

7.1.0

implicit
def Arbitrary_ISet[A](implicit o: Order[A], A: Arbitrary[A]): Arbitrary[ISet[A]]
implicit
def Arbitrary_Maybe[A : Arbitrary]: Arbitrary[Maybe[A]]
implicit
val BigIntMultiplicationArbitrary: Arbitrary[BigInt @@ Multiplication]
implicit
val BigIntegerMultiplicationArbitrary: Arbitrary[BigInteger @@ Multiplication]
implicit
val BooleanConjunctionArbitrary: Arbitrary[Boolean @@ Conjunction]
implicit
val ByteMultiplicationArbitrary: Arbitrary[Byte @@ Multiplication]
implicit
def CallableArbitrary[A : Arbitrary]: Arbitrary[Callable[A]]
implicit
def CaseInsensitiveArbitrary[A](implicit A0: Arbitrary[A], A1: FoldCase[A]): Arbitrary[CaseInsensitive[A]]
implicit
val CharMultiplicationArbitrary: Arbitrary[Char @@ Multiplication]
implicit
def CokleisliArbitrary[M[_], A, B](implicit a: Arbitrary[M[A] => B]): Arbitrary[Cokleisli[M, A, B]]
implicit
def CoproductArbitrary[F[_], G[_], A](implicit a: Arbitrary[F[A] \/ G[A]]): Arbitrary[Coproduct[F, G, A]]
implicit
def CorecursiveListArbitrary[A : Arbitrary]: Arbitrary[CorecursiveList[A]]
implicit
val DigitArbitrary: Arbitrary[Digit]
implicit
def DisjunctionArbitrary[A : Arbitrary, B : Arbitrary]: Arbitrary[A \/ B]
implicit
val DoubleMultiplicationArbitrary: Arbitrary[Double @@ Multiplication]
implicit
def EphemeralStreamArbitrary[A : Arbitrary]: Arbitrary[EphemeralStream[A]]
implicit
def FingerArbitrary[V : Monoid, A](implicit evidence$78: Monoid[V], a: Arbitrary[A], measure: Reducer[A, V]): Arbitrary[Finger[V, A]]
implicit
def FingerTreeArbitrary[V : Monoid, A](implicit evidence$80: Monoid[V], a: Arbitrary[A], measure: Reducer[A, V]): Arbitrary[FingerTree[V, A]]
implicit
def FirstMaybeArbitrary[A : Arbitrary]: Arbitrary[Maybe[A] @@ First]
implicit
def FirstOptionArbitrary[A : Arbitrary]: Arbitrary[Option[A] @@ First]
implicit
val FloatMultiplicationArbitrary: Arbitrary[Float @@ Multiplication]
implicit
def Function0Arbitrary[A : Arbitrary]: Arbitrary[() => A]
implicit
def IStreamArbitrary[A : Arbitrary]: Arbitrary[IStream[A]]
implicit
def ImmutableArrayArbitrary[A : ClassTag]: Arbitrary[ImmutableArray[A]]
implicit
def IndSeqArbibrary[A : Arbitrary]: Arbitrary[IndSeq[A]]
implicit
val IntDualArbitrary: Arbitrary[Int @@ Dual]
implicit
val IntMultiplicationArbitrary: Arbitrary[Int @@ Multiplication]
implicit
def IterableArbitrary[A : Arbitrary]: Arbitrary[Iterable[A]]
implicit
def KleisliArbitrary[M[_], A, B](implicit a: Arbitrary[A => M[B]]): Arbitrary[Kleisli[M, A, B]]
implicit
def LastMaybeArbitrary[A : Arbitrary]: Arbitrary[Maybe[A] @@ Last]
implicit
def LastOptionArbitrary[A : Arbitrary]: Arbitrary[Option[A] @@ Last]
implicit
val LongMultiplicationArbitrary: Arbitrary[Long @@ Multiplication]
implicit
def MaxMaybeArbitrary[A : Arbitrary]: Arbitrary[MaxMaybe[A]]
implicit
def MaxOptionArbitrary[A : Arbitrary]: Arbitrary[MaxOption[A]]
implicit
def MinMaybeArbitrary[A : Arbitrary]: Arbitrary[MinMaybe[A]]
implicit
def MinOptionArbitrary[A : Arbitrary]: Arbitrary[MinOption[A]]
implicit
def NameArbitrary[A : Arbitrary]: Arbitrary[Name[A]]
implicit
def NeedArbitrary[A : Arbitrary]: Arbitrary[Need[A]]
implicit
def NodeArbitrary[V : Monoid, A](implicit evidence$79: Monoid[V], a: Arbitrary[A], measure: Reducer[A, V]): Arbitrary[Node[V, A]]
implicit
def NonEmptyListArbitrary[A : Arbitrary]: Arbitrary[NonEmptyList[A]]
implicit
def OneAndArbitrary[F[_], A](implicit A: Arbitrary[A], FA: Arbitrary[F[A]]): Arbitrary[OneAnd[F, A]]
Since

7.0.3

implicit
def OneOrArbitrary[F[_], A](implicit A: Arbitrary[A], FA: Arbitrary[F[A]]): Arbitrary[OneOr[F, A]]
Since

7.0.3

implicit
val OrderingArbitrary: Arbitrary[Ordering]
implicit
val ShortMultiplicationArbitrary: Arbitrary[Short @@ Multiplication]
implicit
def StrictTreeArbitrary[A : Arbitrary]: Arbitrary[StrictTree[A]]
implicit
def TreeArbitrary[A : Arbitrary]: Arbitrary[Tree[A]]
implicit
def TreeLocArbitrary[A : Arbitrary]: Arbitrary[TreeLoc[A]]
implicit
def Tuple1Arbitrary[A : Arbitrary]: Arbitrary[(A)]
implicit
val UnitArbitrary: Arbitrary[Unit]
implicit
def ValidationArbitrary[A : Arbitrary, B : Arbitrary]: Arbitrary[Validation[A, B]]
implicit
def ValueArbitrary[A : Arbitrary]: Arbitrary[Value[A]]
implicit
def ZipperArbitrary[A : Arbitrary]: Arbitrary[Zipper[A]]
implicit
def alterArbitrary[F[_], A](implicit F: Arbitrary[F[A]]): Arbitrary[Alter[F, A]]
implicit
def apArbitrary[F[_], A](implicit F: Arbitrary[F[A]]): Arbitrary[Ap[F, A]]
implicit
val arbBigInt: Arbitrary[BigInt]
implicit
val arbBigInteger: Arbitrary[BigInteger]
implicit
def cogenAlter[F[_], A](implicit F: Cogen[F[A]]): Cogen[Alter[F, A]]
implicit
def cogenAp[F[_], A](implicit F: Cogen[F[A]]): Cogen[Ap[F, A]]
implicit
def cogenCokleisli[F[_], A, B](implicit F: Cogen[F[A] => B]): Cogen[Cokleisli[F, A, B]]
implicit
def cogenConst[A, B](implicit A: Cogen[A]): Cogen[Const[A, B]]
implicit
def cogenContravariantCoyoneda[F[_] : Contravariant, A](implicit evidence$22: Contravariant[F], F: Cogen[F[A]]): Cogen[ContravariantCoyoneda[F, A]]
implicit
def cogenCoproduct[F[_], G[_], A](implicit A: Cogen[F[A] \/ G[A]]): Cogen[Coproduct[F, G, A]]
implicit
def cogenCoyoneda[F[_] : Functor, A](implicit evidence$29: Functor[F], F: Cogen[F[A]]): Cogen[Coyoneda[F, A]]
implicit
def cogenDList[A : Cogen]: Cogen[DList[A]]
implicit
def cogenDequeue[A : Cogen]: Cogen[Dequeue[A]]
implicit
def cogenDiev[A : Cogen]: Cogen[Diev[A]]
implicit
def cogenDisjunction[A, B](implicit A: Cogen[A], B: Cogen[B]): Cogen[A \/ B]
implicit
def cogenEither3[A1 : Cogen, A2 : Cogen, A3 : Cogen]: Cogen[Either3[A1, A2, A3]]
implicit
def cogenEitherT[A, F[_], B](implicit F: Cogen[F[A \/ B]]): Cogen[EitherT[A, F, B]]
implicit
def cogenEndo[A](implicit A: Cogen[A => A]): Cogen[Endo[A]]
implicit
def cogenEndomorphic[F[_, _], A](implicit F: Cogen[F[A, A]]): Cogen[Endomorphic[F, A]]
implicit
def cogenEphemeralStream[A : Cogen]: Cogen[EphemeralStream[A]]
implicit
def cogenHeap[A : Cogen]: Cogen[Heap[A]]
implicit
def cogenIList[A : Cogen]: Cogen[IList[A]]
implicit
def cogenIMap[A : Cogen, B : Cogen]: Cogen[A ==>> B]
implicit
def cogenISet[A : Cogen]: Cogen[ISet[A]]
implicit
def cogenIdT[F[_], A](implicit F: Cogen[F[A]]): Cogen[IdT[F, A]]
implicit
def cogenImmutableArray[A : Cogen]: Cogen[ImmutableArray[A]]
implicit
def cogenIndSeq[A : Cogen]: Cogen[IndSeq[A]]
implicit
def cogenIndexedContsT[W[_], R, O, M[_], A](implicit F: Cogen[W[A => M[O]] => M[R]]): Cogen[IndexedContsT[W, R, O, M, A]]
implicit
def cogenIndexedReaderWriterStateT[R, W, S1, S2, F[_] : Monad, A](implicit evidence$24: Monad[F], F: Cogen[(R, S1) => F[(W, A, S2)]]): Cogen[IndexedReaderWriterStateT[R, W, S1, S2, F, A]]
implicit
def cogenIndexedStateT[F[_] : Monad, S1, S2, A](implicit evidence$25: Monad[F], F: Cogen[S1 => F[(S2, A)]]): Cogen[IndexedStateT[S1, S2, F, A]]
implicit
def cogenIndexedStoreT[F[_], I : Cogen, A, B](implicit evidence$21: Cogen[I], F: Cogen[F[A => B]]): Cogen[IndexedStoreT[F, I, A, B]]
implicit
def cogenKleisli[F[_], A, B](implicit F: Cogen[A => F[B]]): Cogen[Kleisli[F, A, B]]
implicit
def cogenLazyEither[A : Cogen, B : Cogen]: Cogen[LazyEither[A, B]]
implicit
def cogenLazyEitherT[F[_], A, B](implicit F: Cogen[F[LazyEither[A, B]]]): Cogen[LazyEitherT[F, A, B]]
implicit
def cogenLazyOption[A : Cogen]: Cogen[LazyOption[A]]
implicit
def cogenLazyOptionT[F[_], A](implicit F: Cogen[F[LazyOption[A]]]): Cogen[LazyOptionT[F, A]]
implicit
def cogenLazyTuple2[A1 : Cogen, A2 : Cogen]: Cogen[LazyTuple2[A1, A2]]
implicit
def cogenLazyTuple3[A1 : Cogen, A2 : Cogen, A3 : Cogen]: Cogen[LazyTuple3[A1, A2, A3]]
implicit
def cogenLazyTuple4[A1 : Cogen, A2 : Cogen, A3 : Cogen, A4 : Cogen]: Cogen[LazyTuple4[A1, A2, A3, A4]]
implicit
def cogenMaybe[A : Cogen]: Cogen[Maybe[A]]
implicit
def cogenMaybeT[F[_], A](implicit F: Cogen[F[Maybe[A]]]): Cogen[MaybeT[F, A]]
implicit
def cogenName[A](implicit A: Cogen[A]): Cogen[Name[A]]
implicit
def cogenNeed[A](implicit A: Cogen[A]): Cogen[Need[A]]
implicit
def cogenNonEmptyList[A : Cogen]: Cogen[NonEmptyList[A]]
implicit
def cogenNullArgument[A, B](implicit F: Cogen[Option[A] => B]): Cogen[NullArgument[A, B]]
implicit
def cogenNullResult[A, B](implicit F: Cogen[A => Option[B]]): Cogen[NullResult[A, B]]
implicit
def cogenOneAnd[F[_], A : Cogen](implicit evidence$10: Cogen[A], F: Cogen[F[A]]): Cogen[OneAnd[F, A]]
implicit
def cogenOneOr[F[_], A : Cogen](implicit evidence$9: Cogen[A], F: Cogen[F[A]]): Cogen[OneOr[F, A]]
implicit
def cogenOptionT[F[_], A](implicit F: Cogen[F[Option[A]]]): Cogen[OptionT[F, A]]
implicit
val cogenOrdering: Cogen[Ordering]
implicit
def cogenStreamT[F[_] : Monad, A](implicit evidence$23: Monad[F], F: Cogen[F[Stream[A]]]): Cogen[StreamT[F, A]]
implicit
def cogenStrictTree[A : Cogen]: Cogen[StrictTree[A]]
implicit
def cogenTannen[F[_], G[_, _], A, B](implicit F: Cogen[F[G[A, B]]]): Cogen[Tannen[F, G, A, B]]
implicit
def cogenThese[A, B](implicit A: Cogen[A], B: Cogen[B]): Cogen[A \&/ B]
implicit
def cogenTheseT[F[_], A, B](implicit F: Cogen[F[A \&/ B]]): Cogen[TheseT[F, A, B]]
implicit
def cogenTracedT[W[_], A, B](implicit W: Cogen[W[A => B]]): Cogen[TracedT[W, A, B]]
implicit
def cogenTree[A : Cogen]: Cogen[Tree[A]]
implicit
def cogenTreeLoc[A : Cogen]: Cogen[TreeLoc[A]]
implicit
def cogenUnwriterT[F[_], A, B](implicit F: Cogen[F[(A, B)]]): Cogen[UnwriterT[F, A, B]]
implicit
def cogenValidation[A : Cogen, B : Cogen]: Cogen[Validation[A, B]]
implicit
def cogenValue[A](implicit A: Cogen[A]): Cogen[Value[A]]
implicit
def cogenWriterT[A, F[_], B](implicit F: Cogen[F[(A, B)]]): Cogen[WriterT[A, F, B]]
implicit
def cogenZipper[A](implicit A: Cogen[A]): Cogen[Zipper[A]]
implicit
def constArbitrary[A : Arbitrary, B]: Arbitrary[Const[A, B]]
implicit
def dequeueArbitrary[A](implicit A: Arbitrary[List[A]]): Arbitrary[Dequeue[A]]
implicit
def dievArbitrary[A](implicit A: Arbitrary[List[A]], E: Enum[A]): Arbitrary[Diev[A]]
implicit
def dlistArbitrary[A](implicit A: Arbitrary[List[A]]): Arbitrary[DList[A]]
implicit
def eitherTArb[A, F[_], B](implicit A: Arbitrary[F[A \/ B]]): Arbitrary[EitherT[A, F, B]]
implicit
def endoArb[A](implicit A: Arbitrary[A => A]): Arbitrary[Endo[A]]
implicit
def endoByNameArb[A](implicit A: Arbitrary[A => A]): Arbitrary[EndoByName[A]]
implicit
def endomorphicArbitrary[F[_, _], A](implicit F: Arbitrary[F[A, A]]): Arbitrary[Endomorphic[F, A]]
implicit
def heapArbitrary[A](implicit O: Order[A], A: Arbitrary[List[A]]): Arbitrary[Heap[A]]
implicit
def idTArbitrary[A, F[_]](implicit A: Arbitrary[F[A]]): Arbitrary[IdT[F, A]]
implicit
def ilistArbitrary[A](implicit A: Arbitrary[List[A]]): Arbitrary[IList[A]]
implicit
def indexedContsTArb[W[_], R, O, M[_], A](implicit A: Arbitrary[W[A => M[O]] => M[R]]): Arbitrary[IndexedContsT[W, R, O, M, A]]
implicit
def indexedReaderWriterStateTArb[R, W, S1, S2, F[_], A](implicit A: Arbitrary[(R, S1) => F[(W, A, S2)]]): Arbitrary[IndexedReaderWriterStateT[R, W, S1, S2, F, A]]
implicit
def indexedStateTArb[S1, S2, F[_], A](implicit A: Arbitrary[S1 => F[(S2, A)]]): Arbitrary[IndexedStateT[S1, S2, F, A]]
implicit
def indexedStoreTArb[F[_], I, A, B](implicit A: Arbitrary[(F[A => B], I)]): Arbitrary[IndexedStoreT[F, I, A, B]]
implicit
def iterateeInputArbitrary[A : Arbitrary]: Arbitrary[Input[A]]
implicit
def lazyEitherArb[F[_], A : Arbitrary, B : Arbitrary]: Arbitrary[LazyEither[A, B]]
implicit
def lazyEitherTArb[F[_], A, B](implicit A: Arbitrary[F[LazyEither[A, B]]]): Arbitrary[LazyEitherT[F, A, B]]
implicit
def lazyOptionArb[F[_], A](implicit A: Arbitrary[Option[A]]): Arbitrary[LazyOption[A]]
implicit
def lazyOptionTArb[F[_], A](implicit A: Arbitrary[F[LazyOption[A]]]): Arbitrary[LazyOptionT[F, A]]
implicit
def lazyTuple2Arbitrary[A : Arbitrary, B : Arbitrary]: Arbitrary[LazyTuple2[A, B]]
implicit
def lazyTuple3Arbitrary[A : Arbitrary, B : Arbitrary, C : Arbitrary]: Arbitrary[LazyTuple3[A, B, C]]
implicit
def lazyTuple4Arbitrary[A : Arbitrary, B : Arbitrary, C : Arbitrary, D : Arbitrary]: Arbitrary[LazyTuple4[A, B, C, D]]
implicit
def listTArb[F[_] : Applicative, A](implicit evidence$96: Applicative[F], FA: Arbitrary[F[IList[A]]]): Arbitrary[ListT[F, A]]
implicit
def maybeTArb[F[_], A](implicit A: Arbitrary[F[Maybe[A]]]): Arbitrary[MaybeT[F, A]]
implicit
def monoidCoproductArbitrary[M : Arbitrary, N : Arbitrary]: Arbitrary[M :+: N]
implicit
def optionTArb[F[_], A](implicit A: Arbitrary[F[Option[A]]]): Arbitrary[OptionT[F, A]]
implicit
def streamTArb[F[_], A](implicit FA: Arbitrary[F[Stream[A]]], F: Applicative[F]): Arbitrary[StreamT[F, A]]
implicit
def tannenArbitrary[F[_], G[_, _], A, B](implicit F: Arbitrary[F[G[A, B]]]): Arbitrary[Tannen[F, G, A, B]]
implicit
def theseArb[A : Arbitrary, B : Arbitrary]: Arbitrary[A \&/ B]
Since

7.0.3

implicit
def theseTArb[F[_], A, B](implicit A: Arbitrary[F[A \&/ B]]): Arbitrary[TheseT[F, A, B]]
implicit
def tracedTArb[W[_], A, B](implicit A: Arbitrary[W[A => B]]): Arbitrary[TracedT[W, A, B]]
implicit
def unwriterTArb[F[_], U, A](implicit A: Arbitrary[F[(U, A)]]): Arbitrary[UnwriterT[F, U, A]]
implicit
def writerTArb[W, F[_], A](implicit A: Arbitrary[F[(W, A)]]): Arbitrary[WriterT[W, F, A]]