module Integer.Finite where

import Essentials

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

import qualified Data.Maybe as Maybe
import qualified Integer.Integer as Integer
import qualified Integer.Natural as Natural
import qualified Integer.Positive as Positive
import qualified Integer.Signed as Signed

class ConvertWithFinite a where
    toWord :: a -> Maybe Word
    fromWord :: Word -> Maybe a
    toInt :: a -> Maybe Int
    fromInt :: Int -> Maybe a

instance ConvertWithFinite Natural where
    toWord :: Natural -> Maybe Word
toWord = Natural -> Maybe Word
Natural.toWord
    fromWord :: Word -> Maybe Natural
fromWord = forall a. a -> Maybe a
Maybe.Just forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Word -> Natural
Natural.fromWord
    toInt :: Natural -> Maybe Int
toInt = Natural -> Maybe Int
Natural.toInt
    fromInt :: Int -> Maybe Natural
fromInt = Int -> Maybe Natural
Natural.fromInt

instance ConvertWithFinite Positive where
    toWord :: Positive -> Maybe Word
toWord = Positive -> Maybe Word
Positive.toWord
    fromWord :: Word -> Maybe Positive
fromWord = Word -> Maybe Positive
Positive.fromWord
    toInt :: Positive -> Maybe Int
toInt = Positive -> Maybe Int
Positive.toInt
    fromInt :: Int -> Maybe Positive
fromInt = Int -> Maybe Positive
Positive.fromInt

instance ConvertWithFinite Integer where
    toWord :: Integer -> Maybe Word
toWord = Integer -> Maybe Word
Integer.toWord
    fromWord :: Word -> Maybe Integer
fromWord = forall a. a -> Maybe a
Maybe.Just forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Word -> Integer
Integer.fromWord
    toInt :: Integer -> Maybe Int
toInt = Integer -> Maybe Int
Integer.toInt
    fromInt :: Int -> Maybe Integer
fromInt = forall a. a -> Maybe a
Maybe.Just forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Int -> Integer
Integer.fromInt

instance ConvertWithFinite Signed where
    toWord :: Signed -> Maybe Word
toWord = Signed -> Maybe Word
Signed.toWord
    fromWord :: Word -> Maybe Signed
fromWord = forall a. a -> Maybe a
Maybe.Just forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Word -> Signed
Signed.fromWord
    toInt :: Signed -> Maybe Int
toInt = Signed -> Maybe Int
Signed.toInt
    fromInt :: Int -> Maybe Signed
fromInt = forall a. a -> Maybe a
Maybe.Just forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Int -> Signed
Signed.fromInt

class (Bounded b, Integral b) => Finite b where
    toFinite :: ConvertWithFinite a => a -> Maybe b
    fromFinite :: ConvertWithFinite a => b -> Maybe a

instance Finite Int where
    toFinite :: forall a. ConvertWithFinite a => a -> Maybe Int
toFinite = forall a. ConvertWithFinite a => a -> Maybe Int
toInt
    fromFinite :: forall a. ConvertWithFinite a => Int -> Maybe a
fromFinite = forall a. ConvertWithFinite a => Int -> Maybe a
fromInt

instance Finite Word where
    toFinite :: forall a. ConvertWithFinite a => a -> Maybe Word
toFinite = forall a. ConvertWithFinite a => a -> Maybe Word
toWord
    fromFinite :: forall a. ConvertWithFinite a => Word -> Maybe a
fromFinite = forall a. ConvertWithFinite a => Word -> Maybe a
fromWord