Portability | portable |
---|---|

Stability | experimental |

Maintainer | chris@chr-breitkopf.de |

A conservative implementation of Intervals, mostly for use as keys in
a `Data.IntervalMap`

.

This should really be a typeclass, so you could have a tuple be an instance of Interval, but that is currently not possible in standard Haskell.

The contructor names of the half-open intervals seem somewhat clumsy, and I'm open to suggestions for better names.

- data Interval a
- = IntervalCO !a !a
- | ClosedInterval !a !a
- | OpenInterval !a !a
- | IntervalOC !a !a

- lowerBound :: Interval a -> a
- upperBound :: Interval a -> a
- leftClosed :: Interval a -> Bool
- rightClosed :: Interval a -> Bool
- isEmpty :: Ord a => Interval a -> Bool
- overlaps :: Ord a => Interval a -> Interval a -> Bool
- subsumes :: Ord a => Interval a -> Interval a -> Bool
- before :: Ord a => Interval a -> Interval a -> Bool
- after :: Ord a => Interval a -> Interval a -> Bool
- compareByUpper :: Ord a => Interval a -> Interval a -> Ordering
- below :: Ord a => a -> Interval a -> Bool
- inside :: Ord a => a -> Interval a -> Bool
- above :: Ord a => a -> Interval a -> Bool

# Interval type

Intervals with endpoints of type `a`

.

`Read`

and `Show`

use mathematical notation with square brackets for closed
and parens for open intervals.
This is better for human readability, but is not a valid Haskell expression.
Closed intervals look like a list, open intervals look like a tuple,
and half-open intervals look like mismatched parens.

IntervalCO !a !a | Including lower bound, excluding upper |

ClosedInterval !a !a | Closed at both ends |

OpenInterval !a !a | Open at both ends |

IntervalOC !a !a | Excluding lower bound, including upper |

# Query

lowerBound :: Interval a -> aSource

Get the lower bound.

upperBound :: Interval a -> aSource

Get the upper bound.

leftClosed :: Interval a -> BoolSource

Does the interval include its lower bound?

rightClosed :: Interval a -> BoolSource

Does the interval include its upper bound?

# Interval operations

subsumes :: Ord a => Interval a -> Interval a -> BoolSource

Does the first interval completely contain the second?

before :: Ord a => Interval a -> Interval a -> BoolSource

Interval strictly before another? True if the upper bound of the first interval is below the lower bound of the second.

after :: Ord a => Interval a -> Interval a -> BoolSource

Interval strictly after another? Same as 'flip before'.

compareByUpper :: Ord a => Interval a -> Interval a -> OrderingSource

Like `compare`

, but considering the upper bound first.