- class Ord a => DiscreteOrdered a where
- enumAdjacent :: (Ord a, Enum a) => a -> a -> Bool
- boundedAdjacent :: (Ord a, Enum a) => a -> a -> Bool
- data Boundary a
- above :: Ord v => Boundary v -> v -> Bool
- (/>/) :: Ord v => v -> Boundary v -> Bool
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.
This approach was suggested by Ben Rudiak-Gould on comp.lang.functional.
y are adjacent if
x < y and there does not
exist a third value between them. Always
False for dense types.
|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)|
Check adjacency for sparse enumerated types (i.e. where there
is no value between
succ x). Use as the definition of
adjacent for most enumerated types.
Check adjacency, allowing for case where x = maxBound. Use as the definition of adjacent for bounded enumerated types such as Int and Char.
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.
The argument is the highest value below the boundary.
The argument is the lowest value above the boundary.
The boundary above all values.
The boundary below all values.
True if the value is above the boundary, false otherwise.