Safe Haskell | None |
---|---|
Language | Haskell2010 |
- Type
- Quasi-quoters
- Splice expressions
- Splice patterns
- Converting between D10 and Char
- Converting between D10 and String
- Converting between [D10] and String
- Converting between D10 and Natural
- Converting between D10 and Integer
- Converting between D10 and Int
- Converting between D10 and general numeric types
- Modular arithmetic
Defines a D10
type as
.D0
| D1
| D2
| D3
| D4
| D5
| D6
| D7
| D8
| D9
The following modules define D10
types in different ways
but are otherwise very similar to this one:
This module is called "safe" because, in contrast with the
alternative representations of a digit defined in the other
modules, this D10
type does not include any possibility
of representing an invalid non-digit value.
Synopsis
- data D10
- d10 :: QuasiQuoter
- d10list :: QuasiQuoter
- d10Exp :: Integral a => a -> Q Exp
- d10ListExp :: String -> Q Exp
- d10Pat :: D10 -> Q Pat
- d10ListPat :: [D10] -> Q Pat
- d10Char :: D10 -> Char
- charD10Maybe :: Char -> Maybe D10
- charD10Either :: Char -> Either String D10
- charD10Fail :: MonadFail m => Char -> m D10
- d10Str :: D10 -> String
- strD10Maybe :: String -> Maybe D10
- strD10Either :: String -> Either String D10
- strD10Fail :: MonadFail m => String -> m D10
- strD10ListMaybe :: String -> Maybe [D10]
- strD10ListEither :: String -> Either String [D10]
- strD10ListFail :: MonadFail m => String -> m [D10]
- d10Nat :: D10 -> Natural
- natD10Maybe :: Natural -> Maybe D10
- natD10Either :: Natural -> Either String D10
- natD10Fail :: MonadFail m => Natural -> m D10
- natMod10 :: Natural -> D10
- d10Integer :: D10 -> Integer
- integerD10Maybe :: Integer -> Maybe D10
- integerD10Either :: Integer -> Either String D10
- integerD10Fail :: MonadFail m => Integer -> m D10
- integerMod10 :: Integer -> D10
- d10Int :: D10 -> Int
- intD10Maybe :: Int -> Maybe D10
- intD10Either :: Int -> Either String D10
- intD10Fail :: MonadFail m => Int -> m D10
- intMod10 :: Int -> D10
- d10Num :: Num a => D10 -> a
- integralD10Maybe :: Integral a => a -> Maybe D10
- integralD10Either :: Integral a => a -> Either String D10
- integralD10Fail :: (Integral a, MonadFail m) => a -> m D10
- integralMod10 :: Integral a => a -> D10
- (+) :: D10 -> D10 -> D10
- (-) :: D10 -> D10 -> D10
- (*) :: D10 -> D10 -> D10
Type
A whole number between 0 and 9.
Bounded
>>>
minBound :: D10
D0
>>>
maxBound :: D10
D9
Enum
>>>
[ D5 .. ]
[D5,D6,D7,D8,D9]
>>>
[ D4 .. D7 ]
[D4,D5,D6,D7]
>>>
[ D5, D4 .. ]
[D5,D4,D3,D2,D1,D0]
>>>
[ D1, D3 .. ]
[D1,D3,D5,D7,D9]
>>>
[ minBound .. maxBound ] :: [D10]
[D0,D1,D2,D3,D4,D5,D6,D7,D8,D9]
Quasi-quoters
d10 :: QuasiQuoter Source #
A single base-10 digit.
This isn't very useful, since you can just write D5
instead of '[d10|5|]'. It is included only for completeness,
because each of the modules Data.D10.Char and Data.D10.Num
defines a similar quasi-quoter.
This quasi-quoter, when used as an expression, produces a
value of type D10
.
>>>
[d10|5|]
D5
>>>
[d10|a|]
... ... d10 must be between 0 and 9 ...
>>>
[d10|58|]
... ... d10 must be a single character ...
This quasi-quoter can also be used as a pattern.
>>>
:{
case (charD10Maybe '5') of Just [d10|4|] -> "A" Just [d10|5|] -> "B" _ -> "C">>>
:}
"B"
>>>
:{
case (charD10Maybe '5') of Just [d10|x|] -> "A" Just [d10|5|] -> "B" _ -> "C">>>
:}
... ... d10 must be between 0 and 9 ...
d10list :: QuasiQuoter Source #
A list of base-10 digits.
This quasi-quoter, when used as an expression, produces a
value of type [
.D10
]
>>>
[d10list||]
[]
>>>
[d10list|5|]
[D5]
>>>
[d10list|58|]
[D5,D8]
>>>
[d10list|a|]
... ... d10 must be between 0 and 9 ...
This quasi-quoter can also be used as a pattern.
>>>
:{
case [d10list|56|] of [d10list|41|] -> "A" [d10list|56|] -> "B" _ -> "C">>>
:}
"B"
>>>
:{
case [d10list|56|] of [d10list|4x|] -> "A" [d10list|56|] -> "B" _ -> "C">>>
:}
... ... d10 must be between 0 and 9 ...
Splice expressions
d10ListExp :: String -> Q Exp Source #
Produces an expression of type [
that can be used
in a Template Haskell splice.D10
]
>>>
$(d10ListExp "")
[]
>>>
$(d10ListExp "5")
[D5]
>>>
$(d10ListExp "58")
[D5,D8]
>>>
$(d10ListExp "a")
... ... d10 must be between 0 and 9 ...
You may also be interested in d10list
, a quasi-quoter which
does something similar.
Splice patterns
d10Pat :: D10 -> Q Pat Source #
Produces a pattern that can be used in a splice
to match a particular D10
value.
>>>
:{
case (charD10Maybe '5') of Just $(d10Pat D4) -> "A" Just $(d10Pat D5) -> "B" _ -> "C">>>
:}
"B"
You are unlikely to write any code that resembles this example,
since you can just write D4
instead of $(d10Pat D4)
.
Rather, this function exists to help implement other things
related to Template Haskell, such as d10ListPat
and d10
.
d10ListPat :: [D10] -> Q Pat Source #
Produces a pattern that can be used in a splice
to match a particular list of D10
values.
>>>
:{
case (strD10ListMaybe "56") of Just $(d10ListPat [D4, D2]) -> "A" Just $(d10ListPat [D5, D6]) -> "B" _ -> "C">>>
:}
"B"
You are unlikely to write any code that resembles this example,
since you can just write [D4, D2]
instead of $(d10Pat [D4, D2])
.
Rather, this function exists to help implement other things
related to Template Haskell, such as d10list
.
Converting between D10 and Char
charD10Maybe :: Char -> Maybe D10 Source #
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 D5
>>>
charD10Maybe 'a'
Nothing
charD10Fail :: MonadFail m => Char -> m D10 Source #
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
D5
>>>
charD10Fail 'a' :: IO D10
*** Exception: user error (d10 must be between 0 and 9)
Converting between D10 and String
strD10Maybe :: String -> Maybe D10 Source #
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 D5
>>>
strD10Maybe "a"
Nothing
>>>
strD10Maybe "58"
Nothing
strD10Fail :: MonadFail m => String -> m D10 Source #
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
D5
>>>
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)
Converting between [D10] and String
strD10ListMaybe :: String -> Maybe [D10] Source #
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.
isD10Str
x =isJust
(strD10ListMaybe
x)
strD10ListFail
is a more general version of this function.
>>>
strD10ListMaybe "5"
Just [D5]
>>>
strD10ListMaybe "a"
Nothing
>>>
strD10ListMaybe "58"
Just [D5,D8]
strD10ListFail :: MonadFail m => String -> m [D10] Source #
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]
[D5]
>>>
strD10ListFail "a" :: IO [D10]
*** Exception: user error (d10 must be between 0 and 9)
>>>
strD10ListFail "58" :: IO [D10]
[D5,D8]
Converting between D10 and Natural
natD10Maybe :: Natural -> Maybe D10 Source #
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 D5
>>>
natD10Maybe 12
Nothing
natD10Fail :: MonadFail m => Natural -> m D10 Source #
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
D5
>>>
natD10Fail 12 :: IO D10
*** Exception: user error (d10 must be less than 10)
natMod10 :: Natural -> D10 Source #
The D10
which is uniquely congruent modulo 10 to the given Natural
.
integralMod10
is a more general version of this function.
>>>
natMod10 56
D6
Converting between D10 and Integer
d10Integer :: D10 -> Integer Source #
integerD10Maybe :: Integer -> Maybe D10 Source #
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 D5
>>>
integerD10Maybe 12
Nothing
>>>
integerD10Maybe (-5)
Nothing
integerD10Fail :: MonadFail m => Integer -> m D10 Source #
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
D5
>>>
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 Source #
The D10
which is uniquely congruent modulo 10 to the given Integer
.
integralMod10
is a more general version of this function.
>>>
integerMod10 56
D6
>>>
integerMod10 (-56)
D4
Converting between D10 and Int
intD10Maybe :: Int -> Maybe D10 Source #
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 D5
>>>
intD10Maybe 12
Nothing
>>>
intD10Maybe (-5)
Nothing
intD10Fail :: MonadFail m => Int -> m D10 Source #
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
D5
>>>
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 Source #
The D10
which is uniquely congruent modulo 10 to the given Int
.
integralMod10
is a more general version of this function.
>>>
intMod10 56
D6
>>>
intMod10 (-56)
D4
Converting between D10 and general numeric types
d10Num :: Num a => D10 -> a Source #
Convert a D10
to any kind of number with a Num
instance.
Specialized versions of this function include d10Nat
,
d10Integer
, and d10Int
.
>>>
d10Num D7 :: Integer
7
integralD10Maybe :: Integral a => a -> Maybe D10 Source #
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 D5
>>>
integralD10Maybe (12 :: Integer)
Nothing
>>>
integralD10Maybe ((-5) :: Integer)
Nothing
integralD10Either :: Integral a => a -> Either String D10 Source #
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 D5
>>>
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 Source #
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
D5
>>>
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 Source #
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)
D6
>>>
integralMod10 ((-56) :: Integer)
D4