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

Stability | stable |

Maintainer | http://homepages.nildram.co.uk/~ahey/em.png |

This module defines a useful variant of the Prelude `Ordering`

data type.

Typically this data type is used as the result of a "combining comparison"
which combines values that are deemed to be equal (somehow). Note that the
functions defined here adhere to the same ordering convention as the overloaded
`compare`

(from the `Ord`

class). That is..

a `compare` b -> LT (or Lt) implies a < b a `compare` b -> GT (or Gt) implies a > b

The combinators exported from this module have a "CC" suffix if they return a combining comparison (most of them) and a "C" suffix if they return an ordinary comparison. All the combinators defined here are INLINEd, in the hope that the compiler can avoid the overhead of using HOFs for frequently used comparisons (dunno if this does any good though :-)

- data COrdering a
- unitCC :: Ord a => a -> a -> COrdering ()
- unitByCC :: (a -> b -> Ordering) -> a -> b -> COrdering ()
- fstCC :: Ord a => a -> a -> COrdering a
- fstByCC :: (a -> b -> Ordering) -> a -> b -> COrdering a
- sndCC :: Ord a => a -> a -> COrdering a
- sndByCC :: (a -> b -> Ordering) -> a -> b -> COrdering b
- flipC :: (a -> b -> Ordering) -> b -> a -> Ordering
- flipCC :: (a -> b -> COrdering c) -> b -> a -> COrdering c
- withCC :: Ord a => (a -> a -> b) -> a -> a -> COrdering b
- withCC' :: Ord a => (a -> a -> b) -> a -> a -> COrdering b
- withByCC :: (a -> b -> Ordering) -> (a -> b -> c) -> a -> b -> COrdering c
- withByCC' :: (a -> b -> Ordering) -> (a -> b -> c) -> a -> b -> COrdering c

# Types

Result of a combining comparison.

# Useful combinators

## Misc.

unitCC :: Ord a => a -> a -> COrdering ()Source

A combining comparison for an instance of `Ord`

which returns unit () where appropriate.

unitCC a b = case compare a b of LT -> Lt EQ -> Eq () GT -> Gt

unitByCC :: (a -> b -> Ordering) -> a -> b -> COrdering ()Source

Create a combining comparison from an ordinary comparison by returning unit () where appropriate.

unitByCC cmp a b = case cmp a b of LT -> Lt EQ -> Eq () GT -> Gt

fstCC :: Ord a => a -> a -> COrdering aSource

A combining comparison for an instance of `Ord`

which keeps the first argument
if they are deemed equal. The second argument is discarded in this case.

fstCC a a' = case compare a a' of LT -> Lt EQ -> Eq a GT -> Gt

fstByCC :: (a -> b -> Ordering) -> a -> b -> COrdering aSource

Create a combining comparison from an ordinary comparison by keeping the first argument if they are deemed equal. The second argument is discarded in this case.

fstByCC cmp a b = case cmp a b of LT -> Lt EQ -> Eq a GT -> Gt

sndCC :: Ord a => a -> a -> COrdering aSource

A combining comparison for an instance of `Ord`

which keeps the second argument
if they are deemed equal. The first argument is discarded in this case.

sndCC a a' = case compare a a' of LT -> Lt EQ -> Eq a' GT -> Gt

sndByCC :: (a -> b -> Ordering) -> a -> b -> COrdering bSource

Create a combining comparison from an ordinary comparison by keeping the second argument if they are deemed equal. The first argument is discarded in this case.

sndByCC cmp a b = case cmp a b of LT -> Lt EQ -> Eq b GT -> Gt

flipC :: (a -> b -> Ordering) -> b -> a -> OrderingSource

Converts a comparison to one which takes arguments in flipped order, but
preserves the ordering that would be given by the "unflipped" version (disregarding type issues).
So it's not the same as using the prelude `flip`

(which would reverse the ordering too).

flipC cmp b a = case cmp a b of LT -> GT EQ -> EQ GT -> LT

flipCC :: (a -> b -> COrdering c) -> b -> a -> COrdering cSource

Converts a combining comparison to one which takes arguments in flipped order, but
preserves the ordering that would be given by the "unflipped" version (disregarding type issues).
So it's not the same as using the prelude `flip`

(which would reverse the ordering too).

flipCC cmp b a = case cmp a b of Lt -> Gt e@(Eq _) -> e Gt -> Lt

## For combining "equal" values with a user supplied function.

withCC' :: Ord a => (a -> a -> b) -> a -> a -> COrdering bSource

Same as `withCC`

, except the combining function is applied strictly.

withCC' f a a' = case compare a a' of LT -> Lt EQ -> let b = f a a' in b `seq` Eq b GT -> Gt