japgolly.nyaya.test

Gen

object Gen

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. Gen
  2. AnyRef
  3. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Value Members

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

    Definition Classes
    AnyRef
  2. final def !=(arg0: Any): Boolean

    Definition Classes
    Any
  3. final def ##(): Int

    Definition Classes
    AnyRef → Any
  4. final def ==(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  5. final def ==(arg0: Any): Boolean

    Definition Classes
    Any
  6. object Covariance

  7. implicit object GenScalaz extends Monad[Gen]

  8. def alpha: Gen[Char]

  9. def alphanumeric: Gen[Char]

  10. def alphanumerics: GenS[List[Char]]

  11. def alphanumerics1: GenS[NonEmptyList[Char]]

  12. def alphanumericstring: GenS[String]

  13. def alphanumericstring1: GenS[String]

  14. def alphas: GenS[List[Char]]

  15. def alphas1: GenS[NonEmptyList[Char]]

  16. def alphastring: GenS[String]

  17. def alphastring1: GenS[String]

  18. def apply2[A, B, Z](z: (A, B) ⇒ Z)(A: Gen[A], B: Gen[B]): Gen[Z]

  19. def apply3[A, B, C, Z](z: (A, B, C) ⇒ Z)(A: Gen[A], B: Gen[B], C: Gen[C]): Gen[Z]

  20. def apply4[A, B, C, D, Z](z: (A, B, C, D) ⇒ Z)(A: Gen[A], B: Gen[B], C: Gen[C], D: Gen[D]): Gen[Z]

  21. def apply5[A, B, C, D, E, Z](z: (A, B, C, D, E) ⇒ Z)(A: Gen[A], B: Gen[B], C: Gen[C], D: Gen[D], E: Gen[E]): Gen[Z]

  22. def apply6[A, B, C, D, E, F, Z](z: (A, B, C, D, E, F) ⇒ Z)(A: Gen[A], B: Gen[B], C: Gen[C], D: Gen[D], E: Gen[E], F: Gen[F]): Gen[Z]

  23. def apply7[A, B, C, D, E, F, G, Z](z: (A, B, C, D, E, F, G) ⇒ Z)(A: Gen[A], B: Gen[B], C: Gen[C], D: Gen[D], E: Gen[E], F: Gen[F], G: Gen[G]): Gen[Z]

  24. def apply8[A, B, C, D, E, F, G, H, Z](z: (A, B, C, D, E, F, G, H) ⇒ Z)(A: Gen[A], B: Gen[B], C: Gen[C], D: Gen[D], E: Gen[E], F: Gen[F], G: Gen[G], H: Gen[H]): Gen[Z]

  25. def apply9[A, B, C, D, E, F, G, H, I, Z](z: (A, B, C, D, E, F, G, H, I) ⇒ Z)(A: Gen[A], B: Gen[B], C: Gen[C], D: Gen[D], E: Gen[E], F: Gen[F], G: Gen[G], H: Gen[H], I: Gen[I]): Gen[Z]

  26. final def asInstanceOf[T0]: T0

    Definition Classes
    Any
  27. def boolean: Gen[Boolean]

  28. def byte: Gen[Byte]

  29. def char: Gen[Char]

  30. def charof(ev: Char, s: String, rs: NumericRange[Char]*): Gen[Char]

  31. def chars: GenS[List[Char]]

  32. def chars1: GenS[NonEmptyList[Char]]

  33. def choosedouble(l: Double, h: Double): Gen[Double]

    Args are inclusive.

    Args are inclusive. [l,h]

  34. def choosefloat(l: Float, h: Float): Gen[Float]

    Args are inclusive.

    Args are inclusive. [l,h]

  35. def chooseint(l: Int, h: Int): Gen[Int]

    Args are inclusive.

    Args are inclusive. [l,h]

  36. def chooselong(l: Long, h: Long): Gen[Long]

    Args are inclusive.

    Args are inclusive. [l,h]

  37. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  38. def digit: Gen[Digit]

  39. def digits: GenS[List[Digit]]

  40. def digits1: GenS[NonEmptyList[Digit]]

  41. def distribute[F[_], B](a: Gen[F[B]])(implicit D: Distributive[F]): F[Gen[B]]

  42. def distributeK[F[_], A, B](a: Gen[Kleisli[F, A, B]])(implicit D: Distributive[F]): Kleisli[F, A, Gen[B]]

  43. def distributeR[A, B](a: Gen[(A) ⇒ B]): (A) ⇒ Gen[B]

  44. def distributeRK[A, B](a: Gen[(A) ⇒ B]): Kleisli[Gen, A, B]

  45. def double: Gen[Double]

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

    Definition Classes
    AnyRef
  47. def equals(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any
  48. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  49. def float: Gen[Float]

  50. def frequency[A](x: (Int, Gen[A]), xs: (Int, Gen[A])*): Gen[A]

  51. def frequencyL[A](l: NonEmptyList[(Int, Gen[A])]): Gen[A]

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

    Definition Classes
    AnyRef → Any
  53. def hashCode(): Int

    Definition Classes
    AnyRef → Any
  54. def identifier: GenS[NonEmptyList[Char]]

  55. def identifierstring: GenS[String]

  56. def insert[A](a: A): Gen[A]

  57. def int: Gen[Int]

  58. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any
  59. def lift[A](f: (Size) ⇒ Rng[A]): GenS[A]

  60. def long: Gen[Long]

  61. def lower: Gen[Char]

  62. def lowers: GenS[List[Char]]

  63. def lowers1: GenS[NonEmptyList[Char]]

  64. def lowerstring: GenS[String]

  65. def lowerstring1: GenS[String]

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

    Definition Classes
    AnyRef
  67. def negativedouble: Gen[Double]

  68. def negativefloat: Gen[Float]

  69. def negativeint: Gen[Int]

  70. def negativelong: Gen[Long]

  71. final def notify(): Unit

    Definition Classes
    AnyRef
  72. final def notifyAll(): Unit

    Definition Classes
    AnyRef
  73. def numeric: Gen[Char]

  74. def numerics: GenS[List[Char]]

  75. def numerics1: GenS[NonEmptyList[Char]]

  76. def numericstring: GenS[String]

  77. def numericstring1: GenS[String]

  78. def oneof[A](a: A, as: A*): Gen[A]

  79. def oneofG[A](a: Gen[A], as: Gen[A]*): Gen[A]

  80. def oneofGC[A, B >: A](a: Gen[A], as: Gen[A]*): Gen[B]

  81. def oneofL[A](x: NonEmptyList[A]): Gen[A]

  82. def oneofSeq[A](as: Seq[A]): Gen[Option[A]]

  83. def oneofV[A](x: OneAnd[Vector, A]): Gen[A]

  84. def pair[A, B](A: Gen[A], B: Gen[B]): Gen[(A, B)]

  85. def positivedouble: Gen[Double]

  86. def positivefloat: Gen[Float]

  87. def positiveint: Gen[Int]

  88. def positivelong: Gen[Long]

  89. def propernoun: GenS[NonEmptyList[Char]]

  90. def propernounstring: GenS[String]

  91. def sequence[T[_], A](x: T[Gen[A]])(implicit T: Traverse[T]): Gen[T[A]]

  92. def sequencePair[X, A](x: X, r: Gen[A]): Gen[(X, A)]

  93. def short: Gen[Short]

  94. def shuffle[T, CC[X] <: TraversableOnce[X]](xs: CC[T])(implicit bf: CanBuildFrom[CC[T], T, CC[T]]): Gen[CC[T]]

  95. def string: GenS[String]

  96. def string1: GenS[String]

  97. def subset[A](as: TraversableOnce[A]): Gen[Vector[A]]

    Provides random subsets of the input set.

    Provides random subsets of the input set. Randomly deletes elements.

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

    Definition Classes
    AnyRef
  99. def toString(): String

    Definition Classes
    AnyRef → Any
  100. def triple[A, B, C](A: Gen[A], B: Gen[B], C: Gen[C]): Gen[(A, B, C)]

  101. def tuple2[A, B](A: Gen[A], B: Gen[B]): Gen[(A, B)]

  102. def tuple3[A, B, C](A: Gen[A], B: Gen[B], C: Gen[C]): Gen[(A, B, C)]

  103. def tuple4[A, B, C, D](A: Gen[A], B: Gen[B], C: Gen[C], D: Gen[D]): Gen[(A, B, C, D)]

  104. def tuple5[A, B, C, D, E](A: Gen[A], B: Gen[B], C: Gen[C], D: Gen[D], E: Gen[E]): Gen[(A, B, C, D, E)]

  105. def tuple6[A, B, C, D, E, F](A: Gen[A], B: Gen[B], C: Gen[C], D: Gen[D], E: Gen[E], F: Gen[F]): Gen[(A, B, C, D, E, F)]

  106. def tuple7[A, B, C, D, E, F, G](A: Gen[A], B: Gen[B], C: Gen[C], D: Gen[D], E: Gen[E], F: Gen[F], G: Gen[G]): Gen[(A, B, C, D, E, F, G)]

  107. def tuple8[A, B, C, D, E, F, G, H](A: Gen[A], B: Gen[B], C: Gen[C], D: Gen[D], E: Gen[E], F: Gen[F], G: Gen[G], H: Gen[H]): Gen[(A, B, C, D, E, F, G, H)]

  108. def tuple9[A, B, C, D, E, F, G, H, I](A: Gen[A], B: Gen[B], C: Gen[C], D: Gen[D], E: Gen[E], F: Gen[F], G: Gen[G], H: Gen[H], I: Gen[I]): Gen[(A, B, C, D, E, F, G, H, I)]

  109. def unit: Gen[Unit]

  110. def unsized[A](rng: Rng[A]): Gen[A]

  111. def upper: Gen[Char]

  112. def uppers: GenS[List[Char]]

  113. def uppers1: GenS[NonEmptyList[Char]]

  114. def upperstring: GenS[String]

  115. def upperstring1: GenS[String]

  116. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  117. final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  118. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

Inherited from AnyRef

Inherited from Any

Ungrouped