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 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](implicit arg0: Arbitrary[A]): Arbitrary[Maybe[A]]

implicit def ArraySeqArbitrary[A](implicit arg0: Arbitrary[A]): Arbitrary[ArraySeq[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](implicit arg0: Arbitrary[A]): 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 CoproductArbitrary[F[_], G[_], A](implicit a: Arbitrary[\/[F[A], G[A]]]): Arbitrary[Coproduct[F, G, A]]

implicit def CorecursiveListArbitrary[A](implicit arg0: Arbitrary[A]): Arbitrary[CorecursiveList[A]]

implicit val DigitArbitrary: Arbitrary[Digit]

implicit def DisjunctionArbitrary[A, B](implicit arg0: Arbitrary[A], arg1: Arbitrary[B]): Arbitrary[\/[A, B]]

implicit val DoubleMultiplicationArbitrary: Arbitrary[@@[Double, Multiplication]]

implicit def EitherFirstLeftProjectionArbitrary[A, B](implicit arg0: Arbitrary[A], arg1: Arbitrary[B]): Arbitrary[@@[LeftProjection[A, B], First]]

implicit def EitherFirstRightProjectionArbitrary[A, B](implicit arg0: Arbitrary[A], arg1: Arbitrary[B]): Arbitrary[@@[RightProjection[A, B], First]]

implicit def EitherLastLeftProjectionArbitrary[A, B](implicit arg0: Arbitrary[A], arg1: Arbitrary[B]): Arbitrary[@@[LeftProjection[A, B], Last]]

implicit def EitherLastRightProjectionArbitrary[A, B](implicit arg0: Arbitrary[A], arg1: Arbitrary[B]): Arbitrary[@@[RightProjection[A, B], Last]]

implicit def EitherLeftProjectionArbitrary[A, B](implicit arg0: Arbitrary[A], arg1: Arbitrary[B]): Arbitrary[LeftProjection[A, B]]

implicit def EitherRightProjectionArbitrary[A, B](implicit arg0: Arbitrary[A], arg1: Arbitrary[B]): Arbitrary[RightProjection[A, B]]

implicit def EphemeralStreamArbitrary[A](implicit arg0: Arbitrary[A]): Arbitrary[EphemeralStream[A]]

implicit def FingerArbitrary[V, A](implicit a: Arbitrary[A], measure: Reducer[A, V]): Arbitrary[Finger[V, A]]

implicit def FingerTreeArbitrary[V, A](implicit a: Arbitrary[A], measure: Reducer[A, V]): Arbitrary[FingerTree[V, A]]

implicit def FirstMaybeArbitrary[A](implicit arg0: Arbitrary[A]): Arbitrary[@@[Maybe[A], First]]

implicit def FirstOptionArbitrary[A](implicit arg0: Arbitrary[A]): Arbitrary[@@[Option[A], First]]

implicit val FloatMultiplicationArbitrary: Arbitrary[@@[Float, Multiplication]]

implicit def Function0Arbitrary[A](implicit arg0: Arbitrary[A]): Arbitrary[() ⇒ A]

implicit def FutureArbitrary[A](implicit arg0: Arbitrary[A]): Arbitrary[Future[A]]

implicit def ImmutableArrayArbitrary[A](implicit arg0: Arbitrary[A], arg1: ClassManifest[A]): Arbitrary[ImmutableArray[A]]

implicit def IndSeqArbibrary[A](implicit arg0: Arbitrary[A]): Arbitrary[IndSeq[A]]

implicit val IntMultiplicationArbitrary: Arbitrary[@@[Int, Multiplication]]

implicit def IterableArbitrary[A](implicit arg0: Arbitrary[A]): Arbitrary[Iterable[A]]

implicit def KleisliArbitrary[M[_], A, B](implicit a: Arbitrary[(A) ⇒ M[B]]): Arbitrary[Kleisli[M, A, B]]

implicit def LastMaybeArbitrary[A](implicit arg0: Arbitrary[A]): Arbitrary[@@[Maybe[A], Last]]

implicit def LastOptionArbitrary[A](implicit arg0: Arbitrary[A]): Arbitrary[@@[Option[A], Last]]

implicit val LongMultiplicationArbitrary: Arbitrary[@@[Long, Multiplication]]

implicit def MaxMaybeArbitrary[A](implicit arg0: Arbitrary[A]): Arbitrary[MaxMaybe[A]]

implicit def MaxOptionArbitrary[A](implicit arg0: Arbitrary[A]): Arbitrary[MaxOption[A]]

implicit def MinMaybeArbitrary[A](implicit arg0: Arbitrary[A]): Arbitrary[MinMaybe[A]]

implicit def MinOptionArbitrary[A](implicit arg0: Arbitrary[A]): Arbitrary[MinOption[A]]

implicit def NameArbitrary[A](implicit arg0: Arbitrary[A]): Arbitrary[Name[A]]

implicit def NeedArbitrary[A](implicit arg0: Arbitrary[A]): Arbitrary[Need[A]]

implicit def NodeArbitrary[V, A](implicit a: Arbitrary[A], measure: Reducer[A, V]): Arbitrary[Node[V, A]]

implicit def NonEmptyListArbitrary[A](implicit arg0: Arbitrary[A]): 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 def PromiseArbitrary[A](implicit a: Arbitrary[A], s: Strategy): Arbitrary[Promise[A]]

implicit def RopeArbitrary[A](implicit arg0: Arbitrary[A], arg1: ClassManifest[A]): Arbitrary[Rope[A]]

implicit val ShortMultiplicationArbitrary: Arbitrary[@@[Short, Multiplication]]

implicit def TaskArbitrary[A](implicit arg0: Arbitrary[A]): Arbitrary[Task[A]]

implicit def TreeArbitrary[A](implicit arg0: Arbitrary[A]): Arbitrary[Tree[A]]

implicit def TreeLocArbitrary[A](implicit arg0: Arbitrary[A]): Arbitrary[TreeLoc[A]]

implicit def Tuple1Arbitrary[A](implicit arg0: Arbitrary[A]): Arbitrary[(A)]

implicit val UnitArbitrary: Arbitrary[Unit]

implicit def ValidationArbitrary[A, B](implicit arg0: Arbitrary[A], arg1: Arbitrary[B]): Arbitrary[Validation[A, B]]

implicit def ValueArbitrary[A](implicit arg0: Arbitrary[A]): Arbitrary[Value[A]]

implicit def ZipperArbitrary[A](implicit arg0: Arbitrary[A]): Arbitrary[Zipper[A]]

implicit val arbBigInt: Arbitrary[BigInt]

implicit val arbBigInteger: Arbitrary[BigInteger]

final def asInstanceOf[T0]: T0

Definition Classes: Any

implicit val attrArbitrary: Arbitrary[Attr]

implicit val cdataArbitrary: Arbitrary[CData]

implicit val cdataKindArbitrary: Arbitrary[CDataKind]

def clone(): AnyRef

Attributes: protected[java.lang]
Definition Classes: AnyRef
Annotations: @throws( ... )

implicit def constArbitrary[A, B](implicit arg0: Arbitrary[A]): Arbitrary[Const[A, B]]

implicit val contentArbitrary: Arbitrary[Content]

implicit val cursorArbitrary: Arbitrary[Cursor]

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[F[_], A, B](implicit A: Arbitrary[F[\/[A, B]]]): Arbitrary[EitherT[F, A, B]]

implicit val elementArbitrary: Arbitrary[Element]

final def eq(arg0: AnyRef): Boolean

Definition Classes: AnyRef

def equals(arg0: Any): Boolean

Definition Classes: AnyRef → Any

def finalize(): Unit

Attributes: protected[java.lang]
Definition Classes: AnyRef
Annotations: @throws( classOf[java.lang.Throwable] )

final def getClass(): Class[_]

Definition Classes: AnyRef → Any

implicit val hCursorArbitrary: Arbitrary[HCursor]

def hashCode(): Int

Definition Classes: AnyRef → Any

implicit def heapArbitrary[A](implicit O: Order[A], A: Arbitrary[List[A]]): Arbitrary[Heap[A]]

implicit val historyArbitrary: Arbitrary[History]

implicit def ilistArbitrary[A](implicit A: Arbitrary[List[A]]): Arbitrary[IList[A]]

implicit def indexedStateTArb[F[_], S1, S2, A](implicit A: Arbitrary[(S1) ⇒ F[(S2, A)]]): Arbitrary[IndexedStateT[F, S1, S2, A]]

implicit def indexedStoreTArb[F[_], I, A, B](implicit A: Arbitrary[(F[(A) ⇒ B], I)]): Arbitrary[IndexedStoreT[F, I, A, B]]

implicit def insertionMapArbitrary[A, B](implicit A: Arbitrary[List[(A, B)]]): Arbitrary[InsertionMap[A, B]]

final def isInstanceOf[T0]: Boolean

Definition Classes: Any

implicit def iterateeInputArbitrary[A](implicit arg0: Arbitrary[A]): Arbitrary[Input[A]]

implicit def lazyEitherArb[F[_], A, B](implicit arg0: Arbitrary[A], arg1: Arbitrary[B]): 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, B](implicit arg0: Arbitrary[A], arg1: Arbitrary[B]): Arbitrary[LazyTuple2[A, B]]

implicit def lazyTuple3Arbitrary[A, B, C](implicit arg0: Arbitrary[A], arg1: Arbitrary[B], arg2: Arbitrary[C]): Arbitrary[LazyTuple3[A, B, C]]

implicit def lazyTuple4Arbitrary[A, B, C, D](implicit arg0: Arbitrary[A], arg1: Arbitrary[B], arg2: Arbitrary[C], arg3: Arbitrary[D]): Arbitrary[LazyTuple4[A, B, C, D]]

implicit def listTArb[F[_], A](implicit FA: Arbitrary[F[List[A]]], F: Applicative[F]): Arbitrary[ListT[F, A]]

implicit def maybeTArb[F[_], A](implicit A: Arbitrary[F[Maybe[A]]]): Arbitrary[MaybeT[F, A]]

implicit def monoidCoproductArbitrary[M, N](implicit arg0: Arbitrary[M], arg1: Arbitrary[N]): Arbitrary[:+:[M, N]]

final def ne(arg0: AnyRef): Boolean

Definition Classes: AnyRef

final def notify(): Unit

Definition Classes: AnyRef

final def notifyAll(): Unit

Definition Classes: AnyRef

implicit val nsInfoArbitrary: Arbitrary[NSInfo]

implicit val opArbitrary: Arbitrary[Op]

implicit def optionTArb[F[_], A](implicit A: Arbitrary[F[Option[A]]]): Arbitrary[OptionT[F, A]]

implicit def predicateArbitrary[A](implicit P: Arbitrary[(A) ⇒ Boolean]): Arbitrary[Predicate[A]]

implicit val qnameArbitrary: Arbitrary[QName]

def smallListArb[A](implicit A: Arbitrary[A]): Arbitrary[List[A]]

See also: https://groups.google.com/d/topic/scalacheck/O7e7k5JZKKI

def stateTArb[F[+_], S, A](implicit A: Arbitrary[(S) ⇒ F[(S, A)]]): Arbitrary[StateT[F, S, A]]

def storeTArb[F[+_], A, B](implicit A: Arbitrary[(F[(A) ⇒ B], A)]): Arbitrary[StoreT[F, A, B]]

implicit def streamTArb[F[_], A](implicit FA: Arbitrary[F[Stream[A]]], F: Applicative[F]): Arbitrary[StreamT[F, A]]

final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes: AnyRef

implicit val tagArbitrary: Arbitrary[xml.cursor.Tag]

implicit def theseArb[A, B](implicit arg0: Arbitrary[A], arg1: Arbitrary[B]): Arbitrary[\&/[A, B]]

Since: 7.0.3

def toString(): String

Definition Classes: AnyRef → Any

implicit val tokenArbitrary: Arbitrary[Token]

implicit def unwriterTArb[F[_], U, A](implicit A: Arbitrary[F[(U, A)]]): Arbitrary[UnwriterT[F, U, A]]

final def wait(): Unit

Definition Classes: AnyRef
Annotations: @throws( ... )

final def wait(arg0: Long, arg1: Int): Unit

Definition Classes: AnyRef
Annotations: @throws( ... )

final def wait(arg0: Long): Unit

Definition Classes: AnyRef
Annotations: @throws( ... )

implicit def writerTArb[F[_], W, A](implicit A: Arbitrary[F[(W, A)]]): Arbitrary[WriterT[F, W, A]]

Packages

ScalazArbitrary

object ScalazArbitrary

Value Members

Deprecated Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped