module Integer.Finite where

import Data.Int (Int)
import Data.Maybe qualified as Maybe
import Data.Word (Word)
import Essentials
import Integer.Integer (Integer)
import Integer.Integer qualified as Integer
import Integer.Natural (Natural)
import Integer.Natural qualified as Natural
import Integer.Positive (Positive)
import Integer.Positive qualified as Positive
import Integer.Signed (Signed)
import Integer.Signed qualified as Signed
import Prelude (Integral)

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 = Natural -> Maybe Natural
forall a. a -> Maybe a
Maybe.Just (Natural -> Maybe Natural)
-> (Word -> Natural) -> Word -> Maybe Natural
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
. 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 = Integer -> Maybe Integer
forall a. a -> Maybe a
Maybe.Just (Integer -> Maybe Integer)
-> (Word -> Integer) -> Word -> Maybe 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
. Word -> Integer
Integer.fromWord
  toInt :: Integer -> Maybe Int
toInt = Integer -> Maybe Int
Integer.toInt
  fromInt :: Int -> Maybe Integer
fromInt = Integer -> Maybe Integer
forall a. a -> Maybe a
Maybe.Just (Integer -> Maybe Integer)
-> (Int -> Integer) -> Int -> Maybe 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
. Int -> Integer
Integer.fromInt

instance ConvertWithFinite Signed where
  toWord :: Signed -> Maybe Word
toWord = Signed -> Maybe Word
Signed.toWord
  fromWord :: Word -> Maybe Signed
fromWord = Signed -> Maybe Signed
forall a. a -> Maybe a
Maybe.Just (Signed -> Maybe Signed)
-> (Word -> Signed) -> Word -> Maybe 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
. Word -> Signed
Signed.fromWord
  toInt :: Signed -> Maybe Int
toInt = Signed -> Maybe Int
Signed.toInt
  fromInt :: Int -> Maybe Signed
fromInt = Signed -> Maybe Signed
forall a. a -> Maybe a
Maybe.Just (Signed -> Maybe Signed) -> (Int -> Signed) -> Int -> Maybe 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 -> 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 = a -> Maybe Int
forall a. ConvertWithFinite a => a -> Maybe Int
toInt
  fromFinite :: forall a. ConvertWithFinite a => Int -> Maybe a
fromFinite = Int -> Maybe a
forall a. ConvertWithFinite a => Int -> Maybe a
fromInt

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