hedgehog

Type Members

type Gen[A] = GenT[A]
trait GenTOps extends MonadGenOps[Gen]
type MonadGen[M[_]] = MonadGenT[M]
trait MonadGenOps[M[_]] extends AnyRef
type Property = PropertyT[Result]
type PropertyR[A] = hedgehog.core.PropertyR[A]
trait PropertyTOps extends PropertyTReporting
case class Range[A](origin: A, bounds: (Size) ⇒ (A, A)) extends Product with Serializable

A range describes the bounds of a number to generate, which may or may not be dependent on a 'Size'.
A range describes the bounds of a number to generate, which may or may not be dependent on a 'Size'.
origin
Get the origin of a range. This might be the mid-point or the lower bound, depending on what the range represents. The 'bounds' of a range are scaled around this value when using the 'linear' family of combinators. When using a 'Range' to generate numbers, the shrinking function will shrink towards the origin.
bounds
Get the extents of a range, for a given size.
type Result = hedgehog.core.Result
sealed abstract case class Size extends Product with Serializable

Tests are parameterized by the size of the randomly-generated data, the meaning of which depends on the particular generator used.
implicit class Syntax[A] extends AnyRef

Value Members

object Gen extends GenTOps with ByteOps with CharacterOps with StringOps with Serializable

This is _purely_ to make consuming this library a nicer experience, mainly due to Scala's type inference problems and higher kinds.
def MonadGen[M[_]]: MonadGenOps[M]
object Property extends PropertyTOps with Serializable
val PropertyR: hedgehog.core.PropertyR.type
object Range extends Serializable
val Result: hedgehog.core.Result.type
object Size extends Serializable
package core
package extra
def forTupled[M[_], A, B, C, D, E, F, G, H, I](ma: M[A], mb: M[B], mc: M[C], md: M[D], me: M[E], mf: M[F], mg: M[G], mh: M[H], mi: M[I])(implicit F: Applicative[M]): M[(A, B, C, D, E, F, G, H, I)]

Definition Classes
ApplicativeSyntax
def forTupled[M[_], A, B, C, D, E, F, G, H](ma: M[A], mb: M[B], mc: M[C], md: M[D], me: M[E], mf: M[F], mg: M[G], mh: M[H])(implicit F: Applicative[M]): M[(A, B, C, D, E, F, G, H)]

Definition Classes
ApplicativeSyntax
def forTupled[M[_], A, B, C, D, E, F, G](ma: M[A], mb: M[B], mc: M[C], md: M[D], me: M[E], mf: M[F], mg: M[G])(implicit F: Applicative[M]): M[(A, B, C, D, E, F, G)]

Definition Classes
ApplicativeSyntax
def forTupled[M[_], A, B, C, D, E, F](ma: M[A], mb: M[B], mc: M[C], md: M[D], me: M[E], mf: M[F])(implicit F: Applicative[M]): M[(A, B, C, D, E, F)]

Definition Classes
ApplicativeSyntax
def forTupled[M[_], A, B, C, D, E](ma: M[A], mb: M[B], mc: M[C], md: M[D], me: M[E])(implicit F: Applicative[M]): M[(A, B, C, D, E)]

Definition Classes
ApplicativeSyntax
def forTupled[M[_], A, B, C, D](ma: M[A], mb: M[B], mc: M[C], md: M[D])(implicit F: Applicative[M]): M[(A, B, C, D)]

Definition Classes
ApplicativeSyntax
def forTupled[M[_], A, B, C](ma: M[A], mb: M[B], mc: M[C])(implicit F: Applicative[M]): M[(A, B, C)]

Definition Classes
ApplicativeSyntax
def forTupled[M[_], A, B](ma: M[A], mb: M[B])(implicit F: Applicative[M]): M[(A, B)]

Definition Classes
ApplicativeSyntax
package predef

We have our own FP predef for 2 reasons.
We have our own FP predef for 2 reasons.
1. The obvious political reasons. I don't think there are any really good reasons to need more than one implementation of this library (if we do our job correctly).
Probably more importantly:
2. Library dependencies _do_ have a cost. Especially in the JVM world where we insist of relying on binary compatibility.
def propertyT: PropertyTOps
package random
package state

package hedgehog

Type Members

type Gen[A] = GenT[A]

trait GenTOps extends MonadGenOps[Gen]

type MonadGen[M[_]] = MonadGenT[M]

trait MonadGenOps[M[_]] extends AnyRef

type Property = PropertyT[Result]

type PropertyR[A] = hedgehog.core.PropertyR[A]

trait PropertyTOps extends PropertyTReporting

case class Range[A](origin: A, bounds: (Size) ⇒ (A, A)) extends Product with Serializable

type Result = hedgehog.core.Result

sealed abstract case class Size extends Product with Serializable

implicit class Syntax[A] extends AnyRef

Value Members

object Gen extends GenTOps with ByteOps with CharacterOps with StringOps with Serializable

def MonadGen[M[_]]: MonadGenOps[M]

object Property extends PropertyTOps with Serializable

val PropertyR: hedgehog.core.PropertyR.type

object Range extends Serializable

val Result: hedgehog.core.Result.type

object Size extends Serializable

package core

package extra

def forTupled[M[_], A, B, C, D, E, F, G, H, I](ma: M[A], mb: M[B], mc: M[C], md: M[D], me: M[E], mf: M[F], mg: M[G], mh: M[H], mi: M[I])(implicit F: Applicative[M]): M[(A, B, C, D, E, F, G, H, I)]

def forTupled[M[_], A, B, C, D, E, F, G, H](ma: M[A], mb: M[B], mc: M[C], md: M[D], me: M[E], mf: M[F], mg: M[G], mh: M[H])(implicit F: Applicative[M]): M[(A, B, C, D, E, F, G, H)]

def forTupled[M[_], A, B, C, D, E, F, G](ma: M[A], mb: M[B], mc: M[C], md: M[D], me: M[E], mf: M[F], mg: M[G])(implicit F: Applicative[M]): M[(A, B, C, D, E, F, G)]

def forTupled[M[_], A, B, C, D, E, F](ma: M[A], mb: M[B], mc: M[C], md: M[D], me: M[E], mf: M[F])(implicit F: Applicative[M]): M[(A, B, C, D, E, F)]

def forTupled[M[_], A, B, C, D, E](ma: M[A], mb: M[B], mc: M[C], md: M[D], me: M[E])(implicit F: Applicative[M]): M[(A, B, C, D, E)]

def forTupled[M[_], A, B, C, D](ma: M[A], mb: M[B], mc: M[C], md: M[D])(implicit F: Applicative[M]): M[(A, B, C, D)]

def forTupled[M[_], A, B, C](ma: M[A], mb: M[B], mc: M[C])(implicit F: Applicative[M]): M[(A, B, C)]

def forTupled[M[_], A, B](ma: M[A], mb: M[B])(implicit F: Applicative[M]): M[(A, B)]

package predef

def propertyT: PropertyTOps

package random

package state

Inherited from ApplicativeSyntax

Inherited from AnyRef

Inherited from Any

Ungrouped