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

`>>>`

D0`minBound :: D10`

`>>>`

D9`maxBound :: D10`

#### Enum

`>>>`

[D5,D6,D7,D8,D9]`[ D5 .. ]`

`>>>`

[D4,D5,D6,D7]`[ D4 .. D7 ]`

`>>>`

[D5,D4,D3,D2,D1,D0]`[ D5, D4 .. ]`

`>>>`

[D1,D3,D5,D7,D9]`[ D1, D3 .. ]`

`>>>`

[D0,D1,D2,D3,D4,D5,D6,D7,D8,D9]`[ minBound .. maxBound ] :: [D10]`

# 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`

.

`>>>`

D5`[d10|5|]`

`>>>`

... ... d10 must be between 0 and 9 ...`[d10|a|]`

`>>>`

... ... d10 must be a single character ...`[d10|58|]`

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

`>>>`

[D5]`[d10list|5|]`

`>>>`

[D5,D8]`[d10list|58|]`

`>>>`

... ... d10 must be between 0 and 9 ...`[d10list|a|]`

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 "")`

`>>>`

[D5]`$(d10ListExp "5")`

`>>>`

[D5,D8]`$(d10ListExp "58")`

`>>>`

... ... d10 must be between 0 and 9 ...`$(d10ListExp "a")`

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.

`>>>`

Just D5`charD10Maybe '5'`

`>>>`

Nothing`charD10Maybe 'a'`

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.

`>>>`

D5`charD10Fail '5' :: IO D10`

`>>>`

*** Exception: user error (d10 must be between 0 and 9)`charD10Fail 'a' :: IO D10`

# 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.

`>>>`

Just D5`strD10Maybe "5"`

`>>>`

Nothing`strD10Maybe "a"`

`>>>`

Nothing`strD10Maybe "58"`

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.

`>>>`

D5`strD10Fail "5" :: IO D10`

`>>>`

*** Exception: user error (d10 must be between 0 and 9)`strD10Fail "a" :: IO D10`

`>>>`

*** Exception: user error (d10 must be a single character)`strD10Fail "58" :: IO D10`

# 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.

`>>>`

Just [D5]`strD10ListMaybe "5"`

`>>>`

Nothing`strD10ListMaybe "a"`

`>>>`

Just [D5,D8]`strD10ListMaybe "58"`

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.

`>>>`

[D5]`strD10ListFail "5" :: IO [D10]`

`>>>`

*** Exception: user error (d10 must be between 0 and 9)`strD10ListFail "a" :: IO [D10]`

`>>>`

[D5,D8]`strD10ListFail "58" :: IO [D10]`

# 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.

`>>>`

Just D5`natD10Maybe 5`

`>>>`

Nothing`natD10Maybe 12`

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.

`>>>`

D5`natD10Fail 5 :: IO D10`

`>>>`

*** Exception: user error (d10 must be less than 10)`natD10Fail 12 :: IO D10`

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.

`>>>`

D6`natMod10 56`

# 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.

`>>>`

Just D5`integerD10Maybe 5`

`>>>`

Nothing`integerD10Maybe 12`

`>>>`

Nothing`integerD10Maybe (-5)`

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.

`>>>`

D5`integerD10Fail 5 :: IO D10`

`>>>`

*** Exception: user error (d10 must be between 0 and 9)`integerD10Fail 12 :: IO D10`

`>>>`

*** Exception: user error (d10 must be between 0 and 9)`integerD10Fail (-5) :: IO D10`

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.

`>>>`

D6`integerMod10 56`

`>>>`

D4`integerMod10 (-56)`

# 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.

`>>>`

Just D5`intD10Maybe 5`

`>>>`

Nothing`intD10Maybe 12`

`>>>`

Nothing`intD10Maybe (-5)`

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.

`>>>`

D5`intD10Fail 5 :: IO D10`

`>>>`

*** Exception: user error (d10 must be between 0 and 9)`intD10Fail 12 :: IO D10`

`>>>`

*** Exception: user error (d10 must be between 0 and 9)`intD10Fail (-5) :: IO D10`

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.

`>>>`

D6`intMod10 56`

`>>>`

D4`intMod10 (-56)`

# 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`

.

`>>>`

7`d10Num D7 :: Integer`

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.

`>>>`

Just D5`integralD10Maybe (5 :: Integer)`

`>>>`

Nothing`integralD10Maybe (12 :: Integer)`

`>>>`

Nothing`integralD10Maybe ((-5) :: Integer)`

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.

`>>>`

Right D5`integralD10Either (5 :: Integer)`

`>>>`

Left "d10 must be between 0 and 9"`integralD10Either (12 :: Integer)`

`>>>`

Left "d10 must be between 0 and 9"`integralD10Either ((-5) :: Integer)`

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.

`>>>`

D5`integralD10Fail (5 :: Integer) :: IO D10`

`>>>`

*** Exception: user error (d10 must be between 0 and 9)`integralD10Fail (12 :: Integer) :: IO D10`

`>>>`

*** Exception: user error (d10 must be between 0 and 9)`integralD10Fail ((-5) :: Integer) :: IO D10`

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`

.

`>>>`

D6`integralMod10 (56 :: Integer)`

`>>>`

D4`integralMod10 ((-56) :: Integer)`