hedgehog
package hedgehog
- Alphabetic
- By Inheritance
- hedgehog
- ApplicativeSyntax
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Package Members
- package core
- package examples
- package extra
- package minitest
- package munit
- 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.
- package random
- package runner
- package state
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 final class Syntax[A] extends AnyVal
Value Members
- def MonadGen[M[_]]: MonadGenOps[M]
- val PropertyR: hedgehog.core.PropertyR.type
- val Result: hedgehog.core.Result.type
- 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
- def propertyT: PropertyTOps
- object Gen extends GenTOps with ByteOps with CharacterOps with StringOps
This is _purely_ to make consuming this library a nicer experience, mainly due to Scala's type inference problems and higher kinds.
- object Property extends PropertyTOps
- object Range extends Serializable
- object Size extends Serializable