digit 0.6 → 0.7

raw patch · 56 files changed

+1709/−1863 lines, 56 filesdep −papadep ~basePVP ok

version bump matches the API change (PVP)

Dependencies removed: papa

Dependency ranges changed: base

API changes (from Hackage documentation)

Files

• digit.cabal +22/−34
• src/Data/Digit.hs +6/−6
• src/Data/Digit/Binary.hs +5/−4
• src/Data/Digit/Char.hs +27/−19
• src/Data/Digit/Class/D0.hs +50/−0
• src/Data/Digit/Class/D1.hs +49/−0
• src/Data/Digit/Class/D2.hs +49/−0
• src/Data/Digit/Class/D3.hs +49/−0
• src/Data/Digit/Class/D4.hs +49/−0
• src/Data/Digit/Class/D5.hs +49/−0
• src/Data/Digit/Class/D6.hs +50/−0
• src/Data/Digit/Class/D7.hs +49/−0
• src/Data/Digit/Class/D8.hs +49/−0
• src/Data/Digit/Class/D9.hs +49/−0
• src/Data/Digit/Class/LowerCase.hs +214/−0
• src/Data/Digit/Class/MixedCase.hs +192/−0
• src/Data/Digit/Class/UpperCase.hs +213/−0
• src/Data/Digit/D0.hs +0/−46
• src/Data/Digit/D1.hs +0/−45
• src/Data/Digit/D2.hs +0/−45
• src/Data/Digit/D3.hs +0/−45
• src/Data/Digit/D4.hs +0/−45
• src/Data/Digit/D5.hs +0/−45
• src/Data/Digit/D6.hs +0/−45
• src/Data/Digit/D7.hs +0/−45
• src/Data/Digit/D8.hs +0/−45
• src/Data/Digit/D9.hs +0/−45
• src/Data/Digit/DA.hs +0/−45
• src/Data/Digit/DAa.hs +0/−48
• src/Data/Digit/DB.hs +0/−45
• src/Data/Digit/DBb.hs +0/−45
• src/Data/Digit/DC.hs +0/−45
• src/Data/Digit/DCc.hs +0/−45
• src/Data/Digit/DD.hs +0/−45
• src/Data/Digit/DDd.hs +0/−45
• src/Data/Digit/DE.hs +0/−45
• src/Data/Digit/DEe.hs +0/−45
• src/Data/Digit/DF.hs +0/−45
• src/Data/Digit/DFf.hs +0/−45
• src/Data/Digit/Da.hs +0/−45
• src/Data/Digit/Db.hs +0/−45
• src/Data/Digit/Dc.hs +0/−45
• src/Data/Digit/Dd.hs +0/−45
• src/Data/Digit/De.hs +0/−45
• src/Data/Digit/Decimal.hs +21/−20
• src/Data/Digit/Df.hs +0/−45
• src/Data/Digit/Enum.hs +2/−2
• src/Data/Digit/HEXADECIMAL.hs +0/−136
• src/Data/Digit/HeXaDeCiMaL.hs +0/−154
• src/Data/Digit/Hexadecimal.hs +0/−136
• src/Data/Digit/Hexadecimal/LowerCase.hs +129/−0
• src/Data/Digit/Hexadecimal/MixedCase.hs +144/−0
• src/Data/Digit/Hexadecimal/UpperCase.hs +126/−0
• src/Data/Digit/Integral.hs +71/−57
• src/Data/Digit/Octal.hs +16/−16
• test/Main.hs +29/−15

@@ -1,5 +1,5 @@ name:               digit-version:            0.6+version:            0.7 license:            BSD3 license-file:       LICENCE author:             Queensland Functional Programming Lab <oᴉ˙ldɟb@llǝʞsɐɥ>@@ -33,7 +33,6 @@                     , parsers          >= 0.12.3 && < 0.13                     , semigroups       >= 0.12 && < 1.0                     , template-haskell >= 2.8 && < 3-                    , papa             >= 0.3.1 && < 0.4                     , semigroupoids    >= 5 && < 6                     , scientific       >= 0.3 && < 0.4 @@ -52,37 +51,26 @@                     Data.Digit.Natural                     Data.Digit.Decimal                     Data.Digit.Octal-                    Data.Digit.Hexadecimal-                    Data.Digit.HeXaDeCiMaL-                    Data.Digit.HEXADECIMAL-                    Data.Digit.D0-                    Data.Digit.D1-                    Data.Digit.D2-                    Data.Digit.D3-                    Data.Digit.D4-                    Data.Digit.D5-                    Data.Digit.D6-                    Data.Digit.D7-                    Data.Digit.D8-                    Data.Digit.D9-                    Data.Digit.Da-                    Data.Digit.DA-                    Data.Digit.Db-                    Data.Digit.DB-                    Data.Digit.Dc-                    Data.Digit.DC-                    Data.Digit.Dd-                    Data.Digit.DD-                    Data.Digit.De-                    Data.Digit.DE-                    Data.Digit.Df-                    Data.Digit.DF-                    Data.Digit.DAa-                    Data.Digit.DBb-                    Data.Digit.DCc-                    Data.Digit.DDd-                    Data.Digit.DEe-                    Data.Digit.DFf++                    Data.Digit.Hexadecimal.LowerCase+                    Data.Digit.Hexadecimal.UpperCase+                    Data.Digit.Hexadecimal.MixedCase++                    Data.Digit.Class.D0+                    Data.Digit.Class.D1+                    Data.Digit.Class.D2+                    Data.Digit.Class.D3+                    Data.Digit.Class.D4+                    Data.Digit.Class.D5+                    Data.Digit.Class.D6+                    Data.Digit.Class.D7+                    Data.Digit.Class.D8+                    Data.Digit.Class.D9++                    Data.Digit.Class.LowerCase+                    Data.Digit.Class.MixedCase+                    Data.Digit.Class.UpperCase+                     Data.Digit.Char                     Data.Digit.Enum                     Data.Digit.Integral@@ -105,13 +93,13 @@                     , hedgehog       >=0.5    && <0.7                     , tasty          >=0.11   && <1.2                     , tasty-hspec    >=1.1    && <1.2-                    , papa           >= 0.3.1 && < 0.4                     , parsec         >=3.1    && <3.2                     , parsers        >=0.12.3 && <0.13                     , pretty         >=1.1    && <1.2                     , text           >=1.2    && <1.3                     , tasty-hedgehog >=0.1    && <0.3                     , tasty-hunit    >=0.9    && <0.11+                    , semigroups     >= 0.12 && < 1.0                     , digit    ghc-options:

@@ -4,9 +4,9 @@   module Data.Digit.Binary , module Data.Digit.Decimal , module Data.Digit.Octal-, module Data.Digit.Hexadecimal-, module Data.Digit.HeXaDeCiMaL-, module Data.Digit.HEXADECIMAL+, module Data.Digit.Hexadecimal.LowerCase+, module Data.Digit.Hexadecimal.UpperCase+, module Data.Digit.Hexadecimal.MixedCase -- * Utilities , module Data.Digit.Char , module Data.Digit.Enum@@ -17,9 +17,9 @@ import Data.Digit.Binary import Data.Digit.Decimal import Data.Digit.Octal-import Data.Digit.Hexadecimal-import Data.Digit.HeXaDeCiMaL-import Data.Digit.HEXADECIMAL+import Data.Digit.Hexadecimal.LowerCase+import Data.Digit.Hexadecimal.UpperCase+import Data.Digit.Hexadecimal.MixedCase import Data.Digit.Char import Data.Digit.Enum import Data.Digit.Integral

@@ -12,16 +12,17 @@ , _BinDigit0 , _BinDigit1 -- * Re-exports-, module Data.Digit.D0-, module Data.Digit.D1+, module Data.Digit.Class.D0+, module Data.Digit.Class.D1 ) where  import Prelude (Eq, Show, Ord) import Control.Lens.TH (makePrisms) import Text.Parser.Char(CharParsing) import Text.Parser.Combinators((<?>), choice)-import Data.Digit.D0-import Data.Digit.D1++import Data.Digit.Class.D0+import Data.Digit.Class.D1  data BinDigit   = BinDigit0

@@ -21,16 +21,24 @@ , charHeXaDeCiMaL ) where -import Control.Lens.Extras(is)-import Data.Digit.Binary as D-import Data.Digit.Decimal as D-import Data.Digit.Octal as D-import Data.Digit.Hexadecimal as D-import Data.Digit.HeXaDeCiMaL as D-import Data.Digit.HEXADECIMAL as D-import Papa+import           Prelude                (Char, Eq, fst, lookup) +import           Control.Applicative    (Applicative)+import           Control.Lens           (APrism, Choice, Prism', clonePrism,+                                         prism', ( # ))+import           Control.Lens.Extras    (is) +import           Data.Foldable          (find)+import           Data.Functor           ((<$>))+import           Data.Maybe             (fromMaybe)++import           Data.Digit.Binary      as D+import           Data.Digit.Decimal     as D+import           Data.Digit.Hexadecimal.LowerCase as D+import           Data.Digit.Hexadecimal.UpperCase as D+import           Data.Digit.Hexadecimal.MixedCase as D+import           Data.Digit.Octal       as D+ -- $setup -- >>> import Data.Digit @@ -48,7 +56,7 @@     d charBinaryNoZero =   associatePrism ('1', d1) []-  + -- | -- -- >>> '0' ^? charBinary :: Maybe BinDigit@@ -63,7 +71,7 @@     d charBinary =   associatePrism ('0', d0) [('1', d1)]-  + -- | -- -- >>> '6' ^? charOctalNoZero :: Maybe OctDigit@@ -78,7 +86,7 @@     d charOctalNoZero =   associatePrism ('1', d1) [('2', d2), ('3', d3), ('4', d4), ('5', d5), ('6', d6), ('7', d7)]-  + -- | -- >>> '7' ^? charOctal :: Maybe OctDigit -- Just OctDigit7@@ -92,7 +100,7 @@     d charOctal =   associatePrism ('0', d0) [('1', d1), ('2', d2), ('3', d3), ('4', d4), ('5', d5), ('6', d6), ('7', d7)]-  + -- | -- >>> '9' ^? charDecimalNoZero :: Maybe DecDigit -- Just DecDigit9@@ -106,7 +114,7 @@     d charDecimalNoZero =   associatePrism ('1', d1) [('2', d2), ('3', d3), ('4', d4), ('5', d5), ('6', d6), ('7', d7), ('8', d8), ('9', d9)]-  + -- | -- >>> '9' ^? charDecimal :: Maybe DecDigit -- Just DecDigit9@@ -120,7 +128,7 @@     d charDecimal =   associatePrism ('0', d0) [('1', d1), ('2', d2), ('3', d3), ('4', d4), ('5', d5), ('6', d6), ('7', d7), ('8', d8), ('9', d9)]-  + -- | -- >>> 'f' ^? charHexadecimalNoZero :: Maybe HexDigit -- Just HexDigitf@@ -134,7 +142,7 @@     d charHexadecimalNoZero =   associatePrism ('1', d1) [('2', d2), ('3', d3), ('4', d4), ('5', d5), ('6', d6), ('7', d7), ('8', d8), ('9', d9), ('a', da), ('b', db), ('c', dc), ('d', dd), ('e', de), ('f', df)]-  + -- | -- >>> 'f' ^? charHexadecimal :: Maybe HexDigit -- Just HexDigitf@@ -148,7 +156,7 @@     d charHexadecimal =   associatePrism ('0', d0) [('1', d1), ('2', d2), ('3', d3), ('4', d4), ('5', d5), ('6', d6), ('7', d7), ('8', d8), ('9', d9), ('a', da), ('b', db), ('c', dc), ('d', dd), ('e', de), ('f', df)]-  + -- | -- >>> 'F' ^? charHEXADECIMALNoZero :: Maybe HEXDigit -- Just HEXDigitF@@ -162,7 +170,7 @@     d charHEXADECIMALNoZero =   associatePrism ('1', d1) [('2', d2), ('3', d3), ('4', d4), ('5', d5), ('6', d6), ('7', d7), ('8', d8), ('9', d9), ('A', dA), ('B', dB), ('C', dC), ('D', dD), ('E', dE), ('F', dF)]-  + -- | -- >>> 'F' ^? charHEXADECIMAL :: Maybe HEXDigit -- Just HEXDigitF@@ -176,7 +184,7 @@     d charHEXADECIMAL =   associatePrism ('0', d0) [('1', d1), ('2', d2), ('3', d3), ('4', d4), ('5', d5), ('6', d6), ('7', d7), ('8', d8), ('9', d9), ('A', dA), ('B', dB), ('C', dC), ('D', dD), ('E', dE), ('F', dF)]-  + -- | -- >>> 'f' ^? charHeXaDeCiMaLNoZero :: Maybe HeXDigit -- Just HeXDigitf@@ -196,7 +204,7 @@     d charHeXaDeCiMaLNoZero =   associatePrism ('1', d1) [('2', d2), ('3', d3), ('4', d4), ('5', d5), ('6', d6), ('7', d7), ('8', d8), ('9', d9), ('a', da), ('b', db), ('c', dc), ('d', dd), ('e', de), ('f', df), ('A', dA), ('B', dB), ('C', dC), ('D', dD), ('E', dE), ('F', dF)]-  +  -- | -- >>> 'f' ^? charHeXaDeCiMaL :: Maybe HeXDigit

@@ -0,0 +1,50 @@+{-# LANGUAGE NoImplicitPrelude #-}+{-# LANGUAGE FlexibleInstances #-}++module Data.Digit.Class.D0(+  D0(..)+, parse0+) where++import Control.Category (id)+import Control.Lens (Prism', (#))++import Data.Functor ((<$))++import Text.Parser.Char(CharParsing, char)+import Text.Parser.Combinators((<?>))++-- $setup+-- >>> import Data.Digit.Class+-- >>> import Text.Parsec(parse, ParseError, eof)+-- >>> import Data.Void(Void)++class D0 d where+  d0 ::+    Prism'+      d+      ()+  x0 ::+    d+  x0 =+    d0 # ()++instance D0 () where+  d0 =+    id++-- |+--+-- >>> parse (parse0 <* eof) "test" "0" :: Either ParseError BinDigit+-- Right BinDigit0+--+-- >>> parse parse0 "test" "0xyz" :: Either ParseError BinDigit+-- Right BinDigit0+--+-- >>> isn't _Right (parse parse0 "test" "xyz" :: Either ParseError BinDigit)+-- True+parse0 ::+  (D0 d, CharParsing p) =>+  p d+parse0 =+  x0 <$ char '0' <?> "0"

@@ -0,0 +1,49 @@+{-# LANGUAGE NoImplicitPrelude #-}++module Data.Digit.Class.D1(+  D1(..)+, parse1+) where++import Control.Category (id)+import Control.Lens (Prism', (#))++import Data.Functor ((<$))++import Text.Parser.Char(CharParsing, char)+import Text.Parser.Combinators((<?>))++-- $setup+-- >>> import Data.Digit.Class+-- >>> import Text.Parsec(parse, ParseError, eof)+-- >>> import Data.Void(Void)++class D1 d where+  d1 ::+    Prism'+      d+      ()+  x1 ::+    d+  x1 =+    d1 # ()++instance D1 () where+  d1 =+    id++-- |+--+-- >>> parse (parse1 <* eof) "test" "1" :: Either ParseError BinDigit+-- Right BinDigit1+--+-- >>> parse parse1 "test" "1xyz" :: Either ParseError BinDigit+-- Right BinDigit1+--+-- >>> isn't _Right (parse parse1 "test" "xyz" :: Either ParseError BinDigit)+-- True+parse1 ::+  (D1 d, CharParsing p) =>+  p d+parse1 =+  x1 <$ char '1' <?> "1"

@@ -0,0 +1,49 @@+{-# LANGUAGE NoImplicitPrelude #-}++module Data.Digit.Class.D2(+  D2(..)+, parse2+) where++import Control.Category (id)+import Control.Lens (Prism', (#))++import Data.Functor ((<$))++import Text.Parser.Char(CharParsing, char)+import Text.Parser.Combinators((<?>))++-- $setup+-- >>> import Data.Digit.Class+-- >>> import Text.Parsec(parse, ParseError, eof)+-- >>> import Data.Void(Void)++class D2 d where+  d2 ::+    Prism'+      d+      ()+  x2 ::+    d+  x2 =+    d2 # ()++instance D2 () where+  d2 =+    id+    +-- |+--+-- >>> parse (parse2 <* eof) "test" "2" :: Either ParseError DecDigit+-- Right DecDigit2+--+-- >>> parse parse2 "test" "2xyz" :: Either ParseError DecDigit+-- Right DecDigit2+--+-- >>> isn't _Right (parse parse2 "test" "xyz" :: Either ParseError DecDigit)+-- True+parse2 ::+  (D2 d, CharParsing p) =>+  p d+parse2 =+  x2 <$ char '2' <?> "2"

@@ -0,0 +1,49 @@+{-# LANGUAGE NoImplicitPrelude #-}++module Data.Digit.Class.D3(+  D3(..)+, parse3+) where++import Control.Category (id)+import Control.Lens (Prism', (#))++import Data.Functor ((<$))++import Text.Parser.Char(CharParsing, char)+import Text.Parser.Combinators((<?>))++-- $setup+-- >>> import Data.Digit.Class+-- >>> import Text.Parsec(parse, ParseError, eof)+-- >>> import Data.Void(Void)++class D3 d where+  d3 ::+    Prism'+      d+      ()+  x3 ::+    d+  x3 =+    d3 # ()++instance D3 () where+  d3 =+    id++-- |+--+-- >>> parse (parse3 <* eof) "test" "3" :: Either ParseError DecDigit+-- Right DecDigit3+--+-- >>> parse parse3 "test" "3xyz" :: Either ParseError DecDigit+-- Right DecDigit3+--+-- >>> isn't _Right (parse parse3 "test" "xyz" :: Either ParseError DecDigit)+-- True+parse3 ::+  (D3 d, CharParsing p) =>+  p d+parse3 =+  x3 <$ char '3' <?> "3"

@@ -0,0 +1,49 @@+{-# LANGUAGE NoImplicitPrelude #-}++module Data.Digit.Class.D4(+  D4(..)+, parse4+) where++import Control.Category (id)+import Control.Lens (Prism', (#))++import Data.Functor ((<$))++import Text.Parser.Char(CharParsing, char)+import Text.Parser.Combinators((<?>))++-- $setup+-- >>> import Data.Digit.Class+-- >>> import Text.Parsec(parse, ParseError, eof)+-- >>> import Data.Void(Void)++class D4 d where+  d4 ::+    Prism'+      d+      ()+  x4 ::+    d+  x4 =+    d4 # ()++instance D4 () where+  d4 =+    id+   +-- |+--+-- >>> parse (parse4 <* eof) "test" "4" :: Either ParseError DecDigit+-- Right DecDigit4+--+-- >>> parse parse4 "test" "4xyz" :: Either ParseError DecDigit+-- Right DecDigit4+--+-- >>> isn't _Right (parse parse4 "test" "xyz" :: Either ParseError DecDigit)+-- True+parse4 ::+  (D4 d, CharParsing p) =>+  p d+parse4 =+  x4 <$ char '4' <?> "4"

@@ -0,0 +1,49 @@+{-# LANGUAGE NoImplicitPrelude #-}++module Data.Digit.Class.D5(+  D5(..)+, parse5+) where++import Control.Category (id)+import Control.Lens (Prism', (#))++import Data.Functor ((<$))++import Text.Parser.Char(CharParsing, char)+import Text.Parser.Combinators((<?>))++-- $setup+-- >>> import Data.Digit.Class+-- >>> import Text.Parsec(parse, ParseError, eof)+-- >>> import Data.Void(Void)++class D5 d where+  d5 ::+    Prism'+      d+      ()+  x5 ::+    d+  x5 =+    d5 # ()++instance D5 () where+  d5 =+    id+    +-- |+--+-- >>> parse (parse5 <* eof) "test" "5" :: Either ParseError DecDigit+-- Right DecDigit5+--+-- >>> parse parse5 "test" "5xyz" :: Either ParseError DecDigit+-- Right DecDigit5+--+-- >>> isn't _Right (parse parse5 "test" "xyz" :: Either ParseError DecDigit)+-- True+parse5 ::+  (D5 d, CharParsing p) =>+  p d+parse5 =+  x5 <$ char '5' <?> "5"

@@ -0,0 +1,50 @@+{-# LANGUAGE NoImplicitPrelude #-}++module Data.Digit.Class.D6(+  D6(..)+, parse6+) where+++import Control.Category (id)+import Control.Lens (Prism', (#))++import Data.Functor ((<$))++import Text.Parser.Char(CharParsing, char)+import Text.Parser.Combinators((<?>))++-- $setup+-- >>> import Data.Digit.Class+-- >>> import Text.Parsec(parse, ParseError, eof)+-- >>> import Data.Void(Void)++class D6 d where+  d6 ::+    Prism'+      d+      ()+  x6 ::+    d+  x6 =+    d6 # ()++instance D6 () where+  d6 =+    id+    +-- |+--+-- >>> parse (parse6 <* eof) "test" "6" :: Either ParseError DecDigit+-- Right DecDigit6+--+-- >>> parse parse6 "test" "6xyz" :: Either ParseError DecDigit+-- Right DecDigit6+--+-- >>> isn't _Right (parse parse6 "test" "xyz" :: Either ParseError DecDigit)+-- True+parse6 ::+  (D6 d, CharParsing p) =>+  p d+parse6 =+  x6 <$ char '6' <?> "6"

@@ -0,0 +1,49 @@+{-# LANGUAGE NoImplicitPrelude #-}++module Data.Digit.Class.D7(+  D7(..)+, parse7+) where++import Control.Category (id)+import Control.Lens (Prism', (#))++import Data.Functor ((<$))++import Text.Parser.Char(CharParsing, char)+import Text.Parser.Combinators((<?>))++-- $setup+-- >>> import Data.Digit.Class+-- >>> import Text.Parsec(parse, ParseError, eof)+-- >>> import Data.Void(Void)++class D7 d where+  d7 ::+    Prism'+      d+      ()+  x7 ::+    d+  x7 =+    d7 # ()++instance D7 () where+  d7 =+    id+    +-- |+--+-- >>> parse (parse7 <* eof) "test" "7" :: Either ParseError DecDigit+-- Right DecDigit7+--+-- >>> parse parse7 "test" "7xyz" :: Either ParseError DecDigit+-- Right DecDigit7+--+-- >>> isn't _Right (parse parse7 "test" "xyz" :: Either ParseError DecDigit)+-- True+parse7 ::+  (D7 d, CharParsing p) =>+  p d+parse7 =+  x7 <$ char '7' <?> "7"

@@ -0,0 +1,49 @@+{-# LANGUAGE NoImplicitPrelude #-}++module Data.Digit.Class.D8(+  D8(..)+, parse8+) where++import Control.Category (id)+import Control.Lens (Prism', (#))++import Data.Functor ((<$))++import Text.Parser.Char(CharParsing, char)+import Text.Parser.Combinators((<?>))++-- $setup+-- >>> import Data.Digit.Class+-- >>> import Text.Parsec(parse, ParseError, eof)+-- >>> import Data.Void(Void)++class D8 d where+  d8 ::+    Prism'+      d+      ()+  x8 ::+    d+  x8 =+    d8 # ()++instance D8 () where+  d8 =+    id+    +-- |+--+-- >>> parse (parse8 <* eof) "test" "8" :: Either ParseError DecDigit+-- Right DecDigit8+--+-- >>> parse parse8 "test" "8xyz" :: Either ParseError DecDigit+-- Right DecDigit8+--+-- >>> isn't _Right (parse parse8 "test" "xyz" :: Either ParseError DecDigit)+-- True+parse8 ::+  (D8 d, CharParsing p) =>+  p d+parse8 =+  x8 <$ char '8' <?> "8"

@@ -0,0 +1,49 @@+{-# LANGUAGE NoImplicitPrelude #-}++module Data.Digit.Class.D9(+  D9(..)+, parse9+) where++import Control.Category (id)+import Control.Lens (Prism', (#))++import Data.Functor ((<$))++import Text.Parser.Char(CharParsing, char)+import Text.Parser.Combinators((<?>))++-- $setup+-- >>> import Data.Digit.Class+-- >>> import Text.Parsec(parse, ParseError, eof)+-- >>> import Data.Void(Void)++class D9 d where+  d9 ::+    Prism'+      d+      ()+  x9 ::+    d+  x9 =+    d9 # ()++instance D9 () where+  d9 =+    id+    +-- |+--+-- >>> parse (parse9 <* eof) "test" "9" :: Either ParseError DecDigit+-- Right DecDigit9+--+-- >>> parse parse9 "test" "9xyz" :: Either ParseError DecDigit+-- Right DecDigit9+--+-- >>> isn't _Right (parse parse9 "test" "xyz" :: Either ParseError DecDigit)+-- True+parse9 ::+  (D9 d, CharParsing p) =>+  p d+parse9 =+  x9 <$ char '9' <?> "9"

@@ -0,0 +1,214 @@+{-# LANGUAGE NoImplicitPrelude #-}++module Data.Digit.Class.LowerCase (++  -- * Classes+    Da(..)+  , Db(..)+  , Dc(..)+  , Dd(..)+  , De(..)+  , Df(..)++  -- * Parsers+ , parsea+ , parseb+ , parsec+ , parsed+ , parsee+ , parsef++) where++import           Control.Category        (id)+import           Control.Lens            (Prism', ( # ))++import           Data.Functor            ((<$))++import           Text.Parser.Char        (CharParsing, char)+import           Text.Parser.Combinators ((<?>))++-- $setup+-- >>> import Data.Digit+-- >>> import Text.Parsec(parse, ParseError, eof)+-- >>> import Data.Void(Void)++class Da d where+  da ::+    Prism'+      d+      ()+  xa ::+    d+  xa =+    da # ()++instance Da () where+  da =+    id++class Db d where+  db ::+    Prism'+      d+      ()+  xb ::+    d+  xb =+    db # ()++instance Db () where+  db =+    id++class Dc d where+  dc ::+    Prism'+      d+      ()+  xc ::+    d+  xc =+    dc # ()++instance Dc () where+  dc =+    id++class Dd d where+  dd ::+    Prism'+      d+      ()+  xd ::+    d+  xd =+    dd # ()++instance Dd () where+  dd =+    id++class De d where+  de ::+    Prism'+      d+      ()+  xe ::+    d+  xe =+    de # ()++instance De () where+  de =+    id++class Df d where+  df ::+    Prism'+      d+      ()+  xf ::+    d+  xf =+    df # ()++instance Df () where+  df =+    id++-- |+--+-- >>> parse (parsea <* eof) "test" "a" :: Either ParseError HexDigit+-- Right HexDigita+--+-- >>> parse parsea "test" "axyz" :: Either ParseError HexDigit+-- Right HexDigita+--+-- >>> isn't _Right (parse parsea "test" "xyz" :: Either ParseError HexDigit)+-- True+parsea ::+  (Da d, CharParsing p) =>+  p d+parsea =+  xa <$ char 'a' <?> "a"++-- |+--+-- >>> parse (parseb <* eof) "test" "b" :: Either ParseError HexDigit+-- Right HexDigitb+--+-- >>> parse parseb "test" "bxyz" :: Either ParseError HexDigit+-- Right HexDigitb+--+-- >>> isn't _Right (parse parseb "test" "xyz" :: Either ParseError HexDigit)+-- True+parseb ::+  (Db d, CharParsing p) =>+  p d+parseb =+  xb <$ char 'b' <?> "b"++-- |+--+-- >>> parse (parsec <* eof) "test" "c" :: Either ParseError HexDigit+-- Right HexDigitc+--+-- >>> parse parsec "test" "cxyz" :: Either ParseError HexDigit+-- Right HexDigitc+--+-- >>> isn't _Right (parse parsec "test" "xyz" :: Either ParseError HexDigit)+-- True+parsec ::+  (Dc d, CharParsing p) =>+  p d+parsec =+  xc <$ char 'c' <?> "c"++-- |+--+-- >>> parse (parsed <* eof) "test" "d" :: Either ParseError HexDigit+-- Right HexDigitd+--+-- >>> parse parsed "test" "dxyz" :: Either ParseError HexDigit+-- Right HexDigitd+--+-- >>> isn't _Right (parse parsed "test" "xyz" :: Either ParseError HexDigit)+-- True+parsed ::+  (Dd d, CharParsing p) =>+  p d+parsed =+  xd <$ char 'd' <?> "d"++-- |+--+-- >>> parse (parsee <* eof) "test" "e" :: Either ParseError HexDigit+-- Right HexDigite+--+-- >>> parse parsee "test" "exyz" :: Either ParseError HexDigit+-- Right HexDigite+--+-- >>> isn't _Right (parse parsee "test" "xyz" :: Either ParseError HexDigit)+-- True+parsee ::+  (De d, CharParsing p) =>+  p d+parsee =+  xe <$ char 'e' <?> "e"++-- |+--+-- >>> parse (parsef <* eof) "test" "f" :: Either ParseError HexDigit+-- Right HexDigitf+--+-- >>> parse parsef "test" "fxyz" :: Either ParseError HexDigit+-- Right HexDigitf+--+-- >>> isn't _Right (parse parsef "test" "xyz" :: Either ParseError HexDigit)+-- True+parsef ::+  (Df d, CharParsing p) =>+  p d+parsef =+  xf <$ char 'f' <?> "f"

@@ -0,0 +1,192 @@+{-# LANGUAGE ConstraintKinds       #-}+{-# LANGUAGE FlexibleInstances     #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE NoImplicitPrelude     #-}+{-# LANGUAGE TypeFamilies          #-}++module Data.Digit.Class.MixedCase+  (+    -- * Types+    DAa+  , DBb+  , DCc+  , DDd+  , DEe+  , DFf++    -- * Parsers+  , parseAa+  , parseBb+  , parseCc+  , parseDd+  , parseEe+  , parseFf++    -- * Re-exports+  , module Data.Digit.Class.UpperCase+  , module Data.Digit.Class.LowerCase++  ) where++import           Text.Parser.Char        (CharParsing)+import           Text.Parser.Combinators (choice, (<?>))++import           Data.Digit.Class.LowerCase+import           Data.Digit.Class.UpperCase++-- $setup+-- >>> import Text.Parsec(parse, ParseError, eof)+-- >>> import Data.Void(Void)+-- >>> import Data.Digit+-- >>> import Papa++type DAa a =+  (DA a, Da a)++type DBb a =+  (DB a, Db a)++type DCc a =+  (DC a, Dc a)++type DDd a =+  (DD a, Dd a)++type DEe a =+  (DE a, De a)++type DFf a =+  (DF a, Df a)++-- |+--+-- >>> parse (parseAa <* eof) "test" "A" :: Either ParseError HeXDigit+-- Right HeXDigitA+--+-- >>> parse parseAa "test" "Axyz" :: Either ParseError HeXDigit+-- Right HeXDigitA+--+-- >>> parse (parseAa <* eof) "test" "a" :: Either ParseError HeXDigit+-- Right HeXDigita+--+-- >>> parse parseAa "test" "axyz" :: Either ParseError HeXDigit+-- Right HeXDigita+--+-- >>> isn't _Right (parse parseAa "test" "xyz" :: Either ParseError HeXDigit)+-- True+parseAa ::+  (DAa d, CharParsing p) =>+  p d+parseAa =+  choice [parseA, parsea] <?> "Aa"++-- |+--+-- >>> parse (parseBb <* eof) "test" "B" :: Either ParseError HeXDigit+-- Right HeXDigitB+--+-- >>> parse parseBb "test" "Bxyz" :: Either ParseError HeXDigit+-- Right HeXDigitB+--+-- >>> parse (parseBb <* eof) "test" "b" :: Either ParseError HeXDigit+-- Right HeXDigitb+--+-- >>> parse parseBb "test" "bxyz" :: Either ParseError HeXDigit+-- Right HeXDigitb+--+-- >>> isn't _Right (parse parseBb "test" "xyz" :: Either ParseError HeXDigit)+-- True+parseBb ::+  (DBb d, CharParsing p) =>+  p d+parseBb =+  choice [parseB, parseb] <?> "Bb"++-- |+--+-- >>> parse (parseCc <* eof) "test" "C" :: Either ParseError HeXDigit+-- Right HeXDigitC+--+-- >>> parse parseCc "test" "Cxyz" :: Either ParseError HeXDigit+-- Right HeXDigitC+--+-- >>> parse (parseCc <* eof) "test" "c" :: Either ParseError HeXDigit+-- Right HeXDigitc+--+-- >>> parse parseCc "test" "cxyz" :: Either ParseError HeXDigit+-- Right HeXDigitc+--+-- >>> isn't _Right (parse parseCc "test" "xyz" :: Either ParseError HeXDigit)+-- True+parseCc ::+  (DCc d, CharParsing p) =>+  p d+parseCc =+  choice [parseC, parsec] <?> "Cc"+++-- |+--+-- >>> parse (parseDd <* eof) "test" "D" :: Either ParseError HeXDigit+-- Right HeXDigitD+--+-- >>> parse parseDd "test" "Dxyz" :: Either ParseError HeXDigit+-- Right HeXDigitD+--+-- >>> parse (parseDd <* eof) "test" "d" :: Either ParseError HeXDigit+-- Right HeXDigitd+--+-- >>> parse parseDd "test" "dxyz" :: Either ParseError HeXDigit+-- Right HeXDigitd+--+-- >>> isn't _Right (parse parseDd "test" "xyz" :: Either ParseError HeXDigit)+-- True+parseDd ::+  (DDd d, CharParsing p) =>+  p d+parseDd =+  choice [parseD, parsed] <?> "Dd"++-- |+--+-- >>> parse (parseEe <* eof) "test" "E" :: Either ParseError HeXDigit+-- Right HeXDigitE+--+-- >>> parse parseEe "test" "Exyz" :: Either ParseError HeXDigit+-- Right HeXDigitE+--+-- >>> parse (parseEe <* eof) "test" "e" :: Either ParseError HeXDigit+-- Right HeXDigite+--+-- >>> parse parseEe "test" "exyz" :: Either ParseError HeXDigit+-- Right HeXDigite+--+-- >>> isn't _Right (parse parseEe "test" "xyz" :: Either ParseError HeXDigit)+-- True+parseEe ::+  (DEe d, CharParsing p) =>+  p d+parseEe =+  choice [parseE, parsee] <?> "Ee"++-- |+--+-- >>> parse (parseFf <* eof) "test" "F" :: Either ParseError HeXDigit+-- Right HeXDigitF+--+-- >>> parse parseFf "test" "Fxyz" :: Either ParseError HeXDigit+-- Right HeXDigitF+--+-- >>> parse (parseFf <* eof) "test" "f" :: Either ParseError HeXDigit+-- Right HeXDigitf+--+-- >>> parse parseFf "test" "fxyz" :: Either ParseError HeXDigit+-- Right HeXDigitf+--+-- >>> isn't _Right (parse parseFf "test" "xyz" :: Either ParseError HeXDigit)+-- True+parseFf ::+  (DFf d, CharParsing p) =>+  p d+parseFf =+  choice [parseF, parsef] <?> "Ff"

@@ -0,0 +1,213 @@+{-# LANGUAGE NoImplicitPrelude #-}++module Data.Digit.Class.UpperCase+  (+    -- * Classes+    DA(..)+  , DB(..)+  , DC(..)+  , DD(..)+  , DE(..)+  , DF(..)++    -- * Parsers+  , parseA+  , parseB+  , parseC+  , parseD+  , parseE+  , parseF+  ) where++import           Control.Category        (id)+import           Control.Lens            (Prism', ( # ))++import           Data.Functor            ((<$))++import           Text.Parser.Char        (CharParsing, char)+import           Text.Parser.Combinators ((<?>))++-- $setup+-- >>> import Data.Digit+-- >>> import Text.Parsec(parse, ParseError, eof)+-- >>> import Data.Void(Void)++class DA d where+  dA ::+    Prism'+      d+      ()+  xA ::+    d+  xA =+    dA # ()++instance DA () where+  dA =+    id++class DB d where+  dB ::+    Prism'+      d+      ()+  xB ::+    d+  xB =+    dB # ()++instance DB () where+  dB =+    id++class DC d where+  dC ::+    Prism'+      d+      ()+  xC ::+    d+  xC =+    dC # ()++instance DC () where+  dC =+    id++class DD d where+  dD ::+    Prism'+      d+      ()+  xD ::+    d+  xD =+    dD # ()++instance DD () where+  dD =+    id++class DE d where+  dE ::+    Prism'+      d+      ()+  xE ::+    d+  xE =+    dE # ()++instance DE () where+  dE =+    id++class DF d where+  dF ::+    Prism'+      d+      ()+  xF ::+    d+  xF =+    dF # ()++instance DF () where+  dF =+    id++-- |+--+-- >>> parse (parseA <* eof) "test" "A" :: Either ParseError HEXDigit+-- Right HEXDigitA+--+-- >>> parse parseA "test" "Axyz" :: Either ParseError HEXDigit+-- Right HEXDigitA+--+-- >>> isn't _Right (parse parseA "test" "xyz" :: Either ParseError HEXDigit)+-- True+parseA ::+  (DA d, CharParsing p) =>+  p d+parseA =+  xA <$ char 'A' <?> "A"++-- |+--+-- >>> parse (parseB <* eof) "test" "B" :: Either ParseError HEXDigit+-- Right HEXDigitB+--+-- >>> parse parseB "test" "Bxyz" :: Either ParseError HEXDigit+-- Right HEXDigitB+--+-- >>> isn't _Right (parse parseB "test" "xyz" :: Either ParseError HEXDigit)+-- True+parseB ::+  (DB d, CharParsing p) =>+  p d+parseB =+  xB <$ char 'B' <?> "B"++-- |+--+-- >>> parse (parseC <* eof) "test" "C" :: Either ParseError HEXDigit+-- Right HEXDigitC+--+-- >>> parse parseC "test" "Cxyz" :: Either ParseError HEXDigit+-- Right HEXDigitC+--+-- >>> isn't _Right (parse parseC "test" "xyz" :: Either ParseError HEXDigit)+-- True+parseC ::+  (DC d, CharParsing p) =>+  p d+parseC =+  xC <$ char 'C' <?> "C"++-- |+--+-- >>> parse (parseD <* eof) "test" "D" :: Either ParseError HEXDigit+-- Right HEXDigitD+--+-- >>> parse parseD "test" "Dxyz" :: Either ParseError HEXDigit+-- Right HEXDigitD+--+-- >>> isn't _Right (parse parseD "test" "xyz" :: Either ParseError HEXDigit)+-- True+parseD ::+  (DD d, CharParsing p) =>+  p d+parseD =+  xD <$ char 'D' <?> "D"++-- |+--+-- >>> parse (parseE <* eof) "test" "E" :: Either ParseError HEXDigit+-- Right HEXDigitE+--+-- >>> parse parseE "test" "Exyz" :: Either ParseError HEXDigit+-- Right HEXDigitE+--+-- >>> isn't _Right (parse parseE "test" "xyz" :: Either ParseError HEXDigit)+-- True+parseE ::+  (DE d, CharParsing p) =>+  p d+parseE =+  xE <$ char 'E' <?> "E"++-- |+--+-- >>> parse (parseF <* eof) "test" "F" :: Either ParseError HEXDigit+-- Right HEXDigitF+--+-- >>> parse parseF "test" "Fxyz" :: Either ParseError HEXDigit+-- Right HEXDigitF+--+-- >>> isn't _Right (parse parseF "test" "xyz" :: Either ParseError HEXDigit)+-- True+parseF ::+  (DF d, CharParsing p) =>+  p d+parseF =+  xF <$ char 'F' <?> "F"

@@ -1,46 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE FlexibleInstances #-}--module Data.Digit.D0(-  D0(..)-, parse0-) where-  -import Papa-import Text.Parser.Char(CharParsing, char)-import Text.Parser.Combinators((<?>))---- $setup--- >>> import Data.Digit--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--class D0 d where-  d0 ::-    Prism'-      d-      ()-  x0 ::-    d-  x0 =-    d0 # ()--instance D0 () where-  d0 =-    id---- |------ >>> parse (parse0 <* eof) "test" "0" :: Either ParseError BinDigit--- Right BinDigit0------ >>> parse parse0 "test" "0xyz" :: Either ParseError BinDigit--- Right BinDigit0------ >>> isn't _Right (parse parse0 "test" "xyz" :: Either ParseError BinDigit)--- True-parse0 ::-  (D0 d, CharParsing p) =>-  p d-parse0 =-  x0 <$ char '0' <?> "0"

@@ -1,45 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.D1(-  D1(..)-, parse1-) where--import Papa-import Text.Parser.Char(CharParsing, char)-import Text.Parser.Combinators((<?>))---- $setup--- >>> import Data.Digit--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--class D1 d where-  d1 ::-    Prism'-      d-      ()-  x1 ::-    d-  x1 =-    d1 # ()--instance D1 () where-  d1 =-    id---- |------ >>> parse (parse1 <* eof) "test" "1" :: Either ParseError BinDigit--- Right BinDigit1------ >>> parse parse1 "test" "1xyz" :: Either ParseError BinDigit--- Right BinDigit1------ >>> isn't _Right (parse parse1 "test" "xyz" :: Either ParseError BinDigit)--- True-parse1 ::-  (D1 d, CharParsing p) =>-  p d-parse1 =-  x1 <$ char '1' <?> "1"

@@ -1,45 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.D2(-  D2(..)-, parse2-) where--import Papa-import Text.Parser.Char(CharParsing, char)-import Text.Parser.Combinators((<?>))---- $setup--- >>> import Data.Digit--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--class D2 d where-  d2 ::-    Prism'-      d-      ()-  x2 ::-    d-  x2 =-    d2 # ()--instance D2 () where-  d2 =-    id-    --- |------ >>> parse (parse2 <* eof) "test" "2" :: Either ParseError DecDigit--- Right DecDigit2------ >>> parse parse2 "test" "2xyz" :: Either ParseError DecDigit--- Right DecDigit2------ >>> isn't _Right (parse parse2 "test" "xyz" :: Either ParseError DecDigit)--- True-parse2 ::-  (D2 d, CharParsing p) =>-  p d-parse2 =-  x2 <$ char '2' <?> "2"

@@ -1,45 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.D3(-  D3(..)-, parse3-) where--import Papa-import Text.Parser.Char(CharParsing, char)-import Text.Parser.Combinators((<?>))---- $setup--- >>> import Data.Digit--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--class D3 d where-  d3 ::-    Prism'-      d-      ()-  x3 ::-    d-  x3 =-    d3 # ()--instance D3 () where-  d3 =-    id---- |------ >>> parse (parse3 <* eof) "test" "3" :: Either ParseError DecDigit--- Right DecDigit3------ >>> parse parse3 "test" "3xyz" :: Either ParseError DecDigit--- Right DecDigit3------ >>> isn't _Right (parse parse3 "test" "xyz" :: Either ParseError DecDigit)--- True-parse3 ::-  (D3 d, CharParsing p) =>-  p d-parse3 =-  x3 <$ char '3' <?> "3"

@@ -1,45 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.D4(-  D4(..)-, parse4-) where--import Papa-import Text.Parser.Char(CharParsing, char)-import Text.Parser.Combinators((<?>))---- $setup--- >>> import Data.Digit--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--class D4 d where-  d4 ::-    Prism'-      d-      ()-  x4 ::-    d-  x4 =-    d4 # ()--instance D4 () where-  d4 =-    id-   --- |------ >>> parse (parse4 <* eof) "test" "4" :: Either ParseError DecDigit--- Right DecDigit4------ >>> parse parse4 "test" "4xyz" :: Either ParseError DecDigit--- Right DecDigit4------ >>> isn't _Right (parse parse4 "test" "xyz" :: Either ParseError DecDigit)--- True-parse4 ::-  (D4 d, CharParsing p) =>-  p d-parse4 =-  x4 <$ char '4' <?> "4"

@@ -1,45 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.D5(-  D5(..)-, parse5-) where--import Papa-import Text.Parser.Char(CharParsing, char)-import Text.Parser.Combinators((<?>))---- $setup--- >>> import Data.Digit--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--class D5 d where-  d5 ::-    Prism'-      d-      ()-  x5 ::-    d-  x5 =-    d5 # ()--instance D5 () where-  d5 =-    id-    --- |------ >>> parse (parse5 <* eof) "test" "5" :: Either ParseError DecDigit--- Right DecDigit5------ >>> parse parse5 "test" "5xyz" :: Either ParseError DecDigit--- Right DecDigit5------ >>> isn't _Right (parse parse5 "test" "xyz" :: Either ParseError DecDigit)--- True-parse5 ::-  (D5 d, CharParsing p) =>-  p d-parse5 =-  x5 <$ char '5' <?> "5"

@@ -1,45 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.D6(-  D6(..)-, parse6-) where--import Papa-import Text.Parser.Char(CharParsing, char)-import Text.Parser.Combinators((<?>))---- $setup--- >>> import Data.Digit--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--class D6 d where-  d6 ::-    Prism'-      d-      ()-  x6 ::-    d-  x6 =-    d6 # ()--instance D6 () where-  d6 =-    id-    --- |------ >>> parse (parse6 <* eof) "test" "6" :: Either ParseError DecDigit--- Right DecDigit6------ >>> parse parse6 "test" "6xyz" :: Either ParseError DecDigit--- Right DecDigit6------ >>> isn't _Right (parse parse6 "test" "xyz" :: Either ParseError DecDigit)--- True-parse6 ::-  (D6 d, CharParsing p) =>-  p d-parse6 =-  x6 <$ char '6' <?> "6"

@@ -1,45 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.D7(-  D7(..)-, parse7-) where--import Papa-import Text.Parser.Char(CharParsing, char)-import Text.Parser.Combinators((<?>))---- $setup--- >>> import Data.Digit--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--class D7 d where-  d7 ::-    Prism'-      d-      ()-  x7 ::-    d-  x7 =-    d7 # ()--instance D7 () where-  d7 =-    id-    --- |------ >>> parse (parse7 <* eof) "test" "7" :: Either ParseError DecDigit--- Right DecDigit7------ >>> parse parse7 "test" "7xyz" :: Either ParseError DecDigit--- Right DecDigit7------ >>> isn't _Right (parse parse7 "test" "xyz" :: Either ParseError DecDigit)--- True-parse7 ::-  (D7 d, CharParsing p) =>-  p d-parse7 =-  x7 <$ char '7' <?> "7"

@@ -1,45 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.D8(-  D8(..)-, parse8-) where--import Papa-import Text.Parser.Char(CharParsing, char)-import Text.Parser.Combinators((<?>))---- $setup--- >>> import Data.Digit--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--class D8 d where-  d8 ::-    Prism'-      d-      ()-  x8 ::-    d-  x8 =-    d8 # ()--instance D8 () where-  d8 =-    id-    --- |------ >>> parse (parse8 <* eof) "test" "8" :: Either ParseError DecDigit--- Right DecDigit8------ >>> parse parse8 "test" "8xyz" :: Either ParseError DecDigit--- Right DecDigit8------ >>> isn't _Right (parse parse8 "test" "xyz" :: Either ParseError DecDigit)--- True-parse8 ::-  (D8 d, CharParsing p) =>-  p d-parse8 =-  x8 <$ char '8' <?> "8"

@@ -1,45 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.D9(-  D9(..)-, parse9-) where--import Papa-import Text.Parser.Char(CharParsing, char)-import Text.Parser.Combinators((<?>))---- $setup--- >>> import Data.Digit--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--class D9 d where-  d9 ::-    Prism'-      d-      ()-  x9 ::-    d-  x9 =-    d9 # ()--instance D9 () where-  d9 =-    id-    --- |------ >>> parse (parse9 <* eof) "test" "9" :: Either ParseError DecDigit--- Right DecDigit9------ >>> parse parse9 "test" "9xyz" :: Either ParseError DecDigit--- Right DecDigit9------ >>> isn't _Right (parse parse9 "test" "xyz" :: Either ParseError DecDigit)--- True-parse9 ::-  (D9 d, CharParsing p) =>-  p d-parse9 =-  x9 <$ char '9' <?> "9"

@@ -1,45 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.DA(-  DA(..)-, parseA-) where--import Papa-import Text.Parser.Char(CharParsing, char)-import Text.Parser.Combinators((<?>))---- $setup--- >>> import Data.Digit--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--class DA d where-  dA ::-    Prism'-      d-      ()-  xA ::-    d-  xA =-    dA # ()--instance DA () where-  dA =-    id---- |------ >>> parse (parseA <* eof) "test" "A" :: Either ParseError HEXDigit--- Right HEXDigitA------ >>> parse parseA "test" "Axyz" :: Either ParseError HEXDigit--- Right HEXDigitA------ >>> isn't _Right (parse parseA "test" "xyz" :: Either ParseError HEXDigit)--- True-parseA ::-  (DA d, CharParsing p) =>-  p d-parseA =-  xA <$ char 'A' <?> "A"

@@ -1,48 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE ConstraintKinds #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE MultiParamTypeClasses #-}--module Data.Digit.DAa(-  module Data.Digit.DA-, module Data.Digit.Da-, DAa-, parseAa-) where--import Text.Parser.Char(CharParsing)-import Text.Parser.Combinators((<?>), choice)-import Data.Digit.DA-import Data.Digit.Da---- $setup--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--- >>> import Data.Digit--- >>> import Papa--type DAa a =-  (DA a, Da a)-  --- |------ >>> parse (parseAa <* eof) "test" "A" :: Either ParseError HeXDigit--- Right HeXDigitA------ >>> parse parseAa "test" "Axyz" :: Either ParseError HeXDigit--- Right HeXDigitA------ >>> parse (parseAa <* eof) "test" "a" :: Either ParseError HeXDigit--- Right HeXDigita------ >>> parse parseAa "test" "axyz" :: Either ParseError HeXDigit--- Right HeXDigita------ >>> isn't _Right (parse parseAa "test" "xyz" :: Either ParseError HeXDigit)--- True-parseAa ::-  (DAa d, CharParsing p) =>-  p d-parseAa =-  choice [parseA, parsea] <?> "Aa"

@@ -1,45 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.DB(-  DB(..)-, parseB-) where--import Papa-import Text.Parser.Char(CharParsing, char)-import Text.Parser.Combinators((<?>))---- $setup--- >>> import Data.Digit--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--class DB d where-  dB ::-    Prism'-      d-      ()-  xB ::-    d-  xB =-    dB # ()--instance DB () where-  dB =-    id-    --- |------ >>> parse (parseB <* eof) "test" "B" :: Either ParseError HEXDigit--- Right HEXDigitB------ >>> parse parseB "test" "Bxyz" :: Either ParseError HEXDigit--- Right HEXDigitB------ >>> isn't _Right (parse parseB "test" "xyz" :: Either ParseError HEXDigit)--- True-parseB ::-  (DB d, CharParsing p) =>-  p d-parseB =-  xB <$ char 'B' <?> "B"

@@ -1,45 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE ConstraintKinds #-}--module Data.Digit.DBb(-  module Data.Digit.DB-, module Data.Digit.Db-, DBb-, parseBb-) where--import Text.Parser.Char(CharParsing)-import Text.Parser.Combinators((<?>), choice)-import Data.Digit.DB-import Data.Digit.Db---- $setup--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--- >>> import Data.Digit--- >>> import Papa--type DBb a =-  (DB a, Db a)-  --- |------ >>> parse (parseBb <* eof) "test" "B" :: Either ParseError HeXDigit--- Right HeXDigitB------ >>> parse parseBb "test" "Bxyz" :: Either ParseError HeXDigit--- Right HeXDigitB------ >>> parse (parseBb <* eof) "test" "b" :: Either ParseError HeXDigit--- Right HeXDigitb------ >>> parse parseBb "test" "bxyz" :: Either ParseError HeXDigit--- Right HeXDigitb------ >>> isn't _Right (parse parseBb "test" "xyz" :: Either ParseError HeXDigit)--- True-parseBb ::-  (DBb d, CharParsing p) =>-  p d-parseBb =-  choice [parseB, parseb] <?> "Bb"

@@ -1,45 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.DC(-  DC(..)-, parseC-) where--import Papa-import Text.Parser.Char(CharParsing, char)-import Text.Parser.Combinators((<?>))---- $setup--- >>> import Data.Digit--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--class DC d where-  dC ::-    Prism'-      d-      ()-  xC ::-    d-  xC =-    dC # ()--instance DC () where-  dC =-    id-    --- |------ >>> parse (parseC <* eof) "test" "C" :: Either ParseError HEXDigit--- Right HEXDigitC------ >>> parse parseC "test" "Cxyz" :: Either ParseError HEXDigit--- Right HEXDigitC------ >>> isn't _Right (parse parseC "test" "xyz" :: Either ParseError HEXDigit)--- True-parseC ::-  (DC d, CharParsing p) =>-  p d-parseC =-  xC <$ char 'C' <?> "C"

@@ -1,45 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE ConstraintKinds #-}--module Data.Digit.DCc(-  module Data.Digit.DC-, module Data.Digit.Dc-, DCc-, parseCc-) where--import Text.Parser.Char(CharParsing)-import Text.Parser.Combinators((<?>), choice)-import Data.Digit.DC-import Data.Digit.Dc---- $setup--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--- >>> import Data.Digit--- >>> import Papa--type DCc a =-  (DC a, Dc a)-  --- |------ >>> parse (parseCc <* eof) "test" "C" :: Either ParseError HeXDigit--- Right HeXDigitC------ >>> parse parseCc "test" "Cxyz" :: Either ParseError HeXDigit--- Right HeXDigitC------ >>> parse (parseCc <* eof) "test" "c" :: Either ParseError HeXDigit--- Right HeXDigitc------ >>> parse parseCc "test" "cxyz" :: Either ParseError HeXDigit--- Right HeXDigitc------ >>> isn't _Right (parse parseCc "test" "xyz" :: Either ParseError HeXDigit)--- True-parseCc ::-  (DCc d, CharParsing p) =>-  p d-parseCc =-  choice [parseC, parsec] <?> "Cc"

@@ -1,45 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.DD(-  DD(..)-, parseD-) where--import Papa-import Text.Parser.Char(CharParsing, char)-import Text.Parser.Combinators((<?>))---- $setup--- >>> import Data.Digit--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--class DD d where-  dD ::-    Prism'-      d-      ()-  xD ::-    d-  xD =-    dD # ()--instance DD () where-  dD =-    id-    --- |------ >>> parse (parseD <* eof) "test" "D" :: Either ParseError HEXDigit--- Right HEXDigitD------ >>> parse parseD "test" "Dxyz" :: Either ParseError HEXDigit--- Right HEXDigitD------ >>> isn't _Right (parse parseD "test" "xyz" :: Either ParseError HEXDigit)--- True-parseD ::-  (DD d, CharParsing p) =>-  p d-parseD =-  xD <$ char 'D' <?> "D"

@@ -1,45 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE ConstraintKinds #-}--module Data.Digit.DDd(-  module Data.Digit.DD-, module Data.Digit.Dd-, DDd-, parseDd-) where--import Text.Parser.Char(CharParsing)-import Text.Parser.Combinators((<?>), choice)-import Data.Digit.DD-import Data.Digit.Dd---- $setup--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--- >>> import Data.Digit--- >>> import Papa--type DDd a =-  (DD a, Dd a)-  --- |------ >>> parse (parseDd <* eof) "test" "D" :: Either ParseError HeXDigit--- Right HeXDigitD------ >>> parse parseDd "test" "Dxyz" :: Either ParseError HeXDigit--- Right HeXDigitD------ >>> parse (parseDd <* eof) "test" "d" :: Either ParseError HeXDigit--- Right HeXDigitd------ >>> parse parseDd "test" "dxyz" :: Either ParseError HeXDigit--- Right HeXDigitd------ >>> isn't _Right (parse parseDd "test" "xyz" :: Either ParseError HeXDigit)--- True-parseDd ::-  (DDd d, CharParsing p) =>-  p d-parseDd =-  choice [parseD, parsed] <?> "Dd"

@@ -1,45 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.DE(-  DE(..)-, parseE-) where--import Papa-import Text.Parser.Char(CharParsing, char)-import Text.Parser.Combinators((<?>))---- $setup--- >>> import Data.Digit--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--class DE d where-  dE ::-    Prism'-      d-      ()-  xE ::-    d-  xE =-    dE # ()--instance DE () where-  dE =-    id-    --- |------ >>> parse (parseE <* eof) "test" "E" :: Either ParseError HEXDigit--- Right HEXDigitE------ >>> parse parseE "test" "Exyz" :: Either ParseError HEXDigit--- Right HEXDigitE------ >>> isn't _Right (parse parseE "test" "xyz" :: Either ParseError HEXDigit)--- True-parseE ::-  (DE d, CharParsing p) =>-  p d-parseE =-  xE <$ char 'E' <?> "E"

@@ -1,45 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE ConstraintKinds #-}--module Data.Digit.DEe(-  module Data.Digit.DE-, module Data.Digit.De-, DEe-, parseEe-) where--import Text.Parser.Char(CharParsing)-import Text.Parser.Combinators((<?>), choice)-import Data.Digit.DE-import Data.Digit.De---- $setup--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--- >>> import Data.Digit.Digit--- >>> import Papa--type DEe a =-  (DE a, De a)-  --- |------ >>> parse (parseEe <* eof) "test" "E" :: Either ParseError HeXDigit--- Right HeXDigitE------ >>> parse parseEe "test" "Exyz" :: Either ParseError HeXDigit--- Right HeXDigitE------ >>> parse (parseEe <* eof) "test" "e" :: Either ParseError HeXDigit--- Right HeXDigite------ >>> parse parseEe "test" "exyz" :: Either ParseError HeXDigit--- Right HeXDigite------ >>> isn't _Right (parse parseEe "test" "xyz" :: Either ParseError HeXDigit)--- True-parseEe ::-  (DEe d, CharParsing p) =>-  p d-parseEe =-  choice [parseE, parsee] <?> "Ee"

@@ -1,45 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.DF(-  DF(..)-, parseF-) where--import Papa-import Text.Parser.Char(CharParsing, char)-import Text.Parser.Combinators((<?>))---- $setup--- >>> import Data.Digit--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--class DF d where-  dF ::-    Prism'-      d-      ()-  xF ::-    d-  xF =-    dF # ()--instance DF () where-  dF =-    id-    --- |------ >>> parse (parseF <* eof) "test" "F" :: Either ParseError HEXDigit--- Right HEXDigitF------ >>> parse parseF "test" "Fxyz" :: Either ParseError HEXDigit--- Right HEXDigitF------ >>> isn't _Right (parse parseF "test" "xyz" :: Either ParseError HEXDigit)--- True-parseF ::-  (DF d, CharParsing p) =>-  p d-parseF =-  xF <$ char 'F' <?> "F"

@@ -1,45 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE ConstraintKinds #-}--module Data.Digit.DFf(-  module Data.Digit.DF-, module Data.Digit.Df-, DFf-, parseFf-) where--import Text.Parser.Char(CharParsing)-import Text.Parser.Combinators((<?>), choice)-import Data.Digit.DF-import Data.Digit.Df---- $setup--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--- >>> import Data.Digit--- >>> import Papa--type DFf a =-  (DF a, Df a)-  --- |------ >>> parse (parseFf <* eof) "test" "F" :: Either ParseError HeXDigit--- Right HeXDigitF------ >>> parse parseFf "test" "Fxyz" :: Either ParseError HeXDigit--- Right HeXDigitF------ >>> parse (parseFf <* eof) "test" "f" :: Either ParseError HeXDigit--- Right HeXDigitf------ >>> parse parseFf "test" "fxyz" :: Either ParseError HeXDigit--- Right HeXDigitf------ >>> isn't _Right (parse parseFf "test" "xyz" :: Either ParseError HeXDigit)--- True-parseFf ::-  (DFf d, CharParsing p) =>-  p d-parseFf =-  choice [parseF, parsef] <?> "Ff"

@@ -1,45 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.Da(-  Da(..)-, parsea-) where--import Papa-import Text.Parser.Char(CharParsing, char)-import Text.Parser.Combinators((<?>))---- $setup--- >>> import Data.Digit--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--class Da d where-  da ::-    Prism'-      d-      ()-  xa ::-    d-  xa =-    da # ()--instance Da () where-  da =-    id-    --- |------ >>> parse (parsea <* eof) "test" "a" :: Either ParseError HexDigit--- Right HexDigita------ >>> parse parsea "test" "axyz" :: Either ParseError HexDigit--- Right HexDigita------ >>> isn't _Right (parse parsea "test" "xyz" :: Either ParseError HexDigit)--- True-parsea ::-  (Da d, CharParsing p) =>-  p d-parsea =-  xa <$ char 'a' <?> "a"

@@ -1,45 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.Db(-  Db(..)-, parseb-) where--import Papa-import Text.Parser.Char(CharParsing, char)-import Text.Parser.Combinators((<?>))---- $setup--- >>> import Data.Digit--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--class Db d where-  db ::-    Prism'-      d-      ()-  xb ::-    d-  xb =-    db # ()--instance Db () where-  db =-    id-    --- |------ >>> parse (parseb <* eof) "test" "b" :: Either ParseError HexDigit--- Right HexDigitb------ >>> parse parseb "test" "bxyz" :: Either ParseError HexDigit--- Right HexDigitb------ >>> isn't _Right (parse parseb "test" "xyz" :: Either ParseError HexDigit)--- True-parseb ::-  (Db d, CharParsing p) =>-  p d-parseb =-  xb <$ char 'b' <?> "b"

@@ -1,45 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.Dc(-  Dc(..)-, parsec-) where--import Papa-import Text.Parser.Char(CharParsing, char)-import Text.Parser.Combinators((<?>))---- $setup--- >>> import Data.Digit--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--class Dc d where-  dc ::-    Prism'-      d-      ()-  xc ::-    d-  xc =-    dc # ()--instance Dc () where-  dc =-    id-   --- |------ >>> parse (parsec <* eof) "test" "c" :: Either ParseError HexDigit--- Right HexDigitc------ >>> parse parsec "test" "cxyz" :: Either ParseError HexDigit--- Right HexDigitc------ >>> isn't _Right (parse parsec "test" "xyz" :: Either ParseError HexDigit)--- True-parsec ::-  (Dc d, CharParsing p) =>-  p d-parsec =-  xc <$ char 'c' <?> "c"

@@ -1,45 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.Dd(-  Dd(..)-, parsed-) where--import Papa-import Text.Parser.Char(CharParsing, char)-import Text.Parser.Combinators((<?>))---- $setup--- >>> import Data.Digit--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--class Dd d where-  dd ::-    Prism'-      d-      ()-  xd ::-    d-  xd =-    dd # ()--instance Dd () where-  dd =-    id-    --- |------ >>> parse (parsed <* eof) "test" "d" :: Either ParseError HexDigit--- Right HexDigitd------ >>> parse parsed "test" "dxyz" :: Either ParseError HexDigit--- Right HexDigitd------ >>> isn't _Right (parse parsed "test" "xyz" :: Either ParseError HexDigit)--- True-parsed ::-  (Dd d, CharParsing p) =>-  p d-parsed =-  xd <$ char 'd' <?> "d"

@@ -1,45 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.De(-  De(..)-, parsee-) where--import Papa-import Text.Parser.Char(CharParsing, char)-import Text.Parser.Combinators((<?>))---- $setup--- >>> import Data.Digit--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--class De d where-  de ::-    Prism'-      d-      ()-  xe ::-    d-  xe =-    de # ()--instance De () where-  de =-    id-    --- |------ >>> parse (parsee <* eof) "test" "e" :: Either ParseError HexDigit--- Right HexDigite------ >>> parse parsee "test" "exyz" :: Either ParseError HexDigit--- Right HexDigite------ >>> isn't _Right (parse parsee "test" "xyz" :: Either ParseError HexDigit)--- True-parsee ::-  (De d, CharParsing p) =>-  p d-parsee =-  xe <$ char 'e' <?> "e"

@@ -20,32 +20,33 @@ , _DecDigit8 , _DecDigit9 -- * Re-exports-, module Data.Digit.D0-, module Data.Digit.D1-, module Data.Digit.D2-, module Data.Digit.D3-, module Data.Digit.D4-, module Data.Digit.D5-, module Data.Digit.D6-, module Data.Digit.D7-, module Data.Digit.D8-, module Data.Digit.D9+, module Data.Digit.Class.D0+, module Data.Digit.Class.D1+, module Data.Digit.Class.D2+, module Data.Digit.Class.D3+, module Data.Digit.Class.D4+, module Data.Digit.Class.D5+, module Data.Digit.Class.D6+, module Data.Digit.Class.D7+, module Data.Digit.Class.D8+, module Data.Digit.Class.D9 ) where  import Prelude (Eq, Show, Ord, Enum, Bounded) import Control.Lens.TH (makePrisms) import Text.Parser.Char(CharParsing) import Text.Parser.Combinators((<?>), choice)-import Data.Digit.D0-import Data.Digit.D1-import Data.Digit.D2-import Data.Digit.D3-import Data.Digit.D4-import Data.Digit.D5-import Data.Digit.D6-import Data.Digit.D7-import Data.Digit.D8-import Data.Digit.D9++import Data.Digit.Class.D0+import Data.Digit.Class.D1+import Data.Digit.Class.D2+import Data.Digit.Class.D3+import Data.Digit.Class.D4+import Data.Digit.Class.D5+import Data.Digit.Class.D6+import Data.Digit.Class.D7+import Data.Digit.Class.D8+import Data.Digit.Class.D9  data DecDigit   = DecDigit0

@@ -1,45 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.Df(-  Df(..)-, parsef-) where--import Papa-import Text.Parser.Char(CharParsing, char)-import Text.Parser.Combinators((<?>))---- $setup--- >>> import Data.Digit--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--class Df d where-  df ::-    Prism'-      d-      ()-  xf ::-    d-  xf =-    df # ()--instance Df () where-  df =-    id-    --- |------ >>> parse (parsef <* eof) "test" "f" :: Either ParseError HexDigit--- Right HexDigitf------ >>> parse parsef "test" "fxyz" :: Either ParseError HexDigit--- Right HexDigitf------ >>> isn't _Right (parse parsef "test" "xyz" :: Either ParseError HexDigit)--- True-parsef ::-  (Df d, CharParsing p) =>-  p d-parsef =-  xf <$ char 'f' <?> "f"

@@ -20,8 +20,8 @@ import Control.Lens.Review ((#)) import Data.Digit.Binary import Data.Digit.Decimal-import Data.Digit.Hexadecimal-import Data.Digit.HEXADECIMAL+import Data.Digit.Hexadecimal.LowerCase+import Data.Digit.Hexadecimal.UpperCase import Data.Digit.Octal  -- | @[1]@

@@ -1,136 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE ConstraintKinds #-}-{-# LANGUAGE TemplateHaskell #-}--module Data.Digit.HEXADECIMAL(-  HEXDigit(..)-, HEXADECIMALNoZero-, HEXADECIMAL-, parseHEXADECIMALNoZero-, parseHEXADECIMAL--- * Prisms-, _HEXDigit0-, _HEXDigit1-, _HEXDigit2-, _HEXDigit3-, _HEXDigit4-, _HEXDigit5-, _HEXDigit6-, _HEXDigit7-, _HEXDigit8-, _HEXDigit9-, _HEXDigitA-, _HEXDigitB-, _HEXDigitC-, _HEXDigitD-, _HEXDigitE-, _HEXDigitF--- * Re-exports-, module Data.Digit.D0-, module Data.Digit.D1-, module Data.Digit.D2-, module Data.Digit.D3-, module Data.Digit.D4-, module Data.Digit.D5-, module Data.Digit.D6-, module Data.Digit.D7-, module Data.Digit.D8-, module Data.Digit.D9-, module Data.Digit.DA-, module Data.Digit.DB-, module Data.Digit.DC-, module Data.Digit.DD-, module Data.Digit.DE-, module Data.Digit.DF-) where--import Prelude (Eq, Show, Ord)-import Control.Lens.TH (makePrisms)-import Text.Parser.Char(CharParsing)-import Text.Parser.Combinators((<?>), choice)-import Data.Digit.D0-import Data.Digit.D1-import Data.Digit.D2-import Data.Digit.D3-import Data.Digit.D4-import Data.Digit.D5-import Data.Digit.D6-import Data.Digit.D7-import Data.Digit.D8-import Data.Digit.D9-import Data.Digit.DA-import Data.Digit.DB-import Data.Digit.DC-import Data.Digit.DD-import Data.Digit.DE-import Data.Digit.DF-import Data.Digit.Decimal(parseDecimalNoZero)--data HEXDigit-  = HEXDigit0-  | HEXDigit1-  | HEXDigit2-  | HEXDigit3-  | HEXDigit4-  | HEXDigit5-  | HEXDigit6-  | HEXDigit7-  | HEXDigit8-  | HEXDigit9-  | HEXDigitA-  | HEXDigitB-  | HEXDigitC-  | HEXDigitD-  | HEXDigitE-  | HEXDigitF-  deriving (Show, Eq, Ord)--makePrisms ''HEXDigit--instance D0 HEXDigit where; d0 = _HEXDigit0-instance D1 HEXDigit where; d1 = _HEXDigit1-instance D2 HEXDigit where; d2 = _HEXDigit2-instance D3 HEXDigit where; d3 = _HEXDigit3-instance D4 HEXDigit where; d4 = _HEXDigit4-instance D5 HEXDigit where; d5 = _HEXDigit5-instance D6 HEXDigit where; d6 = _HEXDigit6-instance D7 HEXDigit where; d7 = _HEXDigit7-instance D8 HEXDigit where; d8 = _HEXDigit8-instance D9 HEXDigit where; d9 = _HEXDigit9-instance DA HEXDigit where; dA = _HEXDigitA-instance DB HEXDigit where; dB = _HEXDigitB-instance DC HEXDigit where; dC = _HEXDigitC-instance DD HEXDigit where; dD = _HEXDigitD-instance DE HEXDigit where; dE = _HEXDigitE-instance DF HEXDigit where; dF = _HEXDigitF--type HEXADECIMALNoZero d =-  (D1 d, D2 d, D3 d, D4 d, D5 d, D6 d, D7 d, D8 d, D9 d, DA d, DB d, DC d, DD d, DE d, DF d)--parseHEXADECIMALNoZero ::-  (HEXADECIMALNoZero d, CharParsing p) =>-  p d-parseHEXADECIMALNoZero =-  choice-    [-      parseDecimalNoZero-    , parseA-    , parseB-    , parseC-    , parseD-    , parseE-    , parseF-    ] <?> "HEXADECIMALNoZero"--type HEXADECIMAL d =-  (D0 d, HEXADECIMALNoZero d)--parseHEXADECIMAL ::-  (HEXADECIMAL d, CharParsing p) =>-  p d-parseHEXADECIMAL =-  choice-    [-      parse0-    , parseHEXADECIMALNoZero-    ] <?> "HEXADECIMAL"

@@ -1,154 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE ConstraintKinds #-}-{-# LANGUAGE TemplateHaskell #-}--module Data.Digit.HeXaDeCiMaL(-  HeXDigit(..)-, HeXaDeCiMaLNoZero-, HeXaDeCiMaL-, parseHeXaDeCiMaLNoZero-, parseHeXaDeCiMaL--- * Prisms-, _HeXDigit0-, _HeXDigit1-, _HeXDigit2-, _HeXDigit3-, _HeXDigit4-, _HeXDigit5-, _HeXDigit6-, _HeXDigit7-, _HeXDigit8-, _HeXDigit9-, _HeXDigita-, _HeXDigitb-, _HeXDigitc-, _HeXDigitd-, _HeXDigite-, _HeXDigitf-, _HeXDigitA-, _HeXDigitB-, _HeXDigitC-, _HeXDigitD-, _HeXDigitE-, _HeXDigitF--- * Re-exports-, module Data.Digit.D0-, module Data.Digit.D1-, module Data.Digit.D2-, module Data.Digit.D3-, module Data.Digit.D4-, module Data.Digit.D5-, module Data.Digit.D6-, module Data.Digit.D7-, module Data.Digit.D8-, module Data.Digit.D9-, module Data.Digit.DAa-, module Data.Digit.DBb-, module Data.Digit.DCc-, module Data.Digit.DDd-, module Data.Digit.DEe-, module Data.Digit.DFf-) where--import Prelude (Eq, Show, Ord)-import Control.Lens.TH (makePrisms)-import Text.Parser.Char(CharParsing)-import Text.Parser.Combinators((<?>), choice)-import Data.Digit.D0-import Data.Digit.D1-import Data.Digit.D2-import Data.Digit.D3-import Data.Digit.D4-import Data.Digit.D5-import Data.Digit.D6-import Data.Digit.D7-import Data.Digit.D8-import Data.Digit.D9-import Data.Digit.Decimal(parseDecimalNoZero)-import Data.Digit.DAa-import Data.Digit.DBb-import Data.Digit.DCc-import Data.Digit.DDd-import Data.Digit.DEe-import Data.Digit.DFf--data HeXDigit-  = HeXDigit0-  | HeXDigit1-  | HeXDigit2-  | HeXDigit3-  | HeXDigit4-  | HeXDigit5-  | HeXDigit6-  | HeXDigit7-  | HeXDigit8-  | HeXDigit9-  | HeXDigita-  | HeXDigitb-  | HeXDigitc-  | HeXDigitd-  | HeXDigite-  | HeXDigitf-  | HeXDigitA-  | HeXDigitB-  | HeXDigitC-  | HeXDigitD-  | HeXDigitE-  | HeXDigitF-  deriving (Show, Eq, Ord)--makePrisms ''HeXDigit--instance D0 HeXDigit where; d0 = _HeXDigit0-instance D1 HeXDigit where; d1 = _HeXDigit1-instance D2 HeXDigit where; d2 = _HeXDigit2-instance D3 HeXDigit where; d3 = _HeXDigit3-instance D4 HeXDigit where; d4 = _HeXDigit4-instance D5 HeXDigit where; d5 = _HeXDigit5-instance D6 HeXDigit where; d6 = _HeXDigit6-instance D7 HeXDigit where; d7 = _HeXDigit7-instance D8 HeXDigit where; d8 = _HeXDigit8-instance D9 HeXDigit where; d9 = _HeXDigit9-instance DA HeXDigit where; dA = _HeXDigitA-instance Da HeXDigit where; da = _HeXDigita-instance DB HeXDigit where; dB = _HeXDigitB-instance Db HeXDigit where; db = _HeXDigitb-instance DC HeXDigit where; dC = _HeXDigitC-instance Dc HeXDigit where; dc = _HeXDigitc-instance DD HeXDigit where; dD = _HeXDigitD-instance Dd HeXDigit where; dd = _HeXDigitd-instance DE HeXDigit where; dE = _HeXDigitE-instance De HeXDigit where; de = _HeXDigite-instance DF HeXDigit where; dF = _HeXDigitF-instance Df HeXDigit where; df = _HeXDigitf--type HeXaDeCiMaLNoZero d =-  (D1 d, D2 d, D3 d, D4 d, D5 d, D6 d, D7 d, D8 d, D9 d, DA d, DB d, DC d, DD d, DE d, DF d, Da d, Db d, Dc d, Dd d, De d, De d, Df d)--parseHeXaDeCiMaLNoZero ::-  (HeXaDeCiMaLNoZero d, CharParsing p) =>-  p d-parseHeXaDeCiMaLNoZero =-  choice-    [-      parseDecimalNoZero-    , parseAa-    , parseBb-    , parseCc-    , parseDd-    , parseEe-    , parseFf-    ] <?> "HeXaDeCiMaLNoZero"--type HeXaDeCiMaL d =-  (D0 d, HeXaDeCiMaLNoZero d)--parseHeXaDeCiMaL ::-  (HeXaDeCiMaL d, CharParsing p) =>-  p d-parseHeXaDeCiMaL =-  choice-    [-      parse0-    , parseHeXaDeCiMaLNoZero-    ] <?> "HeXaDeCiMaL"

@@ -1,136 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE ConstraintKinds #-}-{-# LANGUAGE TemplateHaskell #-}--module Data.Digit.Hexadecimal(-  HexDigit(..)-, HexadecimalNoZero-, Hexadecimal-, parseHexadecimalNoZero-, parseHexadecimal--- * Prisms-, _HexDigit0-, _HexDigit1-, _HexDigit2-, _HexDigit3-, _HexDigit4-, _HexDigit5-, _HexDigit6-, _HexDigit7-, _HexDigit8-, _HexDigit9-, _HexDigita-, _HexDigitb-, _HexDigitc-, _HexDigitd-, _HexDigite-, _HexDigitf--- * Re-exports-, module Data.Digit.D0-, module Data.Digit.D1-, module Data.Digit.D2-, module Data.Digit.D3-, module Data.Digit.D4-, module Data.Digit.D5-, module Data.Digit.D6-, module Data.Digit.D7-, module Data.Digit.D8-, module Data.Digit.D9-, module Data.Digit.Da-, module Data.Digit.Db-, module Data.Digit.Dc-, module Data.Digit.Dd-, module Data.Digit.De-, module Data.Digit.Df-) where--import Prelude (Eq, Show, Ord)-import Control.Lens.TH (makePrisms)-import Text.Parser.Char(CharParsing)-import Text.Parser.Combinators((<?>), choice)-import Data.Digit.D0-import Data.Digit.D1-import Data.Digit.D2-import Data.Digit.D3-import Data.Digit.D4-import Data.Digit.D5-import Data.Digit.D6-import Data.Digit.D7-import Data.Digit.D8-import Data.Digit.D9-import Data.Digit.Da-import Data.Digit.Db-import Data.Digit.Dc-import Data.Digit.Dd-import Data.Digit.De-import Data.Digit.Df-import Data.Digit.Decimal(parseDecimalNoZero)--data HexDigit-  = HexDigit0-  | HexDigit1-  | HexDigit2-  | HexDigit3-  | HexDigit4-  | HexDigit5-  | HexDigit6-  | HexDigit7-  | HexDigit8-  | HexDigit9-  | HexDigita-  | HexDigitb-  | HexDigitc-  | HexDigitd-  | HexDigite-  | HexDigitf-  deriving (Show, Eq, Ord)--makePrisms ''HexDigit--instance D0 HexDigit where; d0 = _HexDigit0-instance D1 HexDigit where; d1 = _HexDigit1-instance D2 HexDigit where; d2 = _HexDigit2-instance D3 HexDigit where; d3 = _HexDigit3-instance D4 HexDigit where; d4 = _HexDigit4-instance D5 HexDigit where; d5 = _HexDigit5-instance D6 HexDigit where; d6 = _HexDigit6-instance D7 HexDigit where; d7 = _HexDigit7-instance D8 HexDigit where; d8 = _HexDigit8-instance D9 HexDigit where; d9 = _HexDigit9-instance Da HexDigit where; da = _HexDigita-instance Db HexDigit where; db = _HexDigitb-instance Dc HexDigit where; dc = _HexDigitc-instance Dd HexDigit where; dd = _HexDigitd-instance De HexDigit where; de = _HexDigite-instance Df HexDigit where; df = _HexDigitf--type HexadecimalNoZero d =-  (D1 d, D2 d, D3 d, D4 d, D5 d, D6 d, D7 d, D8 d, D9 d, Da d, Db d, Dc d, Dd d, De d, De d, Df d)--parseHexadecimalNoZero ::-  (HexadecimalNoZero d, CharParsing p) =>-  p d-parseHexadecimalNoZero =-  choice-    [-      parseDecimalNoZero-    , parsea-    , parseb-    , parsec-    , parsed-    , parsee-    , parsef-    ] <?> "HexadecimalNoZero"--type Hexadecimal d =-  (D0 d, HexadecimalNoZero d)--parseHexadecimal ::-  (Hexadecimal d, CharParsing p) =>-  p d-parseHexadecimal =-  choice-    [-      parse0-    , parseHexadecimalNoZero-    ] <?> "Hexadecimal"

@@ -0,0 +1,129 @@+{-# LANGUAGE NoImplicitPrelude #-}+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE TemplateHaskell #-}++module Data.Digit.Hexadecimal.LowerCase(+  HexDigit(..)+, HexadecimalNoZero+, Hexadecimal+, parseHexadecimalNoZero+, parseHexadecimal+-- * Prisms+, _HexDigit0+, _HexDigit1+, _HexDigit2+, _HexDigit3+, _HexDigit4+, _HexDigit5+, _HexDigit6+, _HexDigit7+, _HexDigit8+, _HexDigit9+, _HexDigita+, _HexDigitb+, _HexDigitc+, _HexDigitd+, _HexDigite+, _HexDigitf+-- * Re-exports+, module Data.Digit.Class.D0+, module Data.Digit.Class.D1+, module Data.Digit.Class.D2+, module Data.Digit.Class.D3+, module Data.Digit.Class.D4+, module Data.Digit.Class.D5+, module Data.Digit.Class.D6+, module Data.Digit.Class.D7+, module Data.Digit.Class.D8+, module Data.Digit.Class.D9++, module Data.Digit.Class.LowerCase+) where++import Prelude (Eq, Show, Ord)+import Control.Lens.TH (makePrisms)+import Text.Parser.Char(CharParsing)+import Text.Parser.Combinators((<?>), choice)++import Data.Digit.Class.D0+import Data.Digit.Class.D1+import Data.Digit.Class.D2+import Data.Digit.Class.D3+import Data.Digit.Class.D4+import Data.Digit.Class.D5+import Data.Digit.Class.D6+import Data.Digit.Class.D7+import Data.Digit.Class.D8+import Data.Digit.Class.D9+import Data.Digit.Class.LowerCase++import Data.Digit.Decimal(parseDecimalNoZero)++data HexDigit+  = HexDigit0+  | HexDigit1+  | HexDigit2+  | HexDigit3+  | HexDigit4+  | HexDigit5+  | HexDigit6+  | HexDigit7+  | HexDigit8+  | HexDigit9+  | HexDigita+  | HexDigitb+  | HexDigitc+  | HexDigitd+  | HexDigite+  | HexDigitf+  deriving (Show, Eq, Ord)++makePrisms ''HexDigit++instance D0 HexDigit where; d0 = _HexDigit0+instance D1 HexDigit where; d1 = _HexDigit1+instance D2 HexDigit where; d2 = _HexDigit2+instance D3 HexDigit where; d3 = _HexDigit3+instance D4 HexDigit where; d4 = _HexDigit4+instance D5 HexDigit where; d5 = _HexDigit5+instance D6 HexDigit where; d6 = _HexDigit6+instance D7 HexDigit where; d7 = _HexDigit7+instance D8 HexDigit where; d8 = _HexDigit8+instance D9 HexDigit where; d9 = _HexDigit9+instance Da HexDigit where; da = _HexDigita+instance Db HexDigit where; db = _HexDigitb+instance Dc HexDigit where; dc = _HexDigitc+instance Dd HexDigit where; dd = _HexDigitd+instance De HexDigit where; de = _HexDigite+instance Df HexDigit where; df = _HexDigitf++type HexadecimalNoZero d =+  (D1 d, D2 d, D3 d, D4 d, D5 d, D6 d, D7 d, D8 d, D9 d, Da d, Db d, Dc d, Dd d, De d, De d, Df d)++parseHexadecimalNoZero ::+  (HexadecimalNoZero d, CharParsing p) =>+  p d+parseHexadecimalNoZero =+  choice+    [+      parseDecimalNoZero+    , parsea+    , parseb+    , parsec+    , parsed+    , parsee+    , parsef+    ] <?> "HexadecimalNoZero"++type Hexadecimal d =+  (D0 d, HexadecimalNoZero d)++parseHexadecimal ::+  (Hexadecimal d, CharParsing p) =>+  p d+parseHexadecimal =+  choice+    [+      parse0+    , parseHexadecimalNoZero+    ] <?> "Hexadecimal"

@@ -0,0 +1,144 @@+{-# LANGUAGE NoImplicitPrelude #-}+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE TemplateHaskell #-}++module Data.Digit.Hexadecimal.MixedCase(+  HeXDigit(..)+, HeXaDeCiMaLNoZero+, HeXaDeCiMaL+, parseHeXaDeCiMaLNoZero+, parseHeXaDeCiMaL+-- * Prisms+, _HeXDigit0+, _HeXDigit1+, _HeXDigit2+, _HeXDigit3+, _HeXDigit4+, _HeXDigit5+, _HeXDigit6+, _HeXDigit7+, _HeXDigit8+, _HeXDigit9+, _HeXDigita+, _HeXDigitb+, _HeXDigitc+, _HeXDigitd+, _HeXDigite+, _HeXDigitf+, _HeXDigitA+, _HeXDigitB+, _HeXDigitC+, _HeXDigitD+, _HeXDigitE+, _HeXDigitF+-- * Re-exports+, module Data.Digit.Class.D0+, module Data.Digit.Class.D1+, module Data.Digit.Class.D2+, module Data.Digit.Class.D3+, module Data.Digit.Class.D4+, module Data.Digit.Class.D5+, module Data.Digit.Class.D6+, module Data.Digit.Class.D7+, module Data.Digit.Class.D8+, module Data.Digit.Class.D9+, module Data.Digit.Class.MixedCase+) where++import Prelude (Eq, Show, Ord)+import Control.Lens.TH (makePrisms)+import Text.Parser.Char(CharParsing)+import Text.Parser.Combinators((<?>), choice)+import Data.Digit.Class.D0+import Data.Digit.Class.D1+import Data.Digit.Class.D2+import Data.Digit.Class.D3+import Data.Digit.Class.D4+import Data.Digit.Class.D5+import Data.Digit.Class.D6+import Data.Digit.Class.D7+import Data.Digit.Class.D8+import Data.Digit.Class.D9+import Data.Digit.Class.MixedCase+import Data.Digit.Decimal(parseDecimalNoZero)++data HeXDigit+  = HeXDigit0+  | HeXDigit1+  | HeXDigit2+  | HeXDigit3+  | HeXDigit4+  | HeXDigit5+  | HeXDigit6+  | HeXDigit7+  | HeXDigit8+  | HeXDigit9+  | HeXDigita+  | HeXDigitb+  | HeXDigitc+  | HeXDigitd+  | HeXDigite+  | HeXDigitf+  | HeXDigitA+  | HeXDigitB+  | HeXDigitC+  | HeXDigitD+  | HeXDigitE+  | HeXDigitF+  deriving (Show, Eq, Ord)++makePrisms ''HeXDigit++instance D0 HeXDigit where; d0 = _HeXDigit0+instance D1 HeXDigit where; d1 = _HeXDigit1+instance D2 HeXDigit where; d2 = _HeXDigit2+instance D3 HeXDigit where; d3 = _HeXDigit3+instance D4 HeXDigit where; d4 = _HeXDigit4+instance D5 HeXDigit where; d5 = _HeXDigit5+instance D6 HeXDigit where; d6 = _HeXDigit6+instance D7 HeXDigit where; d7 = _HeXDigit7+instance D8 HeXDigit where; d8 = _HeXDigit8+instance D9 HeXDigit where; d9 = _HeXDigit9+instance DA HeXDigit where; dA = _HeXDigitA+instance Da HeXDigit where; da = _HeXDigita+instance DB HeXDigit where; dB = _HeXDigitB+instance Db HeXDigit where; db = _HeXDigitb+instance DC HeXDigit where; dC = _HeXDigitC+instance Dc HeXDigit where; dc = _HeXDigitc+instance DD HeXDigit where; dD = _HeXDigitD+instance Dd HeXDigit where; dd = _HeXDigitd+instance DE HeXDigit where; dE = _HeXDigitE+instance De HeXDigit where; de = _HeXDigite+instance DF HeXDigit where; dF = _HeXDigitF+instance Df HeXDigit where; df = _HeXDigitf++type HeXaDeCiMaLNoZero d =+  (D1 d, D2 d, D3 d, D4 d, D5 d, D6 d, D7 d, D8 d, D9 d, DA d, DB d, DC d, DD d, DE d, DF d, Da d, Db d, Dc d, Dd d, De d, De d, Df d)++parseHeXaDeCiMaLNoZero ::+  (HeXaDeCiMaLNoZero d, CharParsing p) =>+  p d+parseHeXaDeCiMaLNoZero =+  choice+    [+      parseDecimalNoZero+    , parseAa+    , parseBb+    , parseCc+    , parseDd+    , parseEe+    , parseFf+    ] <?> "HeXaDeCiMaLNoZero"++type HeXaDeCiMaL d =+  (D0 d, HeXaDeCiMaLNoZero d)++parseHeXaDeCiMaL ::+  (HeXaDeCiMaL d, CharParsing p) =>+  p d+parseHeXaDeCiMaL =+  choice+    [+      parse0+    , parseHeXaDeCiMaLNoZero+    ] <?> "HeXaDeCiMaL"

@@ -0,0 +1,126 @@+{-# LANGUAGE NoImplicitPrelude #-}+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE TemplateHaskell #-}++module Data.Digit.Hexadecimal.UpperCase(+  HEXDigit(..)+, HEXADECIMALNoZero+, HEXADECIMAL+, parseHEXADECIMALNoZero+, parseHEXADECIMAL+-- * Prisms+, _HEXDigit0+, _HEXDigit1+, _HEXDigit2+, _HEXDigit3+, _HEXDigit4+, _HEXDigit5+, _HEXDigit6+, _HEXDigit7+, _HEXDigit8+, _HEXDigit9+, _HEXDigitA+, _HEXDigitB+, _HEXDigitC+, _HEXDigitD+, _HEXDigitE+, _HEXDigitF+-- * Re-exports+, module Data.Digit.Class.D0+, module Data.Digit.Class.D1+, module Data.Digit.Class.D2+, module Data.Digit.Class.D3+, module Data.Digit.Class.D4+, module Data.Digit.Class.D5+, module Data.Digit.Class.D6+, module Data.Digit.Class.D7+, module Data.Digit.Class.D8+, module Data.Digit.Class.D9+, module Data.Digit.Class.UpperCase+) where++import Prelude (Eq, Show, Ord)+import Control.Lens.TH (makePrisms)+import Text.Parser.Char(CharParsing)+import Text.Parser.Combinators((<?>), choice)+import Data.Digit.Class.D0+import Data.Digit.Class.D1+import Data.Digit.Class.D2+import Data.Digit.Class.D3+import Data.Digit.Class.D4+import Data.Digit.Class.D5+import Data.Digit.Class.D6+import Data.Digit.Class.D7+import Data.Digit.Class.D8+import Data.Digit.Class.D9+import Data.Digit.Class.UpperCase+import Data.Digit.Decimal(parseDecimalNoZero)++data HEXDigit+  = HEXDigit0+  | HEXDigit1+  | HEXDigit2+  | HEXDigit3+  | HEXDigit4+  | HEXDigit5+  | HEXDigit6+  | HEXDigit7+  | HEXDigit8+  | HEXDigit9+  | HEXDigitA+  | HEXDigitB+  | HEXDigitC+  | HEXDigitD+  | HEXDigitE+  | HEXDigitF+  deriving (Show, Eq, Ord)++makePrisms ''HEXDigit++instance D0 HEXDigit where; d0 = _HEXDigit0+instance D1 HEXDigit where; d1 = _HEXDigit1+instance D2 HEXDigit where; d2 = _HEXDigit2+instance D3 HEXDigit where; d3 = _HEXDigit3+instance D4 HEXDigit where; d4 = _HEXDigit4+instance D5 HEXDigit where; d5 = _HEXDigit5+instance D6 HEXDigit where; d6 = _HEXDigit6+instance D7 HEXDigit where; d7 = _HEXDigit7+instance D8 HEXDigit where; d8 = _HEXDigit8+instance D9 HEXDigit where; d9 = _HEXDigit9+instance DA HEXDigit where; dA = _HEXDigitA+instance DB HEXDigit where; dB = _HEXDigitB+instance DC HEXDigit where; dC = _HEXDigitC+instance DD HEXDigit where; dD = _HEXDigitD+instance DE HEXDigit where; dE = _HEXDigitE+instance DF HEXDigit where; dF = _HEXDigitF++type HEXADECIMALNoZero d =+  (D1 d, D2 d, D3 d, D4 d, D5 d, D6 d, D7 d, D8 d, D9 d, DA d, DB d, DC d, DD d, DE d, DF d)++parseHEXADECIMALNoZero ::+  (HEXADECIMALNoZero d, CharParsing p) =>+  p d+parseHEXADECIMALNoZero =+  choice+    [+      parseDecimalNoZero+    , parseA+    , parseB+    , parseC+    , parseD+    , parseE+    , parseF+    ] <?> "HEXADECIMALNoZero"++type HEXADECIMAL d =+  (D0 d, HEXADECIMALNoZero d)++parseHEXADECIMAL ::+  (HEXADECIMAL d, CharParsing p) =>+  p d+parseHEXADECIMAL =+  choice+    [+      parse0+    , parseHEXADECIMALNoZero+    ] <?> "HEXADECIMAL"

@@ -32,17 +32,31 @@ , _HeXDigitsIntegral ) where -import Prelude (error)-import Control.Lens.Extras(is)-import Data.Digit.Binary-import Data.Digit.Decimal-import Data.Digit.Octal-import Data.Digit.Hexadecimal-import Data.Digit.HEXADECIMAL-import Data.Digit.HeXaDeCiMaL-import qualified Data.List.NonEmpty as NonEmpty-import Papa+import           Prelude                (Eq, Integral, error, fst, lookup,+                                         quotRem, (*), (+), (-), (==), (>=)) +import           Control.Applicative    (Applicative)+import           Control.Category       (id, (.))+import           Control.Lens           (APrism, Choice, Prism', Review,+                                         clonePrism, outside, prism', unto,+                                         ( # ), (.~), (^?!))+import           Control.Lens.Extras    (is)++import           Data.Either            (Either (..), either)+import           Data.Foldable          (find, foldl')+import           Data.Function          (($),const)+import           Data.Functor           ((<$>))+import           Data.List.NonEmpty     (NonEmpty)+import           Data.Maybe             (fromMaybe)++import           Data.Digit.Binary+import           Data.Digit.Decimal+import           Data.Digit.Hexadecimal.LowerCase+import           Data.Digit.Hexadecimal.UpperCase+import           Data.Digit.Hexadecimal.MixedCase+import           Data.Digit.Octal+import qualified Data.List.NonEmpty     as NonEmpty+ -- $setup -- >>> import Data.Digit @@ -60,7 +74,7 @@     d integralBinaryNoZero =   associatePrism (1, d1) []-  + -- | -- -- >>> 0 ^? integralBinary :: Maybe BinDigit@@ -201,7 +215,7 @@     d integralDecimalNoZero =   associatePrism (1, d1) [(2, d2), (3, d3), (4, d4), (5, d5), (6, d6), (7, d7), (8, d8), (9, d9)]-  + -- | -- >>> 9 ^? integralDecimal :: Maybe DecDigit -- Just DecDigit9@@ -271,7 +285,7 @@     d integralHexadecimalNoZero =   associatePrism (1, d1) [(2, d2), (3, d3), (4, d4), (5, d5), (6, d6), (7, d7), (8, d8), (9, d9), (10, da), (11, db), (12, dc), (13, dd), (14, de), (15, df)]-  + -- | -- -- >>> 15 ^? integralHexadecimal :: Maybe HexDigit@@ -342,8 +356,8 @@     d integralHEXADECIMALNoZero =   associatePrism (1, d1) [(2, d2), (3, d3), (4, d4), (5, d5), (6, d6), (7, d7), (8, d8), (9, d9), (10, dA), (11, dB), (12, dC), (13, dD), (14, dE), (15, dF)]-   + -- | -- -- >>> 15 ^? integralHEXADECIMAL :: Maybe HEXDigit@@ -414,27 +428,27 @@     d integralHeXaDeCiMaLNoZero =   unto-    (outside d1 .~ (\_ -> 1) $-     outside d2 .~ (\_ -> 2) $-     outside d3 .~ (\_ -> 3) $-     outside d4 .~ (\_ -> 4) $-     outside d5 .~ (\_ -> 5) $-     outside d6 .~ (\_ -> 6) $-     outside d7 .~ (\_ -> 7) $-     outside d8 .~ (\_ -> 8) $-     outside d9 .~ (\_ -> 9) $-     outside da .~ (\_ -> 10) $-     outside dA .~ (\_ -> 10) $-     outside db .~ (\_ -> 11) $-     outside dB .~ (\_ -> 11) $-     outside dc .~ (\_ -> 12) $-     outside dC .~ (\_ -> 12) $-     outside dd .~ (\_ -> 13) $-     outside dD .~ (\_ -> 13) $-     outside de .~ (\_ -> 14) $-     outside dE .~ (\_ -> 14) $-     outside df .~ (\_ -> 15) $-     outside dF .~ (\_ -> 15) $+    (outside d1 .~ const 1 $+     outside d2 .~ const 2 $+     outside d3 .~ const 3 $+     outside d4 .~ const 4 $+     outside d5 .~ const 5 $+     outside d6 .~ const 6 $+     outside d7 .~ const 7 $+     outside d8 .~ const 8 $+     outside d9 .~ const 9 $+     outside da .~ const 10 $+     outside dA .~ const 10 $+     outside db .~ const 11 $+     outside dB .~ const 11 $+     outside dc .~ const 12 $+     outside dC .~ const 12 $+     outside dd .~ const 13 $+     outside dD .~ const 13 $+     outside de .~ const 14 $+     outside dE .~ const 14 $+     outside df .~ const 15 $+     outside dF .~ const 15 $      error "incomplete pattern")  -- |@@ -451,28 +465,28 @@     d integralHeXaDeCiMaL =   unto-    (outside d0 .~ (\_ -> 0) $-     outside d1 .~ (\_ -> 1) $-     outside d2 .~ (\_ -> 2) $-     outside d3 .~ (\_ -> 3) $-     outside d4 .~ (\_ -> 4) $-     outside d5 .~ (\_ -> 5) $-     outside d6 .~ (\_ -> 6) $-     outside d7 .~ (\_ -> 7) $-     outside d8 .~ (\_ -> 8) $-     outside d9 .~ (\_ -> 9) $-     outside da .~ (\_ -> 10) $-     outside dA .~ (\_ -> 10) $-     outside db .~ (\_ -> 11) $-     outside dB .~ (\_ -> 11) $-     outside dc .~ (\_ -> 12) $-     outside dC .~ (\_ -> 12) $-     outside dd .~ (\_ -> 13) $-     outside dD .~ (\_ -> 13) $-     outside de .~ (\_ -> 14) $-     outside dE .~ (\_ -> 14) $-     outside df .~ (\_ -> 15) $-     outside dF .~ (\_ -> 15) $+    (outside d0 .~ const 0 $+     outside d1 .~ const 1 $+     outside d2 .~ const 2 $+     outside d3 .~ const 3 $+     outside d4 .~ const 4 $+     outside d5 .~ const 5 $+     outside d6 .~ const 6 $+     outside d7 .~ const 7 $+     outside d8 .~ const 8 $+     outside d9 .~ const 9 $+     outside da .~ const 10 $+     outside dA .~ const 10 $+     outside db .~ const 11 $+     outside dB .~ const 11 $+     outside dc .~ const 12 $+     outside dC .~ const 12 $+     outside dd .~ const 13 $+     outside dD .~ const 13 $+     outside de .~ const 14 $+     outside dE .~ const 14 $+     outside df .~ const 15 $+     outside dF .~ const 15 $      error "incomplete pattern")  -- |

@@ -18,28 +18,28 @@ , _OctDigit6 , _OctDigit7 -- * Re-exports-, module Data.Digit.D0-, module Data.Digit.D1-, module Data.Digit.D2-, module Data.Digit.D3-, module Data.Digit.D4-, module Data.Digit.D5-, module Data.Digit.D6-, module Data.Digit.D7+, module Data.Digit.Class.D0+, module Data.Digit.Class.D1+, module Data.Digit.Class.D2+, module Data.Digit.Class.D3+, module Data.Digit.Class.D4+, module Data.Digit.Class.D5+, module Data.Digit.Class.D6+, module Data.Digit.Class.D7 ) where  import Prelude (Eq, Show, Ord, Enum, Bounded) import Control.Lens.TH (makePrisms) import Text.Parser.Char(CharParsing) import Text.Parser.Combinators((<?>), choice)-import Data.Digit.D0-import Data.Digit.D1-import Data.Digit.D2-import Data.Digit.D3-import Data.Digit.D4-import Data.Digit.D5-import Data.Digit.D6-import Data.Digit.D7+import Data.Digit.Class.D0+import Data.Digit.Class.D1+import Data.Digit.Class.D2+import Data.Digit.Class.D3+import Data.Digit.Class.D4+import Data.Digit.Class.D5+import Data.Digit.Class.D6+import Data.Digit.Class.D7  data OctDigit   = OctDigit0

@@ -1,14 +1,28 @@ {-# LANGUAGE RankNTypes #-}-+{-# LANGUAGE NoImplicitPrelude #-} module Main(   main ) where  import Data.Digit import Numeric.Natural (Natural)-import Prelude (minBound, maxBound)-import Papa hiding (re)+import Prelude (Char, Integral, Int, String, Eq, Show, IO, Integer, minBound, maxBound, fromIntegral,fst,notElem)++import Control.Category ((.))+import Control.Monad ((>>=))+import Control.Applicative ((<*))+import Control.Lens (Prism', (^?), (#))++import Data.Semigroup ((<>))+import Data.Monoid (mconcat)+import Data.Functor ((<$>),fmap)+import Data.Function (($))+import Data.Maybe (Maybe (..))+import Data.Either (Either (..),isLeft)+import Data.List.NonEmpty (NonEmpty)+ import Hedgehog(Property, Gen, forAll, property, assert, (===))+ import Test.Tasty(TestTree, defaultMain, testGroup) import Test.Tasty.Hedgehog(testProperty) import Test.Tasty.HUnit(testCase, (@?=))@@ -25,20 +39,20 @@   -> [TestTree] testPrism g n p x =   testProperty-    (n ++ " prism invalid values")+    (n <> " prism invalid values")     (       property $-        do  c <- forAll . Gen.filter (`notElem` (map fst x)) $ g+        do  c <- forAll . Gen.filter (`notElem` (fmap fst x)) $ g             (c ^? p :: Maybe HeXDigit) === Nothing     ) :     (       x >>= \(c, d) ->         [           testCase-            (n ++ " prism ->")+            (n <> " prism ->")             ((c ^? p :: Maybe HeXDigit) @?= Just d)         , testCase-            (n ++ " prism <-")+            (n <> " prism <-")             (p # d @?= c)         ]     )@@ -50,26 +64,26 @@   -> [TestTree] testParser n p x =     (-      let n' = n ++ " parser invalid values"+      let n' = n <> " parser invalid values"       in  testProperty             n'             (               property $-                do  c <- forAll . Gen.filter (`notElem` (map fst x)) . Gen.choice $ [Gen.hexit, Gen.unicode]-                    assert (isLeft (parse p (n' ++ " test") [c] :: Either ParseError HeXDigit))+                do  c <- forAll . Gen.filter (`notElem` (fmap fst x)) . Gen.choice $ [Gen.hexit, Gen.unicode]+                    assert (isLeft (parse p (n' <> " test") [c] :: Either ParseError HeXDigit))             )     ) :     (       x >>= \(c, d) ->         [-          let n' = n ++ " parses exactly one character"+          let n' = n <> " parses exactly one character"           in  testCase                 n'-                ((parse (p <* eof) (n' ++ " test") [c] :: Either ParseError HeXDigit) @?= Right d)-        , let n' = n ++ " parses the correct digit"+                ((parse (p <* eof) (n' <> " test") [c] :: Either ParseError HeXDigit) @?= Right d)+        , let n' = n <> " parses the correct digit"           in  testCase                 n'-                ((parse p (n' ++ "test") (c:"xyz") :: Either ParseError HeXDigit) @?= Right d)+                ((parse p (n' <> "test") (c:"xyz") :: Either ParseError HeXDigit) @?= Right d)             ]     ) @@ -228,7 +242,7 @@         rE =  (14 , HeXDigitE)         rF :: (Integer, HeXDigit)         rF =  (15 , HeXDigitF)-    in  concat [+    in  mconcat [           charPrism "charBinaryNoZero" charBinaryNoZero [q1]         , charPrism "charBinary" charBinary [q0, q1]         , charPrism "charOctalNoZero" charOctalNoZero [q1, q2, q3, q4, q5, q6, q7]