-- | Defines a 'D10' type as a newtype for any type with an
-- instance of the 'Num' class, where the values are restricted
-- to numbers between @'fromInteger' 0@ and @'fromInteger' 9@.
--
-- The following modules define @D10@ types in different ways
-- but are otherwise very similar to this one:
--
-- * "Data.D10.Char"
-- * "Data.D10.Safe"

module Data.D10.Num
    (
    -- * Type
      D10 (..)
    -- $bounded
    -- $enum

    -- * Quasi-quoters
    , d10
    , d10list

    -- * Splice expressions
    , d10Exp
    , d10ListExp

    -- * Splice patterns
    , d10Pat
    , d10ListPat

    -- * Converting between D10 and Char
    , d10Char
    , charD10Maybe
    , charD10Either
    , charD10Fail

    -- * Converting between D10 and String
    , d10Str
    , strD10Maybe
    , strD10Either
    , strD10Fail

    -- * Converting between [D10] and String
    , strD10ListMaybe
    , strD10ListEither
    , strD10ListFail

    -- * Converting between D10 and Natural
    , d10Nat
    , natD10Maybe
    , natD10Either
    , natD10Fail
    , natMod10

    -- * Converting between D10 and Integer
    , d10Integer
    , integerD10Maybe
    , integerD10Either
    , integerD10Fail
    , integerMod10

    -- * Converting between D10 and Int
    , d10Int
    , intD10Maybe
    , intD10Either
    , intD10Fail
    , intMod10

    -- * Converting between D10 and general numeric types
    , d10Num
    , integralD10Maybe
    , integralD10Either
    , integralD10Fail
    , integralMod10

    -- * Modular arithmetic
    , (+), (-), (*)

    ) where

import Data.D10.Predicate

-- base
import Control.Monad      ((>=>))
import Control.Monad.Fail (MonadFail (fail))
import Data.Char          (chr, ord)
import Data.Monoid        (Endo (..))
import Numeric.Natural    (Natural)
import Prelude            hiding (fail, (+), (-), (*))

import qualified Prelude as P

-- template-haskell
import Language.Haskell.TH.Lib    (litP, integerL)
import Language.Haskell.TH.Quote  (QuasiQuoter (..))
import Language.Haskell.TH.Syntax (Exp (..), Lift, Pat (..), Q)

---------------------------------------------------

-- | A value of some numeric type @a@ between
-- @'fromInteger' 0@ and @'fromInteger' 9@.
--
-- The "Data.D10.Num" module provides many functions for
-- constructing 'D10' values, including:
--
-- * @'integerD10Maybe' :: 'Integer' -> 'Maybe' 'D10'@
-- * @'integerMod10' :: 'Integer' -> 'D10'@
--
-- There are also several ways to safely write 'D10' literals
-- using Template Haskell:
--
-- * With the @QuasiQuotes@ GHC extension enabled, you can write
--   use the quasi-quoters 'd10' and 'd10list'.
-- * With the @TemplateHaskell@ GHC extension enabled, you can
--   splice expressions produced by 'd10Exp' and 'd10ListExp'.

newtype D10 a =
    D10_Unsafe a
      -- ^ The constructor's name include the word "unsafe" as a reminder
      --   that you should generally avoid using it directly, because it
      --   allows constructing invalid 'D10' values.
    deriving (D10 a -> D10 a -> Bool
(D10 a -> D10 a -> Bool) -> (D10 a -> D10 a -> Bool) -> Eq (D10 a)
forall a. Eq a => D10 a -> D10 a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: D10 a -> D10 a -> Bool
$c/= :: forall a. Eq a => D10 a -> D10 a -> Bool
== :: D10 a -> D10 a -> Bool
$c== :: forall a. Eq a => D10 a -> D10 a -> Bool
Eq, Eq (D10 a)
Eq (D10 a)
-> (D10 a -> D10 a -> Ordering)
-> (D10 a -> D10 a -> Bool)
-> (D10 a -> D10 a -> Bool)
-> (D10 a -> D10 a -> Bool)
-> (D10 a -> D10 a -> Bool)
-> (D10 a -> D10 a -> D10 a)
-> (D10 a -> D10 a -> D10 a)
-> Ord (D10 a)
D10 a -> D10 a -> Bool
D10 a -> D10 a -> Ordering
D10 a -> D10 a -> D10 a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (D10 a)
forall a. Ord a => D10 a -> D10 a -> Bool
forall a. Ord a => D10 a -> D10 a -> Ordering
forall a. Ord a => D10 a -> D10 a -> D10 a
min :: D10 a -> D10 a -> D10 a
$cmin :: forall a. Ord a => D10 a -> D10 a -> D10 a
max :: D10 a -> D10 a -> D10 a
$cmax :: forall a. Ord a => D10 a -> D10 a -> D10 a
>= :: D10 a -> D10 a -> Bool
$c>= :: forall a. Ord a => D10 a -> D10 a -> Bool
> :: D10 a -> D10 a -> Bool
$c> :: forall a. Ord a => D10 a -> D10 a -> Bool
<= :: D10 a -> D10 a -> Bool
$c<= :: forall a. Ord a => D10 a -> D10 a -> Bool
< :: D10 a -> D10 a -> Bool
$c< :: forall a. Ord a => D10 a -> D10 a -> Bool
compare :: D10 a -> D10 a -> Ordering
$ccompare :: forall a. Ord a => D10 a -> D10 a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (D10 a)
Ord, D10 a -> Q Exp
D10 a -> Q (TExp (D10 a))
(D10 a -> Q Exp) -> (D10 a -> Q (TExp (D10 a))) -> Lift (D10 a)
forall a. Lift a => D10 a -> Q Exp
forall a. Lift a => D10 a -> Q (TExp (D10 a))
forall t. (t -> Q Exp) -> (t -> Q (TExp t)) -> Lift t
liftTyped :: D10 a -> Q (TExp (D10 a))
$cliftTyped :: forall a. Lift a => D10 a -> Q (TExp (D10 a))
lift :: D10 a -> Q Exp
$clift :: forall a. Lift a => D10 a -> Q Exp
Lift)

-- $bounded
-- ==== Bounded
--
-- >>> minBound :: D10 Integer
-- [d10|0|]
--
-- >>> maxBound :: D10 Integer
-- [d10|9|]

instance Num a => Bounded (D10 a)
  where
    minBound :: D10 a
minBound = a -> D10 a
forall a. a -> D10 a
D10_Unsafe a
0
    maxBound :: D10 a
maxBound = a -> D10 a
forall a. a -> D10 a
D10_Unsafe a
9

-- $enum
-- ==== Enum
--
-- >>> [ [d10|5|] .. ]
-- [d10list|56789|]
--
-- >>> [ [d10|4|] .. [d10|7|] ]
-- [d10list|4567|]
--
-- >>> [ [d10|5|], [d10|4|] .. ]
-- [d10list|543210|]
--
-- >>> [ [d10|1|], [d10|3|] .. ]
-- [d10list|13579|]
--
-- >>> [ minBound .. maxBound ] :: [D10 Integer]
-- [d10list|0123456789|]

instance Integral a => Enum (D10 a)
  where
    fromEnum :: D10 a -> Int
    fromEnum :: D10 a -> Int
fromEnum = D10 a -> Int
forall a. Integral a => D10 a -> Int
d10Int

    toEnum :: Int -> D10 a
    toEnum :: Int -> D10 a
toEnum = ([Char] -> D10 a)
-> (D10 a -> D10 a) -> Either [Char] (D10 a) -> D10 a
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either [Char] -> D10 a
forall a. HasCallStack => [Char] -> a
error D10 a -> D10 a
forall a. a -> a
id (Either [Char] (D10 a) -> D10 a)
-> (Int -> Either [Char] (D10 a)) -> Int -> D10 a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Either [Char] (D10 a)
forall a. Num a => Int -> Either [Char] (D10 a)
intD10Either

    enumFrom :: D10 a -> [D10 a]
    enumFrom :: D10 a -> [D10 a]
enumFrom D10 a
x = D10 a -> D10 a -> [D10 a]
forall a. Enum a => a -> a -> [a]
enumFromTo D10 a
x D10 a
forall a. Bounded a => a
maxBound

    enumFromThen :: D10 a -> D10 a -> [D10 a]
    enumFromThen :: D10 a -> D10 a -> [D10 a]
enumFromThen D10 a
x D10 a
y = D10 a -> D10 a -> D10 a -> [D10 a]
forall a. Enum a => a -> a -> a -> [a]
enumFromThenTo D10 a
x D10 a
y D10 a
bound
      where
        bound :: D10 a
bound | D10 a -> Int
forall a. Enum a => a -> Int
fromEnum D10 a
y Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= D10 a -> Int
forall a. Enum a => a -> Int
fromEnum D10 a
x = D10 a
forall a. Bounded a => a
maxBound
              | Bool
otherwise                = D10 a
forall a. Bounded a => a
minBound

    succ :: D10 a -> D10 a
succ (D10_Unsafe a
9) = [Char] -> D10 a
forall a. HasCallStack => [Char] -> a
error [Char]
"D10 overflow"
    succ (D10_Unsafe a
x) = a -> D10 a
forall a. a -> D10 a
D10_Unsafe (a -> a
forall a. Enum a => a -> a
succ a
x)

    pred :: D10 a -> D10 a
pred (D10_Unsafe a
0) = [Char] -> D10 a
forall a. HasCallStack => [Char] -> a
error [Char]
"D10 underflow"
    pred (D10_Unsafe a
x) = a -> D10 a
forall a. a -> D10 a
D10_Unsafe (a -> a
forall a. Enum a => a -> a
pred a
x)

---------------------------------------------------

-- | Shows base-10 digits using the quasiquoters defined in
-- "Data.D10.Char". A single digit is displayed using 'd10'.
-- A list of digits is displayed using 'd10list'.

instance Integral a => Show (D10 a) where
    showsPrec :: Int -> D10 a -> ShowS
showsPrec Int
_ D10 a
x = [Char] -> ShowS
showString [Char]
"[d10|"     ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. D10 a -> ShowS
forall a. Integral a => D10 a -> ShowS
showsChar D10 a
x ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> ShowS
showString [Char]
"|]"
    showList :: [D10 a] -> ShowS
showList [D10 a]
xs   = [Char] -> ShowS
showString [Char]
"[d10list|" ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [D10 a] -> ShowS
forall a. Integral a => [D10 a] -> ShowS
showsStr [D10 a]
xs ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> ShowS
showString [Char]
"|]"

showsChar :: Integral a => D10 a -> ShowS
showsChar :: D10 a -> ShowS
showsChar = Char -> ShowS
showChar (Char -> ShowS) -> (D10 a -> Char) -> D10 a -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. D10 a -> Char
forall a. Integral a => D10 a -> Char
d10Char

showsStr :: Integral a => [D10 a] -> ShowS
showsStr :: [D10 a] -> ShowS
showsStr = Endo [Char] -> ShowS
forall a. Endo a -> a -> a
appEndo (Endo [Char] -> ShowS)
-> ([D10 a] -> Endo [Char]) -> [D10 a] -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (D10 a -> Endo [Char]) -> [D10 a] -> Endo [Char]
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (ShowS -> Endo [Char]
forall a. (a -> a) -> Endo a
Endo (ShowS -> Endo [Char]) -> (D10 a -> ShowS) -> D10 a -> Endo [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. D10 a -> ShowS
forall a. Integral a => D10 a -> ShowS
showsChar)

---------------------------------------------------

-- | Convert a 'D10' to its underlying 'Char' representation.
--
-- >>> d10Char [d10|7|]
-- '7'

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)

-- | Convert a 'D10' to a 'String'.
--
-- @'d10Str' x = ['d10Char' x]@
--
-- >>> d10Str [d10|7|]
-- "7"

d10Str :: Integral a => D10 a -> String
d10Str :: D10 a -> [Char]
d10Str D10 a
x = [D10 a -> Char
forall a. Integral a => D10 a -> Char
d10Char D10 a
x]

-- | Convert a 'D10' to a 'Natural'.
--
-- 'd10Num' is a more general version of this function.
--
-- >>> d10Nat [d10|7|]
-- 7

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

-- | Convert a 'D10' to an 'Integer'.
--
-- 'd10Num' is a more general version of this function.
--
-- >>> d10Integer [d10|7|]
-- 7

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

-- | Convert a 'D10' to an 'Int'.
--
-- 'd10Num' is a more general version of this function.
--
-- >>> d10Int [d10|7|]
-- 7

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

-- | 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 :: (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

---------------------------------------------------

-- | The 'D10' which is uniquely congruent modulo 10 to the given 'Natural'.
--
-- 'integralMod10' is a more general version of this function.
--
-- >>> natMod10 56 :: D10 Int
-- [d10|6|]

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

-- | The 'D10' which is uniquely congruent modulo 10 to the given 'Integer'.
--
-- 'integralMod10' is a more general version of this function.
--
-- >>> integerMod10 56 :: D10 Int
-- [d10|6|]
--
-- >>> integerMod10 (-56) :: D10 Int
-- [d10|4|]

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

-- | The 'D10' which is uniquely congruent modulo 10 to the given 'Int'.
--
-- 'integralMod10' is a more general version of this function.
--
-- >>> intMod10 56 :: D10 Int
-- [d10|6|]
--
-- >>> intMod10 (-56) :: D10 Int
-- [d10|4|]

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

-- | 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 Int
-- [d10|6|]
--
-- >>> integralMod10 ((-56) :: Integer) :: D10 Int
-- [d10|4|]

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

---------------------------------------------------

-- | Convert a 'Char' to a 'D10' if it is within the range
-- @'0'@ to @'9'@, or produce 'Nothing' otherwise.
--
-- @'Data.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 :: 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

-- | 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.
--
-- @'Data.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 :: Num a => String -> Maybe (D10 a)
strD10Maybe :: [Char] -> Maybe (D10 a)
strD10Maybe [Char
x] = Char -> Maybe (D10 a)
forall a. Num a => Char -> Maybe (D10 a)
charD10Maybe Char
x
strD10Maybe [Char]
_   = Maybe (D10 a)
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.
--
-- @'Data.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 :: Num a => String -> Maybe [D10 a]
strD10ListMaybe :: [Char] -> Maybe [D10 a]
strD10ListMaybe = (Char -> Maybe (D10 a)) -> [Char] -> 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

-- | Convert a 'Natural' to a 'D10' if it is less than 10,
-- or produce 'Nothing' otherwise.
--
-- @'Data.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 :: 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

-- | Convert an 'Integer' to a 'D10' if it is within the range 0 to 9,
-- or produce 'Nothing' otherwise.
--
-- @'Data.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 :: 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

-- | Convert an 'Int' to a 'D10' if it is within the range 0 to 9,
-- or produce 'Nothing' otherwise.
--
-- @'Data.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 :: 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

-- | 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.
--
-- @'Data.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 :: (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)

---------------------------------------------------

-- | 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 :: Num a => Char -> Either String (D10 a)
charD10Either :: Char -> Either [Char] (D10 a)
charD10Either Char
x
        | Char -> Bool
isD10Char Char
x  =  D10 a -> Either [Char] (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    =  [Char] -> Either [Char] (D10 a)
forall a b. a -> Either a b
Left [Char]
"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 :: Num a => String -> Either String (D10 a)
strD10Either :: [Char] -> Either [Char] (D10 a)
strD10Either [Char
x]         =  Char -> Either [Char] (D10 a)
forall a. Num a => Char -> Either [Char] (D10 a)
charD10Either Char
x
strD10Either [Char]
_           =  [Char] -> Either [Char] (D10 a)
forall a b. a -> Either a b
Left [Char]
"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 :: Num a => String -> Either String [D10 a]
strD10ListEither :: [Char] -> Either [Char] [D10 a]
strD10ListEither = (Char -> Either [Char] (D10 a)) -> [Char] -> Either [Char] [D10 a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Char -> Either [Char] (D10 a)
forall a. Num a => Char -> Either [Char] (D10 a)
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 :: Num a => Natural -> Either String (D10 a)
natD10Either :: Natural -> Either [Char] (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 [Char] (D10 a)
forall a b. b -> Either a b
Right D10 a
y
        Maybe (D10 a)
Nothing -> [Char] -> Either [Char] (D10 a)
forall a b. a -> Either a b
Left [Char]
"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 :: Num a => Integer -> Either String (D10 a)
integerD10Either :: Integer -> Either [Char] (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 [Char] (D10 a)
forall a b. b -> Either a b
Right D10 a
y
        Maybe (D10 a)
Nothing -> [Char] -> Either [Char] (D10 a)
forall a b. a -> Either a b
Left [Char]
"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 :: Num a => Int -> Either String (D10 a)
intD10Either :: Int -> Either [Char] (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 [Char] (D10 a)
forall a b. b -> Either a b
Right D10 a
y
        Maybe (D10 a)
Nothing ->  [Char] -> Either [Char] (D10 a)
forall a b. a -> Either a b
Left [Char]
"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 :: (Num b, Integral a) => a -> Either String (D10 b)
integralD10Either :: a -> Either [Char] (D10 b)
integralD10Either a
x = Integer -> Either [Char] (D10 b)
forall a. Num a => Integer -> Either [Char] (D10 a)
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 Int)
-- [d10|5|]
--
-- >>> charD10Fail 'a' :: IO (D10 Int)
-- *** Exception: user error (d10 must be between 0 and 9)

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    =  [Char] -> m (D10 a)
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"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 Int)
-- [d10|5|]
--
-- >>> strD10Fail "a" :: IO (D10 Int)
-- *** Exception: user error (d10 must be between 0 and 9)
--
-- >>> strD10Fail "58" :: IO (D10 Int)
-- *** Exception: user error (d10 must be a single character)

strD10Fail :: (Num a, MonadFail m) => String -> m (D10 a)
strD10Fail :: [Char] -> 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 [Char]
_           =  [Char] -> m (D10 a)
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"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 Int]
-- [d10list|5|]
--
-- >>> strD10ListFail "a" :: IO [D10 Int]
-- *** Exception: user error (d10 must be between 0 and 9)
--
-- >>> strD10ListFail "58" :: IO [D10 Int]
-- [d10list|58|]

strD10ListFail :: (Num a, MonadFail m) => String -> m [D10 a]
strD10ListFail :: [Char] -> m [D10 a]
strD10ListFail = (Char -> m (D10 a)) -> [Char] -> 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

-- | 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 Int)
-- [d10|5|]
--
-- >>> natD10Fail 12 :: IO (D10 Int)
-- *** Exception: user error (d10 must be less than 10)

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 -> [Char] -> m (D10 a)
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"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 Int)
-- [d10|5|]
--
-- >>> integerD10Fail 12 :: IO (D10 Int)
-- *** Exception: user error (d10 must be between 0 and 9)
--
-- >>> integerD10Fail (-5) :: IO (D10 Int)
-- *** Exception: user error (d10 must be between 0 and 9)

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 -> [Char] -> m (D10 a)
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"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 Int)
-- [d10|5|]
--
-- >>> intD10Fail 12 :: IO (D10 Int)
-- *** Exception: user error (d10 must be between 0 and 9)
--
-- >>> intD10Fail (-5) :: IO (D10 Int)
-- *** Exception: user error (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 ->  [Char] -> m (D10 a)
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"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 Int)
-- [d10|5|]
--
-- >>> integralD10Fail (12 :: Integer) :: IO (D10 Int)
-- *** Exception: user error (d10 must be between 0 and 9)
--
-- >>> integralD10Fail ((-5) :: Integer) :: IO (D10 Int)
-- *** Exception: user error (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)

---------------------------------------------------

-- | Produces an expression of type @'D10' a@ that can be used
-- in a Template Haskell splice.
--
-- >>> d10Nat $(d10Exp 5)
-- 5
--
-- >>> d10Nat $(d10Exp 12)
-- ...
-- ... d10 must be between 0 and 9
-- ...
--
-- You may also be interested in 'd10', a quasi-quoter which
-- does something similar.

d10Exp :: Integer -> Q Exp
d10Exp :: Integer -> Q Exp
d10Exp = Integer -> Q (D10 Integer)
forall a (m :: * -> *).
(Num a, MonadFail m) =>
Integer -> m (D10 a)
integerD10Fail (Integer -> Q (D10 Integer))
-> (D10 Integer -> Q Exp) -> Integer -> Q Exp
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> D10 Integer -> Q Exp
d10Exp'

d10Exp' :: D10 Integer -> Q Exp
d10Exp' :: D10 Integer -> Q Exp
d10Exp' (D10_Unsafe Integer
x) = [| D10_Unsafe (fromInteger x) |]

-- | Produces an expression of type @['D10' a]@ that can be used
-- in a Template Haskell splice.
--
-- >>> d10Nat <$> $(d10ListExp "")
-- []
--
-- >>> d10Nat <$> $(d10ListExp "5")
-- [5]
--
-- >>> d10Nat <$> $(d10ListExp "58")
-- [5,8]
--
-- >>> d10Nat <$> $(d10ListExp "a")
-- ...
-- ... d10 must be between 0 and 9
-- ...
--
-- You may also be interested in 'd10list', a quasi-quoter which
-- does something similar.

d10ListExp :: String -> Q Exp
d10ListExp :: [Char] -> Q Exp
d10ListExp = [Char] -> Q [D10 Integer]
forall a (m :: * -> *). (Num a, MonadFail m) => [Char] -> m [D10 a]
strD10ListFail ([Char] -> Q [D10 Integer])
-> ([D10 Integer] -> Q Exp) -> [Char] -> Q Exp
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> [D10 Integer] -> Q Exp
d10ListExp'

d10ListExp' :: [D10 Integer] -> Q Exp
d10ListExp' :: [D10 Integer] -> Q Exp
d10ListExp' [D10 Integer]
xs = [| xs |]

---------------------------------------------------

-- | Produces a pattern that can be used in a splice
-- to match a particular @'D10' a@ value.
--
-- >>> :{
--       case (charD10Maybe '5') of
--         Just $(d10Pat 4) -> "A"
--         Just $(d10Pat 5) -> "B"
--         _                -> "C"
-- >>> :}
-- "B"
--
-- You may wish to use the 'd10' quasi-quoter instead.

d10Pat :: Integer -> Q Pat
d10Pat :: Integer -> Q Pat
d10Pat = Integer -> Q (D10 Integer)
forall a (m :: * -> *).
(Num a, MonadFail m) =>
Integer -> m (D10 a)
integerD10Fail (Integer -> Q (D10 Integer))
-> (D10 Integer -> Q Pat) -> Integer -> Q Pat
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> D10 Integer -> Q Pat
d10Pat'

d10Pat' :: D10 Integer -> Q Pat
d10Pat' :: D10 Integer -> Q Pat
d10Pat' (D10_Unsafe Integer
x) = [p| D10_Unsafe $(litP $ integerL x) |]

d10Pat'' :: Integral a => D10 a -> Q Pat
d10Pat'' :: D10 a -> Q Pat
d10Pat'' (D10_Unsafe a
x) = [p| D10_Unsafe $(litP $ integerL $ toInteger x) |]

-- | Produces a pattern that can be used in a splice
-- to match a particular list of @'D10' a@ values.
--
-- >>> :{
--       case (strD10ListMaybe "56") of
--         Just $(d10ListPat "42") -> "A"
--         Just $(d10ListPat "56") -> "B"
--         _                       -> "C"
-- >>> :}
-- "B"
--
-- You may wish to use the 'd10list' quasi-quoter instead.

d10ListPat :: String -> Q Pat
d10ListPat :: [Char] -> Q Pat
d10ListPat = [Char] -> Q [D10 Integer]
forall a (m :: * -> *). (Num a, MonadFail m) => [Char] -> m [D10 a]
strD10ListFail ([Char] -> Q [D10 Integer])
-> ([D10 Integer] -> Q Pat) -> [Char] -> Q Pat
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> [D10 Integer] -> Q Pat
d10ListPat'

d10ListPat' :: [D10 Integer] -> Q Pat
d10ListPat' :: [D10 Integer] -> Q Pat
d10ListPat' = (D10 Integer -> Q Pat -> Q Pat) -> Q Pat -> [D10 Integer] -> Q Pat
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (\D10 Integer
x Q Pat
p -> [p| $(d10Pat'' x) : $(p) |]) [p| [] |]

---------------------------------------------------

-- | A single base-10 digit.
--
-- This quasi-quoter, when used as an expression, produces a
-- value of type @'D10' a@.
--
-- >>> d10Nat [d10|5|]
-- 5
--
-- >>> d10Nat [d10|a|]
-- ...
-- ... d10 must be between 0 and 9
-- ...
--
-- >>> d10Nat [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
-- ...

d10 :: QuasiQuoter
d10 :: QuasiQuoter
d10 = QuasiQuoter :: ([Char] -> Q Exp)
-> ([Char] -> Q Pat)
-> ([Char] -> Q Type)
-> ([Char] -> Q [Dec])
-> QuasiQuoter
QuasiQuoter
    { quoteExp :: [Char] -> Q Exp
quoteExp  = [Char] -> Q (D10 Integer)
forall a (m :: * -> *). (Num a, MonadFail m) => [Char] -> m (D10 a)
strD10Fail ([Char] -> Q (D10 Integer))
-> (D10 Integer -> Q Exp) -> [Char] -> Q Exp
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> D10 Integer -> Q Exp
d10Exp'
    , quotePat :: [Char] -> Q Pat
quotePat  = [Char] -> Q (D10 Integer)
forall a (m :: * -> *). (Num a, MonadFail m) => [Char] -> m (D10 a)
strD10Fail ([Char] -> Q (D10 Integer))
-> (D10 Integer -> Q Pat) -> [Char] -> Q Pat
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> D10 Integer -> Q Pat
d10Pat'
    , quoteType :: [Char] -> Q Type
quoteType = \[Char]
_ -> [Char] -> Q Type
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"d10 cannot be used in a type context"
    , quoteDec :: [Char] -> Q [Dec]
quoteDec  = \[Char]
_ -> [Char] -> Q [Dec]
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"d10 cannot be used in a declaration context"
    }

-- | A list of base-10 digits.
--
-- This quasi-quoter, when used as an expression, produces a
-- value of type @['D10' a]@.
--
-- >>> d10Nat <$> [d10list||]
-- []
--
-- >>> d10Nat <$> [d10list|5|]
-- [5]
--
-- >>> d10Nat <$> [d10list|58|]
-- [5,8]
--
-- >>> d10Nat <$> [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
-- ...

d10list :: QuasiQuoter
d10list :: QuasiQuoter
d10list = QuasiQuoter :: ([Char] -> Q Exp)
-> ([Char] -> Q Pat)
-> ([Char] -> Q Type)
-> ([Char] -> Q [Dec])
-> QuasiQuoter
QuasiQuoter
    { quoteExp :: [Char] -> Q Exp
quoteExp  = [Char] -> Q [D10 Integer]
forall a (m :: * -> *). (Num a, MonadFail m) => [Char] -> m [D10 a]
strD10ListFail ([Char] -> Q [D10 Integer])
-> ([D10 Integer] -> Q Exp) -> [Char] -> Q Exp
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> [D10 Integer] -> Q Exp
d10ListExp'
    , quotePat :: [Char] -> Q Pat
quotePat  = [Char] -> Q [D10 Integer]
forall a (m :: * -> *). (Num a, MonadFail m) => [Char] -> m [D10 a]
strD10ListFail ([Char] -> Q [D10 Integer])
-> ([D10 Integer] -> Q Pat) -> [Char] -> Q Pat
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> [D10 Integer] -> Q Pat
d10ListPat'
    , quoteType :: [Char] -> Q Type
quoteType = \[Char]
_ -> [Char] -> Q Type
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"d10list cannot be used in a type context"
    , quoteDec :: [Char] -> Q [Dec]
quoteDec  = \[Char]
_ -> [Char] -> Q [Dec]
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"d10list cannot be used in a declaration context"
    }

---------------------------------------------------

-- | Addition modulo 10.
--
-- >>> [d10|2|] + [d10|3|]
-- [d10|5|]
--
-- >>> [d10|6|] + [d10|7|]
-- [d10|3|]

(+) :: Integral a => D10 a -> D10 a -> D10 a
D10 a
x + :: D10 a -> D10 a -> D10 a
+ D10 a
y = Int -> D10 a
forall a. Num a => Int -> D10 a
intMod10 (D10 a -> Int
forall a. Integral a => D10 a -> Int
d10Int D10 a
x Int -> Int -> Int
forall a. Num a => a -> a -> a
P.+ D10 a -> Int
forall a. Integral a => D10 a -> Int
d10Int D10 a
y)

-- | Subtraction modulo 10.
--
-- >>> [d10|7|] - [d10|5|]
-- [d10|2|]
--
-- >>> [d10|3|] - [d10|7|]
-- [d10|6|]

(-) :: Integral a => D10 a -> D10 a -> D10 a
D10 a
x - :: D10 a -> D10 a -> D10 a
- D10 a
y = Int -> D10 a
forall a. Num a => Int -> D10 a
intMod10 (D10 a -> Int
forall a. Integral a => D10 a -> Int
d10Int D10 a
x Int -> Int -> Int
forall a. Num a => a -> a -> a
P.- D10 a -> Int
forall a. Integral a => D10 a -> Int
d10Int D10 a
y)

-- | Multiplication modulo 10.
--
-- >>> [d10|2|] * [d10|4|]
-- [d10|8|]
--
-- >>> [d10|7|] * [d10|8|]
-- [d10|6|]

(*) :: Integral a => D10 a -> D10 a -> D10 a
D10 a
x * :: D10 a -> D10 a -> D10 a
* D10 a
y = Int -> D10 a
forall a. Num a => Int -> D10 a
intMod10 (D10 a -> Int
forall a. Integral a => D10 a -> Int
d10Int D10 a
x Int -> Int -> Int
forall a. Num a => a -> a -> a
P.* D10 a -> Int
forall a. Integral a => D10 a -> Int
d10Int D10 a
y)