Safe Haskell	None
Language	Haskell98

Hedgehog.Internal.Range

Contents

Size
Range
Constant
Linear
Exponential
Internal

Synopsis

Size

newtype Size Source #

Tests are parameterized by the size of the randomly-generated data, the meaning of which depends on the particular generator used.

Constructors

Size
Fields unSize :: Int

Instances

Enum Size Source #
Methods succ :: Size -> Size # pred :: Size -> Size # toEnum :: Int -> Size # fromEnum :: Size -> Int # enumFrom :: Size -> [Size] # enumFromThen :: Size -> Size -> [Size] # enumFromTo :: Size -> Size -> [Size] # enumFromThenTo :: Size -> Size -> Size -> [Size] #
Eq Size Source #
Methods (==) :: Size -> Size -> Bool # (/=) :: Size -> Size -> Bool #
Integral Size Source #
Methods quot :: Size -> Size -> Size # rem :: Size -> Size -> Size # div :: Size -> Size -> Size # mod :: Size -> Size -> Size # quotRem :: Size -> Size -> (Size, Size) # divMod :: Size -> Size -> (Size, Size) # toInteger :: Size -> Integer #
Num Size Source #
Methods (+) :: Size -> Size -> Size # (-) :: Size -> Size -> Size # (*) :: Size -> Size -> Size # negate :: Size -> Size # abs :: Size -> Size # signum :: Size -> Size # fromInteger :: Integer -> Size #
Ord Size Source #
Methods compare :: Size -> Size -> Ordering # (<) :: Size -> Size -> Bool # (<=) :: Size -> Size -> Bool # (>) :: Size -> Size -> Bool # (>=) :: Size -> Size -> Bool # max :: Size -> Size -> Size # min :: Size -> Size -> Size #
Read Size Source #
Methods readsPrec :: Int -> ReadS Size # readList :: ReadS [Size] # readPrec :: ReadPrec Size # readListPrec :: ReadPrec [Size] #
Real Size Source #
Methods toRational :: Size -> Rational #
Show Size Source #
Methods showsPrec :: Int -> Size -> ShowS # show :: Size -> String # showList :: [Size] -> ShowS #

Range

data Range a Source #

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.

Constructors

Range !a (Size -> (a, a))

Instances

Functor Range Source #
Methods fmap :: (a -> b) -> Range a -> Range b # (<$) :: a -> Range b -> Range a #

origin :: Range a -> a Source #

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 :: Size -> Range a -> (a, a) Source #

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

lowerBound :: Ord a => Size -> Range a -> a Source #

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

upperBound :: Ord a => Size -> Range a -> a Source #

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

Constant

singleton :: a -> Range a Source #

Construct a range which represents a constant single value.

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

>>> origin $ singleton 5
5

constant :: a -> a -> Range a Source #

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 10
0

constantFrom Source #

Arguments

:: a	Origin (the value produced when the size parameter is 0).
-> a	Lower bound (the bottom of the range when the size parameter is 99).
-> a	Upper bound (the top of the range when the size parameter is 99).
-> Range a

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) 10
0

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

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

>>> origin $ constantFrom 2000 1970 2100
2000

constantBounded :: (Bounded a, Num a) => Range a Source #

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

Linear

linear :: Integral a => a -> a -> Range a Source #

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)

linearFrom Source #

Arguments

:: Integral a
=> a	Origin (the value produced when the size parameter is 0).
-> a	Lower bound (the bottom of the range when the size parameter is 99).
-> a	Upper bound (the top of the range when the size parameter is 99).
-> Range a

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)

linearFrac :: (Fractional a, Ord a) => a -> a -> Range a Source #

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

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

linearFracFrom :: (Fractional a, Ord a) => a -> a -> a -> Range a Source #

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

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

linearBounded :: (Bounded a, Integral a) => Range a Source #

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)

Exponential

exponential :: Integral a => a -> a -> Range a Source #

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)

exponentialFrom Source #

Arguments

:: Integral a
=> a	Origin (the value produced when the size parameter is 0).
-> a	Lower bound (the bottom of the range when the size parameter is 99).
-> a	Upper bound (the top of the range when the size parameter is 99).
-> Range a

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)

exponentialBounded :: (Bounded a, Integral a) => Range a Source #

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)

exponentialFloat :: (Floating a, Ord a) => a -> a -> Range a Source #

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)

exponentialFloatFrom :: (Floating a, Ord a) => a -> a -> a -> Range a Source #

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)

Internal

These functions are exported in case you need them in a pinch, but are not part of the public API and may change at any time, even as part of a minor update.

clamp :: Ord a => a -> a -> a -> a Source #

Truncate a value so it stays within some range.

>>> clamp 5 10 15
10

>>> clamp 5 10 0
5

scaleLinear :: Integral a => Size -> a -> a -> a Source #

Scale an integral linearly with the size parameter.

scaleLinearFrac :: Fractional a => Size -> a -> a -> a Source #

Scale a fractional number linearly with the size parameter.

scaleExponential :: Integral a => Size -> a -> a -> a Source #

Scale an integral exponentially with the size parameter.

scaleExponentialFloat :: Floating a => Size -> a -> a -> a Source #

Scale a floating-point number exponentially with the size parameter.