
Data.Ranged.Boundaries  Portability  portable  Stability  experimental  Maintainer  paul@cogito.org.uk 





Description 


Synopsis 



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.
This approach was suggested by Ben RudiakGould on comp.lang.functional.
  Methods  adjacent :: a > a > Bool  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.

  Instances  DiscreteOrdered Bool  DiscreteOrdered Char  DiscreteOrdered Double  DiscreteOrdered Float  DiscreteOrdered Int  DiscreteOrdered Integer  DiscreteOrdered Ordering  (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)  Integral a => DiscreteOrdered (Ratio a)  Ord a => DiscreteOrdered [a] 



adjacent :: DiscreteOrdered a => a > a > Bool 
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.


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). Use as the definition of
adjacent for most enumerated types.


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.


data Boundary a 
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
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  


above :: Ord v => Boundary v > v > Bool 
True if the value is above the boundary, false otherwise.


(/>/) :: Ord v => v > Boundary v > Bool 
Same as above, but with the arguments reversed for more intuitive infix
usage.


Produced by Haddock version 0.8 