module Integer.Signed
  ( -- * Type
    Signed (Zero, NonZero, Plus, Minus, NotPlus, NotMinus),

    -- * Conversion

    -- ** Integer
    toInteger,
    fromInteger,

    -- ** Natural
    toNatural,
    fromNatural,

    -- ** Positive
    toPositive,
    fromPositive,

    -- ** Int
    toInt,
    fromInt,

    -- ** Word
    toWord,
    fromWord,

    -- * Arithmetic

    -- ** Increase
    increase,
    strictlyIncrease,

    -- ** One (1)
    one,
    addOne,
    subtractOne,
  )
where

import Control.DeepSeq qualified as DeepSeq
import Data.Hashable (Hashable (hashWithSalt))
import Data.Int (Int)
import Data.List qualified as List
import Data.Ord qualified as Ord
import Data.Word (Word)
import Essentials
import Integer.Positive.Unsafe (Positive)
import Integer.Positive.Unsafe qualified as Positive.Unsafe
import Integer.Sign (Sign (..))
import Integer.Sign qualified as Sign
import Numeric.Natural (Natural)
import Text.Show qualified as Show
import Prelude (Integer, Integral, Num, Real, seq)
import Prelude qualified as Bounded (Bounded (..))
import Prelude qualified as Enum (Enum (..))
import Prelude qualified as Num (Integral (..), Num (..), Real (..))

data Signed = Zero | NonZero Sign Positive
  deriving stock (Signed -> Signed -> Bool
(Signed -> Signed -> Bool)
-> (Signed -> Signed -> Bool) -> Eq Signed
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Signed -> Signed -> Bool
== :: Signed -> Signed -> Bool
$c/= :: Signed -> Signed -> Bool
/= :: Signed -> Signed -> Bool
Eq)

instance Ord Signed where
  compare :: Signed -> Signed -> Ordering
compare Signed
Zero Signed
Zero = Ordering
Ord.EQ
  compare Signed
Zero (Minus Positive
_) = Ordering
Ord.GT
  compare Signed
Zero (Plus Positive
_) = Ordering
Ord.LT
  compare (Minus Positive
_) Signed
Zero = Ordering
Ord.LT
  compare (Plus Positive
_) Signed
Zero = Ordering
Ord.GT
  compare (Plus Positive
_) (Minus Positive
_) = Ordering
Ord.GT
  compare (Minus Positive
_) (Plus Positive
_) = Ordering
Ord.LT
  compare (Plus Positive
a) (Plus Positive
b) = Positive -> Positive -> Ordering
forall a. Ord a => a -> a -> Ordering
Ord.compare Positive
a Positive
b
  compare (Minus Positive
a) (Minus Positive
b) = Positive -> Positive -> Ordering
forall a. Ord a => a -> a -> Ordering
Ord.compare Positive
b Positive
a

instance DeepSeq.NFData Signed where
  rnf :: Signed -> ()
rnf Signed
Zero = ()
  rnf (NonZero Sign
a Positive
b) = Sign
a Sign -> () -> ()
forall a b. a -> b -> b
`seq` Positive
b Positive -> () -> ()
forall a b. a -> b -> b
`seq` ()

instance Hashable Signed where
  hashWithSalt :: Int -> Signed -> Int
hashWithSalt Int
s Signed
Zero = Int
s Int -> Int -> Int
forall a. Hashable a => Int -> a -> Int
`hashWithSalt` (Int
0 :: Int)
  hashWithSalt Int
s (Plus Positive
x) = Int
s Int -> Int -> Int
forall a. Hashable a => Int -> a -> Int
`hashWithSalt` (Int
1 :: Int) Int -> Positive -> Int
forall a. Hashable a => Int -> a -> Int
`hashWithSalt` Positive
x
  hashWithSalt Int
s (Minus Positive
x) = Int
s Int -> Int -> Int
forall a. Hashable a => Int -> a -> Int
`hashWithSalt` (-Int
1 :: Int) Int -> Positive -> Int
forall a. Hashable a => Int -> a -> Int
`hashWithSalt` Positive
x

pattern Minus :: Positive -> Signed
pattern $mMinus :: forall {r}. Signed -> (Positive -> r) -> ((# #) -> r) -> r
$bMinus :: Positive -> Signed
Minus x = NonZero MinusSign x

pattern Plus :: Positive -> Signed
pattern $mPlus :: forall {r}. Signed -> (Positive -> r) -> ((# #) -> r) -> r
$bPlus :: Positive -> Signed
Plus x = NonZero PlusSign x

-- | A 'Signed' that is either zero or positive
pattern NotMinus :: Natural -> Signed
pattern $mNotMinus :: forall {r}. Signed -> (Natural -> r) -> ((# #) -> r) -> r
$bNotMinus :: Natural -> Signed
NotMinus x <- (toNatural -> Just x)
  where
    NotMinus = Natural -> Signed
fromNatural

-- | A 'Signed' that is either zero or negative;
-- the 'Natural' gives the magnitude of the negative
pattern NotPlus :: Natural -> Signed
pattern $mNotPlus :: forall {r}. Signed -> (Natural -> r) -> ((# #) -> r) -> r
$bNotPlus :: Natural -> Signed
NotPlus x <- ((toNatural . negate) -> Just x)
  where
    NotPlus = Signed -> Signed
negate (Signed -> Signed) -> (Natural -> Signed) -> Natural -> Signed
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Natural -> Signed
fromNatural

{-# COMPLETE Zero, Minus, Plus #-}

{-# COMPLETE Plus, NotPlus #-}

{-# COMPLETE Minus, NotMinus #-}

fromPositive :: Positive -> Signed
fromPositive :: Positive -> Signed
fromPositive = Positive -> Signed
Plus

toPositive :: Signed -> Maybe Positive
toPositive :: Signed -> Maybe Positive
toPositive (Plus Positive
x) = Positive -> Maybe Positive
forall a. a -> Maybe a
Just Positive
x
toPositive Signed
_ = Maybe Positive
forall a. Maybe a
Nothing

fromNatural :: Natural -> Signed
fromNatural :: Natural -> Signed
fromNatural Natural
0 = Signed
Zero
fromNatural Natural
x = Positive -> Signed
Plus (Positive -> Signed) -> Positive -> Signed
forall a b. (a -> b) -> a -> b
$ Natural -> Positive
Positive.Unsafe.fromNatural Natural
x

toNatural :: Signed -> Maybe Natural
toNatural :: Signed -> Maybe Natural
toNatural (Minus Positive
_) = Maybe Natural
forall a. Maybe a
Nothing
toNatural Signed
Zero = Natural -> Maybe Natural
forall a. a -> Maybe a
Just Natural
0
toNatural (Plus Positive
x) = Natural -> Maybe Natural
forall a. a -> Maybe a
Just (Positive -> Natural
Positive.Unsafe.toNatural Positive
x)

one :: Signed
one :: Signed
one = Positive -> Signed
Plus Positive
Positive.Unsafe.one

addOne :: Signed -> Signed
addOne :: Signed -> Signed
addOne Signed
Zero = Signed
one
addOne (Minus Positive
1) = Signed
Zero
addOne (Minus Positive
n) = Positive -> Signed
Minus (Positive -> Positive
Positive.Unsafe.subtractOne Positive
n)
addOne (Plus Positive
n) = Positive -> Signed
Plus (Positive -> Positive
Positive.Unsafe.addOne Positive
n)

subtractOne :: Signed -> Signed
subtractOne :: Signed -> Signed
subtractOne Signed
Zero = Positive -> Signed
Minus Positive
1
subtractOne (Plus Positive
1) = Signed
Zero
subtractOne (Plus Positive
n) = Positive -> Signed
Plus (Positive -> Positive
Positive.Unsafe.subtractOne Positive
n)
subtractOne (Minus Positive
n) = Positive -> Signed
Minus (Positive -> Positive
Positive.Unsafe.addOne Positive
n)

increase :: Natural -> Signed -> Signed
increase :: Natural -> Signed -> Signed
increase Natural
0 Signed
x = Signed
x
increase Natural
n Signed
x = Positive -> Signed -> Signed
strictlyIncrease (Natural -> Positive
Positive.Unsafe.fromNatural Natural
n) Signed
x

strictlyIncrease :: Positive -> Signed -> Signed
strictlyIncrease :: Positive -> Signed -> Signed
strictlyIncrease Positive
a Signed
Zero = Positive -> Signed
Plus Positive
a
strictlyIncrease Positive
a (Plus Positive
b) = Positive -> Signed
Plus (Positive -> Positive -> Positive
forall a. Num a => a -> a -> a
(Num.+) Positive
a Positive
b)
strictlyIncrease Positive
a (Minus Positive
b) = case Positive -> Positive -> Ordering
forall a. Ord a => a -> a -> Ordering
Ord.compare Positive
a Positive
b of
  Ordering
Ord.EQ -> Signed
Zero
  Ordering
Ord.LT -> Positive -> Signed
Minus (Positive -> Signed) -> Positive -> Signed
forall a b. (a -> b) -> a -> b
$ Positive -> Positive -> Positive
Positive.Unsafe.subtract Positive
b Positive
a
  Ordering
Ord.GT -> Positive -> Signed
Plus (Positive -> Signed) -> Positive -> Signed
forall a b. (a -> b) -> a -> b
$ Positive -> Positive -> Positive
Positive.Unsafe.subtract Positive
a Positive
b

add :: Signed -> Signed -> Signed
add :: Signed -> Signed -> Signed
add Signed
Zero Signed
x = Signed
x
add Signed
x Signed
Zero = Signed
x
add (NonZero Sign
sa Positive
a) (NonZero Sign
sb Positive
b) = case (Sign
sa, Sign
sb) of
  (Sign
PlusSign, Sign
PlusSign) -> Positive -> Signed
Plus (Positive -> Signed) -> Positive -> Signed
forall a b. (a -> b) -> a -> b
$ Positive
a Positive -> Positive -> Positive
forall a. Num a => a -> a -> a
Num.+ Positive
b
  (Sign
MinusSign, Sign
MinusSign) -> Positive -> Signed
Minus (Positive -> Signed) -> Positive -> Signed
forall a b. (a -> b) -> a -> b
$ Positive
a Positive -> Positive -> Positive
forall a. Num a => a -> a -> a
Num.+ Positive
b
  (Sign
MinusSign, Sign
PlusSign) -> case Positive -> Positive -> Ordering
forall a. Ord a => a -> a -> Ordering
Ord.compare Positive
a Positive
b of
    Ordering
Ord.EQ -> Signed
Zero
    Ordering
Ord.LT -> Positive -> Signed
Plus (Positive -> Signed) -> Positive -> Signed
forall a b. (a -> b) -> a -> b
$ Positive -> Positive -> Positive
Positive.Unsafe.subtract Positive
b Positive
a
    Ordering
Ord.GT -> Positive -> Signed
Minus (Positive -> Signed) -> Positive -> Signed
forall a b. (a -> b) -> a -> b
$ Positive -> Positive -> Positive
Positive.Unsafe.subtract Positive
a Positive
b
  (Sign
PlusSign, Sign
MinusSign) -> case Positive -> Positive -> Ordering
forall a. Ord a => a -> a -> Ordering
Ord.compare Positive
a Positive
b of
    Ordering
Ord.EQ -> Signed
Zero
    Ordering
Ord.LT -> Positive -> Signed
Minus (Positive -> Signed) -> Positive -> Signed
forall a b. (a -> b) -> a -> b
$ Positive -> Positive -> Positive
Positive.Unsafe.subtract Positive
b Positive
a
    Ordering
Ord.GT -> Positive -> Signed
Plus (Positive -> Signed) -> Positive -> Signed
forall a b. (a -> b) -> a -> b
$ Positive -> Positive -> Positive
Positive.Unsafe.subtract Positive
a Positive
b

negate :: Signed -> Signed
negate :: Signed -> Signed
negate Signed
Zero = Signed
Zero
negate (NonZero Sign
s Positive
x) = Sign -> Positive -> Signed
NonZero (Sign -> Sign
Sign.negate Sign
s) Positive
x

multiply :: Signed -> Signed -> Signed
multiply :: Signed -> Signed -> Signed
multiply Signed
Zero Signed
_ = Signed
Zero
multiply Signed
_ Signed
Zero = Signed
Zero
multiply (NonZero Sign
sa Positive
a) (NonZero Sign
sb Positive
b) =
  Sign -> Positive -> Signed
NonZero (Sign -> Sign -> Sign
Sign.multiply Sign
sa Sign
sb) (Positive
a Positive -> Positive -> Positive
forall a. Num a => a -> a -> a
Num.* Positive
b)

abs :: Signed -> Signed
abs :: Signed -> Signed
abs Signed
Zero = Signed
Zero
abs x :: Signed
x@(NonZero Sign
s Positive
p) = case Sign
s of
  Sign
PlusSign -> Signed
x
  Sign
MinusSign -> Sign -> Positive -> Signed
NonZero Sign
PlusSign Positive
p

signum :: Signed -> Signed
signum :: Signed -> Signed
signum Signed
Zero = Signed
Zero
signum (NonZero Sign
s Positive
_) = Sign -> Positive -> Signed
NonZero Sign
s Positive
Positive.Unsafe.one

fromInteger :: Integer -> Signed
fromInteger :: Integer -> Signed
fromInteger Integer
x = case Integer -> Integer -> Ordering
forall a. Ord a => a -> a -> Ordering
Ord.compare Integer
x Integer
0 of
  Ordering
Ord.EQ -> Signed
Zero
  Ordering
Ord.LT -> Positive -> Signed
Minus (Positive -> Signed) -> Positive -> Signed
forall a b. (a -> b) -> a -> b
$ Integer -> Positive
Positive.Unsafe.fromInteger (Integer -> Positive) -> Integer -> Positive
forall a b. (a -> b) -> a -> b
$ Integer -> Integer
forall a. Num a => a -> a
Num.abs Integer
x
  Ordering
Ord.GT -> Positive -> Signed
Plus (Positive -> Signed) -> Positive -> Signed
forall a b. (a -> b) -> a -> b
$ Integer -> Positive
Positive.Unsafe.fromInteger Integer
x

toInteger :: Signed -> Integer
toInteger :: Signed -> Integer
toInteger Signed
Zero = Integer
0
toInteger (Plus Positive
x) = Positive -> Integer
Positive.Unsafe.toInteger Positive
x
toInteger (Minus Positive
x) = Integer -> Integer
forall a. Num a => a -> a
Num.negate (Integer -> Integer) -> Integer -> Integer
forall a b. (a -> b) -> a -> b
$ Positive -> Integer
Positive.Unsafe.toInteger Positive
x

toInt :: Signed -> Maybe Int
toInt :: Signed -> Maybe Int
toInt Signed
x = case Signed
x of
  Signed
Zero -> Int -> Maybe Int
forall a. a -> Maybe a
Just Int
0
  Plus Positive
p -> if Bool
ok then Int -> Maybe Int
forall a. a -> Maybe a
Just (Integer -> Int
forall a. Num a => Integer -> a
Num.fromInteger Integer
i) else Maybe Int
forall a. Maybe a
Nothing
    where
      ok :: Bool
ok = Integer
i Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
Ord.<= Int -> Integer
forall a. Integral a => a -> Integer
Num.toInteger (Int
forall a. Bounded a => a
Bounded.maxBound :: Int)
      i :: Integer
i = Positive -> Integer
Positive.Unsafe.toInteger Positive
p
  Minus Positive
p -> if Bool
ok then Int -> Maybe Int
forall a. a -> Maybe a
Just (Integer -> Int
forall a. Num a => Integer -> a
Num.fromInteger Integer
i) else Maybe Int
forall a. Maybe a
Nothing
    where
      ok :: Bool
ok = Integer
i Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
Ord.>= Int -> Integer
forall a. Integral a => a -> Integer
Num.toInteger (Int
forall a. Bounded a => a
Bounded.minBound :: Int)
      i :: Integer
i = Integer -> Integer
forall a. Num a => a -> a
Num.negate (Positive -> Integer
Positive.Unsafe.toInteger Positive
p)

fromInt :: Int -> Signed
fromInt :: Int -> Signed
fromInt Int
x = case Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
Ord.compare Int
x Int
0 of
  Ordering
Ord.EQ -> Signed
Zero
  Ordering
Ord.GT -> Positive -> Signed
Plus (Positive -> Signed) -> Positive -> Signed
forall a b. (a -> b) -> a -> b
$ Int -> Positive
Positive.Unsafe.fromInt Int
x
  Ordering
Ord.LT -> Positive -> Signed
Minus (Positive -> Signed) -> Positive -> Signed
forall a b. (a -> b) -> a -> b
$ Integer -> Positive
Positive.Unsafe.fromInteger (Integer -> Positive) -> Integer -> Positive
forall a b. (a -> b) -> a -> b
$ Integer -> Integer
forall a. Num a => a -> a
Num.negate (Integer -> Integer) -> Integer -> Integer
forall a b. (a -> b) -> a -> b
$ Int -> Integer
forall a. Integral a => a -> Integer
Num.toInteger Int
x

toWord :: Signed -> Maybe Word
toWord :: Signed -> Maybe Word
toWord Signed
x = case Signed
x of
  Signed
Zero -> Word -> Maybe Word
forall a. a -> Maybe a
Just Word
0
  Plus Positive
p -> if Bool
ok then Word -> Maybe Word
forall a. a -> Maybe a
Just (Integer -> Word
forall a. Num a => Integer -> a
Num.fromInteger Integer
i) else Maybe Word
forall a. Maybe a
Nothing
    where
      ok :: Bool
ok = Integer
i Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
Ord.<= Word -> Integer
forall a. Integral a => a -> Integer
Num.toInteger (Word
forall a. Bounded a => a
Bounded.maxBound :: Word)
      i :: Integer
i = Positive -> Integer
Positive.Unsafe.toInteger Positive
p
  Minus Positive
_ -> Maybe Word
forall a. Maybe a
Nothing

fromWord :: Word -> Signed
fromWord :: Word -> Signed
fromWord Word
x = case Word
x of
  Word
0 -> Signed
Zero
  Word
_ -> Positive -> Signed
Plus (Positive -> Signed) -> Positive -> Signed
forall a b. (a -> b) -> a -> b
$ Integer -> Positive
Positive.Unsafe.fromInteger (Word -> Integer
forall a. Integral a => a -> Integer
Num.toInteger Word
x)

type Div a = a -> a -> (a, a)

divisionOp :: Div Integer -> Div Signed
divisionOp :: Div Integer -> Div Signed
divisionOp Div Integer
o Signed
a Signed
b =
  let (Integer
q, Integer
r) = Div Integer
o (Signed -> Integer
toInteger Signed
a) (Signed -> Integer
toInteger Signed
b)
   in (Integer -> Signed
fromInteger Integer
q, Integer -> Signed
fromInteger Integer
r)

instance Num Signed where
  + :: Signed -> Signed -> Signed
(+) = Signed -> Signed -> Signed
add
  * :: Signed -> Signed -> Signed
(*) = Signed -> Signed -> Signed
multiply
  negate :: Signed -> Signed
negate = Signed -> Signed
negate
  abs :: Signed -> Signed
abs = Signed -> Signed
abs
  signum :: Signed -> Signed
signum = Signed -> Signed
signum
  fromInteger :: Integer -> Signed
fromInteger = Integer -> Signed
fromInteger

instance Enum Signed where
  pred :: Signed -> Signed
pred = Integer -> Signed
fromInteger (Integer -> Signed) -> (Signed -> Integer) -> Signed -> Signed
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Integer -> Integer
forall a. Enum a => a -> a
Enum.pred (Integer -> Integer) -> (Signed -> Integer) -> Signed -> Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Signed -> Integer
toInteger
  succ :: Signed -> Signed
succ = Integer -> Signed
fromInteger (Integer -> Signed) -> (Signed -> Integer) -> Signed -> Signed
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Integer -> Integer
forall a. Enum a => a -> a
Enum.succ (Integer -> Integer) -> (Signed -> Integer) -> Signed -> Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Signed -> Integer
toInteger

  toEnum :: Int -> Signed
toEnum = Integer -> Signed
fromInteger (Integer -> Signed) -> (Int -> Integer) -> Int -> Signed
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Int -> Integer
forall a. Enum a => Int -> a
Enum.toEnum
  fromEnum :: Signed -> Int
fromEnum = Integer -> Int
forall a. Enum a => a -> Int
Enum.fromEnum (Integer -> Int) -> (Signed -> Integer) -> Signed -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Signed -> Integer
toInteger

  enumFrom :: Signed -> [Signed]
enumFrom Signed
a = (Integer -> Signed) -> [Integer] -> [Signed]
forall a b. (a -> b) -> [a] -> [b]
List.map Integer -> Signed
fromInteger ([Integer] -> [Signed]) -> [Integer] -> [Signed]
forall a b. (a -> b) -> a -> b
$ Integer -> [Integer]
forall a. Enum a => a -> [a]
Enum.enumFrom (Signed -> Integer
toInteger Signed
a)
  enumFromTo :: Signed -> Signed -> [Signed]
enumFromTo Signed
a Signed
b = (Integer -> Signed) -> [Integer] -> [Signed]
forall a b. (a -> b) -> [a] -> [b]
List.map Integer -> Signed
fromInteger ([Integer] -> [Signed]) -> [Integer] -> [Signed]
forall a b. (a -> b) -> a -> b
$ Integer -> Integer -> [Integer]
forall a. Enum a => a -> a -> [a]
Enum.enumFromTo (Signed -> Integer
toInteger Signed
a) (Signed -> Integer
toInteger Signed
b)
  enumFromThen :: Signed -> Signed -> [Signed]
enumFromThen Signed
a Signed
b = (Integer -> Signed) -> [Integer] -> [Signed]
forall a b. (a -> b) -> [a] -> [b]
List.map Integer -> Signed
fromInteger ([Integer] -> [Signed]) -> [Integer] -> [Signed]
forall a b. (a -> b) -> a -> b
$ Integer -> Integer -> [Integer]
forall a. Enum a => a -> a -> [a]
Enum.enumFromThen (Signed -> Integer
toInteger Signed
a) (Signed -> Integer
toInteger Signed
b)
  enumFromThenTo :: Signed -> Signed -> Signed -> [Signed]
enumFromThenTo Signed
a Signed
b Signed
c = (Integer -> Signed) -> [Integer] -> [Signed]
forall a b. (a -> b) -> [a] -> [b]
List.map Integer -> Signed
fromInteger ([Integer] -> [Signed]) -> [Integer] -> [Signed]
forall a b. (a -> b) -> a -> b
$ Integer -> Integer -> Integer -> [Integer]
forall a. Enum a => a -> a -> a -> [a]
Enum.enumFromThenTo (Signed -> Integer
toInteger Signed
a) (Signed -> Integer
toInteger Signed
b) (Signed -> Integer
toInteger Signed
c)

instance Real Signed where
  toRational :: Signed -> Rational
toRational = Integer -> Rational
forall a. Real a => a -> Rational
Num.toRational (Integer -> Rational) -> (Signed -> Integer) -> Signed -> Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Signed -> Integer
toInteger

instance Integral Signed where
  toInteger :: Signed -> Integer
toInteger = Signed -> Integer
toInteger
  quotRem :: Div Signed
quotRem = Div Integer -> Div Signed
divisionOp Div Integer
forall a. Integral a => a -> a -> (a, a)
Num.quotRem
  divMod :: Div Signed
divMod = Div Integer -> Div Signed
divisionOp Div Integer
forall a. Integral a => a -> a -> (a, a)
Num.divMod

instance Show Signed where
  show :: Signed -> String
show = Integer -> String
forall a. Show a => a -> String
Show.show (Integer -> String) -> (Signed -> Integer) -> Signed -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Signed -> Integer
forall a. Integral a => a -> Integer
Num.toInteger
  showsPrec :: Int -> Signed -> ShowS
showsPrec Int
i = Int -> Integer -> ShowS
forall a. Show a => Int -> a -> ShowS
Show.showsPrec Int
i (Integer -> ShowS) -> (Signed -> Integer) -> Signed -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Signed -> Integer
forall a. Integral a => a -> Integer
Num.toInteger