Hedgehog.Range

Tests are parameterized by the size of the randomly-generated data. The meaning of a Size value depends on the particular generator used, but it must always be a number between 0 and 99 inclusive.

A range describes the bounds of a number to generate, which may or may not be dependent on a Size.

The constructor takes an origin between the lower and upper bound, and a function from Size to bounds. As the size goes towards 0, the values go towards the 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.

Get the extents of a range, for a given size.

Get the lower bound of a range for the given size.

Get the upper bound of a range for the given size.

Construct a range which represents a constant single value.

>>> bounds x $ singleton 5(5,5)

>>> origin $ singleton 55

Construct a range which is unaffected by the size parameter.

A range from 0 to 10, with the origin at 0:

>>> bounds x $ constant 0 10(0,10)

>>> origin $ constant 0 100

Construct a range which is unaffected by the size parameter with a origin point which may differ from the bounds.

A range from -10 to 10, with the origin at 0:

>>> bounds x $ constantFrom 0 (-10) 10(-10,10)

>>> origin $ constantFrom 0 (-10) 100

A range from 1970 to 2100, with the origin at 2000:

>>> bounds x $ constantFrom 2000 1970 2100(1970,2100)

>>> origin $ constantFrom 2000 1970 21002000

Construct a range which is unaffected by the size parameter using the full range of a data type.

A range from -128 to 127, with the origin at 0:

>>> bounds x (constantBounded :: Range Int8)(-128,127)

>>> origin (constantBounded :: Range Int8)0

Construct a range which scales the second bound relative to the size parameter.

>>> bounds 0 $ linear 0 10(0,0)

>>> bounds 50 $ linear 0 10(0,5)

>>> bounds 99 $ linear 0 10(0,10)

Construct a range which scales the bounds relative to the size parameter.

>>> bounds 0 $ linearFrom 0 (-10) 10(0,0)

>>> bounds 50 $ linearFrom 0 (-10) 20(-5,10)

>>> bounds 99 $ linearFrom 0 (-10) 20(-10,20)

Construct a range which scales the second bound relative to the size parameter.

This works the same as linear, but for fractional values.

Construct a range which scales the bounds relative to the size parameter.

This works the same as linearFrom, but for fractional values.

Construct a range which is scaled relative to the size parameter and uses the full range of a data type.

>>> bounds 0 (linearBounded :: Range Int8)(0,0)

>>> bounds 50 (linearBounded :: Range Int8)(-64,64)

>>> bounds 99 (linearBounded :: Range Int8)(-128,127)

Construct a range which scales the second bound exponentially relative to the size parameter.

>>> bounds 0 $ exponential 1 512(1,1)

>>> bounds 11 $ exponential 1 512(1,2)

>>> bounds 22 $ exponential 1 512(1,4)

>>> bounds 77 $ exponential 1 512(1,128)

>>> bounds 88 $ exponential 1 512(1,256)

>>> bounds 99 $ exponential 1 512(1,512)

Construct a range which scales the bounds exponentially relative to the size parameter.

>>> bounds 0 $ exponentialFrom 0 (-128) 512(0,0)

>>> bounds 25 $ exponentialFrom 0 (-128) 512(-2,4)

>>> bounds 50 $ exponentialFrom 0 (-128) 512(-11,22)

>>> bounds 75 $ exponentialFrom 0 (-128) 512(-39,112)

>>> bounds 99 $ exponentialFrom x (-128) 512(-128,512)

Construct a range which is scaled exponentially relative to the size parameter and uses the full range of a data type.

>>> bounds 0 (exponentialBounded :: Range Int8)(0,0)

>>> bounds 50 (exponentialBounded :: Range Int8)(-11,11)

>>> bounds 99 (exponentialBounded :: Range Int8)(-128,127)

Construct a range which scales the second bound exponentially relative to the size parameter.

This works the same as exponential, but for floating-point values.

>>> bounds 0 $ exponentialFloat 0 10(0.0,0.0)

>>> bounds 50 $ exponentialFloat 0 10(0.0,2.357035250656098)

>>> bounds 99 $ exponentialFloat 0 10(0.0,10.0)

Construct a range which scales the bounds exponentially relative to the size parameter.

This works the same as exponentialFrom, but for floating-point values.

>>> bounds 0 $ exponentialFloatFrom 0 (-10) 20(0.0,0.0)

>>> bounds 50 $ exponentialFloatFrom 0 (-10) 20(-2.357035250656098,3.6535836249197002)

>>> bounds 99 $ exponentialFloatFrom x (-10) 20(-10.0,20.0)