module Integer.Integer
  (
    {- * Type -} Integer,
    {- * Conversion -}
    {- ** Positive -} toPositive, fromPositive,
    {- ** Natural -} toNatural, fromNatural,
    {- ** Signed -} toSigned, fromSigned,
    {- ** Int -} toInt, fromInt,
    {- ** Word -} toWord, fromWord,
  )
  where

import Essentials

import Data.Int (Int)
import Data.Word (Word)
import Integer.Positive (Positive)
import Integer.Signed (Signed (..))
import Numeric.Natural (Natural)
import Prelude (Integer)

import qualified Data.Bool as Bool
import qualified Data.Ord as Ord
import qualified Integer.Natural as Natural
import qualified Integer.Positive as Positive
import qualified Integer.Signed as Signed
import qualified Prelude as Bounded (Bounded (..))
import qualified Prelude as Num (Integral (..), Num (..))

toPositive :: Integer -> Maybe Positive
toPositive :: Integer -> Maybe Positive
toPositive = Integer -> Maybe Positive
Positive.fromInteger

fromPositive :: Positive -> Integer
fromPositive :: Positive -> Integer
fromPositive = Positive -> Integer
Positive.toInteger

toNatural :: Integer -> Maybe Natural
toNatural :: Integer -> Maybe Natural
toNatural = Integer -> Maybe Natural
Natural.fromInteger

fromNatural :: Natural -> Integer
fromNatural :: Natural -> Integer
fromNatural = Natural -> Integer
Natural.toInteger

toSigned :: Integer -> Signed
toSigned :: Integer -> Signed
toSigned = Integer -> Signed
Signed.fromInteger

fromSigned :: Signed -> Integer
fromSigned :: Signed -> Integer
fromSigned = Signed -> Integer
Signed.toInteger

toInt :: Integer -> Maybe Int
toInt :: Integer -> Maybe Int
toInt Integer
x = if Bool
ok then forall a. a -> Maybe a
Just (forall a. Num a => Integer -> a
Num.fromInteger Integer
x) else forall a. Maybe a
Nothing
  where
    ok :: Bool
ok = Integer
x forall a. Ord a => a -> a -> Bool
Ord.>= forall a. Integral a => a -> Integer
Num.toInteger (forall a. Bounded a => a
Bounded.minBound :: Int) Bool -> Bool -> Bool
Bool.&&
         Integer
x forall a. Ord a => a -> a -> Bool
Ord.<= forall a. Integral a => a -> Integer
Num.toInteger (forall a. Bounded a => a
Bounded.maxBound :: Int)

fromInt :: Int -> Integer
fromInt :: Int -> Integer
fromInt = forall a. Integral a => a -> Integer
Num.toInteger

toWord :: Integer -> Maybe Word
toWord :: Integer -> Maybe Word
toWord Integer
x = if Bool
ok then forall a. a -> Maybe a
Just (forall a. Num a => Integer -> a
Num.fromInteger Integer
x) else forall a. Maybe a
Nothing
  where
    ok :: Bool
ok = Integer
x forall a. Ord a => a -> a -> Bool
Ord.>= forall a. Integral a => a -> Integer
Num.toInteger (forall a. Bounded a => a
Bounded.minBound :: Word) Bool -> Bool -> Bool
Bool.&&
         Integer
x forall a. Ord a => a -> a -> Bool
Ord.<= forall a. Integral a => a -> Integer
Num.toInteger (forall a. Bounded a => a
Bounded.maxBound :: Word)

fromWord :: Word -> Integer
fromWord :: Word -> Integer
fromWord = forall a. Integral a => a -> Integer
Num.toInteger