| Copyright | (c) Paul Johnson 2006 |
|---|---|
| License | BSD-style |
| Maintainer | paul@cogito.org.uk |
| Stability | experimental |
| Portability | portable |
| Safe Haskell | Safe |
| Language | Haskell98 |
Data.Ranged.Boundaries
Description
Documentation
class Ord a => DiscreteOrdered a where #
Distinguish between dense and sparse ordered types. A dense type is
one in which any two values v1 < v2 have a third value v3 such that
v1 < v3 < v2.
In theory the floating types are dense, although in practice they can only have finitely many values. This class treats them as dense.
Tuples up to 4 members are declared as instances. Larger tuples may be added if necessary.
Most values of sparse types have an adjacentBelow, such that, for all x:
case adjacentBelow x of Just x1 -> adjacent x1 x Nothing -> True
The exception is for bounded types when x == lowerBound. For dense types
adjacentBelow always returns Nothing.
This approach was suggested by Ben Rudiak-Gould on comp.lang.functional.
Minimal complete definition
Methods
Two values x and y are adjacent if x < y and there does not
exist a third value between them. Always False for dense types.
adjacentBelow :: a -> Maybe a #
The value immediately below the argument, if it can be determined.
Instances
| DiscreteOrdered Bool # | |
| DiscreteOrdered Char # | |
| DiscreteOrdered Double # | |
| DiscreteOrdered Float # | |
| DiscreteOrdered Int # | |
| DiscreteOrdered Integer # | |
| DiscreteOrdered Ordering # | |
| Ord a => DiscreteOrdered [a] # | |
| Integral a => DiscreteOrdered (Ratio a) # | |
| (Ord a, DiscreteOrdered b) => DiscreteOrdered (a, b) # | |
| (Ord a, Ord b, DiscreteOrdered c) => DiscreteOrdered (a, b, c) # | |
| (Ord a, Ord b, Ord c, DiscreteOrdered d) => DiscreteOrdered (a, b, c, d) # | |
enumAdjacent :: (Ord a, Enum a) => a -> a -> Bool #
Check adjacency for sparse enumerated types (i.e. where there
is no value between x and succ x).
boundedAdjacent :: (Ord a, Enum a) => a -> a -> Bool #
Check adjacency, allowing for case where x = maxBound. Use as the definition of "adjacent" for bounded enumerated types such as Int and Char.
boundedBelow :: (Eq a, Enum a, Bounded a) => a -> Maybe a #
The usual implementation of adjacentBelow for bounded enumerated types.
A Boundary is a division of an ordered type into values above and below the boundary. No value can sit on a boundary.
Known bug: for Bounded types
BoundaryAbove maxBound < BoundaryAboveAll
BoundaryBelow minBound > BoundaryBelowAll
This is incorrect because there are no possible values in between the left and right sides of these inequalities.
Constructors
| BoundaryAbove a | The argument is the highest value below the boundary. |
| BoundaryBelow a | The argument is the lowest value above the boundary. |
| BoundaryAboveAll | The boundary above all values. |
| BoundaryBelowAll | The boundary below all values. |
Instances
| DiscreteOrdered a => Eq (Boundary a) # | |
| DiscreteOrdered a => Ord (Boundary a) # | |
| Show a => Show (Boundary a) # | |
| Arbitrary a => Arbitrary (Boundary a) # | |
| CoArbitrary a => CoArbitrary (Boundary a) # | |