D10.Char.Conversions

D10 / Char

d10Char :: D10 -> Char

Convert a D10 to its underlying Char representation.

>>> d10Char [d10|7|]
'7'

charD10Maybe :: Char -> Maybe D10

Convert a Char to a D10 if it is within the range '0' to '9', or produce Nothing otherwise.

isD10Char x = isJust (charD10Maybe x)

charD10Fail is a more general version of this function.

>>> charD10Maybe '5'
Just [d10|5|]

>>> charD10Maybe 'a'
Nothing

charD10Either :: Char -> Either String D10

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"

charD10Fail :: MonadFail m => Char -> m D10

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)

D10 / String

d10Str :: D10 -> String

Convert a D10 to a String.

d10Str x = [d10Char x]

>>> d10Str [d10|7|]
"7"

strD10Maybe :: String -> Maybe D10

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.

isD10Str x = isJust (strD10Maybe x)

strD10Fail is a more general version of this function.

>>> strD10Maybe "5"
Just [d10|5|]

>>> strD10Maybe "a"
Nothing

>>> strD10Maybe "58"
Nothing

strD10Either :: String -> Either String D10

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"

strD10Fail :: MonadFail m => String -> m D10

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)

[D10] / String

strD10ListMaybe :: String -> Maybe [D10]

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.

isD10ListStr x = 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|]

strD10ListEither :: String -> Either String [D10]

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|]

strD10ListFail :: MonadFail m => String -> m [D10]

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|]

D10 / Natural

d10Nat :: D10 -> Natural

Convert a D10 to a Natural.

d10Num is a more general version of this function.

>>> d10Nat [d10|7|]
7

natD10Maybe :: Natural -> Maybe D10

Convert a Natural to a D10 if it is less than 10, or produce Nothing otherwise.

isD10Nat x = isJust (natD10Maybe x)

integralD10Maybe, natD10Fail, and integralD10Fail are more general versions of this function.

>>> natD10Maybe 5
Just [d10|5|]

>>> natD10Maybe 12
Nothing

natD10Either :: Natural -> Either String D10

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"

natD10Fail :: MonadFail m => Natural -> m D10

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)

natMod10 :: Natural -> D10

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|]

D10 / Integer

d10Integer :: D10 -> Integer

Convert a D10 to an Integer.

d10Num is a more general version of this function.

>>> d10Integer [d10|7|]
7

integerD10Maybe :: Integer -> Maybe D10

Convert an Integer to a D10 if it is within the range 0 to 9, or produce Nothing otherwise.

isD10Integer x = 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

integerD10Either :: Integer -> Either String D10

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"

integerD10Fail :: MonadFail m => Integer -> m D10

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)

integerMod10 :: Integer -> D10

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|]

D10 / Int

d10Int :: D10 -> Int

Convert a D10 to an Int.

d10Num is a more general version of this function.

>>> d10Int [d10|7|]
7

intD10Maybe :: Int -> Maybe D10

Convert an Int to a D10 if it is within the range 0 to 9, or produce Nothing otherwise.

isD10Int x = 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

intD10Either :: Int -> Either String D10

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"

intD10Fail :: MonadFail m => Int -> m D10

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)

intMod10 :: Int -> D10

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|]

D10 / general numeric types

d10Num :: Num a => D10 -> a

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

integralD10Maybe :: Integral a => a -> Maybe D10

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.

isD10Integral x = 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

integralD10Either :: Integral a => a -> Either String D10

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"

integralD10Fail :: (Integral a, MonadFail m) => a -> m D10

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)

integralMod10 :: Integral a => a -> D10

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|]