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

-----------------------------------------------------------------------------
-- |
-- Module      :  GHC.Internal.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 GHC.Internal.Data.Ord (
Ord(..),
Ordering(..),
Down(..),
comparing,
clamp,
) where

import GHC.Internal.Data.Bits (Bits, FiniteBits, complement)
import GHC.Internal.Foreign.Storable (Storable)
import GHC.Internal.Ix (Ix)
import GHC.Internal.Base
import GHC.Internal.Enum (Bounded(..), Enum(..))
import GHC.Internal.Float (Floating, RealFloat)
import GHC.Internal.Num
import GHC.Internal.Read
import GHC.Internal.Real (Fractional, Real, RealFrac)
import GHC.Internal.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'
--
-- @since base-4.16.0.0
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 base-4.6.0.0
newtype Down a = Down
{ forall a. Down a -> a
getDown :: a -- ^ @since base-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 base-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 base-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 base-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 base-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 base-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 base-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 base-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 base-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 base-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 base-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 base-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 base-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 base-4.14.0.0
)

-- | This instance would be equivalent to the derived instances of the
-- 'Down' newtype if the 'getDown' field were removed
--
-- @since base-4.7.0.0
instance (Read a) => Read (Down a) where
readsPrec :: Int -> ReadS (Down a)
readsPrec Int
d = Bool -> ReadS (Down a) -> ReadS (Down a)
forall a. Bool -> ReadS a -> ReadS a
readParen (Int
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
readsPrec Int
11 String
s]

-- | This instance would be equivalent to the derived instances of the
-- 'Down' newtype if the 'getDown' field were removed
--
-- @since base-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 base-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 base-4.14.0.0
instance  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 base-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
fromEnum = Int -> 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 base-4.11.0.0
instance  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 base-4.11.0.0
instance  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 base-4.11.0.0
instance  where
Down a
a >>= :: forall a b. Down a -> (a -> Down b) -> Down b
>>= a -> Down b
k = a -> Down b
k a
a