/scalacheck-binding/src/main/scala/scalaz/scalacheck/ScalazArbitrary.scala

http://github.com/scalaz/scalaz · Scala · 615 lines · 438 code · 167 blank · 10 comment · 11 complexity · c0fc798718e6616ac343a5d39ffff264 MD5 · raw file

  1. package scalaz
  2. package scalacheck
  3. import java.math.BigInteger
  4. import org.scalacheck.{Cogen, Gen, Arbitrary}
  5. import reflect.ClassTag
  6. /**
  7. * Instances of {@link scalacheck.Arbitrary} for many types in Scalaz.
  8. */
  9. object ScalazArbitrary extends ScalazArbitraryPlatform {
  10. import Scalaz._
  11. import Tags._
  12. import Arbitrary._
  13. import Gen._
  14. import ScalaCheckBinding._
  15. private def arb[A: Arbitrary]: Arbitrary[A] = implicitly[Arbitrary[A]]
  16. implicit def cogenIList[A: Cogen]: Cogen[IList[A]] =
  17. Cogen[List[A]].contramap(_.toList)
  18. implicit def cogenMaybe[A: Cogen]: Cogen[Maybe[A]] =
  19. Cogen[Option[A]].contramap(_.toOption)
  20. implicit def cogenLazyOption[A: Cogen]: Cogen[LazyOption[A]] =
  21. Cogen[Option[A]].contramap(_.toOption)
  22. implicit def cogenThese[A, B](implicit A: Cogen[A], B: Cogen[B]): Cogen[A \&/ B] =
  23. Cogen[(A \/ B) \/ (A, B)].contramap{
  24. case x @ \&/.Both(a, b) =>
  25. \/-((a, b))
  26. case \&/.This(a) =>
  27. -\/(-\/(a))
  28. case \&/.That(b) =>
  29. -\/(\/-(b))
  30. }
  31. implicit def cogenLazyEither[A: Cogen, B: Cogen]: Cogen[LazyEither[A, B]] =
  32. Cogen[Either[A, B]].contramap(_.toEither)
  33. implicit def cogenDisjunction[A, B](implicit A: Cogen[A], B: Cogen[B]): Cogen[A \/ B] =
  34. Cogen[Either[A, B]].contramap(_.toEither)
  35. implicit def cogenValidation[A: Cogen, B: Cogen]: Cogen[Validation[A, B]] =
  36. Cogen[Either[A, B]].contramap(_.toEither)
  37. implicit val cogenOrdering: Cogen[Ordering] =
  38. Cogen[Int].contramap {
  39. case Ordering.GT => 0
  40. case Ordering.EQ => 1
  41. case Ordering.LT => 2
  42. }
  43. implicit def cogenOneOr[F[_], A: Cogen](implicit F: Cogen[F[A]]): Cogen[OneOr[F, A]] =
  44. Cogen[F[A] \/ A].contramap(_.run)
  45. implicit def cogenOneAnd[F[_], A: Cogen](implicit F: Cogen[F[A]]): Cogen[OneAnd[F, A]] =
  46. Cogen[(A, F[A])].contramap(a => (a.head, a.tail))
  47. implicit def cogenISet[A: Cogen]: Cogen[ISet[A]] =
  48. Cogen[List[A]].contramap(_.toList)
  49. implicit def cogenIMap[A: Cogen, B: Cogen]: Cogen[A ==>> B] =
  50. Cogen[List[(A, B)]].contramap(_.toList)
  51. implicit def cogenDList[A: Cogen]: Cogen[DList[A]] =
  52. Cogen[List[A]].contramap(_.toList)
  53. implicit def cogenEphemeralStream[A: Cogen]: Cogen[EphemeralStream[A]] =
  54. Cogen[List[A]].contramap(_.toList)
  55. implicit def cogenHeap[A: Cogen]: Cogen[Heap[A]] =
  56. Cogen[EphemeralStream[A]].contramap(_.toUnsortedStream)
  57. implicit def cogenDequeue[A: Cogen]: Cogen[Dequeue[A]] =
  58. Cogen[List[A]].contramap(_.toList)
  59. implicit def cogenNonEmptyList[A: Cogen]: Cogen[NonEmptyList[A]] =
  60. Cogen[(A, IList[A])].contramap(nel => (nel.head, nel.tail))
  61. implicit def cogenIndSeq[A: Cogen]: Cogen[IndSeq[A]] =
  62. Cogen[List[A]].contramap(Foldable[IndSeq].toList)
  63. implicit def cogenDiev[A: Cogen]: Cogen[Diev[A]] =
  64. Cogen[Vector[(A, A)]].contramap(_.intervals)
  65. implicit def cogenCoproduct[F[_], G[_], A](implicit A: Cogen[F[A] \/ G[A]]): Cogen[Coproduct[F, G, A]] =
  66. Cogen[F[A] \/ G[A]].contramap(_.run)
  67. implicit def cogenConst[A, B](implicit A: Cogen[A]): Cogen[Const[A, B]] =
  68. A.contramap(_.getConst)
  69. implicit def cogenZipper[A](implicit A: Cogen[A]): Cogen[Zipper[A]] =
  70. Cogen[(Stream[A], A, Stream[A])].contramap(z => (z.lefts, z.focus, z.rights))
  71. implicit def cogenTracedT[W[_], A, B](implicit W: Cogen[W[A => B]]): Cogen[TracedT[W, A, B]] =
  72. W.contramap(_.run)
  73. implicit def cogenIndexedStoreT[F[_], I: Cogen, A, B](implicit F: Cogen[F[A => B]]): Cogen[IndexedStoreT[F, I, A, B]] =
  74. Cogen[(F[A => B], I)].contramap(_.run)
  75. implicit def cogenIndexedContsT[W[_], R, O, M[_], A](implicit F: Cogen[W[A => M[O]] => M[R]]): Cogen[IndexedContsT[W, R, O, M, A]] =
  76. F.contramap(_.run)
  77. implicit def cogenEndo[A](implicit A: Cogen[A => A]): Cogen[Endo[A]] =
  78. A.contramap(_.run)
  79. implicit def cogenEndomorphic[F[_, _], A](implicit F: Cogen[F[A, A]]): Cogen[Endomorphic[F, A]] =
  80. F.contramap(_.run)
  81. implicit def cogenKleisli[F[_], A, B](implicit F: Cogen[A => F[B]]): Cogen[Kleisli[F, A, B]] =
  82. F.contramap(_.run)
  83. implicit def cogenCokleisli[F[_], A, B](implicit F: Cogen[F[A] => B]): Cogen[Cokleisli[F, A, B]] =
  84. F.contramap(_.run)
  85. implicit def cogenNullResult[A, B](implicit F: Cogen[A => Option[B]]): Cogen[NullResult[A, B]] =
  86. F.contramap(_.apply)
  87. implicit def cogenNullArgument[A, B](implicit F: Cogen[Option[A] => B]): Cogen[NullArgument[A, B]] =
  88. F.contramap(_.apply)
  89. implicit def cogenContravariantCoyoneda[F[_]: Contravariant, A](implicit F: Cogen[F[A]]): Cogen[ContravariantCoyoneda[F, A]] =
  90. Cogen[F[A]].contramap(_.run)
  91. implicit def cogenEitherT[A, F[_], B](implicit F: Cogen[F[A \/ B]]): Cogen[EitherT[A, F, B]] =
  92. F.contramap(_.run)
  93. implicit def cogenLazyEitherT[F[_], A, B](implicit F: Cogen[F[LazyEither[A, B]]]): Cogen[LazyEitherT[F, A, B]] =
  94. F.contramap(_.run)
  95. implicit def cogenTheseT[F[_], A, B](implicit F: Cogen[F[A \&/ B]]): Cogen[TheseT[F, A, B]] =
  96. F.contramap(_.run)
  97. implicit def cogenMaybeT[F[_], A](implicit F: Cogen[F[Maybe[A]]]): Cogen[MaybeT[F, A]] =
  98. F.contramap(_.run)
  99. implicit def cogenStreamT[F[_]: Monad, A](implicit F: Cogen[F[LazyList[A]]]): Cogen[StreamT[F, A]] =
  100. F.contramap(_.toLazyList)
  101. implicit def cogenOptionT[F[_], A](implicit F: Cogen[F[Option[A]]]): Cogen[OptionT[F, A]] =
  102. F.contramap(_.run)
  103. implicit def cogenLazyOptionT[F[_], A](implicit F: Cogen[F[LazyOption[A]]]): Cogen[LazyOptionT[F, A]] =
  104. F.contramap(_.run)
  105. implicit def cogenIdT[F[_], A](implicit F: Cogen[F[A]]): Cogen[IdT[F, A]] =
  106. F.contramap(_.run)
  107. implicit def cogenIndexedReaderWriterStateT[R, W, S1, S2, F[_]: Monad, A](implicit F: Cogen[(R, S1) => F[(W, A, S2)]]): Cogen[IndexedReaderWriterStateT[R, W, S1, S2, F, A]] =
  108. F.contramap(_.run)
  109. implicit def cogenIndexedStateT[F[_]: Monad, S1, S2, A](implicit F: Cogen[S1 => F[(S2, A)]]): Cogen[IndexedStateT[S1, S2, F, A]] =
  110. F.contramap(s => s.apply(_))
  111. implicit def cogenWriterT[A, F[_], B](implicit F: Cogen[F[(A, B)]]): Cogen[WriterT[A, F, B]] =
  112. F.contramap(_.run)
  113. implicit def cogenUnwriterT[F[_], A, B](implicit F: Cogen[F[(A, B)]]): Cogen[UnwriterT[F, A, B]] =
  114. F.contramap(_.run)
  115. implicit def cogenTree[A: Cogen]: Cogen[Tree[A]] =
  116. Cogen[List[A]].contramap(_.toList)
  117. implicit def cogenTreeLoc[A: Cogen]: Cogen[TreeLoc[A]] =
  118. Divide[Cogen].dividing4(Function.unlift(TreeLoc.unapply))
  119. implicit def cogenStrictTree[A: Cogen]: Cogen[StrictTree[A]] =
  120. Cogen[List[A]].contramap(_.toList)
  121. implicit def cogenCoyoneda[F[_]: Functor, A](implicit F: Cogen[F[A]]): Cogen[Coyoneda[F, A]] =
  122. F.contramap(_.run)
  123. private[this] def nameToValue[A]: Name[A] => A = _.value
  124. implicit def cogenNeed[A](implicit A: Cogen[A]): Cogen[Need[A]] =
  125. A.contramap(nameToValue)
  126. implicit def cogenValue[A](implicit A: Cogen[A]): Cogen[Value[A]] =
  127. A.contramap(nameToValue)
  128. implicit def cogenName[A](implicit A: Cogen[A]): Cogen[Name[A]] =
  129. A.contramap(nameToValue)
  130. implicit def cogenImmutableArray[A: Cogen]: Cogen[ImmutableArray[A]] =
  131. Cogen[List[A]].contramap(_.toList)
  132. implicit def cogenEither3[A1: Cogen, A2: Cogen, A3: Cogen]: Cogen[Either3[A1, A2, A3]] =
  133. Cogen[A1 \/ A2 \/ A3].contramap{
  134. case Left3(a) => -\/(-\/(a))
  135. case Middle3(a) => -\/(\/-(a))
  136. case Right3(a) => \/-(a)
  137. }
  138. implicit def cogenLazyTuple2[A1: Cogen, A2: Cogen]: Cogen[LazyTuple2[A1, A2]] =
  139. Cogen[(A1, A2)].contramap(t => (t._1, t._2))
  140. implicit def cogenLazyTuple3[A1: Cogen, A2: Cogen, A3: Cogen]: Cogen[LazyTuple3[A1, A2, A3]] =
  141. Cogen[(A1, A2, A3)].contramap(t => (t._1, t._2, t._3))
  142. implicit def cogenLazyTuple4[A1: Cogen, A2: Cogen, A3: Cogen, A4: Cogen]: Cogen[LazyTuple4[A1, A2, A3, A4]] =
  143. Cogen[(A1, A2, A3, A4)].contramap(t => (t._1, t._2, t._3, t._4))
  144. implicit def cogenAp[F[_], A](implicit F: Cogen[F[A]]): Cogen[Ap[F, A]] =
  145. F.contramap(_.f)
  146. implicit def cogenTannen[F[_], G[_, _], A, B](implicit F: Cogen[F[G[A, B]]]): Cogen[Tannen[F, G, A, B]] =
  147. F.contramap(_.f)
  148. implicit def tannenArbitrary[F[_], G[_, _], A, B](implicit F: Arbitrary[F[G[A, B]]]): Arbitrary[Tannen[F, G, A, B]] =
  149. Functor[Arbitrary].map(F)(Tannen[F, G, A, B](_))
  150. implicit def apArbitrary[F[_], A](implicit F: Arbitrary[F[A]]): Arbitrary[Ap[F, A]] =
  151. Functor[Arbitrary].map(F)(Ap[F, A](_))
  152. implicit def cogenAlter[F[_], A](implicit F: Cogen[F[A]]): Cogen[Alter[F, A]] =
  153. F.contramap(_.f)
  154. implicit def alterArbitrary[F[_], A](implicit F: Arbitrary[F[A]]): Arbitrary[Alter[F, A]] =
  155. Functor[Arbitrary].map(F)(Alter[F, A](_))
  156. implicit def monoidCoproductArbitrary[M: Arbitrary, N: Arbitrary]: Arbitrary[M :+: N] =
  157. Functor[Arbitrary].map(arb[Vector[M \/ N]])(new :+:(_))
  158. /** @since 7.0.3 */
  159. implicit def theseArb[A: Arbitrary, B: Arbitrary]: Arbitrary[A \&/ B] =
  160. Arbitrary(Gen.oneOf(
  161. ^(arbitrary[A], arbitrary[B])(\&/.Both(_, _)),
  162. arbitrary[A].map(\&/.This[A, B](_)),
  163. arbitrary[B].map(\&/.That[A, B](_))
  164. ))
  165. implicit def endoArb[A](implicit A: Arbitrary[A => A]): Arbitrary[Endo[A]] =
  166. Functor[Arbitrary].map(A)(Endo.endo)
  167. implicit def endoByNameArb[A](implicit A: Arbitrary[A => A]): Arbitrary[EndoByName[A]] =
  168. Functor[Arbitrary].map(A)(f => Endo.endoByName(f(_)))
  169. implicit def endomorphicArbitrary[F[_, _], A](implicit F: Arbitrary[F[A, A]]): Arbitrary[Endomorphic[F, A]] =
  170. Functor[Arbitrary].map(F)(Endomorphic[F, A](_))
  171. implicit def EphemeralStreamArbitrary[A : Arbitrary]: Arbitrary[EphemeralStream[A]] =
  172. Functor[Arbitrary].map(arb[Stream[A]])(EphemeralStream.fromStream[A](_))
  173. implicit def IStreamArbitrary[A : Arbitrary]: Arbitrary[IStream[A]] =
  174. Functor[Arbitrary].map(arb[Stream[A]])(IStream.fromStream[A](_))
  175. implicit def CorecursiveListArbitrary[A : Arbitrary]: Arbitrary[CorecursiveList[A]] =
  176. Functor[Arbitrary].map(arb[Stream[A]])(CorecursiveList.fromStream)
  177. implicit def ImmutableArrayArbitrary[A : Arbitrary : ClassTag]: Arbitrary[ImmutableArray[A]] =
  178. Functor[Arbitrary].map(arb[Array[A]])(ImmutableArray.fromArray[A](_))
  179. implicit def ValueArbitrary[A: Arbitrary]: Arbitrary[Value[A]] = Functor[Arbitrary].map(arb[A])(a => Value(a))
  180. implicit def NameArbitrary[A: Arbitrary]: Arbitrary[Name[A]] = Functor[Arbitrary].map(arb[A])(a => Name(a))
  181. implicit def NeedArbitrary[A: Arbitrary]: Arbitrary[Need[A]] = Functor[Arbitrary].map(arb[A])(a => Need(a))
  182. implicit val UnitArbitrary: Arbitrary[Unit] = Arbitrary(const(()))
  183. implicit val AlphaArbitrary: Arbitrary[Alpha] = {
  184. val alphaList = Alpha.alphas.toList
  185. Arbitrary(oneOf(alphaList))
  186. }
  187. implicit val BooleanConjunctionArbitrary: Arbitrary[Boolean @@ Conjunction] = Functor[Arbitrary].map(arb[Boolean])(_.conjunction)
  188. implicit val arbBigInt: Arbitrary[BigInt] = Apply[Arbitrary].apply2[Int, Int, BigInt](arb[Int], arb[Int])(_ + _)
  189. implicit val arbBigInteger: Arbitrary[BigInteger] = Functor[Arbitrary].map(arb[BigInt])(_.bigInteger)
  190. implicit val BigIntegerMultiplicationArbitrary: Arbitrary[BigInteger @@ Multiplication] =
  191. Tag.subst[BigInteger, Arbitrary, Multiplication](arb[BigInteger])
  192. implicit val BigIntMultiplicationArbitrary: Arbitrary[BigInt @@ Multiplication] = Tag.subst(arb[BigInt])
  193. implicit val ByteMultiplicationArbitrary: Arbitrary[Byte @@ Multiplication] = Tag.subst(arb[Byte])
  194. implicit val CharMultiplicationArbitrary: Arbitrary[Char @@ Multiplication] = Tag.subst(arb[Char])
  195. implicit val ShortMultiplicationArbitrary: Arbitrary[Short @@ Multiplication] = Tag.subst(arb[Short])
  196. implicit val IntMultiplicationArbitrary: Arbitrary[Int @@ Multiplication] = Tag.subst(arb[Int])
  197. implicit val LongMultiplicationArbitrary: Arbitrary[Long @@ Multiplication] = Tag.subst(arb[Long])
  198. implicit val FloatMultiplicationArbitrary: Arbitrary[Float @@ Multiplication] = Tag.subst(arb[Float])
  199. implicit val DoubleMultiplicationArbitrary: Arbitrary[Double @@ Multiplication] = Tag.subst(arb[Double])
  200. implicit val IntDualArbitrary: Arbitrary[Int @@ Dual] = Tag.subst(arb[Int])
  201. implicit val DigitArbitrary: Arbitrary[Digit] = {
  202. val digitList = Digit.digits.toList
  203. Arbitrary(oneOf(digitList))
  204. }
  205. import NonEmptyList._
  206. implicit def NonEmptyListArbitrary[A: Arbitrary]: Arbitrary[NonEmptyList[A]] = Apply[Arbitrary].apply2[A, IList[A], NonEmptyList[A]](arb[A], ilistArbitrary)(nel(_, _))
  207. /** @since 7.0.3 */
  208. implicit def OneAndArbitrary[F[_], A](implicit A: Arbitrary[A], FA: Arbitrary[F[A]]
  209. ): Arbitrary[OneAnd[F, A]] =
  210. Apply[Arbitrary].apply2(arb[A], arb[F[A]])(OneAnd.apply)
  211. /** @since 7.0.3 */
  212. implicit def OneOrArbitrary[F[_], A](implicit A: Arbitrary[A], FA: Arbitrary[F[A]]): Arbitrary[OneOr[F, A]] =
  213. Functor[Arbitrary].map(arb[F[A] \/ A])(OneOr(_))
  214. /** @since 7.1.0 */
  215. implicit def Arbitrary_==>>[A, B](implicit o: Order[A], A: Arbitrary[A], B: Arbitrary[B]): Arbitrary[A ==>> B] =
  216. Functor[Arbitrary].map(arb[List[(A, B)]])(as => ==>>.fromList(as))
  217. implicit def Arbitrary_ISet[A](implicit o: Order[A], A: Arbitrary[A]): Arbitrary[ISet[A]] =
  218. Functor[Arbitrary].map(arb[List[A]])(as => ISet.fromList(as))
  219. implicit def Arbitrary_Maybe[A: Arbitrary]: Arbitrary[Maybe[A]] =
  220. Functor[Arbitrary].map(arb[Option[A]])(Maybe.fromOption)
  221. import scalaz.Ordering._
  222. implicit val OrderingArbitrary: Arbitrary[Ordering] = Arbitrary(oneOf(LT, EQ, GT))
  223. private[this] def withSize[A](size: Int)(f: Int => Gen[A]): Gen[EphemeralStream[A]] = {
  224. Applicative[Gen].sequence(
  225. (IList.fill(size)(Gen.choose(1, size max 1))).toEphemeralStream
  226. ).flatMap { s =>
  227. val ns = Traverse[EphemeralStream].traverseS(s) { n =>
  228. for {
  229. sum <- State.get[Int]
  230. r <- if (sum >= size) {
  231. State.state[Int, Option[Int]](None)
  232. } else if ((sum + n) > size) {
  233. State((s: Int) => (s + n) -> Option(size - sum))
  234. } else {
  235. State((s: Int) => (s + n) -> Option(n))
  236. }
  237. } yield r
  238. }.eval(0).flatMap(o => o.cata[EphemeralStream[Int]](EphemeralStream(_), EphemeralStream.emptyEphemeralStream))
  239. Applicative[Gen].sequence(ns.map(f))
  240. }
  241. }
  242. private[scalaz] def treeGenSized[A: NotNothing](size: Int)(implicit A: Arbitrary[A]): Gen[Tree[A]] =
  243. size match {
  244. case n if n <= 1 =>
  245. A.arbitrary.map(a => Tree.Leaf(a))
  246. case 2 =>
  247. arb[(A, A)].arbitrary.map{ case (a1, a2) =>
  248. Tree.Node(a1, EphemeralStream(Tree.Leaf(a2)))
  249. }
  250. case 3 =>
  251. arb[(A, A, A)].arbitrary.flatMap{ case (a1, a2, a3) =>
  252. Gen.oneOf(
  253. Tree.Node(a1, EphemeralStream(Tree.Leaf(a2), Tree.Leaf(a3))),
  254. Tree.Node(a1, EphemeralStream(Tree.Node(a2, EphemeralStream(Tree.Leaf(a3)))))
  255. )
  256. }
  257. case _ =>
  258. withSize(size - 1)(treeGenSized[A]).flatMap{ as =>
  259. A.arbitrary.map(a => Tree.Node(a, as))
  260. }
  261. }
  262. implicit def TreeArbitrary[A: Arbitrary]: Arbitrary[Tree[A]] =
  263. Arbitrary(Gen.sized(n =>
  264. if (n < 1) treeGenSized[A](0)
  265. else Gen.choose(1, n).flatMap(treeGenSized[A])
  266. ))
  267. private[scalaz] def strictTreeGenSized[A: NotNothing](size: Int)(implicit A: Arbitrary[A]): Gen[StrictTree[A]] =
  268. size match {
  269. case n if n <= 1 =>
  270. A.arbitrary.map(a => StrictTree.Leaf(a))
  271. case 2 =>
  272. arb[(A, A)].arbitrary.map{ case (a1, a2) =>
  273. StrictTree(a1, Vector(StrictTree.Leaf(a2)))
  274. }
  275. case 3 =>
  276. arb[(A, A, A)].arbitrary.flatMap{ case (a1, a2, a3) =>
  277. Gen.oneOf(
  278. StrictTree(a1, Vector(StrictTree.Leaf(a2), StrictTree.Leaf(a3))),
  279. StrictTree(a1, Vector(StrictTree(a2, Vector(StrictTree.Leaf(a3)))))
  280. )
  281. }
  282. case _ =>
  283. withSize(size - 1)(strictTreeGenSized[A]).flatMap{ as =>
  284. A.arbitrary.map(a => StrictTree(a, as.toVector))
  285. }
  286. }
  287. implicit def StrictTreeArbitrary[A: Arbitrary]: Arbitrary[StrictTree[A]] =
  288. Arbitrary(Gen.sized(n =>
  289. if (n < 1) strictTreeGenSized[A](0)
  290. else Gen.choose(1, n).flatMap(strictTreeGenSized[A])
  291. ))
  292. private[scalaz] def treeLocGenSized[A: NotNothing](size: Int)(implicit A: Arbitrary[A]): Gen[TreeLoc[A]] = {
  293. def forest(n: Int): Gen[TreeLoc.TreeForest[A]] =
  294. withSize(n)(treeGenSized[A])
  295. val parent: Int => Gen[TreeLoc.Parent[A]] = { n =>
  296. Gen.choose(0, (n - 1) max 0).flatMap { x1 =>
  297. Apply[Gen].tuple3(
  298. forest(x1), A.arbitrary, forest(n - x1 - 1)
  299. )
  300. }
  301. }
  302. for{
  303. a <- Gen.choose(1, size max 1)
  304. b = size - a
  305. aa <- Gen.choose(1, a max 1)
  306. ba <- Gen.choose(0, b max 0)
  307. t <- Apply[Gen].apply4(
  308. treeGenSized[A](aa),
  309. forest(a - aa),
  310. forest(ba),
  311. withSize(b - ba)(parent)
  312. )(TreeLoc.apply[A])
  313. } yield t
  314. }
  315. implicit def IterableArbitrary[A: Arbitrary]: Arbitrary[Iterable[A]] =
  316. Apply[Arbitrary].apply2[A, List[A], Iterable[A]](arb[A], arb[List[A]])((a, list) => a :: list)
  317. implicit def TreeLocArbitrary[A: Arbitrary]: Arbitrary[TreeLoc[A]] =
  318. Arbitrary(Gen.sized(n =>
  319. Gen.choose(0, n).flatMap(treeLocGenSized[A])
  320. ))
  321. implicit def DisjunctionArbitrary[A: Arbitrary, B: Arbitrary]: Arbitrary[A \/ B] =
  322. Functor[Arbitrary].map(arb[Either[A, B]]) {
  323. case Left(a) => -\/(a)
  324. case Right(b) => \/-(b)
  325. }
  326. implicit def ValidationArbitrary[A: Arbitrary, B: Arbitrary]: Arbitrary[Validation[A, B]] =
  327. Functor[Arbitrary].map(arb[A \/ B])(_.toValidation)
  328. // implicit def ZipStreamArbitrary[A](implicit a: Arbitrary[A]): Arbitrary[ZipStream[A]] = arb[Stream[A]] ∘ ((s: Stream[A]) => s.ʐ)
  329. implicit def Tuple1Arbitrary[A: Arbitrary]: Arbitrary[Tuple1[A]] = Functor[Arbitrary].map(arb[A])(Tuple1(_))
  330. implicit def Function0Arbitrary[A: Arbitrary]: Arbitrary[() => A] = Functor[Arbitrary].map(arb[A])(() => _)
  331. implicit def FirstOptionArbitrary[A: Arbitrary]: Arbitrary[Option[A] @@ First] = Functor[Arbitrary].map(arb[Option[A]])(_.first)
  332. implicit def LastOptionArbitrary[A: Arbitrary]: Arbitrary[Option[A] @@ Last] = Functor[Arbitrary].map(arb[Option[A]])(_.last)
  333. implicit def MinOptionArbitrary[A: Arbitrary]: Arbitrary[MinOption[A]] = Tag.subst(arb[Option[A]])
  334. implicit def MaxOptionArbitrary[A: Arbitrary]: Arbitrary[MaxOption[A]] = Tag.subst(arb[Option[A]])
  335. implicit def FirstMaybeArbitrary[A: Arbitrary]: Arbitrary[Maybe[A] @@ First] = Functor[Arbitrary].map(arb[Maybe[A]])(_.first)
  336. implicit def LastMaybeArbitrary[A: Arbitrary]: Arbitrary[Maybe[A] @@ Last] = Functor[Arbitrary].map(arb[Maybe[A]])(_.last)
  337. implicit def MinMaybeArbitrary[A: Arbitrary]: Arbitrary[MinMaybe[A]] = Tag.subst(arb[Maybe[A]])
  338. implicit def MaxMaybeArbitrary[A: Arbitrary]: Arbitrary[MaxMaybe[A]] = Tag.subst(arb[Maybe[A]])
  339. import FingerTree._
  340. implicit def FingerArbitrary[V: Monoid, A](implicit a: Arbitrary[A], measure: Reducer[A, V]): Arbitrary[Finger[V, A]] = Arbitrary(oneOf(
  341. arbitrary[A].map(one(_): Finger[V, A]),
  342. ^(arbitrary[A], arbitrary[A])(two(_, _): Finger[V, A]),
  343. ^^(arbitrary[A], arbitrary[A], arbitrary[A])(three(_, _, _): Finger[V, A]),
  344. ^^^(arbitrary[A], arbitrary[A], arbitrary[A], arbitrary[A])(four(_, _, _, _): Finger[V, A])
  345. ))
  346. implicit def NodeArbitrary[V: Monoid, A](implicit a: Arbitrary[A], measure: Reducer[A, V]): Arbitrary[Node[V, A]] = Arbitrary(oneOf(
  347. ^(arbitrary[A], arbitrary[A])(node2[V, A](_, _)),
  348. ^^(arbitrary[A], arbitrary[A], arbitrary[A])(node3[V, A](_, _, _))
  349. ))
  350. implicit def FingerTreeArbitrary[V: Monoid, A](implicit a: Arbitrary[A], measure: Reducer[A, V]): Arbitrary[FingerTree[V, A]] = Arbitrary {
  351. def fingerTree[A](n: Int)(implicit a1: Arbitrary[A], measure1: Reducer[A, V]): Gen[FingerTree[V, A]] = n match {
  352. case 0 => empty[V, A]
  353. case 1 => arbitrary[A].map(single[V, A](_))
  354. case n => {
  355. val nextSize = n.abs / 2
  356. ^^(FingerArbitrary[V, A].arbitrary,
  357. fingerTree[Node[V, A]](nextSize)(NodeArbitrary[V, A], implicitly),
  358. FingerArbitrary[V, A].arbitrary
  359. )(deep[V, A](_, _, _))
  360. }
  361. }
  362. Gen.sized(fingerTree[A] _)
  363. }
  364. implicit def IndSeqArbibrary[A: Arbitrary]: Arbitrary[IndSeq[A]] = Functor[Arbitrary].map(arb[List[A]])(IndSeq.fromSeq)
  365. import java.util.concurrent.Callable
  366. implicit def CallableArbitrary[A: Arbitrary]: Arbitrary[Callable[A]] = Functor[Arbitrary].map(arb[A])((x: A) => Applicative[Callable].point(x))
  367. import Zipper._
  368. implicit def ZipperArbitrary[A: Arbitrary]: Arbitrary[Zipper[A]] =
  369. Apply[Arbitrary].apply3[Stream[A], A, Stream[A], Zipper[A]](arb[Stream[A]], arb[A], arb[Stream[A]])(zipper[A](_, _, _))
  370. implicit def KleisliArbitrary[M[_], A, B](implicit a: Arbitrary[A => M[B]]): Arbitrary[Kleisli[M, A, B]] =
  371. Functor[Arbitrary].map(a)(Kleisli[M, A, B](_))
  372. implicit def CokleisliArbitrary[M[_], A, B](implicit a: Arbitrary[M[A] => B]): Arbitrary[Cokleisli[M, A, B]] =
  373. Functor[Arbitrary].map(a)(Cokleisli[M, A, B](_))
  374. implicit def CoproductArbitrary[F[_], G[_], A](implicit a: Arbitrary[F[A] \/ G[A]]): Arbitrary[Coproduct[F, G, A]] =
  375. Functor[Arbitrary].map(a)(Coproduct(_))
  376. implicit def writerTArb[W, F[_], A](implicit A: Arbitrary[F[(W, A)]]): Arbitrary[WriterT[W, F, A]] =
  377. Functor[Arbitrary].map(A)(WriterT[W, F, A](_))
  378. implicit def unwriterTArb[F[_], U, A](implicit A: Arbitrary[F[(U, A)]]): Arbitrary[UnwriterT[F, U, A]] =
  379. Functor[Arbitrary].map(A)(UnwriterT[F, U, A](_))
  380. implicit def optionTArb[F[_], A](implicit A: Arbitrary[F[Option[A]]]): Arbitrary[OptionT[F, A]] =
  381. Functor[Arbitrary].map(A)(OptionT[F, A](_))
  382. implicit def maybeTArb[F[_], A](implicit A: Arbitrary[F[Maybe[A]]]): Arbitrary[MaybeT[F, A]] =
  383. Functor[Arbitrary].map(A)(MaybeT[F, A](_))
  384. implicit def lazyOptionArb[F[_], A](implicit A: Arbitrary[Option[A]]): Arbitrary[LazyOption[A]] =
  385. Functor[Arbitrary].map(A)(LazyOption.fromOption[A](_))
  386. implicit def lazyOptionTArb[F[_], A](implicit A: Arbitrary[F[LazyOption[A]]]): Arbitrary[LazyOptionT[F, A]] =
  387. Functor[Arbitrary].map(A)(LazyOptionT[F, A](_))
  388. implicit def lazyEitherArb[F[_], A: Arbitrary, B: Arbitrary]: Arbitrary[LazyEither[A, B]] =
  389. Functor[Arbitrary].map(arb[Either[A, B]]) {
  390. case Left(a) => LazyEither.lazyLeft(a)
  391. case Right(b) => LazyEither.lazyRight(b)
  392. }
  393. implicit def lazyEitherTArb[F[_], A, B](implicit A: Arbitrary[F[LazyEither[A, B]]]): Arbitrary[LazyEitherT[F, A, B]] =
  394. Functor[Arbitrary].map(A)(LazyEitherT[F, A, B](_))
  395. implicit def idTArbitrary[A, F[_]](implicit A: Arbitrary[F[A]]): Arbitrary[IdT[F, A]] =
  396. Functor[Arbitrary].map(A)(IdT[F, A])
  397. // backwards compatibility
  398. def stateTArb[S, F[+_], A](implicit A: Arbitrary[S => F[(S, A)]]): Arbitrary[StateT[S, F, A]] =
  399. indexedStateTArb[S, S, F, A](A)
  400. 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]] =
  401. Functor[Arbitrary].map(A)(IndexedReaderWriterStateT[R, W, S1, S2, F, A](_))
  402. implicit def tracedTArb[W[_], A, B](implicit A: Arbitrary[W[A => B]]): Arbitrary[TracedT[W, A, B]] =
  403. Functor[Arbitrary].map(A)(TracedT(_))
  404. implicit def indexedContsTArb[W[_], R, O, M[_], A](implicit A: Arbitrary[W[A => M[O]] => M[R]]): Arbitrary[IndexedContsT[W, R, O, M, A]] =
  405. Functor[Arbitrary].map(A)(IndexedContsT(_))
  406. implicit def indexedStateTArb[S1, S2, F[_], A](implicit A: Arbitrary[S1 => F[(S2, A)]]): Arbitrary[IndexedStateT[S1, S2, F, A]] =
  407. Functor[Arbitrary].map(A)(IndexedStateT[S1, S2, F, A](_))
  408. implicit def eitherTArb[A, F[_], B](implicit A: Arbitrary[F[A \/ B]]): Arbitrary[EitherT[A, F, B]] =
  409. Functor[Arbitrary].map(A)(EitherT[A, F, B](_))
  410. implicit def theseTArb[F[_], A, B](implicit A: Arbitrary[F[A \&/ B]]): Arbitrary[TheseT[F, A, B]] =
  411. Functor[Arbitrary].map(A)(TheseT[F, A, B](_))
  412. implicit def constArbitrary[A: Arbitrary, B]: Arbitrary[Const[A, B]] =
  413. Functor[Arbitrary].map(arb[A])(Const(_))
  414. implicit def dlistArbitrary[A](implicit A: Arbitrary[List[A]]): Arbitrary[DList[A]] = Functor[Arbitrary].map(A)(as => DList(as : _*))
  415. implicit def ilistArbitrary[A](implicit A: Arbitrary[List[A]]): Arbitrary[IList[A]] = Functor[Arbitrary].map(A)(IList.fromList)
  416. implicit def dequeueArbitrary[A](implicit A: Arbitrary[List[A]]): Arbitrary[Dequeue[A]] = Functor[Arbitrary].map(A)(Dequeue.apply)
  417. implicit def lazyTuple2Arbitrary[A: Arbitrary, B: Arbitrary]: Arbitrary[LazyTuple2[A, B]] =
  418. Applicative[Arbitrary].apply2(arb[A], arb[B])(LazyTuple2(_, _))
  419. implicit def lazyTuple3Arbitrary[A: Arbitrary, B: Arbitrary, C: Arbitrary]: Arbitrary[LazyTuple3[A, B, C]] =
  420. Applicative[Arbitrary].apply3(arb[A], arb[B], arb[C])(LazyTuple3(_, _, _))
  421. implicit def lazyTuple4Arbitrary[A: Arbitrary, B: Arbitrary, C: Arbitrary, D: Arbitrary]: Arbitrary[LazyTuple4[A, B, C, D]] =
  422. Applicative[Arbitrary].apply4(arb[A], arb[B], arb[C], arb[D])(LazyTuple4(_, _, _, _))
  423. implicit def heapArbitrary[A](implicit O: Order[A], A: Arbitrary[List[A]]): Arbitrary[Heap[A]] = {
  424. Functor[Arbitrary].map(A)(as => Heap.fromData(as))
  425. }
  426. // backwards compatibility
  427. def storeTArb[F[+_], A, B](implicit A: Arbitrary[(F[A => B], A)]): Arbitrary[StoreT[F, A, B]] = indexedStoreTArb[F, A, A, B](A)
  428. implicit def indexedStoreTArb[F[_], I, A, B](implicit A: Arbitrary[(F[A => B], I)]): Arbitrary[IndexedStoreT[F, I, A, B]] = Functor[Arbitrary].map(A)(IndexedStoreT[F, I, A, B](_))
  429. implicit def listTArb[F[_]: Applicative, A](implicit FA: Arbitrary[F[IList[A]]]): Arbitrary[ListT[F, A]] = Functor[Arbitrary].map(FA)(ListT.fromIList(_))
  430. implicit def streamTArb[F[_], A](implicit FA: Arbitrary[F[LazyList[A]]], F: Applicative[F]): Arbitrary[StreamT[F, A]] = Functor[Arbitrary].map(FA)(StreamT.fromLazyList(_))
  431. implicit def CaseInsensitiveArbitrary[A](implicit A0: Arbitrary[A], A1: FoldCase[A]): Arbitrary[CaseInsensitive[A]] =
  432. Functor[Arbitrary].map(A0)(CaseInsensitive(_))
  433. implicit def dievArbitrary[A](implicit A: Arbitrary[List[A]], E: Enum[A]): Arbitrary[Diev[A]] = Functor[Arbitrary].map(A)(_.grouped(2).foldLeft(Diev.empty[A]){(working, possiblePair) =>
  434. possiblePair match {
  435. case first :: second :: Nil => working + ((first, second))
  436. case value :: Nil => working
  437. case _ => sys.error("Unexpected amount of items in paired list.")
  438. }
  439. })
  440. implicit def iterateeInputArbitrary[A: Arbitrary]: Arbitrary[scalaz.iteratee.Input[A]] = {
  441. import scalaz.iteratee.Input._
  442. Arbitrary(Gen.oneOf(
  443. Gen.const(emptyInput[A]),
  444. Gen.const(eofInput[A]),
  445. arbitrary[A].map(e => elInput(e))
  446. ))
  447. }
  448. }