ScalapropsScalaz

Value Members

1. final def !=(arg0: Any): Boolean

   

   Definition Classes

   AnyRef → Any

2. final def ##(): Int

   

   Definition Classes

   AnyRef → Any

3. final def ==(arg0: Any): Boolean

   

   Definition Classes

   AnyRef → Any

4. implicit def alterGen[F[_], A](implicit F: Gen[F[A]]): Gen[Alter[F, A]]

   

5. implicit def apGen[F[_], A](implicit F: Gen[F[A]]): Gen[Ap[F, A]]

   

6. final def asInstanceOf[T0]: T0

   

   Definition Classes

   Any

7. implicit val asPropertyInstance: Contravariant[AsProperty]

   

8. implicit def bijectionTGen[F[_], G[_], A, B](implicit A: Cogen[A], B: Cogen[B], F: Gen[F[B]], G: Gen[G[A]]): Gen[BijectionT[F, G, A, B]]

   

9. implicit val chooseInstance: InvariantFunctor[Choose]

   

10. def clone(): AnyRef

    

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

11. implicit def codensityGen[F[_], A](implicit arg0: Monad[F], F: Gen[F[A]], A: Gen[A]): Gen[Codensity[F, A]]

    

12. implicit def cogenAlter[F[_], A](implicit F: Cogen[F[A]]): Cogen[Alter[F, A]]

    

13. implicit def cogenAp[F[_], A](implicit F: Cogen[F[A]]): Cogen[Ap[F, A]]

    

14. implicit def cogenBijectionT[F[_], G[_], A, B](implicit A: Gen[A], B: Gen[B], F: Cogen[F[B]], G: Cogen[G[A]]): Cogen[BijectionT[F, G, A, B]]

    

15. implicit val cogenByteIList: Cogen[IList[Byte]]

    

16. implicit def cogenCokleisli[F[_], A, B](implicit F: Cogen[(F[A]) ⇒ B]): Cogen[Cokleisli[F, A, B]]

    

17. implicit def cogenConst[A, B](implicit A: Cogen[A]): Cogen[Const[A, B]]

    

18. implicit def cogenContravariantCoyoneda[F[_], A](implicit arg0: Contravariant[F], F: Cogen[F[A]]): Cogen[ContravariantCoyoneda[F, A]]

    

19. implicit def cogenCoproduct[F[_], G[_], A](implicit A: Cogen[\/[F[A], G[A]]]): Cogen[Coproduct[F, G, A]]

    

20. implicit def cogenCorecursiveList[A](implicit arg0: Cogen[A]): Cogen[CorecursiveList[A]]

    

21. implicit def cogenCoyoneda[F[_], A](implicit arg0: Functor[F], F: Cogen[F[A]]): Cogen[Coyoneda[F, A]]

    

22. implicit def cogenDList[A](implicit arg0: Cogen[A]): Cogen[DList[A]]

    

23. implicit def cogenDequeue[A](implicit arg0: Cogen[A]): Cogen[Dequeue[A]]

    

24. implicit def cogenDiev[A](implicit arg0: Cogen[A]): Cogen[Diev[A]]

    

25. implicit def cogenDisjunction[A, B](implicit A: Cogen[A], B: Cogen[B]): Cogen[\/[A, B]]

    

26. implicit def cogenEither3[A1, A2, A3](implicit arg0: Cogen[A1], arg1: Cogen[A2], arg2: Cogen[A3]): Cogen[Either3[A1, A2, A3]]

    

27. implicit def cogenEitherT[F[_], A, B](implicit F: Cogen[F[\/[A, B]]]): Cogen[EitherT[A, F, B]]

    

28. implicit def cogenEndo[A](implicit arg0: Gen[A], arg1: Cogen[A]): Cogen[Endo[A]]

    

29. implicit final def cogenEndomorphic[F[_, _], A](implicit F: Cogen[F[A, A]]): Cogen[Endomorphic[F, A]]

    

    Definition Classes

    ScalapropsScalaz0

30. implicit def cogenEndomorphicKleisliLike[G[_[_], _, _], F[_], A](implicit F: Cogen[G[F, A, A]]): Cogen[Endomorphic[[a, b]G[F, a, b], A]]

    

31. implicit def cogenEphemeralStream[A](implicit arg0: Cogen[A]): Cogen[EphemeralStream[A]]

    

32. implicit def cogenHeap[A](implicit arg0: Cogen[A]): Cogen[Heap[A]]

    

33. implicit def cogenIList[A](implicit A: Cogen[A]): Cogen[IList[A]]

    

    Definition Classes

    ScalapropsScalaz0

34. implicit def cogenIMap[A, B](implicit arg0: Cogen[A], arg1: Cogen[B]): Cogen[==>>[A, B]]

    

35. implicit def cogenISet[A](implicit arg0: Cogen[A]): Cogen[ISet[A]]

    

36. implicit def cogenIdT[F[_], A](implicit F: Cogen[F[A]]): Cogen[IdT[F, A]]

    

37. implicit def cogenImmutableArray[A](implicit arg0: Cogen[A]): Cogen[ImmutableArray[A]]

    

38. implicit def cogenIndSeq[A](implicit arg0: Cogen[A]): Cogen[IndSeq[A]]

    

39. implicit def cogenIndexedContsT[W[_], M[_], R, O, A](implicit F: Cogen[(W[(A) ⇒ M[O]]) ⇒ M[R]]): Cogen[IndexedContsT[W, R, O, M, A]]

    

40. implicit def cogenIndexedReaderWriterStateT[F[_], R, W, S1, S2, A](implicit arg0: Monad[F], F: Cogen[(R, S1) ⇒ F[(W, A, S2)]]): Cogen[IndexedReaderWriterStateT[R, W, S1, S2, F, A]]

    

41. implicit def cogenIndexedStateT[F[_], S1, S2, A](implicit arg0: Monad[F], F: Cogen[(S1) ⇒ F[(S2, A)]]): Cogen[IndexedStateT[S1, S2, F, A]]

    

42. implicit def cogenIndexedStoreT[F[_], I, A, B](implicit arg0: Cogen[I], F: Cogen[F[(A) ⇒ B]]): Cogen[IndexedStoreT[F, I, A, B]]

    

43. implicit val cogenInstance: Divisible[Cogen]

    

44. implicit def cogenKleisli[F[_], A, B](implicit F: Cogen[(A) ⇒ F[B]]): Cogen[Kleisli[F, A, B]]

    

45. implicit def cogenLazyEither[A, B](implicit arg0: Cogen[A], arg1: Cogen[B]): Cogen[LazyEither[A, B]]

    

46. implicit def cogenLazyEitherT[F[_], A, B](implicit F: Cogen[F[LazyEither[A, B]]]): Cogen[LazyEitherT[F, A, B]]

    

47. implicit def cogenLazyOption[A](implicit arg0: Cogen[A]): Cogen[LazyOption[A]]

    

48. implicit def cogenLazyOptionT[F[_], A](implicit F: Cogen[F[LazyOption[A]]]): Cogen[LazyOptionT[F, A]]

    

49. implicit def cogenLazyTuple2[A1, A2](implicit A1: Cogen[A1], A2: Cogen[A2]): Cogen[LazyTuple2[A1, A2]]

    

50. implicit def cogenLazyTuple3[A1, A2, A3](implicit A1: Cogen[A1], A2: Cogen[A2], A3: Cogen[A3]): Cogen[LazyTuple3[A1, A2, A3]]

    

51. implicit def cogenLazyTuple4[A1, A2, A3, A4](implicit A1: Cogen[A1], A2: Cogen[A2], A3: Cogen[A3], A4: Cogen[A4]): Cogen[LazyTuple4[A1, A2, A3, A4]]

    

52. implicit def cogenMaybe[A](implicit arg0: Cogen[A]): Cogen[Maybe[A]]

    

53. implicit def cogenMaybeT[F[_], A](implicit F: Cogen[F[Maybe[A]]]): Cogen[MaybeT[F, A]]

    

54. implicit def cogenName[A](implicit A: Cogen[A]): Cogen[Name[A]]

    

55. implicit def cogenNeed[A](implicit A: Cogen[A]): Cogen[Need[A]]

    

56. implicit def cogenNonEmptyList[A](implicit arg0: Cogen[A]): Cogen[NonEmptyList[A]]

    

57. implicit def cogenNullArgument[A, B](implicit arg0: Gen[A], arg1: Cogen[B]): Cogen[NullArgument[A, B]]

    

58. implicit def cogenNullResult[A, B](implicit arg0: Gen[A], arg1: Cogen[B]): Cogen[NullResult[A, B]]

    

59. implicit def cogenOneAnd[F[_], A](implicit arg0: Cogen[A], F: Cogen[F[A]]): Cogen[OneAnd[F, A]]

    

60. implicit def cogenOneOr[F[_], A](implicit arg0: Cogen[A], F: Cogen[F[A]]): Cogen[OneOr[F, A]]

    

61. implicit def cogenOptionT[F[_], A](implicit F: Cogen[F[Option[A]]]): Cogen[OptionT[F, A]]

    

62. implicit val cogenOrdering: Cogen[Ordering]

    

63. implicit def cogenSelectT[R, M[_], A](implicit F: Cogen[((A) ⇒ M[R]) ⇒ M[A]]): Cogen[SelectT[R, M, A]]

    

64. implicit val cogenStateInstance: Functor[CogenState]

    

65. implicit def cogenStreamT[F[_], A](implicit arg0: Monad[F], F: Cogen[F[Stream[A]]]): Cogen[StreamT[F, A]]

    

66. implicit def cogenStrictTree[A](implicit arg0: Cogen[A]): Cogen[StrictTree[A]]

    

67. implicit def cogenTannen[F[_], G[_, _], A, B](implicit F: Cogen[F[G[A, B]]]): Cogen[Tannen[F, G, A, B]]

    

68. implicit def cogenThese[A, B](implicit A: Cogen[A], B: Cogen[B]): Cogen[\&/[A, B]]

    

69. implicit def cogenTheseT[F[_], A, B](implicit F: Cogen[F[\&/[A, B]]]): Cogen[TheseT[F, A, B]]

    

70. implicit def cogenTracedT[W[_], A, B](implicit W: Cogen[W[(A) ⇒ B]]): Cogen[TracedT[W, A, B]]

    

71. implicit def cogenTree[A](implicit arg0: Cogen[A]): Cogen[Tree[A]]

    

72. implicit def cogenTreeLoc[A](implicit arg0: Cogen[A]): Cogen[TreeLoc[A]]

    

73. implicit def cogenUnwriterT[F[_], A, B](implicit F: Cogen[F[(A, B)]]): Cogen[UnwriterT[F, A, B]]

    

74. implicit def cogenValidation[A, B](implicit arg0: Cogen[A], arg1: Cogen[B]): Cogen[Validation[A, B]]

    

75. implicit def cogenValue[A](implicit A: Cogen[A]): Cogen[Value[A]]

    

76. implicit def cogenWriterT[F[_], A, B](implicit F: Cogen[F[(A, B)]]): Cogen[WriterT[A, F, B]]

    

77. implicit def cogenZipper[A](implicit A: Cogen[A]): Cogen[Zipper[A]]

    

78. implicit def cokleisliGen[F[_], A, B](implicit F: Gen[(F[A]) ⇒ B]): Gen[Cokleisli[F, A, B]]

    

79. implicit def constGen[A, B](implicit A: Gen[A]): Gen[Const[A, B]]

    

80. implicit def contravariantCoyonedaGen[F[_], A](implicit F: Gen[F[A]]): Gen[ContravariantCoyoneda[F, A]]

    

81. implicit def coproductGen[F[_], G[_], A](implicit F: Gen[\/[F[A], G[A]]]): Gen[Coproduct[F, G, A]]

    

82. implicit def corecursiveListGen[A](implicit arg0: Gen[A]): Gen[CorecursiveList[A]]

    

83. implicit def coyonedaGen[F[_], A](implicit F: Gen[F[A]]): Gen[Coyoneda[F, A]]

    

84. implicit def dequeueGen[A](implicit A: Gen[A]): Gen[Dequeue[A]]

    

85. implicit def dievGen[A](implicit arg0: Gen[A], arg1: Enum[A]): Gen[Diev[A]]

    

86. implicit def disjunctionGen[A, B](implicit A: Gen[A], B: Gen[B]): Gen[\/[A, B]]

    

87. implicit def dlistGen[A](implicit arg0: Gen[A]): Gen[DList[A]]

    

88. implicit def either3Gen[A1, A2, A3](implicit A1: Gen[A1], A2: Gen[A2], A3: Gen[A3]): Gen[Either3[A1, A2, A3]]

    

89. implicit def eitherGen[A, B](implicit A: Gen[A], B: Gen[B]): Gen[Either[A, B]]

    

90. implicit def eitherTGen[F[_], A, B](implicit F: Gen[F[\/[A, B]]]): Gen[EitherT[A, F, B]]

    

91. implicit final def endomorphicGen[F[_, _], A](implicit F: Gen[F[A, A]]): Gen[Endomorphic[F, A]]

    

    Definition Classes

    ScalapropsScalaz0

92. implicit def ephemeralStreamGen[A](implicit arg0: Gen[A]): Gen[EphemeralStream[A]]

    

93. final def eq(arg0: AnyRef): Boolean

    

    Definition Classes

    AnyRef

94. def equals(arg0: Any): Boolean

    

    Definition Classes

    AnyRef → Any

95. def finalize(): Unit

    

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( classOf[java.lang.Throwable] )

96. implicit def fingerGen[V, A](implicit arg0: Monoid[V], A: Gen[A], R: Reducer[A, V]): Gen[Finger[V, A]]

    

97. implicit def freeTGen[S[_], M[_], A](implicit arg0: Functor[S], arg1: Applicative[M], arg2: Gen[A], G1: Gen[S[A]], G2: Gen[M[A]]): Gen[FreeT[S, M, A]]

    

98. implicit val genInstance: Monad[Gen] with BindRec[Gen]

    

99. final def getClass(): Class[_]

    

    Definition Classes

    AnyRef → Any

100. def hashCode(): Int

     

     Definition Classes

     AnyRef → Any

101. implicit def heapGen[A](implicit arg0: Gen[A], arg1: Order[A]): Gen[Heap[A]]

     

102. implicit def idTGen[F[_], A](implicit F: Gen[F[A]]): Gen[IdT[F, A]]

     

103. implicit def ilistGen[A](implicit A: Gen[A]): Gen[IList[A]]

     

104. implicit def imapGen[A, B](implicit arg0: Order[A], arg1: Gen[A], arg2: Gen[B]): Gen[==>>[A, B]]

     

105. implicit def immutableArrayGen[A](implicit arg0: Gen[A], arg1: ClassTag[A]): Gen[ImmutableArray[A]]

     

106. implicit def indSeqGen[A](implicit arg0: Gen[A]): Gen[IndSeq[A]]

     

107. implicit def indexedContsTGen[W[_], M[_], R, O, A](implicit F: Gen[(W[(A) ⇒ M[O]]) ⇒ M[R]]): Gen[IndexedContsT[W, R, O, M, A]]

     

108. implicit def indexedReaderWriterStateTGen[F[_], R, W, S1, S2, A](implicit F: Gen[(R, S1) ⇒ F[(W, A, S2)]]): Gen[IndexedReaderWriterStateT[R, W, S1, S2, F, A]]

     

109. implicit def indexedStateTGen[F[_], S1, S2, A](implicit arg0: Monad[F], F: Gen[(S1) ⇒ F[(S2, A)]]): Gen[IndexedStateT[S1, S2, F, A]]

     

110. implicit def indexedStoreTGen[F[_], I, A, B](implicit arg0: Gen[I], F: Gen[F[(A) ⇒ B]]): Gen[IndexedStoreT[F, I, A, B]]

     

111. final def isInstanceOf[T0]: Boolean

     

     Definition Classes

     Any

112. implicit def isetGen[A](implicit arg0: Order[A], arg1: Gen[A]): Gen[ISet[A]]

     

113. val isoFunction: scalaz.Isomorphism.<~>[Gen, [a](Int, Rand) ⇒ (Rand, a)]

     

114. val isoRWS: scalaz.Isomorphism.<~>[Gen, [a]IndexedReaderWriterStateT[Int, Unit, Rand, Rand, [X]X, a]]

     

115. val isoReaderState: scalaz.Isomorphism.<~>[Gen, [a]Kleisli[[b]IndexedStateT[Rand, Rand, [X]X, b], Int, a]]

     

116. val isoStateReader: scalaz.Isomorphism.<~>[Gen, [a]IndexedStateT[Rand, Rand, [b]Kleisli[[X]X, Int, b], a]]

     

117. implicit def kleisliGen[F[_], A, B](implicit F: Gen[(A) ⇒ F[B]]): Gen[Kleisli[F, A, B]]

     

118. implicit def kleisliLikeEndoGen[G[_[_], _, _], F[_], A](implicit F: Gen[G[F, A, A]]): Gen[Endomorphic[[a, b]G[F, a, b], A]]

     

119. implicit def lazyEitherGen[A1, A2](implicit A1: Gen[A1], A2: Gen[A2]): Gen[LazyEither[A1, A2]]

     

120. implicit def lazyEitherTGen[F[_], A, B](implicit F: Gen[F[LazyEither[A, B]]]): Gen[LazyEitherT[F, A, B]]

     

121. implicit def lazyOptionGen[A](implicit arg0: Gen[A]): Gen[LazyOption[A]]

     

122. implicit def lazyOptionTGen[F[_], A](implicit F: Gen[F[LazyOption[A]]]): Gen[LazyOptionT[F, A]]

     

123. implicit def lazyTuple2Gen[A1, A2](implicit A1: Gen[A1], A2: Gen[A2]): Gen[LazyTuple2[A1, A2]]

     

124. implicit def lazyTuple3Gen[A1, A2, A3](implicit A1: Gen[A1], A2: Gen[A2], A3: Gen[A3]): Gen[LazyTuple3[A1, A2, A3]]

     

125. implicit def lazyTuple4Gen[A1, A2, A3, A4](implicit A1: Gen[A1], A2: Gen[A2], A3: Gen[A3], A4: Gen[A4]): Gen[LazyTuple4[A1, A2, A3, A4]]

     

126. implicit def listTGen[F[_], A](implicit F: Gen[F[IList[A]]]): Gen[ListT[F, A]]

     

127. implicit def maybeGen[A](implicit A: Gen[A]): Gen[Maybe[A]]

     

128. implicit def maybeTGen[F[_], A](implicit F: Gen[F[Maybe[A]]]): Gen[MaybeT[F, A]]

     

129. implicit def monoidCoproduct[A, B](implicit arg0: Gen[A], arg1: Gen[B]): Gen[:+:[A, B]]

     

130. implicit def nameGen[A](implicit A: Gen[A]): Gen[Name[A]]

     

131. final def ne(arg0: AnyRef): Boolean

     

     Definition Classes

     AnyRef

132. implicit def needGen[A](implicit A: Gen[A]): Gen[Need[A]]

     

133. implicit def nonEmptyListGen[A](implicit A: Gen[A]): Gen[NonEmptyList[A]]

     

134. final def notify(): Unit

     

     Definition Classes

     AnyRef

135. final def notifyAll(): Unit

     

     Definition Classes

     AnyRef

136. implicit def nullArgumentGen[A, B](implicit F: Gen[(Option[A]) ⇒ B]): Gen[NullArgument[A, B]]

     

137. implicit def nullResultGen[A, B](implicit F: Gen[(A) ⇒ Option[B]]): Gen[NullResult[A, B]]

     

138. implicit def oneAndGen[F[_], A](implicit F: Gen[F[A]], A: Gen[A]): Gen[OneAnd[F, A]]

     

139. implicit def oneOrGen[F[_], A](implicit F: Gen[F[A]], A: Gen[A]): Gen[OneOr[F, A]]

     

140. implicit def optionTGen[F[_], A](implicit F: Gen[F[Option[A]]]): Gen[OptionT[F, A]]

     

141. implicit val orderingGen: Gen[Ordering]

     

142. implicit val randCogen: Cogen[Rand]

     

143. implicit val randEqual: Equal[Rand]

     

144. implicit val randGen: Gen[Rand]

     

145. implicit def scalazEndoGen[A](implicit arg0: Gen[A], arg1: Cogen[A]): Gen[Endo[A]]

     

146. implicit def selectTGen[R, M[_], A](implicit F: Gen[((A) ⇒ M[R]) ⇒ M[A]]): Gen[SelectT[R, M, A]]

     

147. val shrinkFunctionIso: scalaz.Isomorphism.<~>[Shrink, [a](a) ⇒ Stream[a]]

     

148. implicit val shrinkInstance: InvariantFunctor[Shrink]

     

149. implicit def streamTGen[F[_], A](implicit arg0: Applicative[F], F: Gen[F[Stream[A]]]): Gen[StreamT[F, A]]

     

150. implicit def strictTreeGen[A](implicit A: Gen[A]): Gen[StrictTree[A]]

     

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

     

     Definition Classes

     AnyRef

152. implicit def tannenGen[F[_], G[_, _], A, B](implicit F: Gen[F[G[A, B]]]): Gen[Tannen[F, G, A, B]]

     

153. implicit def theseGen[A, B](implicit A: Gen[A], B: Gen[B]): Gen[\&/[A, B]]

     

154. implicit def theseTGen[F[_], A, B](implicit F: Gen[F[\&/[A, B]]]): Gen[TheseT[F, A, B]]

     

155. def toString(): String

     

     Definition Classes

     AnyRef → Any

156. implicit def tracedTGen[W[_], A, B](implicit W: Gen[W[(A) ⇒ B]]): Gen[TracedT[W, A, B]]

     

157. implicit def treeGen[A](implicit A: Gen[A]): Gen[Tree[A]]

     

158. implicit def treeLocGen[A](implicit arg0: Gen[A]): Gen[TreeLoc[A]]

     

159. implicit def unwriterTGen[F[_], A, B](implicit F: Gen[F[(A, B)]]): Gen[UnwriterT[F, A, B]]

     

160. implicit def validationGen[A, B](implicit arg0: Gen[A], arg1: Gen[B]): Gen[Validation[A, B]]

     

161. implicit def valueGen[A](implicit A: Gen[A]): Gen[Value[A]]

     

162. final def wait(): Unit

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

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

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

164. final def wait(arg0: Long): Unit

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

165. implicit def writerTGen[F[_], A, B](implicit F: Gen[F[(A, B)]]): Gen[WriterT[A, F, B]]

     

166. implicit def zipperGen[A](implicit arg0: Gen[A]): Gen[Zipper[A]]