Safe Haskell | None |
---|---|

Language | Haskell2010 |

## Synopsis

- newtype Size = Size {}
- data Range a
- origin :: Range a -> a
- bounds :: Size -> Range a -> (a, a)
- lowerBound :: Ord a => Size -> Range a -> a
- upperBound :: Ord a => Size -> Range a -> a
- singleton :: a -> Range a
- constant :: a -> a -> Range a
- constantFrom :: a -> a -> a -> Range a
- constantBounded :: (Bounded a, Num a) => Range a
- linear :: Integral a => a -> a -> Range a
- linearFrom :: Integral a => a -> a -> a -> Range a
- linearFrac :: (Fractional a, Ord a) => a -> a -> Range a
- linearFracFrom :: (Fractional a, Ord a) => a -> a -> a -> Range a
- linearBounded :: (Bounded a, Integral a) => Range a
- exponential :: Integral a => a -> a -> Range a
- exponentialFrom :: Integral a => a -> a -> a -> Range a
- exponentialBounded :: (Bounded a, Integral a) => Range a
- exponentialFloat :: (Floating a, Ord a) => a -> a -> Range a
- exponentialFloatFrom :: (Floating a, Ord a) => a -> a -> a -> Range a

# Size

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.

# Range

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.

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.

`>>>`

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

`>>>`

5`origin $ singleton 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`

:

`>>>`

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

`>>>`

0`origin $ constant 0 10`

:: 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`

:

`>>>`

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

`>>>`

0`origin $ constantFrom 0 (-10) 10`

A range from `1970`

to `2100`

, with the origin at `2000`

:

`>>>`

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

`>>>`

2000`origin $ constantFrom 2000 1970 2100`

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`

:

`>>>`

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

`>>>`

0`origin (constantBounded :: Range Int8)`

# Linear

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

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

`>>>`

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

`>>>`

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

`>>>`

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

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

`>>>`

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

`>>>`

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

`>>>`

(-10,20)`bounds 99 $ linearFrom 0 (-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.

`>>>`

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

`>>>`

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

`>>>`

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

# Exponential

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

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

`>>>`

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

`>>>`

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

`>>>`

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

`>>>`

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

`>>>`

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

`>>>`

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

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

`>>>`

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

`>>>`

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

`>>>`

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

`>>>`

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

`>>>`

(-128,512)`bounds 99 $ exponentialFrom x (-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.

`>>>`

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

`>>>`

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

`>>>`

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

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

`>>>`

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

`>>>`

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

`>>>`

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

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

`>>>`

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

`>>>`

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

`>>>`

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