{-# language Trustworthy #-}
module D10.Num.Conversions
(
d10Char, charD10Maybe, charD10Either, charD10Fail
, d10Str, strD10Maybe, strD10Either, strD10Fail
, strD10ListMaybe, strD10ListEither, strD10ListFail
, d10Nat, natD10Maybe, natD10Either, natD10Fail
, natMod10
, d10Integer, integerD10Maybe, integerD10Either
, integerD10Fail, integerMod10
, d10Int, intD10Maybe, intD10Either, intD10Fail
, intMod10
, d10Num, integralD10Maybe, integralD10Either
, integralD10Fail, integralMod10
) where
import D10.Num.Unsafe (D10(..))
import D10.Predicate (isD10Char, isD10Int, isD10Integer, isD10Nat)
import Control.Monad.Fail (MonadFail (fail))
import Data.Char (chr, ord)
import Numeric.Natural (Natural)
import Prelude hiding (fail)
import qualified Prelude as P
d10Char :: Integral a => D10 a -> Char
d10Char :: D10 a -> Char
d10Char (D10_Unsafe a
x) = Int -> Char
chr (Char -> Int
ord Char
'0' Int -> Int -> Int
forall a. Num a => a -> a -> a
P.+ a -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
x)
d10Str :: Integral a => D10 a -> String
d10Str :: D10 a -> String
d10Str D10 a
x = [D10 a -> Char
forall a. Integral a => D10 a -> Char
d10Char D10 a
x]
d10Nat :: Integral a => D10 a -> Natural
d10Nat :: D10 a -> Natural
d10Nat = D10 a -> Natural
forall b a. (Integral b, Num a) => D10 b -> a
d10Num
d10Integer :: Integral a => D10 a -> Integer
d10Integer :: D10 a -> Integer
d10Integer = D10 a -> Integer
forall b a. (Integral b, Num a) => D10 b -> a
d10Num
d10Int :: Integral a => D10 a -> Int
d10Int :: D10 a -> Int
d10Int = D10 a -> Int
forall b a. (Integral b, Num a) => D10 b -> a
d10Num
d10Num :: (Integral b, Num a) => D10 b -> a
d10Num :: D10 b -> a
d10Num (D10_Unsafe b
x) = b -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral b
x
natMod10 :: Num a => Natural -> D10 a
natMod10 :: Natural -> D10 a
natMod10 = Natural -> D10 a
forall b a. (Num b, Integral a) => a -> D10 b
integralMod10
integerMod10 :: Num a => Integer -> D10 a
integerMod10 :: Integer -> D10 a
integerMod10 = Integer -> D10 a
forall b a. (Num b, Integral a) => a -> D10 b
integralMod10
intMod10 :: Num a => Int -> D10 a
intMod10 :: Int -> D10 a
intMod10 = Int -> D10 a
forall b a. (Num b, Integral a) => a -> D10 b
integralMod10
integralMod10 :: (Num b, Integral a) => a -> D10 b
integralMod10 :: a -> D10 b
integralMod10 a
x = b -> D10 b
forall a. a -> D10 a
D10_Unsafe (a -> b
forall a b. (Integral a, Num b) => a -> b
fromIntegral (a
x a -> a -> a
forall a. Integral a => a -> a -> a
`mod` a
10))
charD10Maybe :: Num a => Char -> Maybe (D10 a)
charD10Maybe :: Char -> Maybe (D10 a)
charD10Maybe Char
x
| Char -> Bool
isD10Char Char
x = D10 a -> Maybe (D10 a)
forall a. a -> Maybe a
Just (a -> D10 a
forall a. a -> D10 a
D10_Unsafe (Int -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Char -> Int
ord Char
x Int -> Int -> Int
forall a. Num a => a -> a -> a
P.- Char -> Int
ord Char
'0')))
| Bool
otherwise = Maybe (D10 a)
forall a. Maybe a
Nothing
strD10Maybe :: Num a => String -> Maybe (D10 a)
strD10Maybe :: String -> Maybe (D10 a)
strD10Maybe [Char
x] = Char -> Maybe (D10 a)
forall a. Num a => Char -> Maybe (D10 a)
charD10Maybe Char
x
strD10Maybe String
_ = Maybe (D10 a)
forall a. Maybe a
Nothing
strD10ListMaybe :: Num a => String -> Maybe [D10 a]
strD10ListMaybe :: String -> Maybe [D10 a]
strD10ListMaybe = (Char -> Maybe (D10 a)) -> String -> Maybe [D10 a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Char -> Maybe (D10 a)
forall a. Num a => Char -> Maybe (D10 a)
charD10Maybe
natD10Maybe :: Num a => Natural -> Maybe (D10 a)
natD10Maybe :: Natural -> Maybe (D10 a)
natD10Maybe Natural
x
| Natural -> Bool
isD10Nat Natural
x = D10 a -> Maybe (D10 a)
forall a. a -> Maybe a
Just (a -> D10 a
forall a. a -> D10 a
D10_Unsafe (Natural -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral Natural
x))
| Bool
otherwise = Maybe (D10 a)
forall a. Maybe a
Nothing
integerD10Maybe :: Num a => Integer -> Maybe (D10 a)
integerD10Maybe :: Integer -> Maybe (D10 a)
integerD10Maybe Integer
x
| Integer -> Bool
isD10Integer Integer
x = D10 a -> Maybe (D10 a)
forall a. a -> Maybe a
Just (a -> D10 a
forall a. a -> D10 a
D10_Unsafe (Integer -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
x))
| Bool
otherwise = Maybe (D10 a)
forall a. Maybe a
Nothing
intD10Maybe :: Num a => Int -> Maybe (D10 a)
intD10Maybe :: Int -> Maybe (D10 a)
intD10Maybe Int
x
| Int -> Bool
isD10Int Int
x = D10 a -> Maybe (D10 a)
forall a. a -> Maybe a
Just (a -> D10 a
forall a. a -> D10 a
D10_Unsafe (Int -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
x))
| Bool
otherwise = Maybe (D10 a)
forall a. Maybe a
Nothing
integralD10Maybe :: (Num b, Integral a) => a -> Maybe (D10 b)
integralD10Maybe :: a -> Maybe (D10 b)
integralD10Maybe a
x = Integer -> Maybe (D10 b)
forall a. Num a => Integer -> Maybe (D10 a)
integerD10Maybe (a -> Integer
forall a. Integral a => a -> Integer
toInteger a
x)
charD10Either :: Num a => Char -> Either String (D10 a)
charD10Either :: Char -> Either String (D10 a)
charD10Either Char
x
| Char -> Bool
isD10Char Char
x = D10 a -> Either String (D10 a)
forall a b. b -> Either a b
Right (a -> D10 a
forall a. a -> D10 a
D10_Unsafe (Int -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Char -> Int
ord Char
x Int -> Int -> Int
forall a. Num a => a -> a -> a
P.- Char -> Int
ord Char
'0')))
| Bool
otherwise = String -> Either String (D10 a)
forall a b. a -> Either a b
Left String
"d10 must be between 0 and 9"
strD10Either :: Num a => String -> Either String (D10 a)
strD10Either :: String -> Either String (D10 a)
strD10Either [Char
x] = Char -> Either String (D10 a)
forall a. Num a => Char -> Either String (D10 a)
charD10Either Char
x
strD10Either String
_ = String -> Either String (D10 a)
forall a b. a -> Either a b
Left String
"d10 must be a single character"
strD10ListEither :: Num a => String -> Either String [D10 a]
strD10ListEither :: String -> Either String [D10 a]
strD10ListEither = (Char -> Either String (D10 a)) -> String -> Either String [D10 a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Char -> Either String (D10 a)
forall a. Num a => Char -> Either String (D10 a)
charD10Either
natD10Either :: Num a => Natural -> Either String (D10 a)
natD10Either :: Natural -> Either String (D10 a)
natD10Either Natural
x =
case (Natural -> Maybe (D10 a)
forall a. Num a => Natural -> Maybe (D10 a)
natD10Maybe Natural
x) of
Just D10 a
y -> D10 a -> Either String (D10 a)
forall a b. b -> Either a b
Right D10 a
y
Maybe (D10 a)
Nothing -> String -> Either String (D10 a)
forall a b. a -> Either a b
Left String
"d10 must be less than 10"
integerD10Either :: Num a => Integer -> Either String (D10 a)
integerD10Either :: Integer -> Either String (D10 a)
integerD10Either Integer
x =
case (Integer -> Maybe (D10 a)
forall a. Num a => Integer -> Maybe (D10 a)
integerD10Maybe Integer
x) of
Just D10 a
y -> D10 a -> Either String (D10 a)
forall a b. b -> Either a b
Right D10 a
y
Maybe (D10 a)
Nothing -> String -> Either String (D10 a)
forall a b. a -> Either a b
Left String
"d10 must be between 0 and 9"
intD10Either :: Num a => Int -> Either String (D10 a)
intD10Either :: Int -> Either String (D10 a)
intD10Either Int
x =
case (Int -> Maybe (D10 a)
forall a. Num a => Int -> Maybe (D10 a)
intD10Maybe Int
x) of
Just D10 a
y -> D10 a -> Either String (D10 a)
forall a b. b -> Either a b
Right D10 a
y
Maybe (D10 a)
Nothing -> String -> Either String (D10 a)
forall a b. a -> Either a b
Left String
"d10 must be between 0 and 9"
integralD10Either :: (Num b, Integral a) => a -> Either String (D10 b)
integralD10Either :: a -> Either String (D10 b)
integralD10Either a
x = Integer -> Either String (D10 b)
forall a. Num a => Integer -> Either String (D10 a)
integerD10Either (a -> Integer
forall a. Integral a => a -> Integer
toInteger a
x)
charD10Fail :: (Num a, MonadFail m) => Char -> m (D10 a)
charD10Fail :: Char -> m (D10 a)
charD10Fail Char
x
| Char -> Bool
isD10Char Char
x = D10 a -> m (D10 a)
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> D10 a
forall a. a -> D10 a
D10_Unsafe (Int -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Char -> Int
ord Char
x Int -> Int -> Int
forall a. Num a => a -> a -> a
P.- Char -> Int
ord Char
'0')))
| Bool
otherwise = String -> m (D10 a)
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"d10 must be between 0 and 9"
strD10Fail :: (Num a, MonadFail m) => String -> m (D10 a)
strD10Fail :: String -> m (D10 a)
strD10Fail [Char
x] = Char -> m (D10 a)
forall a (m :: * -> *). (Num a, MonadFail m) => Char -> m (D10 a)
charD10Fail Char
x
strD10Fail String
_ = String -> m (D10 a)
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"d10 must be a single character"
strD10ListFail :: (Num a, MonadFail m) => String -> m [D10 a]
strD10ListFail :: String -> m [D10 a]
strD10ListFail = (Char -> m (D10 a)) -> String -> m [D10 a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Char -> m (D10 a)
forall a (m :: * -> *). (Num a, MonadFail m) => Char -> m (D10 a)
charD10Fail
natD10Fail :: (Num a, MonadFail m) => Natural -> m (D10 a)
natD10Fail :: Natural -> m (D10 a)
natD10Fail Natural
x =
case (Natural -> Maybe (D10 a)
forall a. Num a => Natural -> Maybe (D10 a)
natD10Maybe Natural
x) of
Just D10 a
y -> D10 a -> m (D10 a)
forall (m :: * -> *) a. Monad m => a -> m a
return D10 a
y
Maybe (D10 a)
Nothing -> String -> m (D10 a)
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"d10 must be less than 10"
integerD10Fail :: (Num a, MonadFail m) => Integer -> m (D10 a)
integerD10Fail :: Integer -> m (D10 a)
integerD10Fail Integer
x =
case (Integer -> Maybe (D10 a)
forall a. Num a => Integer -> Maybe (D10 a)
integerD10Maybe Integer
x) of
Just D10 a
y -> D10 a -> m (D10 a)
forall (m :: * -> *) a. Monad m => a -> m a
return D10 a
y
Maybe (D10 a)
Nothing -> String -> m (D10 a)
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"d10 must be between 0 and 9"
intD10Fail :: (Num a, MonadFail m) => Int -> m (D10 a)
intD10Fail :: Int -> m (D10 a)
intD10Fail Int
x =
case (Int -> Maybe (D10 a)
forall a. Num a => Int -> Maybe (D10 a)
intD10Maybe Int
x) of
Just D10 a
y -> D10 a -> m (D10 a)
forall (m :: * -> *) a. Monad m => a -> m a
return D10 a
y
Maybe (D10 a)
Nothing -> String -> m (D10 a)
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"d10 must be between 0 and 9"
integralD10Fail :: (Num b, Integral a, MonadFail m) => a -> m (D10 b)
integralD10Fail :: a -> m (D10 b)
integralD10Fail a
x = Integer -> m (D10 b)
forall a (m :: * -> *).
(Num a, MonadFail m) =>
Integer -> m (D10 a)
integerD10Fail (a -> Integer
forall a. Integral a => a -> Integer
toInteger a
x)