```{-# LANGUAGE Trustworthy #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}

-----------------------------------------------------------------------------
-- |
-- Module      :  Data.Ord
-- Copyright   :  (c) The University of Glasgow 2005
-- License     :  BSD-style (see the file libraries/base/LICENSE)
--
-- Maintainer  :  libraries@haskell.org
-- Stability   :  stable
-- Portability :  portable
--
-- Orderings
--
-----------------------------------------------------------------------------

module Data.Ord (
Ord(..),
Ordering(..),
Down(..),
comparing,
) where

import Data.Bits (Bits, FiniteBits)
import Foreign.Storable (Storable)
import GHC.Ix (Ix)
import GHC.Base
import GHC.Enum (Bounded, Enum)
import GHC.Float (Floating, RealFloat)
import GHC.Num
import GHC.Real (Fractional, Integral, Real, RealFrac)
import GHC.Show

-- |
-- > comparing p x y = compare (p x) (p y)
--
-- Useful combinator for use in conjunction with the @xxxBy@ family
-- of functions from "Data.List", for example:
--
-- >   ... sortBy (comparing fst) ...
comparing :: (Ord a) => (b -> a) -> b -> b -> Ordering
comparing :: (b -> a) -> b -> b -> Ordering
comparing b -> a
p b
x b
y = a -> a -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (b -> a
p b
x) (b -> a
p b
y)

-- | The 'Down' type allows you to reverse sort order conveniently.  A value of type
-- @'Down' a@ contains a value of type @a@ (represented as @'Down' a@).
-- If @a@ has an @'Ord'@ instance associated with it then comparing two
-- values thus wrapped will give you the opposite of their normal sort order.
-- This is particularly useful when sorting in generalised list comprehensions,
-- as in: @then sortWith by 'Down' x@
--
-- @since 4.6.0.0
newtype Down a = Down
{ Down a -> a
getDown :: a -- ^ @since 4.14.0.0
}
deriving
( Eq        -- ^ @since 4.6.0.0
, Num       -- ^ @since 4.11.0.0
, Semigroup -- ^ @since 4.11.0.0
, Monoid    -- ^ @since 4.11.0.0
, Bits       -- ^ @since 4.14.0.0
, Bounded    -- ^ @since 4.14.0.0
, Enum       -- ^ @since 4.14.0.0
, FiniteBits -- ^ @since 4.14.0.0
, Floating   -- ^ @since 4.14.0.0
, Fractional -- ^ @since 4.14.0.0
, Integral   -- ^ @since 4.14.0.0
, Ix         -- ^ @since 4.14.0.0
, Real       -- ^ @since 4.14.0.0
, RealFrac   -- ^ @since 4.14.0.0
, RealFloat  -- ^ @since 4.14.0.0
, Storable   -- ^ @since 4.14.0.0
)

-- | This instance would be equivalent to the derived instances of the
-- 'Down' newtype if the 'getDown' field were removed
--
-- @since 4.7.0.0
instance (Read a) => Read (Down a) where
readsPrec :: Int -> ReadS (Down a)
d = Bool -> ReadS (Down a) -> ReadS (Down a)
forall a. Bool -> ReadS a -> ReadS a
d Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
10) (ReadS (Down a) -> ReadS (Down a))
-> ReadS (Down a) -> ReadS (Down a)
forall a b. (a -> b) -> a -> b
\$ \ String
r ->
[(a -> Down a
forall a. a -> Down a
Down a
x,String
t) | (String
"Down",String
s) <- ReadS String
lex String
r, (a
x,String
t) <- Int -> ReadS a
forall a. Read a => Int -> ReadS a
11 String
s]

-- | This instance would be equivalent to the derived instances of the
-- 'Down' newtype if the 'getDown' field were removed
--
-- @since 4.7.0.0
instance (Show a) => Show (Down a) where
showsPrec :: Int -> Down a -> ShowS
showsPrec Int
d (Down a
x) = Bool -> ShowS -> ShowS
showParen (Int
d Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
10) (ShowS -> ShowS) -> ShowS -> ShowS
forall a b. (a -> b) -> a -> b
\$
String -> ShowS
showString String
"Down " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> a -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 a
x

-- | @since 4.6.0.0
instance Ord a => Ord (Down a) where
compare :: Down a -> Down a -> Ordering
compare (Down a
x) (Down a
y) = a
y a -> a -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` a
x

-- | @since 4.11.0.0
instance Functor Down where
fmap :: (a -> b) -> Down a -> Down b
fmap = (a -> b) -> Down a -> Down b
coerce

-- | @since 4.11.0.0
instance Applicative Down where
pure :: a -> Down a
pure = a -> Down a
forall a. a -> Down a
Down
<*> :: Down (a -> b) -> Down a -> Down b
(<*>) = Down (a -> b) -> Down a -> Down b
coerce

-- | @since 4.11.0.0
instance Monad Down where
Down a
a >>= :: Down a -> (a -> Down b) -> Down b
>>= a -> Down b
k = a -> Down b
k a
a
```