    {-# LANGUAGE DeriveDataTypeable         #-}
    {-# LANGUAGE DeriveGeneric              #-}
    {-# LANGUAGE FlexibleContexts           #-}
    {-# LANGUAGE FlexibleInstances          #-}
    {-# LANGUAGE GeneralizedNewtypeDeriving #-}
    {-# LANGUAGE StandaloneDeriving         #-}
    {-# LANGUAGE Trustworthy                #-}

    -- |
    -- Module: Data.Ring.Ordered
    -- Copyright: (C) 2021 Koz Ross
    -- License: BSD3
    -- Maintainer: Koz Ross <koz.ross@retro-freedom.nz>
    -- Stability: stable
    -- Portability: GHC only
    --
    -- An \'ordered ring\' is a ring with a total order.
    --
    -- = Mathematical pedantry note
    --
    -- Many (if not most) of the instances of the 'OrderedRing' type class are not
    -- truly ordered rings in the mathematical sense, as the
    -- [axioms](https://en.wikipedia.org/wiki/Ordered_ring) imply that the
    -- underlying set is either a singleton or infinite. Thus, the [additional
    -- properties](https://en.wikipedia.org/wiki/Ordered_ring#Basic_properties) of
    -- ordered rings do not, in general, hold.
    --
    -- We indicate those instances that /are/ \'truly\' or \'mathematically\'
    -- ordered rings in their documentation.
    module Data.Ring.Ordered
      (
        -- * Helper types
        Modular(..),
        -- * Ordered ring type class
        OrderedRing(..),
      ) where

    import Control.Applicative (Const (Const))
    import Data.Data (Data)
    import Data.Fixed (HasResolution, Fixed)
    import Data.Functor.Identity (Identity (Identity))
    import Data.Int (Int8, Int16, Int32, Int64)
    import Data.Monoid (Dual (Dual))
    import Data.Ord (Down (Down))
    import Data.Ratio (Ratio)
    import Data.Semiring (Ring, Semiring(zero))
    import Data.Word (Word8, Word16, Word32, Word64)
    import GHC.Generics (Generic)
    import Prelude hiding (signum, abs, negate, (-))
    import qualified Prelude as Num
    import Data.Typeable (Typeable)

    -- | A wrapper to indicate the type is being treated as a [modular arithmetic
    -- system](https://en.wikipedia.org/wiki/Modular_arithmetic) whose modulus is
    -- the type's cardinality.
    --
    -- While we cannot guarantee that infinite types won't be wrapped by this, we
    -- only provide instances of the relevant type classes for those types we are
    -- certain are finite.
    --
    -- @since 0.7
    newtype Modular a = Modular { forall a. Modular a -> a
    getModular :: a }
      deriving
        ( Modular a
    Modular a -> Modular a -> Bounded (Modular a)
    forall a. a -> a -> Bounded a
    forall a. Bounded a => Modular a
    $cminBound :: forall a. Bounded a => Modular a
    minBound :: Modular a
    $cmaxBound :: forall a. Bounded a => Modular a
    maxBound :: Modular a
    Bounded -- ^ @since 0.7
        , Modular a -> Modular a -> Bool
    (Modular a -> Modular a -> Bool)
    -> (Modular a -> Modular a -> Bool) -> Eq (Modular a)
    forall a. Eq a => Modular a -> Modular a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall a. Eq a => Modular a -> Modular a -> Bool
    == :: Modular a -> Modular a -> Bool
    $c/= :: forall a. Eq a => Modular a -> Modular a -> Bool
    /= :: Modular a -> Modular a -> Bool
    Eq -- ^ @since 0.7
        , Eq (Modular a)
    Eq (Modular a) =>
    (Modular a -> Modular a -> Ordering)
    -> (Modular a -> Modular a -> Bool)
    -> (Modular a -> Modular a -> Bool)
    -> (Modular a -> Modular a -> Bool)
    -> (Modular a -> Modular a -> Bool)
    -> (Modular a -> Modular a -> Modular a)
    -> (Modular a -> Modular a -> Modular a)
    -> Ord (Modular a)
    Modular a -> Modular a -> Bool
    Modular a -> Modular a -> Ordering
    Modular a -> Modular a -> Modular a
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall a. Ord a => Eq (Modular a)
    forall a. Ord a => Modular a -> Modular a -> Bool
    forall a. Ord a => Modular a -> Modular a -> Ordering
    forall a. Ord a => Modular a -> Modular a -> Modular a
    $ccompare :: forall a. Ord a => Modular a -> Modular a -> Ordering
    compare :: Modular a -> Modular a -> Ordering
    $c< :: forall a. Ord a => Modular a -> Modular a -> Bool
    < :: Modular a -> Modular a -> Bool
    $c<= :: forall a. Ord a => Modular a -> Modular a -> Bool
    <= :: Modular a -> Modular a -> Bool
    $c> :: forall a. Ord a => Modular a -> Modular a -> Bool
    > :: Modular a -> Modular a -> Bool
    $c>= :: forall a. Ord a => Modular a -> Modular a -> Bool
    >= :: Modular a -> Modular a -> Bool
    $cmax :: forall a. Ord a => Modular a -> Modular a -> Modular a
    max :: Modular a -> Modular a -> Modular a
    $cmin :: forall a. Ord a => Modular a -> Modular a -> Modular a
    min :: Modular a -> Modular a -> Modular a
    Ord -- ^ @since 0.7
        , Int -> Modular a -> ShowS
    [Modular a] -> ShowS
    Modular a -> String
    (Int -> Modular a -> ShowS)
    -> (Modular a -> String)
    -> ([Modular a] -> ShowS)
    -> Show (Modular a)
    forall a. Show a => Int -> Modular a -> ShowS
    forall a. Show a => [Modular a] -> ShowS
    forall a. Show a => Modular a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall a. Show a => Int -> Modular a -> ShowS
    showsPrec :: Int -> Modular a -> ShowS
    $cshow :: forall a. Show a => Modular a -> String
    show :: Modular a -> String
    $cshowList :: forall a. Show a => [Modular a] -> ShowS
    showList :: [Modular a] -> ShowS
    Show -- ^ @since 0.7
        , ReadPrec [Modular a]
    ReadPrec (Modular a)
    Int -> ReadS (Modular a)
    ReadS [Modular a]
    (Int -> ReadS (Modular a))
    -> ReadS [Modular a]
    -> ReadPrec (Modular a)
    -> ReadPrec [Modular a]
    -> Read (Modular a)
    forall a. Read a => ReadPrec [Modular a]
    forall a. Read a => ReadPrec (Modular a)
    forall a. Read a => Int -> ReadS (Modular a)
    forall a. Read a => ReadS [Modular a]
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: forall a. Read a => Int -> ReadS (Modular a)
    readsPrec :: Int -> ReadS (Modular a)
    $creadList :: forall a. Read a => ReadS [Modular a]
    readList :: ReadS [Modular a]
    $creadPrec :: forall a. Read a => ReadPrec (Modular a)
    readPrec :: ReadPrec (Modular a)
    $creadListPrec :: forall a. Read a => ReadPrec [Modular a]
    readListPrec :: ReadPrec [Modular a]
    Read -- ^ @since 0.7
        , (forall x. Modular a -> Rep (Modular a) x)
    -> (forall x. Rep (Modular a) x -> Modular a)
    -> Generic (Modular a)
    forall x. Rep (Modular a) x -> Modular a
    forall x. Modular a -> Rep (Modular a) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall a x. Rep (Modular a) x -> Modular a
    forall a x. Modular a -> Rep (Modular a) x
    $cfrom :: forall a x. Modular a -> Rep (Modular a) x
    from :: forall x. Modular a -> Rep (Modular a) x
    $cto :: forall a x. Rep (Modular a) x -> Modular a
    to :: forall x. Rep (Modular a) x -> Modular a
    Generic -- ^ @since 0.7
        , Typeable (Modular a)
    Typeable (Modular a) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Modular a -> c (Modular a))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Modular a))
    -> (Modular a -> Constr)
    -> (Modular a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Modular a)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (Modular a)))
    -> ((forall b. Data b => b -> b) -> Modular a -> Modular a)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Modular a -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Modular a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Modular a -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> Modular a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Modular a -> m (Modular a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Modular a -> m (Modular a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Modular a -> m (Modular a))
    -> Data (Modular a)
    Modular a -> Constr
    Modular a -> DataType
    (forall b. Data b => b -> b) -> Modular a -> Modular a
    forall a. Data a => Typeable (Modular a)
    forall a. Data a => Modular a -> Constr
    forall a. Data a => Modular a -> DataType
    forall a.
    Data a =>
    (forall b. Data b => b -> b) -> Modular a -> Modular a
    forall a u.
    Data a =>
    Int -> (forall d. Data d => d -> u) -> Modular a -> u
    forall a u.
    Data a =>
    (forall d. Data d => d -> u) -> Modular a -> [u]
    forall a r r'.
    Data a =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Modular a -> r
    forall a r r'.
    Data a =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Modular a -> r
    forall a (m :: * -> *).
    (Data a, Monad m) =>
    (forall d. Data d => d -> m d) -> Modular a -> m (Modular a)
    forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Modular a -> m (Modular a)
    forall a (c :: * -> *).
    Data a =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Modular a)
    forall a (c :: * -> *).
    Data a =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Modular a -> c (Modular a)
    forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Modular a))
    forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Modular a))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Modular a -> u
    forall u. (forall d. Data d => d -> u) -> Modular a -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Modular a -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Modular a -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Modular a -> m (Modular a)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Modular a -> m (Modular a)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Modular a)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Modular a -> c (Modular a)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Modular a))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Modular a))
    $cgfoldl :: forall a (c :: * -> *).
    Data a =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Modular a -> c (Modular a)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Modular a -> c (Modular a)
    $cgunfold :: forall a (c :: * -> *).
    Data a =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Modular a)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Modular a)
    $ctoConstr :: forall a. Data a => Modular a -> Constr
    toConstr :: Modular a -> Constr
    $cdataTypeOf :: forall a. Data a => Modular a -> DataType
    dataTypeOf :: Modular a -> DataType
    $cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Modular a))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Modular a))
    $cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Modular a))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Modular a))
    $cgmapT :: forall a.
    Data a =>
    (forall b. Data b => b -> b) -> Modular a -> Modular a
    gmapT :: (forall b. Data b => b -> b) -> Modular a -> Modular a
    $cgmapQl :: forall a r r'.
    Data a =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Modular a -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Modular a -> r
    $cgmapQr :: forall a r r'.
    Data a =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Modular a -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Modular a -> r
    $cgmapQ :: forall a u.
    Data a =>
    (forall d. Data d => d -> u) -> Modular a -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Modular a -> [u]
    $cgmapQi :: forall a u.
    Data a =>
    Int -> (forall d. Data d => d -> u) -> Modular a -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Modular a -> u
    $cgmapM :: forall a (m :: * -> *).
    (Data a, Monad m) =>
    (forall d. Data d => d -> m d) -> Modular a -> m (Modular a)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Modular a -> m (Modular a)
    $cgmapMp :: forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Modular a -> m (Modular a)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Modular a -> m (Modular a)
    $cgmapMo :: forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Modular a -> m (Modular a)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Modular a -> m (Modular a)
    Data -- ^ @since 0.7
        , Typeable -- ^ @since 0.7
        )

    -- @since 0.7
    deriving instance Semiring (Modular Word8)

    -- @since 0.7
    deriving instance Semiring (Modular Word16)

    -- @since 0.7
    deriving instance Semiring (Modular Word32)

    -- @since 0.7
    deriving instance Semiring (Modular Word64)

    -- @since 0.7
    deriving instance Semiring (Modular Word)

    -- @since 0.7
    deriving instance Ring (Modular Word8)

    -- @since 0.7
    deriving instance Ring (Modular Word16)

    -- @since 0.7
    deriving instance Ring (Modular Word32)

    -- @since 0.7
    deriving instance Ring (Modular Word64)

    -- @since 0.7
    deriving instance Ring (Modular Word)

    -- | The class of rings which also have a total order.
    --
    -- Instance should satisfy the following laws:
    --
    -- * @'abs' 'zero' = 'zero'@
    -- * @'abs' x = 'abs' ('negate' x)@
    -- * @x 'Data.Semiring.-' 'abs' x = 'zero'@
    -- * @'signum' 'zero' = 'zero'@
    -- * If @x '>' 'zero'@, then @'signum' x = 'one'@
    -- * If @x '<' 'zero'@, then @'signum' x = 'negate' 'one'@
    --
    -- @since 0.7
    class (Ring a, Ord a) => OrderedRing a where
      -- | Compute the absolute value.
      abs :: a -> a
      -- | Determine the \'sign\' of a value.
      signum :: a -> a

    -- | This instance is a \'true\' or \'mathematical\' ordered ring, as it is a
    -- singleton. We assume that '()' has a zero signum.
    --
    -- @since 0.7
    instance OrderedRing () where
      abs :: () -> ()
    abs = () -> () -> ()
    forall a b. a -> b -> a
    const ()
      signum :: () -> ()
    signum = () -> () -> ()
    forall a b. a -> b -> a
    const ()
    forall a. Semiring a => a
    zero

    -- | Where @a@ is a \'true\' or \'mathematical\' ordered ring, so is this.
    --
    -- @since 0.7
    instance (OrderedRing a) => OrderedRing (Dual a) where
      abs :: Dual a -> Dual a
    abs (Dual a
    x) = a -> Dual a
    forall a. a -> Dual a
    Dual (a -> Dual a) -> (a -> a) -> a -> Dual a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> a
    forall a. OrderedRing a => a -> a
    abs (a -> Dual a) -> a -> Dual a
    forall a b. (a -> b) -> a -> b
    $ a
    x
      signum :: Dual a -> Dual a
    signum (Dual a
    x) = a -> Dual a
    forall a. a -> Dual a
    Dual (a -> Dual a) -> (a -> a) -> a -> Dual a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> a
    forall a. OrderedRing a => a -> a
    signum (a -> Dual a) -> a -> Dual a
    forall a b. (a -> b) -> a -> b
    $ a
    x

    -- | Where @a@ is a \'true\' or \'mathematical\' ordered ring, so is this.
    --
    -- @since 0.7
    instance (OrderedRing a) => OrderedRing (Const a b) where
      abs :: Const a b -> Const a b
    abs (Const a
    x) = a -> Const a b
    forall {k} a (b :: k). a -> Const a b
    Const (a -> Const a b) -> (a -> a) -> a -> Const a b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> a
    forall a. OrderedRing a => a -> a
    abs (a -> Const a b) -> a -> Const a b
    forall a b. (a -> b) -> a -> b
    $ a
    x
      signum :: Const a b -> Const a b
    signum (Const a
    x) = a -> Const a b
    forall {k} a (b :: k). a -> Const a b
    Const (a -> Const a b) -> (a -> a) -> a -> Const a b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> a
    forall a. OrderedRing a => a -> a
    signum (a -> Const a b) -> a -> Const a b
    forall a b. (a -> b) -> a -> b
    $ a
    x

    -- | Where @a ~ 'Integer'@, this instance is a \'true\' or \'mathematical\'
    -- ordered ring, as the resulting type is infinite.
    --
    -- @since 0.7
    instance (Integral a) => OrderedRing (Ratio a) where
      abs :: Ratio a -> Ratio a
    abs = Ratio a -> Ratio a
    forall a. Num a => a -> a
    Num.abs
      signum :: Ratio a -> Ratio a
    signum = Ratio a -> Ratio a
    forall a. Num a => a -> a
    Num.signum

    -- | Where @a@ is a \'true\' or \'mathematical\' ordered ring, so is this.
    --
    -- @since 0.7
    deriving instance (OrderedRing a) => OrderedRing (Down a)

    -- | Where @a@ is a \'true\' or \'mathematical\' ordered ring, so is this.
    --
    -- @since 0.7
    deriving instance (OrderedRing a) => OrderedRing (Identity a)

    -- | @since 0.7
    instance (HasResolution a) => OrderedRing (Fixed a) where
      abs :: Fixed a -> Fixed a
    abs = Fixed a -> Fixed a
    forall a. Num a => a -> a
    Num.abs
      signum :: Fixed a -> Fixed a
    signum = Fixed a -> Fixed a
    forall a. Num a => a -> a
    Num.signum

    -- | @since 0.7
    instance OrderedRing Int8 where
      abs :: Int8 -> Int8
    abs = Int8 -> Int8
    forall a. Num a => a -> a
    Num.abs
      signum :: Int8 -> Int8
    signum = Int8 -> Int8
    forall a. Num a => a -> a
    Num.signum

    -- | @since 0.7
    instance OrderedRing Int16 where
      abs :: Int16 -> Int16
    abs = Int16 -> Int16
    forall a. Num a => a -> a
    Num.abs
      signum :: Int16 -> Int16
    signum = Int16 -> Int16
    forall a. Num a => a -> a
    Num.signum

    -- | @since 0.7
    instance OrderedRing Int32 where
      abs :: Int32 -> Int32
    abs = Int32 -> Int32
    forall a. Num a => a -> a
    Num.abs
      signum :: Int32 -> Int32
    signum = Int32 -> Int32
    forall a. Num a => a -> a
    Num.signum

    -- | @since 0.7
    instance OrderedRing Int64 where
      abs :: Int64 -> Int64
    abs = Int64 -> Int64
    forall a. Num a => a -> a
    Num.abs
      signum :: Int64 -> Int64
    signum = Int64 -> Int64
    forall a. Num a => a -> a
    Num.signum

    -- | @since 0.7
    instance OrderedRing Int where
      abs :: Int -> Int
    abs = Int -> Int
    forall a. Num a => a -> a
    Num.abs
      signum :: Int -> Int
    signum = Int -> Int
    forall a. Num a => a -> a
    Num.signum

    -- | This instance is a \'true\' or \'mathematical\' ordered ring, as 'Integer'
    -- is an infinite type.
    --
    -- @since 0.7
    instance OrderedRing Integer where
      abs :: Integer -> Integer
    abs = Integer -> Integer
    forall a. Num a => a -> a
    Num.abs
      signum :: Integer -> Integer
    signum = Integer -> Integer
    forall a. Num a => a -> a
    Num.signum

    -- | @since 0.7
    instance OrderedRing (Modular Word8) where
      abs :: Modular Word8 -> Modular Word8
    abs Modular Word8
    x = Modular Word8
    x
      signum :: Modular Word8 -> Modular Word8
    signum (Modular Word8
    x) = Word8 -> Modular Word8
    forall a. a -> Modular a
    Modular (Word8 -> Modular Word8)
    -> (Word8 -> Word8) -> Word8 -> Modular Word8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word8 -> Word8
    forall a. Num a => a -> a
    Num.signum (Word8 -> Modular Word8) -> Word8 -> Modular Word8
    forall a b. (a -> b) -> a -> b
    $ Word8
    x

    -- | @since 0.7
    instance OrderedRing (Modular Word16) where
      abs :: Modular Word16 -> Modular Word16
    abs Modular Word16
    x = Modular Word16
    x
      signum :: Modular Word16 -> Modular Word16
    signum (Modular Word16
    x) = Word16 -> Modular Word16
    forall a. a -> Modular a
    Modular (Word16 -> Modular Word16)
    -> (Word16 -> Word16) -> Word16 -> Modular Word16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word16 -> Word16
    forall a. Num a => a -> a
    Num.signum (Word16 -> Modular Word16) -> Word16 -> Modular Word16
    forall a b. (a -> b) -> a -> b
    $ Word16
    x

    -- | @since 0.7
    instance OrderedRing (Modular Word32) where
      abs :: Modular Word32 -> Modular Word32
    abs Modular Word32
    x = Modular Word32
    x
      signum :: Modular Word32 -> Modular Word32
    signum (Modular Word32
    x) = Word32 -> Modular Word32
    forall a. a -> Modular a
    Modular (Word32 -> Modular Word32)
    -> (Word32 -> Word32) -> Word32 -> Modular Word32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word32 -> Word32
    forall a. Num a => a -> a
    Num.signum (Word32 -> Modular Word32) -> Word32 -> Modular Word32
    forall a b. (a -> b) -> a -> b
    $ Word32
    x

    -- | @since 0.7
    instance OrderedRing (Modular Word64) where
      abs :: Modular Word64 -> Modular Word64
    abs Modular Word64
    x = Modular Word64
    x
      signum :: Modular Word64 -> Modular Word64
    signum (Modular Word64
    x) = Word64 -> Modular Word64
    forall a. a -> Modular a
    Modular (Word64 -> Modular Word64)
    -> (Word64 -> Word64) -> Word64 -> Modular Word64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word64 -> Word64
    forall a. Num a => a -> a
    Num.signum (Word64 -> Modular Word64) -> Word64 -> Modular Word64
    forall a b. (a -> b) -> a -> b
    $ Word64
    x

    -- | @since 0.7
    instance OrderedRing (Modular Word) where
      abs :: Modular Word -> Modular Word
    abs Modular Word
    x = Modular Word
    x
      signum :: Modular Word -> Modular Word
    signum (Modular Word
    x) = Word -> Modular Word
    forall a. a -> Modular a
    Modular (Word -> Modular Word) -> (Word -> Word) -> Word -> Modular Word
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word -> Word
    forall a. Num a => a -> a
    Num.signum (Word -> Modular Word) -> Word -> Modular Word
    forall a b. (a -> b) -> a -> b
    $ Word
    x