digit-0.3.0: A data-type representing digits 0-9 and other combinations

Safe HaskellNone
LanguageHaskell2010

Data.Digit

Description

A data type with ten nullary constructors [0-9] and combinators.

Synopsis

Documentation

data Digit Source #

A data type with ten nullary constructors.

Instances

Bounded Digit Source # 
Enum Digit Source # 
Eq Digit Source # 

Methods

(==) :: Digit -> Digit -> Bool #

(/=) :: Digit -> Digit -> Bool #

Data Digit Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Digit -> c Digit #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Digit #

toConstr :: Digit -> Constr #

dataTypeOf :: Digit -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Digit) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Digit) #

gmapT :: (forall b. Data b => b -> b) -> Digit -> Digit #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Digit -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Digit -> r #

gmapQ :: (forall d. Data d => d -> u) -> Digit -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Digit -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Digit -> m Digit #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Digit -> m Digit #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Digit -> m Digit #

Ord Digit Source # 

Methods

compare :: Digit -> Digit -> Ordering #

(<) :: Digit -> Digit -> Bool #

(<=) :: Digit -> Digit -> Bool #

(>) :: Digit -> Digit -> Bool #

(>=) :: Digit -> Digit -> Bool #

max :: Digit -> Digit -> Digit #

min :: Digit -> Digit -> Digit #

Show Digit Source # 

Methods

showsPrec :: Int -> Digit -> ShowS #

show :: Digit -> String #

showList :: [Digit] -> ShowS #

ManyDigit Digit Source # 
AsDigit Digit Source # 
D9 Digit Source # 

Methods

d9 :: Prism' Digit () Source #

x9 :: Digit Source #

D8 Digit Source # 

Methods

d8 :: Prism' Digit () Source #

x8 :: Digit Source #

D7 Digit Source # 

Methods

d7 :: Prism' Digit () Source #

x7 :: Digit Source #

D6 Digit Source # 

Methods

d6 :: Prism' Digit () Source #

x6 :: Digit Source #

D5 Digit Source # 

Methods

d5 :: Prism' Digit () Source #

x5 :: Digit Source #

D4 Digit Source # 

Methods

d4 :: Prism' Digit () Source #

x4 :: Digit Source #

D3 Digit Source # 

Methods

d3 :: Prism' Digit () Source #

x3 :: Digit Source #

D2 Digit Source # 

Methods

d2 :: Prism' Digit () Source #

x2 :: Digit Source #

D1 Digit Source # 

Methods

d1 :: Prism' Digit () Source #

x1 :: Digit Source #

D0 Digit Source # 

Methods

d0 :: Prism' Digit () Source #

x0 :: Digit Source #

HasDigit Digit Source # 
Cons Digits1 Digits1 Digit Digit # 
Cons Digits Digits Digit Digit # 
Snoc Digits1 Digits1 Digit Digit # 
Snoc Digits Digits Digit Digit # 
Each Digits1 Digits1 Digit Digit # 
Each Digits Digits Digit Digit # 

foldDigit Source #

Arguments

:: a

Zero.

-> a

One.

-> a

Two.

-> a

Three.

-> a

Four.

-> a

Five.

-> a

Six.

-> a

Seven.

-> a

Eight.

-> a

Nine.

-> Digit

The digit to fold.

-> a 

Catamorphism for Digit.

foldDigit q0 q1 q2 q3 q4 q5 q6 q7 q8 q9 D0 == q0
foldDigit q0 q1 q2 q3 q4 q5 q6 q7 q8 q9 D1 == q1
foldDigit q0 q1 q2 q3 q4 q5 q6 q7 q8 q9 D2 == q2
foldDigit q0 q1 q2 q3 q4 q5 q6 q7 q8 q9 D3 == q3
foldDigit q0 q1 q2 q3 q4 q5 q6 q7 q8 q9 D4 == q4
foldDigit q0 q1 q2 q3 q4 q5 q6 q7 q8 q9 D5 == q5
foldDigit q0 q1 q2 q3 q4 q5 q6 q7 q8 q9 D6 == q6
foldDigit q0 q1 q2 q3 q4 q5 q6 q7 q8 q9 D7 == q7
foldDigit q0 q1 q2 q3 q4 q5 q6 q7 q8 q9 D8 == q8
foldDigit q0 q1 q2 q3 q4 q5 q6 q7 q8 q9 D9 == q9

class HasDigit a where Source #

Minimal complete definition

hasdigit

Methods

hasdigit :: Lens' a Digit Source #

Instances

class AsDigit a where Source #

Minimal complete definition

digit

Methods

digit :: Prism' a Digit Source #

Instances

AsDigit Char Source #
>>> '5' ^? digit
Just 5

>>> '0' ^? digit
Just 0

>>> '9' ^? digit
Just 9

>>> 'a' ^? digit
Nothing

>>> '@' ^? digit
Nothing

>>> digit # D5 :: Char
'5'

>>> digit # D9 :: Char
'9'

>>> digit # D0 :: Char
'0'
AsDigit Int Source #
>>> (5 :: Int) ^? digitIntegral
Just 5

>>> (0 :: Int) ^? digitIntegral
Just 0

>>> (9 :: Int) ^? digitIntegral
Just 9

>>> (10 :: Int) ^? digitIntegral
Nothing

>>> ((-5) :: Int) ^? digitIntegral
Nothing

>>> digitIntegral # D5 :: Int
5

>>> digitIntegral # D9 :: Int
9

>>> digitIntegral # D0 :: Int
0
AsDigit Int8 Source #
>>> (5 :: Int8) ^? digitIntegral
Just 5

>>> (0 :: Int8) ^? digitIntegral
Just 0

>>> (9 :: Int8) ^? digitIntegral
Just 9

>>> (10 :: Int8) ^? digitIntegral
Nothing

>>> ((-5) :: Int8) ^? digitIntegral
Nothing

>>> digitIntegral # D5 :: Int8
5

>>> digitIntegral # D9 :: Int8
9

>>> digitIntegral # D0 :: Int8
0
AsDigit Int16 Source #
>>> (5 :: Int16) ^? digitIntegral
Just 5

>>> (0 :: Int16) ^? digitIntegral
Just 0

>>> (9 :: Int16) ^? digitIntegral
Just 9

>>> (10 :: Int16) ^? digitIntegral
Nothing

>>> ((-5) :: Int16) ^? digitIntegral
Nothing

>>> digitIntegral # D5 :: Int16
5

>>> digitIntegral # D9 :: Int16
9

>>> digitIntegral # D0 :: Int16
0
AsDigit Int32 Source #
>>> (5 :: Int32) ^? digitIntegral
Just 5

>>> (0 :: Int32) ^? digitIntegral
Just 0

>>> (9 :: Int32) ^? digitIntegral
Just 9

>>> (10 :: Int32) ^? digitIntegral
Nothing

>>> ((-5) :: Int32) ^? digitIntegral
Nothing

>>> digitIntegral # D5 :: Int32
5

>>> digitIntegral # D9 :: Int32
9

>>> digitIntegral # D0 :: Int32
0
AsDigit Int64 Source #
>>> (5 :: Int64) ^? digitIntegral
Just 5

>>> (0 :: Int64) ^? digitIntegral
Just 0

>>> (9 :: Int64) ^? digitIntegral
Just 9

>>> (10 :: Int64) ^? digitIntegral
Nothing

>>> ((-5) :: Int64) ^? digitIntegral
Nothing

>>> digitIntegral # D5 :: Int64
5

>>> digitIntegral # D9 :: Int64
9

>>> digitIntegral # D0 :: Int64
0
AsDigit Integer Source #
>>> (5 :: Integer) ^? digitIntegral
Just 5

>>> (0 :: Integer) ^? digitIntegral
Just 0

>>> (9 :: Integer) ^? digitIntegral
Just 9

>>> (10 :: Integer) ^? digitIntegral
Nothing

>>> ((-5) :: Integer) ^? digitIntegral
Nothing

>>> digitIntegral # D5 :: Integer
5

>>> digitIntegral # D9 :: Integer
9

>>> digitIntegral # D0 :: Integer
0
AsDigit Word Source #
>>> (5 :: Word) ^? digitIntegral
Just 5

>>> (0 :: Word) ^? digitIntegral
Just 0

>>> (9 :: Word) ^? digitIntegral
Just 9

>>> (10 :: Word) ^? digitIntegral
Nothing

>>> ((-5) :: Word) ^? digitIntegral
Nothing

>>> digitIntegral # D5 :: Word
5

>>> digitIntegral # D9 :: Word
9

>>> digitIntegral # D0 :: Word
0
AsDigit Digit Source # 
Integral a => AsDigit (Identity a) Source #
>>> (5 :: Identity Int) ^? digitIntegral
Just 5

>>> (0 :: Identity Int) ^? digitIntegral
Just 0

>>> (9 :: Identity Int) ^? digitIntegral
Just 9

>>> (10 :: Identity Int) ^? digitIntegral
Nothing

>>> ((-5) :: Identity Int) ^? digitIntegral
Nothing

>>> digitIntegral # D5 :: Identity Int
Identity 5

>>> digitIntegral # D9 :: Identity Int
Identity 9

>>> digitIntegral # D0 :: Identity Int
Identity 0
Integral a => AsDigit (Const * a b) Source #
>>> (5 :: Const Int String) ^? digitIntegral
Just 5

>>> (0 :: Const Int String) ^? digitIntegral
Just 0

>>> (9 :: Const Int String) ^? digitIntegral
Just 9

>>> (10 :: Const Int String) ^? digitIntegral
Nothing

>>> ((-5) :: Const Int String) ^? digitIntegral
Nothing

>>> digitIntegral # D5 :: Const Int String
Const 5

>>> digitIntegral # D9 :: Const Int String
Const 9

>>> digitIntegral # D0 :: Const Int String
Const 0

Methods

digit :: Prism' (Const * a b) Digit Source #

class ManyDigit a where Source #

Minimal complete definition

digitT

Methods

digitT :: Traversal' a Digit Source #

Instances

class D0 d where Source #

Minimal complete definition

d0

Methods

d0 :: Prism' d () Source #

x0 :: D0 d => d Source #

Instances

class D1 d where Source #

Minimal complete definition

d1

Methods

d1 :: Prism' d () Source #

x1 :: D1 d => d Source #

Instances

class D2 d where Source #

Minimal complete definition

d2

Methods

d2 :: Prism' d () Source #

x2 :: D2 d => d Source #

Instances

class D3 d where Source #

Minimal complete definition

d3

Methods

d3 :: Prism' d () Source #

x3 :: D3 d => d Source #

Instances

class D4 d where Source #

Minimal complete definition

d4

Methods

d4 :: Prism' d () Source #

x4 :: D4 d => d Source #

Instances

class D5 d where Source #

Minimal complete definition

d5

Methods

d5 :: Prism' d () Source #

x5 :: D5 d => d Source #

Instances

class D6 d where Source #

Minimal complete definition

d6

Methods

d6 :: Prism' d () Source #

x6 :: D6 d => d Source #

Instances

class D7 d where Source #

Minimal complete definition

d7

Methods

d7 :: Prism' d () Source #

x7 :: D7 d => d Source #

Instances

class D8 d where Source #

Minimal complete definition

d8

Methods

d8 :: Prism' d () Source #

x8 :: D8 d => d Source #

Instances

class D9 d where Source #

Minimal complete definition

d9

Methods

d9 :: Prism' d () Source #

x9 :: D9 d => d Source #

Instances

mod10 :: Integral a => a -> Digit Source #

Modulus with 10.

>>> mod10 0
0

>>> mod10 1
1

>>> mod10 8
8

>>> mod10 9
9

>>> mod10 10
0

>>> mod10 90
0

>>> mod10 91
1

>>> mod10 (-1)
9

>>> mod10 (-12)
8

absrem10 :: Integral a => a -> Digit Source #

Absolute value of remainder 10.

>>> absrem10 0
0

>>> absrem10 1
1

>>> absrem10 8
8

>>> absrem10 9
9

>>> absrem10 10
0

>>> absrem10 90
0

>>> absrem10 91
1

>>> absrem10 (-1)
1

>>> absrem10 (-12)
2

divMod10 :: Integral a => a -> (a, Digit) Source #

Division/modulus with 10.

>>> divMod10 0
(0,0)

>>> divMod10 1
(0,1)

>>> divMod10 8
(0,8)

>>> divMod10 9
(0,9)

>>> divMod10 10
(1,0)

>>> divMod10 90
(9,0)

>>> divMod10 91
(9,1)

>>> divMod10 (-1)
(-1,9)

parsedigit :: CharParsing p => p Digit Source #

digitQ :: QuasiQuoter Source #

A QuasiQuoter for any range of Digit.

digitQ|4|
:: Digit 4

named [digitQ|4|] = "four" named [digitQ|$x|] = "not four, " ++ show x ++ " instead"

mod10D x = let y = mod x 10 in [digitQ|$y|]

(/+/) :: Digit -> Digit -> (Digit, Digit) Source #

>>> D0 /+/ D0
(0,0)

>>> D0 /+/ D1
(0,1)

>>> D1 /+/ D0
(0,1)

>>> D4 /+/ D5
(0,9)

>>> D5 /+/ D5
(1,0)

>>> D5 /+/ D6
(1,1)

>>> D8 /+/ D7
(1,5)

>>> D9 /+/ D9
(1,8)