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

-----------------------------------------------------------------------------
-- |
-- Module      :  Data.Ord
-- Copyright   :  (c) The University of Glasgow 2005
--
-- Stability   :  stable
-- Portability :  portable
--
-- Orderings
--
-----------------------------------------------------------------------------

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

import Data.Bits (Bits, FiniteBits, complement)
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, Real, RealFrac)
import GHC.Show

-- \$setup
-- >>> import Prelude

-- |
-- > 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 :: forall a b. Ord a => (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)

-- |
-- > clamp (low, high) a = min high (max a low)
--
-- Function for ensuring the value @a@ is within the inclusive bounds given by
-- @low@ and @high@. If it is, @a@ is returned unchanged. The result
-- is otherwise @low@ if @a <= low@, or @high@ if @high <= a@.
--
-- When clamp is used at Double and Float, it has NaN propagating semantics in
-- its second argument. That is, @clamp (l,h) NaN = NaN@, but @clamp (NaN, NaN)
-- x = x@.
--
-- >>> clamp (0, 10) 2
-- 2
--
-- >>> clamp ('a', 'm') 'x'
-- 'm'
clamp :: (Ord a) => (a, a) -> a -> a
clamp :: forall a. Ord a => (a, a) -> a -> a
clamp (a
low, a
high) a
a = a -> a -> a
forall a. Ord a => a -> a -> a
min a
high (a -> a -> a
forall a. Ord a => a -> a -> a
max a
a a
low)

-- | 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@.
--
-- >>> compare True False
-- GT
--
-- >>> compare (Down True) (Down False)
-- LT
--
-- If @a@ has a @'Bounded'@ instance then the wrapped instance also respects
-- the reversed ordering by exchanging the values of @'minBound'@ and
-- @'maxBound'@.
--
-- >>> minBound :: Int
-- -9223372036854775808
--
-- >>> minBound :: Down Int
-- Down 9223372036854775807
--
-- All other instances of @'Down' a@ behave as they do for @a@.
--
-- @since 4.6.0.0
newtype Down a = Down
{ forall a. Down a -> a
getDown :: a -- ^ @since 4.14.0.0
}
deriving
( Down a -> Down a -> Bool
(Down a -> Down a -> Bool)
-> (Down a -> Down a -> Bool) -> Eq (Down a)
forall a. Eq a => Down a -> Down a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
\$c== :: forall a. Eq a => Down a -> Down a -> Bool
== :: Down a -> Down a -> Bool
\$c/= :: forall a. Eq a => Down a -> Down a -> Bool
/= :: Down a -> Down a -> Bool
Eq        -- ^ @since 4.6.0.0
, Integer -> Down a
Down a -> Down a
Down a -> Down a -> Down a
(Down a -> Down a -> Down a)
-> (Down a -> Down a -> Down a)
-> (Down a -> Down a -> Down a)
-> (Down a -> Down a)
-> (Down a -> Down a)
-> (Down a -> Down a)
-> (Integer -> Down a)
-> Num (Down a)
forall a. Num a => Integer -> Down a
forall a. Num a => Down a -> Down a
forall a. Num a => Down a -> Down a -> Down a
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
\$c+ :: forall a. Num a => Down a -> Down a -> Down a
+ :: Down a -> Down a -> Down a
\$c- :: forall a. Num a => Down a -> Down a -> Down a
- :: Down a -> Down a -> Down a
\$c* :: forall a. Num a => Down a -> Down a -> Down a
* :: Down a -> Down a -> Down a
\$cnegate :: forall a. Num a => Down a -> Down a
negate :: Down a -> Down a
\$cabs :: forall a. Num a => Down a -> Down a
abs :: Down a -> Down a
\$csignum :: forall a. Num a => Down a -> Down a
signum :: Down a -> Down a
\$cfromInteger :: forall a. Num a => Integer -> Down a
fromInteger :: Integer -> Down a
Num       -- ^ @since 4.11.0.0
, NonEmpty (Down a) -> Down a
Down a -> Down a -> Down a
(Down a -> Down a -> Down a)
-> (NonEmpty (Down a) -> Down a)
-> (forall b. Integral b => b -> Down a -> Down a)
-> Semigroup (Down a)
forall b. Integral b => b -> Down a -> Down a
forall a. Semigroup a => NonEmpty (Down a) -> Down a
forall a. Semigroup a => Down a -> Down a -> Down a
forall a b. (Semigroup a, Integral b) => b -> Down a -> Down a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
\$c<> :: forall a. Semigroup a => Down a -> Down a -> Down a
<> :: Down a -> Down a -> Down a
\$csconcat :: forall a. Semigroup a => NonEmpty (Down a) -> Down a
sconcat :: NonEmpty (Down a) -> Down a
\$cstimes :: forall a b. (Semigroup a, Integral b) => b -> Down a -> Down a
stimes :: forall b. Integral b => b -> Down a -> Down a
Semigroup -- ^ @since 4.11.0.0
, Semigroup (Down a)
Down a
Semigroup (Down a) =>
Down a
-> (Down a -> Down a -> Down a)
-> ([Down a] -> Down a)
-> Monoid (Down a)
[Down a] -> Down a
Down a -> Down a -> Down a
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall a. Monoid a => Semigroup (Down a)
forall a. Monoid a => Down a
forall a. Monoid a => [Down a] -> Down a
forall a. Monoid a => Down a -> Down a -> Down a
\$cmempty :: forall a. Monoid a => Down a
mempty :: Down a
\$cmappend :: forall a. Monoid a => Down a -> Down a -> Down a
mappend :: Down a -> Down a -> Down a
\$cmconcat :: forall a. Monoid a => [Down a] -> Down a
mconcat :: [Down a] -> Down a
Monoid    -- ^ @since 4.11.0.0
, Eq (Down a)
Down a
Eq (Down a) =>
(Down a -> Down a -> Down a)
-> (Down a -> Down a -> Down a)
-> (Down a -> Down a -> Down a)
-> (Down a -> Down a)
-> (Down a -> Int -> Down a)
-> (Down a -> Int -> Down a)
-> Down a
-> (Int -> Down a)
-> (Down a -> Int -> Down a)
-> (Down a -> Int -> Down a)
-> (Down a -> Int -> Down a)
-> (Down a -> Int -> Bool)
-> (Down a -> Maybe Int)
-> (Down a -> Int)
-> (Down a -> Bool)
-> (Down a -> Int -> Down a)
-> (Down a -> Int -> Down a)
-> (Down a -> Int -> Down a)
-> (Down a -> Int -> Down a)
-> (Down a -> Int -> Down a)
-> (Down a -> Int -> Down a)
-> (Down a -> Int)
-> Bits (Down a)
Int -> Down a
Down a -> Bool
Down a -> Int
Down a -> Maybe Int
Down a -> Down a
Down a -> Int -> Bool
Down a -> Int -> Down a
Down a -> Down a -> Down a
forall a.
Eq a =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
forall a. Bits a => Eq (Down a)
forall a. Bits a => Down a
forall a. Bits a => Int -> Down a
forall a. Bits a => Down a -> Bool
forall a. Bits a => Down a -> Int
forall a. Bits a => Down a -> Maybe Int
forall a. Bits a => Down a -> Down a
forall a. Bits a => Down a -> Int -> Bool
forall a. Bits a => Down a -> Int -> Down a
forall a. Bits a => Down a -> Down a -> Down a
\$c.&. :: forall a. Bits a => Down a -> Down a -> Down a
.&. :: Down a -> Down a -> Down a
\$c.|. :: forall a. Bits a => Down a -> Down a -> Down a
.|. :: Down a -> Down a -> Down a
\$cxor :: forall a. Bits a => Down a -> Down a -> Down a
xor :: Down a -> Down a -> Down a
\$ccomplement :: forall a. Bits a => Down a -> Down a
complement :: Down a -> Down a
\$cshift :: forall a. Bits a => Down a -> Int -> Down a
shift :: Down a -> Int -> Down a
\$crotate :: forall a. Bits a => Down a -> Int -> Down a
rotate :: Down a -> Int -> Down a
\$czeroBits :: forall a. Bits a => Down a
zeroBits :: Down a
\$cbit :: forall a. Bits a => Int -> Down a
bit :: Int -> Down a
\$csetBit :: forall a. Bits a => Down a -> Int -> Down a
setBit :: Down a -> Int -> Down a
\$cclearBit :: forall a. Bits a => Down a -> Int -> Down a
clearBit :: Down a -> Int -> Down a
\$ccomplementBit :: forall a. Bits a => Down a -> Int -> Down a
complementBit :: Down a -> Int -> Down a
\$ctestBit :: forall a. Bits a => Down a -> Int -> Bool
testBit :: Down a -> Int -> Bool
\$cbitSizeMaybe :: forall a. Bits a => Down a -> Maybe Int
bitSizeMaybe :: Down a -> Maybe Int
\$cbitSize :: forall a. Bits a => Down a -> Int
bitSize :: Down a -> Int
\$cisSigned :: forall a. Bits a => Down a -> Bool
isSigned :: Down a -> Bool
\$cshiftL :: forall a. Bits a => Down a -> Int -> Down a
shiftL :: Down a -> Int -> Down a
\$cunsafeShiftL :: forall a. Bits a => Down a -> Int -> Down a
unsafeShiftL :: Down a -> Int -> Down a
\$cshiftR :: forall a. Bits a => Down a -> Int -> Down a
shiftR :: Down a -> Int -> Down a
\$cunsafeShiftR :: forall a. Bits a => Down a -> Int -> Down a
unsafeShiftR :: Down a -> Int -> Down a
\$crotateL :: forall a. Bits a => Down a -> Int -> Down a
rotateL :: Down a -> Int -> Down a
\$crotateR :: forall a. Bits a => Down a -> Int -> Down a
rotateR :: Down a -> Int -> Down a
\$cpopCount :: forall a. Bits a => Down a -> Int
popCount :: Down a -> Int
Bits       -- ^ @since 4.14.0.0
, Bits (Down a)
Bits (Down a) =>
(Down a -> Int)
-> (Down a -> Int) -> (Down a -> Int) -> FiniteBits (Down a)
Down a -> Int
forall a. FiniteBits a => Bits (Down a)
forall a. FiniteBits a => Down a -> Int
forall b.
Bits b =>
(b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
\$cfiniteBitSize :: forall a. FiniteBits a => Down a -> Int
finiteBitSize :: Down a -> Int
\$ccountLeadingZeros :: forall a. FiniteBits a => Down a -> Int
countLeadingZeros :: Down a -> Int
\$ccountTrailingZeros :: forall a. FiniteBits a => Down a -> Int
countTrailingZeros :: Down a -> Int
FiniteBits -- ^ @since 4.14.0.0
, Fractional (Down a)
Down a
Fractional (Down a) =>
Down a
-> (Down a -> Down a)
-> (Down a -> Down a)
-> (Down a -> Down a)
-> (Down a -> Down a -> Down a)
-> (Down a -> Down a -> Down a)
-> (Down a -> Down a)
-> (Down a -> Down a)
-> (Down a -> Down a)
-> (Down a -> Down a)
-> (Down a -> Down a)
-> (Down a -> Down a)
-> (Down a -> Down a)
-> (Down a -> Down a)
-> (Down a -> Down a)
-> (Down a -> Down a)
-> (Down a -> Down a)
-> (Down a -> Down a)
-> (Down a -> Down a)
-> (Down a -> Down a)
-> (Down a -> Down a)
-> (Down a -> Down a)
-> Floating (Down a)
Down a -> Down a
Down a -> Down a -> Down a
forall a. Floating a => Fractional (Down a)
forall a. Floating a => Down a
forall a. Floating a => Down a -> Down a
forall a. Floating a => Down a -> Down a -> Down a
forall a.
Fractional a =>
a
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> Floating a
\$cpi :: forall a. Floating a => Down a
pi :: Down a
\$cexp :: forall a. Floating a => Down a -> Down a
exp :: Down a -> Down a
\$clog :: forall a. Floating a => Down a -> Down a
log :: Down a -> Down a
\$csqrt :: forall a. Floating a => Down a -> Down a
sqrt :: Down a -> Down a
\$c** :: forall a. Floating a => Down a -> Down a -> Down a
** :: Down a -> Down a -> Down a
\$clogBase :: forall a. Floating a => Down a -> Down a -> Down a
logBase :: Down a -> Down a -> Down a
\$csin :: forall a. Floating a => Down a -> Down a
sin :: Down a -> Down a
\$ccos :: forall a. Floating a => Down a -> Down a
cos :: Down a -> Down a
\$ctan :: forall a. Floating a => Down a -> Down a
tan :: Down a -> Down a
\$casin :: forall a. Floating a => Down a -> Down a
asin :: Down a -> Down a
\$cacos :: forall a. Floating a => Down a -> Down a
acos :: Down a -> Down a
\$catan :: forall a. Floating a => Down a -> Down a
atan :: Down a -> Down a
\$csinh :: forall a. Floating a => Down a -> Down a
sinh :: Down a -> Down a
\$ccosh :: forall a. Floating a => Down a -> Down a
cosh :: Down a -> Down a
\$ctanh :: forall a. Floating a => Down a -> Down a
tanh :: Down a -> Down a
\$casinh :: forall a. Floating a => Down a -> Down a
asinh :: Down a -> Down a
\$cacosh :: forall a. Floating a => Down a -> Down a
acosh :: Down a -> Down a
\$catanh :: forall a. Floating a => Down a -> Down a
atanh :: Down a -> Down a
\$clog1p :: forall a. Floating a => Down a -> Down a
log1p :: Down a -> Down a
\$cexpm1 :: forall a. Floating a => Down a -> Down a
expm1 :: Down a -> Down a
\$clog1pexp :: forall a. Floating a => Down a -> Down a
log1pexp :: Down a -> Down a
\$clog1mexp :: forall a. Floating a => Down a -> Down a
log1mexp :: Down a -> Down a
Floating   -- ^ @since 4.14.0.0
, Num (Down a)
Num (Down a) =>
(Down a -> Down a -> Down a)
-> (Down a -> Down a)
-> (Rational -> Down a)
-> Fractional (Down a)
Rational -> Down a
Down a -> Down a
Down a -> Down a -> Down a
forall a. Fractional a => Num (Down a)
forall a. Fractional a => Rational -> Down a
forall a. Fractional a => Down a -> Down a
forall a. Fractional a => Down a -> Down a -> Down a
forall a.
Num a =>
(a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
\$c/ :: forall a. Fractional a => Down a -> Down a -> Down a
/ :: Down a -> Down a -> Down a
\$crecip :: forall a. Fractional a => Down a -> Down a
recip :: Down a -> Down a
\$cfromRational :: forall a. Fractional a => Rational -> Down a
fromRational :: Rational -> Down a
Fractional -- ^ @since 4.14.0.0
, Ord (Down a)
Ord (Down a) =>
((Down a, Down a) -> [Down a])
-> ((Down a, Down a) -> Down a -> Int)
-> ((Down a, Down a) -> Down a -> Int)
-> ((Down a, Down a) -> Down a -> Bool)
-> ((Down a, Down a) -> Int)
-> ((Down a, Down a) -> Int)
-> Ix (Down a)
(Down a, Down a) -> Int
(Down a, Down a) -> [Down a]
(Down a, Down a) -> Down a -> Bool
(Down a, Down a) -> Down a -> Int
forall a.
Ord a =>
((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
forall a. Ix a => Ord (Down a)
forall a. Ix a => (Down a, Down a) -> Int
forall a. Ix a => (Down a, Down a) -> [Down a]
forall a. Ix a => (Down a, Down a) -> Down a -> Bool
forall a. Ix a => (Down a, Down a) -> Down a -> Int
\$crange :: forall a. Ix a => (Down a, Down a) -> [Down a]
range :: (Down a, Down a) -> [Down a]
\$cindex :: forall a. Ix a => (Down a, Down a) -> Down a -> Int
index :: (Down a, Down a) -> Down a -> Int
\$cunsafeIndex :: forall a. Ix a => (Down a, Down a) -> Down a -> Int
unsafeIndex :: (Down a, Down a) -> Down a -> Int
\$cinRange :: forall a. Ix a => (Down a, Down a) -> Down a -> Bool
inRange :: (Down a, Down a) -> Down a -> Bool
\$crangeSize :: forall a. Ix a => (Down a, Down a) -> Int
rangeSize :: (Down a, Down a) -> Int
\$cunsafeRangeSize :: forall a. Ix a => (Down a, Down a) -> Int
unsafeRangeSize :: (Down a, Down a) -> Int
Ix         -- ^ @since 4.14.0.0
, Num (Down a)
Ord (Down a)
(Num (Down a), Ord (Down a)) =>
(Down a -> Rational) -> Real (Down a)
Down a -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
forall a. Real a => Num (Down a)
forall a. Real a => Ord (Down a)
forall a. Real a => Down a -> Rational
\$ctoRational :: forall a. Real a => Down a -> Rational
toRational :: Down a -> Rational
Real       -- ^ @since 4.14.0.0
, Fractional (Down a)
Real (Down a)
(Real (Down a), Fractional (Down a)) =>
(forall b. Integral b => Down a -> (b, Down a))
-> (forall b. Integral b => Down a -> b)
-> (forall b. Integral b => Down a -> b)
-> (forall b. Integral b => Down a -> b)
-> (forall b. Integral b => Down a -> b)
-> RealFrac (Down a)
forall b. Integral b => Down a -> b
forall b. Integral b => Down a -> (b, Down a)
forall a.
(Real a, Fractional a) =>
(forall b. Integral b => a -> (b, a))
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> RealFrac a
forall a. RealFrac a => Fractional (Down a)
forall a. RealFrac a => Real (Down a)
forall a b. (RealFrac a, Integral b) => Down a -> b
forall a b. (RealFrac a, Integral b) => Down a -> (b, Down a)
\$cproperFraction :: forall a b. (RealFrac a, Integral b) => Down a -> (b, Down a)
properFraction :: forall b. Integral b => Down a -> (b, Down a)
\$ctruncate :: forall a b. (RealFrac a, Integral b) => Down a -> b
truncate :: forall b. Integral b => Down a -> b
\$cround :: forall a b. (RealFrac a, Integral b) => Down a -> b
round :: forall b. Integral b => Down a -> b
\$cceiling :: forall a b. (RealFrac a, Integral b) => Down a -> b
ceiling :: forall b. Integral b => Down a -> b
\$cfloor :: forall a b. (RealFrac a, Integral b) => Down a -> b
floor :: forall b. Integral b => Down a -> b
RealFrac   -- ^ @since 4.14.0.0
, Floating (Down a)
RealFrac (Down a)
(RealFrac (Down a), Floating (Down a)) =>
(Down a -> Integer)
-> (Down a -> Int)
-> (Down a -> (Int, Int))
-> (Down a -> (Integer, Int))
-> (Integer -> Int -> Down a)
-> (Down a -> Int)
-> (Down a -> Down a)
-> (Int -> Down a -> Down a)
-> (Down a -> Bool)
-> (Down a -> Bool)
-> (Down a -> Bool)
-> (Down a -> Bool)
-> (Down a -> Bool)
-> (Down a -> Down a -> Down a)
-> RealFloat (Down a)
Int -> Down a -> Down a
Integer -> Int -> Down a
Down a -> Bool
Down a -> Int
Down a -> Integer
Down a -> (Int, Int)
Down a -> (Integer, Int)
Down a -> Down a
Down a -> Down a -> Down a
forall a. RealFloat a => Floating (Down a)
forall a. RealFloat a => RealFrac (Down a)
forall a. RealFloat a => Int -> Down a -> Down a
forall a. RealFloat a => Integer -> Int -> Down a
forall a. RealFloat a => Down a -> Bool
forall a. RealFloat a => Down a -> Int
forall a. RealFloat a => Down a -> Integer
forall a. RealFloat a => Down a -> (Int, Int)
forall a. RealFloat a => Down a -> (Integer, Int)
forall a. RealFloat a => Down a -> Down a
forall a. RealFloat a => Down a -> Down a -> Down a
forall a.
(RealFrac a, Floating a) =>
(a -> Integer)
-> (a -> Int)
-> (a -> (Int, Int))
-> (a -> (Integer, Int))
-> (Integer -> Int -> a)
-> (a -> Int)
-> (a -> a)
-> (Int -> a -> a)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> a -> a)
-> RealFloat a
\$cfloatRadix :: forall a. RealFloat a => Down a -> Integer
floatRadix :: Down a -> Integer
\$cfloatDigits :: forall a. RealFloat a => Down a -> Int
floatDigits :: Down a -> Int
\$cfloatRange :: forall a. RealFloat a => Down a -> (Int, Int)
floatRange :: Down a -> (Int, Int)
\$cdecodeFloat :: forall a. RealFloat a => Down a -> (Integer, Int)
decodeFloat :: Down a -> (Integer, Int)
\$cencodeFloat :: forall a. RealFloat a => Integer -> Int -> Down a
encodeFloat :: Integer -> Int -> Down a
\$cexponent :: forall a. RealFloat a => Down a -> Int
exponent :: Down a -> Int
\$csignificand :: forall a. RealFloat a => Down a -> Down a
significand :: Down a -> Down a
\$cscaleFloat :: forall a. RealFloat a => Int -> Down a -> Down a
scaleFloat :: Int -> Down a -> Down a
\$cisNaN :: forall a. RealFloat a => Down a -> Bool
isNaN :: Down a -> Bool
\$cisInfinite :: forall a. RealFloat a => Down a -> Bool
isInfinite :: Down a -> Bool
\$cisDenormalized :: forall a. RealFloat a => Down a -> Bool
isDenormalized :: Down a -> Bool
\$cisNegativeZero :: forall a. RealFloat a => Down a -> Bool
isNegativeZero :: Down a -> Bool
\$cisIEEE :: forall a. RealFloat a => Down a -> Bool
isIEEE :: Down a -> Bool
\$catan2 :: forall a. RealFloat a => Down a -> Down a -> Down a
atan2 :: Down a -> Down a -> Down a
RealFloat  -- ^ @since 4.14.0.0
, Ptr (Down a) -> IO (Down a)
Ptr (Down a) -> Int -> IO (Down a)
Ptr (Down a) -> Int -> Down a -> IO ()
Ptr (Down a) -> Down a -> IO ()
Down a -> Int
(Down a -> Int)
-> (Down a -> Int)
-> (Ptr (Down a) -> Int -> IO (Down a))
-> (Ptr (Down a) -> Int -> Down a -> IO ())
-> (forall b. Ptr b -> Int -> IO (Down a))
-> (forall b. Ptr b -> Int -> Down a -> IO ())
-> (Ptr (Down a) -> IO (Down a))
-> (Ptr (Down a) -> Down a -> IO ())
-> Storable (Down a)
forall b. Ptr b -> Int -> IO (Down a)
forall b. Ptr b -> Int -> Down a -> IO ()
forall a. Storable a => Ptr (Down a) -> IO (Down a)
forall a. Storable a => Ptr (Down a) -> Int -> IO (Down a)
forall a. Storable a => Ptr (Down a) -> Int -> Down a -> IO ()
forall a. Storable a => Ptr (Down a) -> Down a -> IO ()
forall a. Storable a => Down a -> Int
forall a b. Storable a => Ptr b -> Int -> IO (Down a)
forall a b. Storable a => Ptr b -> Int -> Down a -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
\$csizeOf :: forall a. Storable a => Down a -> Int
sizeOf :: Down a -> Int
\$calignment :: forall a. Storable a => Down a -> Int
alignment :: Down a -> Int
\$cpeekElemOff :: forall a. Storable a => Ptr (Down a) -> Int -> IO (Down a)
peekElemOff :: Ptr (Down a) -> Int -> IO (Down a)
\$cpokeElemOff :: forall a. Storable a => Ptr (Down a) -> Int -> Down a -> IO ()
pokeElemOff :: Ptr (Down a) -> Int -> Down a -> IO ()
\$cpeekByteOff :: forall a b. Storable a => Ptr b -> Int -> IO (Down a)
peekByteOff :: forall b. Ptr b -> Int -> IO (Down a)
\$cpokeByteOff :: forall a b. Storable a => Ptr b -> Int -> Down a -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> Down a -> IO ()
\$cpeek :: forall a. Storable a => Ptr (Down a) -> IO (Down a)
peek :: Ptr (Down a) -> IO (Down a)
\$cpoke :: forall a. Storable a => Ptr (Down a) -> Down a -> IO ()
poke :: Ptr (Down a) -> Down a -> IO ()
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
d Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
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
lex String
r, (a
x,String
t) <- 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
Down a
x < :: Down a -> Down a -> Bool
< Down a
y = a
y a -> a -> Bool
forall a. Ord a => a -> a -> Bool
< a
x
Down a
x > :: Down a -> Down a -> Bool
> Down a
y = a
y a -> a -> Bool
forall a. Ord a => a -> a -> Bool
> a
x
Down a
x <= :: Down a -> Down a -> Bool
<= Down a
y = a
y a -> a -> Bool
forall a. Ord a => a -> a -> Bool
<= a
x
Down a
x >= :: Down a -> Down a -> Bool
>= Down a
y = a
y a -> a -> Bool
forall a. Ord a => a -> a -> Bool
>= a
x
min :: Down a -> Down a -> Down a
min (Down a
x) (Down a
y) = a -> Down a
forall a. a -> Down a
Down (a -> a -> a
forall a. Ord a => a -> a -> a
max a
y a
x)
max :: Down a -> Down a -> Down a
max (Down a
x) (Down a
y) = a -> Down a
forall a. a -> Down a
Down (a -> a -> a
forall a. Ord a => a -> a -> a
min a
y a
x)

-- | Swaps @'minBound'@ and @'maxBound'@ of the underlying type.
--
-- @since 4.14.0.0
instance Bounded a => Bounded (Down a) where
minBound :: Down a
minBound = a -> Down a
forall a. a -> Down a
Down a
forall a. Bounded a => a
maxBound
maxBound :: Down a
maxBound = a -> Down a
forall a. a -> Down a
Down a
forall a. Bounded a => a
minBound

-- | Swaps @'succ'@ and @'pred'@ of the underlying type.
--
-- @since 4.18.0.0
instance (Enum a, Bounded a, Eq a) => Enum (Down a) where
succ :: Down a -> Down a
succ = (a -> a) -> Down a -> Down a
forall a b. (a -> b) -> Down a -> Down b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Enum a => a -> a
pred
pred :: Down a -> Down a
pred = (a -> a) -> Down a -> Down a
forall a b. (a -> b) -> Down a -> Down b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Enum a => a -> a
succ

-- Here we use the fact that 'comparing (complement @Int)' behaves
-- as an order-swapping `compare @Int`.
fromEnum :: Down a -> Int
forall a. Bits a => a -> a
complement (Int -> Int) -> (Down a -> Int) -> Down a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Int
forall a. Enum a => a -> Int
fromEnum (a -> Int) -> (Down a -> a) -> Down a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Down a -> a
forall a. Down a -> a
getDown
toEnum :: Int -> Down a
toEnum = a -> Down a
forall a. a -> Down a
Down (a -> Down a) -> (Int -> a) -> Int -> Down a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> a
forall a. Enum a => Int -> a
toEnum (Int -> a) -> (Int -> Int) -> Int -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int
forall a. Bits a => a -> a
complement

enumFrom :: Down a -> [Down a]
enumFrom (Down a
x)
| a
x a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
forall a. Bounded a => a
minBound
= [a -> Down a
forall a. a -> Down a
Down a
x] -- We can't rely on 'enumFromThen _ (pred @a minBound)` behaving nicely,
-- since 'enumFromThen _' might be strict and 'pred minBound' might throw
| Bool
otherwise
= [a] -> [Down a]
forall a b. Coercible a b => a -> b
coerce ([a] -> [Down a]) -> [a] -> [Down a]
forall a b. (a -> b) -> a -> b
\$ a -> a -> [a]
forall a. Enum a => a -> a -> [a]
enumFromThen a
x (a -> a
forall a. Enum a => a -> a
pred a
x)
enumFromThen :: Down a -> Down a -> [Down a]
enumFromThen (Down a
x) (Down a
y) = [a] -> [Down a]
forall a b. Coercible a b => a -> b
coerce ([a] -> [Down a]) -> [a] -> [Down a]
forall a b. (a -> b) -> a -> b
\$ a -> a -> [a]
forall a. Enum a => a -> a -> [a]
enumFromThen a
x a
y

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

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

-- | @since 4.11.0.0