hedgehog-0.5.2: Hedgehog will eat all your bugs.

Safe HaskellNone
LanguageHaskell98

Hedgehog.Internal.Range

Contents

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

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 # 
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.

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 :: a -> a -> a -> Range a Source #

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 :: Integral a => a -> a -> a -> Range a Source #

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 :: Integral a => a -> a -> a -> Range a Source #

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.