{-# language Trustworthy #-} module D10.Char.Conversions ( -- * D10 / Char d10Char, charD10Maybe, charD10Either, charD10Fail -- * D10 / String , d10Str, strD10Maybe, strD10Either, strD10Fail -- * [D10] / String , strD10ListMaybe, strD10ListEither, strD10ListFail -- * D10 / Natural , d10Nat, natD10Maybe, natD10Either, natD10Fail , natMod10 -- * D10 / Integer , d10Integer, integerD10Maybe, integerD10Either , integerD10Fail, integerMod10 -- * D10 / Int , d10Int, intD10Maybe, intD10Either , intD10Fail, intMod10 -- * D10 / general numeric types , d10Num, integralD10Maybe, integralD10Either , integralD10Fail, integralMod10 ) where import D10.Char.Unsafe (D10(..)) import D10.Predicate (isD10Char, isD10Int, isD10Integer, isD10Nat) -- base import Control.Monad.Fail (MonadFail (fail)) import Data.Char (chr, ord) import Numeric.Natural (Natural) import Prelude hiding (fail) import qualified Prelude as P -- | Convert a 'D10' to its underlying 'Char' representation. -- -- >>> d10Char [d10|7|] -- '7' d10Char :: D10 -> Char d10Char :: D10 -> Char d10Char (D10_Unsafe Char x) = Char x -- | Convert a 'D10' to a 'String'. -- -- @'d10Str' x = ['d10Char' x]@ -- -- >>> d10Str [d10|7|] -- "7" d10Str :: D10 -> String d10Str :: D10 -> String d10Str (D10_Unsafe Char x) = [Char x] -- | Convert a 'D10' to a 'Natural'. -- -- 'd10Num' is a more general version of this function. -- -- >>> d10Nat [d10|7|] -- 7 d10Nat :: D10 -> Natural d10Nat :: D10 -> Natural d10Nat (D10_Unsafe Char x) = Int -> Natural 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') -- | Convert a 'D10' to an 'Integer'. -- -- 'd10Num' is a more general version of this function. -- -- >>> d10Integer [d10|7|] -- 7 d10Integer :: D10 -> Integer d10Integer :: D10 -> Integer d10Integer (D10_Unsafe Char x) = Int -> Integer forall a. Integral a => a -> Integer toInteger (Char -> Int ord Char x Int -> Int -> Int forall a. Num a => a -> a -> a P.- Char -> Int ord Char '0') -- | Convert a 'D10' to an 'Int'. -- -- 'd10Num' is a more general version of this function. -- -- >>> d10Int [d10|7|] -- 7 d10Int :: D10 -> Int d10Int :: D10 -> Int d10Int (D10_Unsafe Char x) = Char -> Int ord Char x Int -> Int -> Int forall a. Num a => a -> a -> a P.- Char -> Int ord Char '0' -- | Convert a 'D10' to any kind of number with a 'Num' instance. -- -- Specialized versions of this function include 'd10Nat', -- 'd10Integer', and 'd10Int'. -- -- >>> d10Num [d10|7|] :: Integer -- 7 d10Num :: Num a => D10 -> a d10Num :: D10 -> a d10Num (D10_Unsafe Char x) = 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') --------------------------------------------------- -- | The 'D10' which is uniquely congruent modulo 10 to the given 'Natural'. -- -- 'integralMod10' is a more general version of this function. -- -- >>> natMod10 56 -- [d10|6|] natMod10 :: Natural -> D10 natMod10 :: Natural -> D10 natMod10 Natural x = Char -> D10 D10_Unsafe (Int -> Char chr (Char -> Int ord Char '0' Int -> Int -> Int forall a. Num a => a -> a -> a P.+ Natural -> Int forall a b. (Integral a, Num b) => a -> b fromIntegral (Natural x Natural -> Natural -> Natural forall a. Integral a => a -> a -> a `mod` Natural 10))) -- | The 'D10' which is uniquely congruent modulo 10 to the given 'Integer'. -- -- 'integralMod10' is a more general version of this function. -- -- >>> integerMod10 56 -- [d10|6|] -- -- >>> integerMod10 (-56) -- [d10|4|] integerMod10 :: Integer -> D10 integerMod10 :: Integer -> D10 integerMod10 Integer x = Char -> D10 D10_Unsafe (Int -> Char chr (Char -> Int ord Char '0' Int -> Int -> Int forall a. Num a => a -> a -> a P.+ Integer -> Int forall a. Num a => Integer -> a fromInteger (Integer x Integer -> Integer -> Integer forall a. Integral a => a -> a -> a `mod` Integer 10))) -- | The 'D10' which is uniquely congruent modulo 10 to the given 'Int'. -- -- 'integralMod10' is a more general version of this function. -- -- >>> intMod10 56 -- [d10|6|] -- -- >>> intMod10 (-56) -- [d10|4|] intMod10 :: Int -> D10 intMod10 :: Int -> D10 intMod10 Int x = Char -> D10 D10_Unsafe (Int -> Char chr (Char -> Int ord Char '0' Int -> Int -> Int forall a. Num a => a -> a -> a P.+ (Int x Int -> Int -> Int forall a. Integral a => a -> a -> a `mod` Int 10))) -- | The 'D10' which is uniquely congruent modulo 10 to the given number -- (whose type must have an instance of the 'Integral' class). -- -- Specialized versions of this function include 'natMod10', -- 'integerMod10', and 'intMod10'. -- -- >>> integralMod10 (56 :: Integer) -- [d10|6|] -- -- >>> integralMod10 ((-56) :: Integer) -- [d10|4|] integralMod10 :: Integral a => a -> D10 integralMod10 :: a -> D10 integralMod10 a x = Char -> D10 D10_Unsafe (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 a -> a -> a forall a. Integral a => a -> a -> a `mod` a 10))) --------------------------------------------------- -- | Convert a 'Char' to a 'D10' if it is within the range -- @'0'@ to @'9'@, or produce 'Nothing' otherwise. -- -- @'D10.Predicate.isD10Char' x = 'Data.Maybe.isJust' ('charD10Maybe' x)@ -- -- 'charD10Fail' is a more general version of this function. -- -- >>> charD10Maybe '5' -- Just [d10|5|] -- -- >>> charD10Maybe 'a' -- Nothing charD10Maybe :: Char -> Maybe D10 charD10Maybe :: Char -> Maybe D10 charD10Maybe Char x | Char -> Bool isD10Char Char x = D10 -> Maybe D10 forall a. a -> Maybe a Just (Char -> D10 D10_Unsafe Char x) | Bool otherwise = Maybe D10 forall a. Maybe a Nothing -- | Convert a 'String' to a 'D10' if it consists of exactly one -- character and that character is within the range @'0'@ to @'9'@, -- or produce 'Nothing' otherwise. -- -- @'D10.Predicate.isD10Str' x = 'Data.Maybe.isJust' ('strD10Maybe' x)@ -- -- 'strD10Fail' is a more general version of this function. -- -- >>> strD10Maybe "5" -- Just [d10|5|] -- -- >>> strD10Maybe "a" -- Nothing -- -- >>> strD10Maybe "58" -- Nothing strD10Maybe :: String -> Maybe D10 strD10Maybe :: String -> Maybe D10 strD10Maybe [Char x] = Char -> Maybe D10 charD10Maybe Char x strD10Maybe String _ = Maybe D10 forall a. Maybe a Nothing -- | Convert a 'String' to a list of 'D10' if all of the characters -- in the string are within the range @'0'@ to @'9'@, or produce -- 'Nothing' otherwise. -- -- @'D10.Predicate.isD10ListStr' x = 'Data.Maybe.isJust' ('strD10ListMaybe' x)@ -- -- 'strD10ListFail' is a more general version of this function. -- -- >>> strD10ListMaybe "5" -- Just [d10list|5|] -- -- >>> strD10ListMaybe "a" -- Nothing -- -- >>> strD10ListMaybe "58" -- Just [d10list|58|] strD10ListMaybe :: String -> Maybe [D10] strD10ListMaybe :: String -> Maybe [D10] strD10ListMaybe = (Char -> Maybe D10) -> String -> Maybe [D10] forall (t :: * -> *) (f :: * -> *) a b. (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b) traverse Char -> Maybe D10 charD10Maybe -- | Convert a 'Natural' to a 'D10' if it is less than 10, -- or produce 'Nothing' otherwise. -- -- @'D10.Predicate.isD10Nat' x = 'Data.Maybe.isJust' ('natD10Maybe' x)@ -- -- 'integralD10Maybe', 'natD10Fail', and 'integralD10Fail' -- are more general versions of this function. -- -- >>> natD10Maybe 5 -- Just [d10|5|] -- -- >>> natD10Maybe 12 -- Nothing natD10Maybe :: Natural -> Maybe D10 natD10Maybe :: Natural -> Maybe D10 natD10Maybe Natural x | Natural -> Bool isD10Nat Natural x = D10 -> Maybe D10 forall a. a -> Maybe a Just (Char -> D10 D10_Unsafe (Int -> Char chr (Natural -> Int forall a b. (Integral a, Num b) => a -> b fromIntegral Natural x Int -> Int -> Int forall a. Num a => a -> a -> a P.+ Char -> Int ord Char '0'))) | Bool otherwise = Maybe D10 forall a. Maybe a Nothing -- | Convert an 'Integer' to a 'D10' if it is within the range 0 to 9, -- or produce 'Nothing' otherwise. -- -- @'D10.Predicate.isD10Integer' x = 'Data.Maybe.isJust' ('integerD10Maybe' x)@ -- -- 'integralD10Maybe', 'integerD10Fail', and 'integralD10Fail' -- are more general versions of this function. -- -- >>> integerD10Maybe 5 -- Just [d10|5|] -- -- >>> integerD10Maybe 12 -- Nothing -- -- >>> integerD10Maybe (-5) -- Nothing integerD10Maybe :: Integer -> Maybe D10 integerD10Maybe :: Integer -> Maybe D10 integerD10Maybe Integer x | Integer -> Bool isD10Integer Integer x = D10 -> Maybe D10 forall a. a -> Maybe a Just (Char -> D10 D10_Unsafe (Int -> Char chr (Integer -> Int forall a. Num a => Integer -> a fromInteger Integer x Int -> Int -> Int forall a. Num a => a -> a -> a P.+ Char -> Int ord Char '0'))) | Bool otherwise = Maybe D10 forall a. Maybe a Nothing -- | Convert an 'Int' to a 'D10' if it is within the range 0 to 9, -- or produce 'Nothing' otherwise. -- -- @'D10.Predicate.isD10Int' x = 'Data.Maybe.isJust' ('intD10Maybe' x)@ -- -- 'integralD10Maybe', 'intD10Fail', and 'integralD10Fail' -- are more general versions of this function. -- -- >>> intD10Maybe 5 -- Just [d10|5|] -- -- >>> intD10Maybe 12 -- Nothing -- -- >>> intD10Maybe (-5) -- Nothing intD10Maybe :: Int -> Maybe D10 intD10Maybe :: Int -> Maybe D10 intD10Maybe Int x | Int -> Bool isD10Int Int x = D10 -> Maybe D10 forall a. a -> Maybe a Just (Char -> D10 D10_Unsafe (Int -> Char chr (Int x Int -> Int -> Int forall a. Num a => a -> a -> a P.+ Char -> Int ord Char '0'))) | Bool otherwise = Maybe D10 forall a. Maybe a Nothing -- | Construct a 'D10' from any kind of number with an 'Integral' -- instance, or produce 'Nothing' if the number falls outside the -- range 0 to 9. -- -- @'D10.Predicate.isD10Integral' x = 'Data.Maybe.isJust' ('integralD10Maybe' x)@ -- -- Specialized versions of this function include 'natD10Maybe', -- 'integerD10Maybe', and 'intD10Maybe'. -- -- 'integralD10Fail' is a more general version of this function. -- -- >>> integralD10Maybe (5 :: Integer) -- Just [d10|5|] -- -- >>> integralD10Maybe (12 :: Integer) -- Nothing -- -- >>> integralD10Maybe ((-5) :: Integer) -- Nothing integralD10Maybe :: Integral a => a -> Maybe D10 integralD10Maybe :: a -> Maybe D10 integralD10Maybe a x = Integer -> Maybe D10 integerD10Maybe (a -> Integer forall a. Integral a => a -> Integer toInteger a x) --------------------------------------------------- -- | Convert a 'Char' to a 'D10' if it is within the range -- @'0'@ to @'9'@, or 'Left' with an error message otherwise. -- -- >>> charD10Either '5' -- Right [d10|5|] -- -- >>> charD10Either 'a' -- Left "d10 must be between 0 and 9" charD10Either :: Char -> Either String D10 charD10Either :: Char -> Either String D10 charD10Either Char x | Char -> Bool isD10Char Char x = D10 -> Either String D10 forall a b. b -> Either a b Right (Char -> D10 D10_Unsafe Char x) | Bool otherwise = String -> Either String D10 forall a b. a -> Either a b Left String "d10 must be between 0 and 9" -- | Convert a 'String' to a 'D10' if it consists of a single -- character and that character is within the range @'0'@ to -- @'9'@, or 'Left' with an error message otherwise. -- -- >>> strD10Either "5" -- Right [d10|5|] -- -- >>> strD10Either "a" -- Left "d10 must be between 0 and 9" -- -- >>> strD10Either "58" -- Left "d10 must be a single character" strD10Either :: String -> Either String D10 strD10Either :: String -> Either String D10 strD10Either [Char x] = Char -> Either String D10 charD10Either Char x strD10Either String _ = String -> Either String D10 forall a b. a -> Either a b Left String "d10 must be a single character" -- | Convert a 'String' to a 'D10' if all of the characters in -- the string fall within the range @'0'@ to @'9'@, or 'Left' -- with an error message otherwise. -- -- >>> strD10ListEither "5" -- Right [d10list|5|] -- -- >>> strD10ListEither "a" -- Left "d10 must be between 0 and 9" -- -- >>> strD10ListEither "58" -- Right [d10list|58|] strD10ListEither :: String -> Either String [D10] strD10ListEither :: String -> Either String [D10] strD10ListEither = (Char -> Either String D10) -> String -> Either String [D10] forall (t :: * -> *) (f :: * -> *) a b. (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b) traverse Char -> Either String D10 charD10Either -- | Convert a 'Natural' to a 'D10' if it is less than 10, -- or 'Left' with an error message otherwise. -- -- >>> natD10Either 5 -- Right [d10|5|] -- -- >>> natD10Either 12 -- Left "d10 must be less than 10" natD10Either :: Natural -> Either String D10 natD10Either :: Natural -> Either String D10 natD10Either Natural x = case (Natural -> Maybe D10 natD10Maybe Natural x) of Just D10 y -> D10 -> Either String D10 forall a b. b -> Either a b Right D10 y Maybe D10 Nothing -> String -> Either String D10 forall a b. a -> Either a b Left String "d10 must be less than 10" -- | Convert an 'Integer' to a 'D10' if it is within the -- range 0 to 9, or 'Left' with an error message otherwise. -- -- >>> integerD10Either 5 -- Right [d10|5|] -- -- >>> integerD10Either 12 -- Left "d10 must be between 0 and 9" -- -- >>> integerD10Either (-5) -- Left "d10 must be between 0 and 9" integerD10Either :: Integer -> Either String D10 integerD10Either :: Integer -> Either String D10 integerD10Either Integer x = case (Integer -> Maybe D10 integerD10Maybe Integer x) of Just D10 y -> D10 -> Either String D10 forall a b. b -> Either a b Right D10 y Maybe D10 Nothing -> String -> Either String D10 forall a b. a -> Either a b Left String "d10 must be between 0 and 9" -- | Convert an 'Int' to a 'D10' if it is within the range -- 0 to 9, or 'Left' with an error message otherwise. -- -- >>> intD10Either 5 -- Right [d10|5|] -- -- >>> intD10Either 12 -- Left "d10 must be between 0 and 9" -- -- >>> intD10Either (-5) -- Left "d10 must be between 0 and 9" intD10Either :: Int -> Either String D10 intD10Either :: Int -> Either String D10 intD10Either Int x = case (Int -> Maybe D10 intD10Maybe Int x) of Just D10 y -> D10 -> Either String D10 forall a b. b -> Either a b Right D10 y Maybe D10 Nothing -> String -> Either String D10 forall a b. a -> Either a b Left String "d10 must be between 0 and 9" -- | Convert a number of a type that has an 'Integral' instance -- to a 'D10' if it falls within the range 0 to 9, or 'Left' -- with an error message otherwise. -- -- >>> integralD10Either (5 :: Integer) -- Right [d10|5|] -- -- >>> integralD10Either (12 :: Integer) -- Left "d10 must be between 0 and 9" -- -- >>> integralD10Either ((-5) :: Integer) -- Left "d10 must be between 0 and 9" integralD10Either :: Integral a => a -> Either String D10 integralD10Either :: a -> Either String D10 integralD10Either a x = Integer -> Either String D10 integerD10Either (a -> Integer forall a. Integral a => a -> Integer toInteger a x) --------------------------------------------------- -- | Convert a 'Char' to a 'D10' if it is within the range -- @'0'@ to @'9'@, or 'fail' with an error message otherwise. -- -- 'charD10Maybe' is a specialized version of this function. -- -- >>> charD10Fail '5' :: IO D10 -- [d10|5|] -- -- >>> charD10Fail 'a' :: IO D10 -- *** Exception: user error (d10 must be between 0 and 9) charD10Fail :: MonadFail m => Char -> m D10 charD10Fail :: Char -> m D10 charD10Fail Char x | Char -> Bool isD10Char Char x = D10 -> m D10 forall (m :: * -> *) a. Monad m => a -> m a return (Char -> D10 D10_Unsafe Char x) | Bool otherwise = String -> m D10 forall (m :: * -> *) a. MonadFail m => String -> m a fail String "d10 must be between 0 and 9" -- | Convert a 'String' to a 'D10' if it consists of a single -- character and that character is within the range @'0'@ to -- @'9'@, or 'fail' with an error message otherwise. -- -- 'strD10Maybe' is a specialized version of this function. -- -- >>> strD10Fail "5" :: IO D10 -- [d10|5|] -- -- >>> strD10Fail "a" :: IO D10 -- *** Exception: user error (d10 must be between 0 and 9) -- -- >>> strD10Fail "58" :: IO D10 -- *** Exception: user error (d10 must be a single character) strD10Fail :: MonadFail m => String -> m D10 strD10Fail :: String -> m D10 strD10Fail [Char x] = Char -> m D10 forall (m :: * -> *). MonadFail m => Char -> m D10 charD10Fail Char x strD10Fail String _ = String -> m D10 forall (m :: * -> *) a. MonadFail m => String -> m a fail String "d10 must be a single character" -- | Convert a 'String' to a 'D10' if all of the characters in -- the string fall within the range @'0'@ to @'9'@, or 'fail' -- with an error message otherwise. -- -- 'strD10ListMaybe' is a specialized version of this function. -- -- >>> strD10ListFail "5" :: IO [D10] -- [d10list|5|] -- -- >>> strD10ListFail "a" :: IO [D10] -- *** Exception: user error (d10 must be between 0 and 9) -- -- >>> strD10ListFail "58" :: IO [D10] -- [d10list|58|] strD10ListFail :: MonadFail m => String -> m [D10] strD10ListFail :: String -> m [D10] strD10ListFail = (Char -> m D10) -> String -> m [D10] forall (t :: * -> *) (f :: * -> *) a b. (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b) traverse Char -> m D10 forall (m :: * -> *). MonadFail m => Char -> m D10 charD10Fail -- | Convert a 'Natural' to a 'D10' if it is less than 10, -- or 'fail' with an error message otherwise. -- -- 'natD10Maybe' is a specialized version of this function. -- -- 'integralD10Fail' is a more general version of this function. -- -- >>> natD10Fail 5 :: IO D10 -- [d10|5|] -- -- >>> natD10Fail 12 :: IO D10 -- *** Exception: user error (d10 must be less than 10) natD10Fail :: MonadFail m => Natural -> m D10 natD10Fail :: Natural -> m D10 natD10Fail Natural x = case (Natural -> Maybe D10 natD10Maybe Natural x) of Just D10 y -> D10 -> m D10 forall (m :: * -> *) a. Monad m => a -> m a return D10 y Maybe D10 Nothing -> String -> m D10 forall (m :: * -> *) a. MonadFail m => String -> m a fail String "d10 must be less than 10" -- | Convert an 'Integer' to a 'D10' if it is within the -- range 0 to 9, or 'fail' with an error message otherwise. -- -- 'integerD10Maybe' is a specialized version of this function. -- -- 'integralD10Fail' is a more general version of this function. -- -- >>> integerD10Fail 5 :: IO D10 -- [d10|5|] -- -- >>> integerD10Fail 12 :: IO D10 -- *** Exception: user error (d10 must be between 0 and 9) -- -- >>> integerD10Fail (-5) :: IO D10 -- *** Exception: user error (d10 must be between 0 and 9) integerD10Fail :: MonadFail m => Integer -> m D10 integerD10Fail :: Integer -> m D10 integerD10Fail Integer x = case (Integer -> Maybe D10 integerD10Maybe Integer x) of Just D10 y -> D10 -> m D10 forall (m :: * -> *) a. Monad m => a -> m a return D10 y Maybe D10 Nothing -> String -> m D10 forall (m :: * -> *) a. MonadFail m => String -> m a fail String "d10 must be between 0 and 9" -- | Convert an 'Int' to a 'D10' if it is within the range -- 0 to 9, or 'fail' with an error message otherwise. -- -- 'intD10Maybe' is a specialized version of this function. -- -- 'integralD10Fail' is a more general version of this function. -- -- >>> intD10Fail 5 :: IO D10 -- [d10|5|] -- -- >>> intD10Fail 12 :: IO D10 -- *** Exception: user error (d10 must be between 0 and 9) -- -- >>> intD10Fail (-5) :: IO D10 -- *** Exception: user error (d10 must be between 0 and 9) intD10Fail :: MonadFail m => Int -> m D10 intD10Fail :: Int -> m D10 intD10Fail Int x = case (Int -> Maybe D10 intD10Maybe Int x) of Just D10 y -> D10 -> m D10 forall (m :: * -> *) a. Monad m => a -> m a return D10 y Maybe D10 Nothing -> String -> m D10 forall (m :: * -> *) a. MonadFail m => String -> m a fail String "d10 must be between 0 and 9" -- | Convert a number of a type that has an 'Integral' instance -- to a 'D10' if it falls within the range 0 to 9, or 'fail' -- with an error message otherwise. -- -- 'natD10Maybe', 'integerD10Maybe', 'intD10Maybe', -- 'integralD10Maybe', 'natD10Fail', 'integerD10Fail', and -- 'intD10Fail' are all specialized versions of this function. -- -- >>> integralD10Fail (5 :: Integer) :: IO D10 -- [d10|5|] -- -- >>> integralD10Fail (12 :: Integer) :: IO D10 -- *** Exception: user error (d10 must be between 0 and 9) -- -- >>> integralD10Fail ((-5) :: Integer) :: IO D10 -- *** Exception: user error (d10 must be between 0 and 9) integralD10Fail :: (Integral a, MonadFail m) => a -> m D10 integralD10Fail :: a -> m D10 integralD10Fail a x = Integer -> m D10 forall (m :: * -> *). MonadFail m => Integer -> m D10 integerD10Fail (a -> Integer forall a. Integral a => a -> Integer toInteger a x)