module Data.Ordering (
    -- * Simple functions
    flipOrdering,
    ifEQ, noLT, noGT,
    isLE, isNE, isGE,
    toSign, fromSign, adjustBy,
    -- * Reexports from @base@
    Ordering(..)
) where

import Data.Ord (Ordering(..))

-- | Flip an 'Ordering'
flipOrdering :: Ordering -> Ordering
flipOrdering :: Ordering -> Ordering
flipOrdering Ordering
o =
  case Ordering
o of
    Ordering
LT -> Ordering
GT
    Ordering
EQ -> Ordering
EQ
    Ordering
GT -> Ordering
LT

-- | Replace the 'EQ' case with another 'Ordering'
ifEQ :: Ordering -> Ordering -> Ordering
ifEQ :: Ordering -> Ordering -> Ordering
ifEQ Ordering
i Ordering
o =
  case Ordering
o of
    Ordering
EQ -> Ordering
i
    Ordering
x -> Ordering
x

-- | Clamp 'LT' to 'EQ'
noLT :: Ordering -> Ordering
noLT :: Ordering -> Ordering
noLT Ordering
o =
  case Ordering
o of
    Ordering
LT -> Ordering
EQ
    Ordering
x -> Ordering
x

-- | Clamp 'GT' to 'EQ'
noGT :: Ordering -> Ordering
noGT :: Ordering -> Ordering
noGT Ordering
o =
  case Ordering
o of
    Ordering
GT -> Ordering
EQ
    Ordering
x -> Ordering
x

-- | Check an 'Ordering' represents less-or-equal
isLE :: Ordering -> Bool
isLE :: Ordering -> Bool
isLE = (Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
/= Ordering
GT)

-- | Check an 'Ordering' represents not-equal
isNE :: Ordering -> Bool
isNE :: Ordering -> Bool
isNE = (Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
/= Ordering
EQ)

-- | Check an 'Ordering' represents greater-or-equal
isGE :: Ordering -> Bool
isGE :: Ordering -> Bool
isGE = (Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
/= Ordering
LT)

-- | Returns -1, 0, and 1 for 'LT', 'EQ', and 'GT', respectively
toSign :: Num n => Ordering -> n
toSign :: forall n. Num n => Ordering -> n
toSign Ordering
o =
  case Ordering
o of
    Ordering
LT -> -n
1
    Ordering
EQ -> n
0
    Ordering
GT -> n
1

-- | Get an 'Ordering' depending on the sign of a number
--
--   Compares the number to 0
fromSign :: (Ord n, Num n) => n -> Ordering
fromSign :: forall n. (Ord n, Num n) => n -> Ordering
fromSign n
o = n -> n -> Ordering
forall a. Ord a => a -> a -> Ordering
compare n
o n
0

-- | Adjust a number by a difference up, down, or not at all
adjustBy :: Num a => a -> Ordering -> a -> a
adjustBy :: forall a. Num a => a -> Ordering -> a -> a
adjustBy a
d Ordering
o a
x =
  case Ordering
o of
    Ordering
LT -> a
x a -> a -> a
forall a. Num a => a -> a -> a
- a
d
    Ordering
EQ -> a
x
    Ordering
GT -> a
x a -> a -> a
forall a. Num a => a -> a -> a
+ a
d