digit 0.4.0 → 0.5.0

raw patch · 62 files changed

+2910/−3255 lines, 62 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• changelog.md +6/−1
• digit.cabal +4/−23
• src/Data/Digit.hs +4/−23
• src/Data/Digit/Binary.hs +18/−31
• src/Data/Digit/Char.hs +1048/−0
• src/Data/Digit/D0.hs +16/−9
• src/Data/Digit/D1.hs +16/−10
• src/Data/Digit/D2.hs +16/−9
• src/Data/Digit/D3.hs +15/−9
• src/Data/Digit/D4.hs +15/−9
• src/Data/Digit/D5.hs +15/−9
• src/Data/Digit/D6.hs +15/−9
• src/Data/Digit/D7.hs +15/−9
• src/Data/Digit/D8.hs +15/−9
• src/Data/Digit/D9.hs +15/−9
• src/Data/Digit/DA.hs +15/−9
• src/Data/Digit/DAa.hs +11/−11
• src/Data/Digit/DB.hs +15/−9
• src/Data/Digit/DBb.hs +11/−12
• src/Data/Digit/DC.hs +15/−9
• src/Data/Digit/DCc.hs +11/−11
• src/Data/Digit/DD.hs +15/−9
• src/Data/Digit/DDd.hs +11/−11
• src/Data/Digit/DE.hs +15/−9
• src/Data/Digit/DEe.hs +11/−11
• src/Data/Digit/DF.hs +15/−9
• src/Data/Digit/DFf.hs +11/−11
• src/Data/Digit/Da.hs +15/−9
• src/Data/Digit/Db.hs +15/−9
• src/Data/Digit/Dc.hs +15/−9
• src/Data/Digit/Dd.hs +16/−9
• src/Data/Digit/De.hs +15/−9
• src/Data/Digit/Decimal.hs +82/−99
• src/Data/Digit/Df.hs +15/−9
• src/Data/Digit/Digit.hs +78/−0
• src/Data/Digit/Digit0.hs +0/−102
• src/Data/Digit/Digit1.hs +0/−102
• src/Data/Digit/Digit2.hs +0/−102
• src/Data/Digit/Digit3.hs +0/−102
• src/Data/Digit/Digit4.hs +0/−102
• src/Data/Digit/Digit5.hs +0/−103
• src/Data/Digit/Digit6.hs +0/−102
• src/Data/Digit/Digit7.hs +0/−102
• src/Data/Digit/Digit8.hs +0/−102
• src/Data/Digit/Digit9.hs +0/−102
• src/Data/Digit/DigitA.hs +0/−102
• src/Data/Digit/DigitB.hs +0/−102
• src/Data/Digit/DigitC.hs +0/−102
• src/Data/Digit/DigitD.hs +0/−102
• src/Data/Digit/DigitE.hs +0/−102
• src/Data/Digit/DigitF.hs +0/−102
• src/Data/Digit/Digita.hs +0/−102
• src/Data/Digit/Digitb.hs +0/−102
• src/Data/Digit/Digitc.hs +0/−102
• src/Data/Digit/Digitd.hs +0/−102
• src/Data/Digit/Digite.hs +0/−102
• src/Data/Digit/Digitf.hs +0/−102
• src/Data/Digit/HEXADECIMAL.hs +130/−147
• src/Data/Digit/HeXaDeCiMaL.hs +180/−191
• src/Data/Digit/Hexadecimal.hs +130/−147
• src/Data/Digit/Integral.hs +764/−0
• src/Data/Digit/Octal.hs +66/−82

@@ -1,7 +1,12 @@+0.5.0++* Data types for other bases (binary, octal, hexadecimal).+* Remove the `Digit…` data types.+* Introduce the `Digit` data type.+ 0.4.0  * Refactor to classy prisms for each digit.-* Data types for other bases (binary, octal, hexadecimal).  0.3.0 

@@ -1,5 +1,5 @@ name:               digit-version:            0.4.0+version:            0.5.0 license:            BSD3 license-file:       LICENCE author:             Queensland Functional Programming Lab <oᴉ˙ldɟb@llǝʞsɐɥ>@@ -80,28 +80,9 @@                     Data.Digit.DDd                     Data.Digit.DEe                     Data.Digit.DFf-                    Data.Digit.Digit0-                    Data.Digit.Digit1-                    Data.Digit.Digit2-                    Data.Digit.Digit3-                    Data.Digit.Digit4-                    Data.Digit.Digit5-                    Data.Digit.Digit6-                    Data.Digit.Digit7-                    Data.Digit.Digit8-                    Data.Digit.Digit9-                    Data.Digit.Digita-                    Data.Digit.DigitA-                    Data.Digit.Digitb-                    Data.Digit.DigitB-                    Data.Digit.Digitc-                    Data.Digit.DigitC-                    Data.Digit.Digitd-                    Data.Digit.DigitD-                    Data.Digit.Digite-                    Data.Digit.DigitE-                    Data.Digit.Digitf-                    Data.Digit.DigitF+                    Data.Digit.Digit+                    Data.Digit.Char+                    Data.Digit.Integral   test-suite doctests

@@ -1,6 +1,6 @@ {-# LANGUAGE NoImplicitPrelude #-} -module Data.Digit(+module Data.Digit (   module D ) where @@ -38,25 +38,6 @@ import Data.Digit.DDd as D import Data.Digit.DEe as D import Data.Digit.DFf as D-import Data.Digit.Digit0 as D-import Data.Digit.Digit1 as D-import Data.Digit.Digit2 as D-import Data.Digit.Digit3 as D-import Data.Digit.Digit4 as D-import Data.Digit.Digit5 as D-import Data.Digit.Digit6 as D-import Data.Digit.Digit7 as D-import Data.Digit.Digit8 as D-import Data.Digit.Digit9 as D-import Data.Digit.Digita as D-import Data.Digit.DigitA as D-import Data.Digit.Digitb as D-import Data.Digit.DigitB as D-import Data.Digit.Digitc as D-import Data.Digit.DigitC as D-import Data.Digit.Digitd as D-import Data.Digit.DigitD as D-import Data.Digit.Digite as D-import Data.Digit.DigitE as D-import Data.Digit.Digitf as D-import Data.Digit.DigitF as D+import Data.Digit.Digit as D+import Data.Digit.Integral as D+import Data.Digit.Char as D

@@ -6,13 +6,8 @@ , Binary , parseBinaryNoZero , parseBinary-, BinaryNoZeroDigit-, BinaryDigit-, BinaryDigit'   ) where -import Papa-import Data.Void(Void) import Text.Parser.Char(CharParsing) import Text.Parser.Combinators((<?>), choice) import Data.Digit.D0(D0, parse0)@@ -21,53 +16,51 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)--- >>> import Data.Digit.Digit1+-- >>> import Data.Digit.Digit+-- >>> import Papa  type BinaryNoZero d =   D1 d  -- | ----- >>> parse (parseBinaryNoZero <* eof) "test" "1" :: Either ParseError (Digit1 ())--- Right (Digit1 ())+-- >>> parse (parseBinaryNoZero <* eof) "test" "1" :: Either ParseError Digit+-- Right 1 ----- >>> parse parseBinaryNoZero "test" "1xyz" :: Either ParseError (Digit1 ())--- Right (Digit1 ())+-- >>> parse parseBinaryNoZero "test" "1xyz" :: Either ParseError Digit+-- Right 1 ----- >>> isn't _Right (parse parseBinaryNoZero "test" "xyz" :: Either ParseError (Digit1 ()))+-- >>> isn't _Right (parse parseBinaryNoZero "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> (c `notElem` "1") ==> isn't _Right (parse parseBinaryNoZero "test" [c] :: Either ParseError (Digit1 ()))+-- prop> \c -> (c `notElem` "1") ==> isn't _Right (parse parseBinaryNoZero "test" [c] :: Either ParseError Digit) parseBinaryNoZero ::   (BinaryNoZero d, CharParsing p) =>   p d parseBinaryNoZero =   parse1 <?> "BinaryNoZero" -type BinaryNoZeroDigit d1 =-  Either d1 Void- type Binary d =   (D0 d, BinaryNoZero d)  -- | ----- >>> parse (parseBinary <* eof) "test" "0" :: Either ParseError (BinaryDigit' ())--- Right (Left ())+-- >>> parse (parseBinary <* eof) "test" "0" :: Either ParseError Digit+-- Right 0 ----- >>> parse parseBinary "test" "0xyz" :: Either ParseError (BinaryDigit' ())--- Right (Left ())+-- >>> parse parseBinary "test" "0xyz" :: Either ParseError Digit+-- Right 0 ----- >>> parse (parseBinary <* eof) "test" "1" :: Either ParseError (BinaryDigit' ())--- Right (Left ())+-- >>> parse (parseBinary <* eof) "test" "1" :: Either ParseError Digit+-- Right 1 ----- >>> parse parseBinary "test" "1xyz" :: Either ParseError (BinaryDigit' ())--- Right (Left ())+-- >>> parse parseBinary "test" "1xyz" :: Either ParseError Digit+-- Right 1 ----- >>> isn't _Right (parse parseBinary "test" "xyz" :: Either ParseError (BinaryDigit' ()))+-- >>> isn't _Right (parse parseBinary "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> (c `notElem` "01") ==> isn't _Right (parse parseBinary "test" [c] :: Either ParseError (BinaryDigit' ()))+-- prop> \c -> (c `notElem` "01") ==> isn't _Right (parse parseBinary "test" [c] :: Either ParseError Digit) parseBinary ::   (Binary d, CharParsing p) =>   p d@@ -77,9 +70,3 @@       parse0     , parseBinaryNoZero     ] <?> "Binary"--type BinaryDigit d0 d1 =-  Either d0 (BinaryNoZeroDigit d1)--type BinaryDigit' d =-  BinaryDigit d d

@@ -0,0 +1,1048 @@+{-# LANGUAGE NoImplicitPrelude #-}++module Data.Digit.Char(+  charBinaryNoZero+, charBinary+, charOctalNoZero+, charOctal+, charDecimal+, charDecimalNoZero+, charHexadecimalNoZero+, charHexadecimal+, charHEXADECIMALNoZero+, charHEXADECIMAL+, charHeXaDeCiMaLNoZero+, 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 Data.Digit.D0 as D+import Data.Digit.D1 as D+import Data.Digit.D2 as D+import Data.Digit.D3 as D+import Data.Digit.D4 as D+import Data.Digit.D5 as D+import Data.Digit.D6 as D+import Data.Digit.D7 as D+import Data.Digit.D8 as D+import Data.Digit.D9 as D+import Data.Digit.Da as D+import Data.Digit.DA as D+import Data.Digit.Db as D+import Data.Digit.DB as D+import Data.Digit.Dc as D+import Data.Digit.DC as D+import Data.Digit.Dd as D+import Data.Digit.DD as D+import Data.Digit.De as D+import Data.Digit.DE as D+import Data.Digit.Df as D+import Data.Digit.DF as D+import Papa+++-- $setup+-- >>> import Data.Digit.Digit++-- |+--+-- >>> '1' ^? charBinaryNoZero+-- Just ()+--+-- >>> charBinaryNoZero # Digit1 :: Char+-- '1'+--+-- prop> \c -> c /= '1' ==> (c ^? charBinaryNoZero == Nothing)+charBinaryNoZero ::+  BinaryNoZero d =>+  Prism'+    Char+    d+charBinaryNoZero =+  associatePrism ('1', d1) []+  +-- |+--+-- >>> '0' ^? charBinary :: Maybe Digit+-- Just 0+--+-- >>> '1' ^? charBinary :: Maybe Digit+-- Just 1+--+-- >>> charBinary # Digit0 :: Char+-- '0'+--+-- >>> charBinary # Digit1 :: Char+-- '1'+--+-- prop> \c -> (c `notElem` "01") ==> (c ^? charBinary == Nothing)+charBinary ::+  Binary d =>+  Prism'+    Char+    d+charBinary =+  associatePrism ('0', d0) [('1', d1)]+  +-- |+--+-- >>> '1' ^? charOctalNoZero :: Maybe Digit+-- Just 1+--+-- >>> '2' ^? charOctalNoZero :: Maybe Digit+-- Just 2+--+-- >>> '3' ^? charOctalNoZero :: Maybe Digit+-- Just 3+--+-- >>> '4' ^? charOctalNoZero :: Maybe Digit+-- Just 4+--+-- >>> '5' ^? charOctalNoZero :: Maybe Digit+-- Just 5+--+-- >>> '6' ^? charOctalNoZero :: Maybe Digit+-- Just 6+--+-- >>> '7' ^? charOctalNoZero :: Maybe Digit+-- Just 7+--+-- >>> charOctalNoZero # Digit1 :: Char+-- '1'+--+-- >>> charOctalNoZero # Digit2 :: Char+-- '2'+--+-- >>> charOctalNoZero # Digit3 :: Char+-- '3'+--+-- >>> charOctalNoZero # Digit4 :: Char+-- '4'+--+-- >>> charOctalNoZero # Digit5 :: Char+-- '5'+--+-- >>> charOctalNoZero # Digit6 :: Char+-- '6'+--+-- >>> charOctalNoZero # Digit7 :: Char+-- '7'+--+-- prop> \c -> (c `notElem` "1234567") ==> (c ^? charOctalNoZero == Nothing)+charOctalNoZero ::+  OctalNoZero d =>+  Prism'+    Char+    d+charOctalNoZero =+  associatePrism ('1', d1) [('2', d2), ('3', d3), ('4', d4), ('5', d5), ('6', d6), ('7', d7)]+  +-- |+--+-- >>> '0' ^? charOctal :: Maybe Digit+-- Just 0+--+-- >>> '1' ^? charOctal :: Maybe Digit+-- Just 1+--+-- >>> '2' ^? charOctal :: Maybe Digit+-- Just 2+--+-- >>> '3' ^? charOctal :: Maybe Digit+-- Just 3+--+-- >>> '4' ^? charOctal :: Maybe Digit+-- Just 4+--+-- >>> '5' ^? charOctal :: Maybe Digit+-- Just 5+--+-- >>> '6' ^? charOctal :: Maybe Digit+-- Just 6+--+-- >>> '7' ^? charOctal :: Maybe Digit+-- Just 7+--+-- >>> charOctal # Digit0 :: Char+-- '0'+--+-- >>> charOctal # Digit1 :: Char+-- '1'+--+-- >>> charOctal # Digit2 :: Char+-- '2'+--+-- >>> charOctal # Digit3 :: Char+-- '3'+--+-- >>> charOctal # Digit4 :: Char+-- '4'+--+-- >>> charOctal # Digit5 :: Char+-- '5'+--+-- >>> charOctal # Digit6 :: Char+-- '6'+--+-- >>> charOctal # Digit7 :: Char+-- '7'+--+-- prop> \c -> (c `notElem` "01234567") ==> (c ^? charOctal == Nothing)+charOctal ::+  Octal d =>+  Prism'+    Char+    d+charOctal =+  associatePrism ('0', d0) [('1', d1), ('2', d2), ('3', d3), ('4', d4), ('5', d5), ('6', d6), ('7', d7)]+  +-- |+--+-- >>> '1' ^? charDecimalNoZero :: Maybe Digit+-- Just 1+--+-- >>> '2' ^? charDecimalNoZero :: Maybe Digit+-- Just 2+--+-- >>> '3' ^? charDecimalNoZero :: Maybe Digit+-- Just 3+--+-- >>> '4' ^? charDecimalNoZero :: Maybe Digit+-- Just 4+--+-- >>> '5' ^? charDecimalNoZero :: Maybe Digit+-- Just 5+--+-- >>> '6' ^? charDecimalNoZero :: Maybe Digit+-- Just 6+--+-- >>> '7' ^? charDecimalNoZero :: Maybe Digit+-- Just 7+--+-- >>> '8' ^? charDecimalNoZero :: Maybe Digit+-- Just 8+--+-- >>> '9' ^? charDecimalNoZero :: Maybe Digit+-- Just 9+--+-- >>> charDecimalNoZero # Digit1 :: Char+-- '1'+--+-- >>> charDecimalNoZero # Digit2 :: Char+-- '2'+--+-- >>> charDecimalNoZero # Digit3 :: Char+-- '3'+--+-- >>> charDecimalNoZero # Digit4 :: Char+-- '4'+--+-- >>> charDecimalNoZero # Digit5 :: Char+-- '5'+--+-- >>> charDecimalNoZero # Digit6 :: Char+-- '6'+--+-- >>> charDecimalNoZero # Digit7 :: Char+-- '7'+--+-- >>> charDecimalNoZero # Digit8 :: Char+-- '8'+--+-- >>> charDecimalNoZero # Digit9 :: Char+-- '9'+--+-- prop> \c -> (c `notElem` "123456789") ==> (c ^? charDecimalNoZero == Nothing)+charDecimalNoZero ::+  DecimalNoZero d =>+  Prism'+    Char+    d+charDecimalNoZero =+  associatePrism ('1', d1) [('2', d2), ('3', d3), ('4', d4), ('5', d5), ('6', d6), ('7', d7), ('8', d8), ('9', d9)]+  +-- |+--+-- >>> '0' ^? charDecimal :: Maybe Digit+-- Just 0+--+-- >>> '1' ^? charDecimal :: Maybe Digit+-- Just 1+--+-- >>> '2' ^? charDecimal :: Maybe Digit+-- Just 2+--+-- >>> '3' ^? charDecimal :: Maybe Digit+-- Just 3+--+-- >>> '4' ^? charDecimal :: Maybe Digit+-- Just 4+--+-- >>> '5' ^? charDecimal :: Maybe Digit+-- Just 5+--+-- >>> '6' ^? charDecimal :: Maybe Digit+-- Just 6+--+-- >>> '7' ^? charDecimal :: Maybe Digit+-- Just 7+--+-- >>> '8' ^? charDecimal :: Maybe Digit+-- Just 8+--+-- >>> '9' ^? charDecimal :: Maybe Digit+-- Just 9+--+-- >>> charDecimal # Digit0 :: Char+-- '0'+--+-- >>> charDecimal # Digit1 :: Char+-- '1'+--+-- >>> charDecimal # Digit2 :: Char+-- '2'+--+-- >>> charDecimal # Digit3 :: Char+-- '3'+--+-- >>> charDecimal # Digit4 :: Char+-- '4'+--+-- >>> charDecimal # Digit5 :: Char+-- '5'+--+-- >>> charDecimal # Digit6 :: Char+-- '6'+--+-- >>> charDecimal # Digit7 :: Char+-- '7'+--+-- >>> charDecimal # Digit8 :: Char+-- '8'+--+-- >>> charDecimal # Digit9 :: Char+-- '9'+--+-- prop> \c -> (c `notElem` "0123456789") ==> (c ^? charDecimal == Nothing)+charDecimal ::+  Decimal d =>+  Prism'+    Char+    d+charDecimal =+  associatePrism ('0', d0) [('1', d1), ('2', d2), ('3', d3), ('4', d4), ('5', d5), ('6', d6), ('7', d7), ('8', d8), ('9', d9)]+  +-- |+--+-- >>> '1' ^? charHexadecimalNoZero :: Maybe Digit+-- Just 1+--+-- >>> '2' ^? charHexadecimalNoZero :: Maybe Digit+-- Just 2+--+-- >>> '3' ^? charHexadecimalNoZero :: Maybe Digit+-- Just 3+--+-- >>> '4' ^? charHexadecimalNoZero :: Maybe Digit+-- Just 4+--+-- >>> '5' ^? charHexadecimalNoZero :: Maybe Digit+-- Just 5+--+-- >>> '6' ^? charHexadecimalNoZero :: Maybe Digit+-- Just 6+--+-- >>> '7' ^? charHexadecimalNoZero :: Maybe Digit+-- Just 7+--+-- >>> '8' ^? charHexadecimalNoZero :: Maybe Digit+-- Just 8+--+-- >>> '9' ^? charHexadecimalNoZero :: Maybe Digit+-- Just 9+--+-- >>> 'a' ^? charHexadecimalNoZero :: Maybe Digit+-- Just a+--+-- >>> 'b' ^? charHexadecimalNoZero :: Maybe Digit+-- Just b+--+-- >>> 'c' ^? charHexadecimalNoZero :: Maybe Digit+-- Just c+--+-- >>> 'd' ^? charHexadecimalNoZero :: Maybe Digit+-- Just d+--+-- >>> 'e' ^? charHexadecimalNoZero :: Maybe Digit+-- Just e+--+-- >>> 'f' ^? charHexadecimalNoZero :: Maybe Digit+-- Just f+--+-- >>> charHexadecimalNoZero # Digit1 :: Char+-- '1'+--+-- >>> charHexadecimalNoZero # Digit2 :: Char+-- '2'+--+-- >>> charHexadecimalNoZero # Digit3 :: Char+-- '3'+--+-- >>> charHexadecimalNoZero # Digit4 :: Char+-- '4'+--+-- >>> charHexadecimalNoZero # Digit5 :: Char+-- '5'+--+-- >>> charHexadecimalNoZero # Digit6 :: Char+-- '6'+--+-- >>> charHexadecimalNoZero # Digit7 :: Char+-- '7'+--+-- >>> charHexadecimalNoZero # Digit8 :: Char+-- '8'+--+-- >>> charHexadecimalNoZero # Digit9 :: Char+-- '9'+--+-- >>> charHexadecimalNoZero # Digita :: Char+-- 'a'+--+-- >>> charHexadecimalNoZero # Digitb :: Char+-- 'b'+--+-- >>> charHexadecimalNoZero # Digitc :: Char+-- 'c'+--+-- >>> charHexadecimalNoZero # Digitd :: Char+-- 'd'+--+-- >>> charHexadecimalNoZero # Digite :: Char+-- 'e'+--+-- >>> charHexadecimalNoZero # Digitf :: Char+-- 'f'+--+-- prop> \c -> (c `notElem` "123456789abcdef") ==> (c ^? charHexadecimalNoZero == Nothing)+charHexadecimalNoZero ::+  HexadecimalNoZero d =>+  Prism'+    Char+    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)]+  +-- |+--+-- >>> '0' ^? charHexadecimal :: Maybe Digit+-- Just 0+--+-- >>> '1' ^? charHexadecimal :: Maybe Digit+-- Just 1+--+-- >>> '2' ^? charHexadecimal :: Maybe Digit+-- Just 2+--+-- >>> '3' ^? charHexadecimal :: Maybe Digit+-- Just 3+--+-- >>> '4' ^? charHexadecimal :: Maybe Digit+-- Just 4+--+-- >>> '5' ^? charHexadecimal :: Maybe Digit+-- Just 5+--+-- >>> '6' ^? charHexadecimal :: Maybe Digit+-- Just 6+--+-- >>> '7' ^? charHexadecimal :: Maybe Digit+-- Just 7+--+-- >>> '8' ^? charHexadecimal :: Maybe Digit+-- Just 8+--+-- >>> '9' ^? charHexadecimal :: Maybe Digit+-- Just 9+--+-- >>> 'a' ^? charHexadecimal :: Maybe Digit+-- Just a+--+-- >>> 'b' ^? charHexadecimal :: Maybe Digit+-- Just b+--+-- >>> 'c' ^? charHexadecimal :: Maybe Digit+-- Just c+--+-- >>> 'd' ^? charHexadecimal :: Maybe Digit+-- Just d+--+-- >>> 'e' ^? charHexadecimal :: Maybe Digit+-- Just e+--+-- >>> 'f' ^? charHexadecimal :: Maybe Digit+-- Just f+--+-- >>> charHexadecimal # Digit0 :: Char+-- '0'+--+-- >>> charHexadecimal # Digit1 :: Char+-- '1'+--+-- >>> charHexadecimal # Digit2 :: Char+-- '2'+--+-- >>> charHexadecimal # Digit3 :: Char+-- '3'+--+-- >>> charHexadecimal # Digit4 :: Char+-- '4'+--+-- >>> charHexadecimal # Digit5 :: Char+-- '5'+--+-- >>> charHexadecimal # Digit6 :: Char+-- '6'+--+-- >>> charHexadecimal # Digit7 :: Char+-- '7'+--+-- >>> charHexadecimal # Digit8 :: Char+-- '8'+--+-- >>> charHexadecimal # Digit9 :: Char+-- '9'+--+-- >>> charHexadecimal # Digita :: Char+-- 'a'+--+-- >>> charHexadecimal # Digitb :: Char+-- 'b'+--+-- >>> charHexadecimal # Digitc :: Char+-- 'c'+--+-- >>> charHexadecimal # Digitd :: Char+-- 'd'+--+-- >>> charHexadecimal # Digite :: Char+-- 'e'+--+-- >>> charHexadecimal # Digitf :: Char+-- 'f'+--+-- prop> \c -> (c `notElem` "0123456789abcdef") ==> (c ^? charHexadecimal == Nothing)+charHexadecimal ::+  Hexadecimal d =>+  Prism'+    Char+    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)]+  +-- |+--+-- >>> '1' ^? charHEXADECIMALNoZero :: Maybe Digit+-- Just 1+--+-- >>> '2' ^? charHEXADECIMALNoZero :: Maybe Digit+-- Just 2+--+-- >>> '3' ^? charHEXADECIMALNoZero :: Maybe Digit+-- Just 3+--+-- >>> '4' ^? charHEXADECIMALNoZero :: Maybe Digit+-- Just 4+--+-- >>> '5' ^? charHEXADECIMALNoZero :: Maybe Digit+-- Just 5+--+-- >>> '6' ^? charHEXADECIMALNoZero :: Maybe Digit+-- Just 6+--+-- >>> '7' ^? charHEXADECIMALNoZero :: Maybe Digit+-- Just 7+--+-- >>> '8' ^? charHEXADECIMALNoZero :: Maybe Digit+-- Just 8+--+-- >>> '9' ^? charHEXADECIMALNoZero :: Maybe Digit+-- Just 9+--+-- >>> 'A' ^? charHEXADECIMALNoZero :: Maybe Digit+-- Just A+--+-- >>> 'B' ^? charHEXADECIMALNoZero :: Maybe Digit+-- Just B+--+-- >>> 'C' ^? charHEXADECIMALNoZero :: Maybe Digit+-- Just C+--+-- >>> 'D' ^? charHEXADECIMALNoZero :: Maybe Digit+-- Just D+--+-- >>> 'E' ^? charHEXADECIMALNoZero :: Maybe Digit+-- Just E+--+-- >>> 'F' ^? charHEXADECIMALNoZero :: Maybe Digit+-- Just F+--+-- >>> charHEXADECIMALNoZero # Digit1 :: Char+-- '1'+--+-- >>> charHEXADECIMALNoZero # Digit2 :: Char+-- '2'+--+-- >>> charHEXADECIMALNoZero # Digit3 :: Char+-- '3'+--+-- >>> charHEXADECIMALNoZero # Digit4 :: Char+-- '4'+--+-- >>> charHEXADECIMALNoZero # Digit5 :: Char+-- '5'+--+-- >>> charHEXADECIMALNoZero # Digit6 :: Char+-- '6'+--+-- >>> charHEXADECIMALNoZero # Digit7 :: Char+-- '7'+--+-- >>> charHEXADECIMALNoZero # Digit8 :: Char+-- '8'+--+-- >>> charHEXADECIMALNoZero # Digit9 :: Char+-- '9'+--+-- >>> charHEXADECIMALNoZero # DigitA :: Char+-- 'A'+--+-- >>> charHEXADECIMALNoZero # DigitB :: Char+-- 'B'+--+-- >>> charHEXADECIMALNoZero # DigitC :: Char+-- 'C'+--+-- >>> charHEXADECIMALNoZero # DigitD :: Char+-- 'D'+--+-- >>> charHEXADECIMALNoZero # DigitE :: Char+-- 'E'+--+-- >>> charHEXADECIMALNoZero # DigitF :: Char+-- 'F'+--+-- prop> \c -> (c `notElem` "123456789ABCDEF") ==> (c ^? charHEXADECIMALNoZero == Nothing)+charHEXADECIMALNoZero ::+  HEXADECIMALNoZero d =>+  Prism'+    Char+    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)]+  +-- |+--+-- >>> '0' ^? charHEXADECIMAL :: Maybe Digit+-- Just 0+--+-- >>> '1' ^? charHEXADECIMAL :: Maybe Digit+-- Just 1+--+-- >>> '2' ^? charHEXADECIMAL :: Maybe Digit+-- Just 2+--+-- >>> '3' ^? charHEXADECIMAL :: Maybe Digit+-- Just 3+--+-- >>> '4' ^? charHEXADECIMAL :: Maybe Digit+-- Just 4+--+-- >>> '5' ^? charHEXADECIMAL :: Maybe Digit+-- Just 5+--+-- >>> '6' ^? charHEXADECIMAL :: Maybe Digit+-- Just 6+--+-- >>> '7' ^? charHEXADECIMAL :: Maybe Digit+-- Just 7+--+-- >>> '8' ^? charHEXADECIMAL :: Maybe Digit+-- Just 8+--+-- >>> '9' ^? charHEXADECIMAL :: Maybe Digit+-- Just 9+--+-- >>> 'A' ^? charHEXADECIMAL :: Maybe Digit+-- Just A+--+-- >>> 'B' ^? charHEXADECIMAL :: Maybe Digit+-- Just B+--+-- >>> 'C' ^? charHEXADECIMAL :: Maybe Digit+-- Just C+--+-- >>> 'D' ^? charHEXADECIMAL :: Maybe Digit+-- Just D+--+-- >>> 'E' ^? charHEXADECIMAL :: Maybe Digit+-- Just E+--+-- >>> 'F' ^? charHEXADECIMAL :: Maybe Digit+-- Just F+--+-- >>> charHEXADECIMAL # Digit0 :: Char+-- '0'+--+-- >>> charHEXADECIMAL # Digit1 :: Char+-- '1'+--+-- >>> charHEXADECIMAL # Digit2 :: Char+-- '2'+--+-- >>> charHEXADECIMAL # Digit3 :: Char+-- '3'+--+-- >>> charHEXADECIMAL # Digit4 :: Char+-- '4'+--+-- >>> charHEXADECIMAL # Digit5 :: Char+-- '5'+--+-- >>> charHEXADECIMAL # Digit6 :: Char+-- '6'+--+-- >>> charHEXADECIMAL # Digit7 :: Char+-- '7'+--+-- >>> charHEXADECIMAL # Digit8 :: Char+-- '8'+--+-- >>> charHEXADECIMAL # Digit9 :: Char+-- '9'+--+-- >>> charHEXADECIMAL # DigitA :: Char+-- 'A'+--+-- >>> charHEXADECIMAL # DigitB :: Char+-- 'B'+--+-- >>> charHEXADECIMAL # DigitC :: Char+-- 'C'+--+-- >>> charHEXADECIMAL # DigitD :: Char+-- 'D'+--+-- >>> charHEXADECIMAL # DigitE :: Char+-- 'E'+--+-- >>> charHEXADECIMAL # DigitF :: Char+-- 'F'+--+-- prop> \c -> (c `notElem` "0123456789ABCDEF") ==> (c ^? charHEXADECIMAL == Nothing)+charHEXADECIMAL ::+  HEXADECIMAL d =>+  Prism'+    Char+    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)]+  +-- |+--+-- >>> '1' ^? charHeXaDeCiMaLNoZero :: Maybe Digit+-- Just 1+--+-- >>> '2' ^? charHeXaDeCiMaLNoZero :: Maybe Digit+-- Just 2+--+-- >>> '3' ^? charHeXaDeCiMaLNoZero :: Maybe Digit+-- Just 3+--+-- >>> '4' ^? charHeXaDeCiMaLNoZero :: Maybe Digit+-- Just 4+--+-- >>> '5' ^? charHeXaDeCiMaLNoZero :: Maybe Digit+-- Just 5+--+-- >>> '6' ^? charHeXaDeCiMaLNoZero :: Maybe Digit+-- Just 6+--+-- >>> '7' ^? charHeXaDeCiMaLNoZero :: Maybe Digit+-- Just 7+--+-- >>> '8' ^? charHeXaDeCiMaLNoZero :: Maybe Digit+-- Just 8+--+-- >>> '9' ^? charHeXaDeCiMaLNoZero :: Maybe Digit+-- Just 9+--+-- >>> 'a' ^? charHeXaDeCiMaLNoZero :: Maybe Digit+-- Just a+--+-- >>> 'b' ^? charHeXaDeCiMaLNoZero :: Maybe Digit+-- Just b+--+-- >>> 'c' ^? charHeXaDeCiMaLNoZero :: Maybe Digit+-- Just c+--+-- >>> 'd' ^? charHeXaDeCiMaLNoZero :: Maybe Digit+-- Just d+--+-- >>> 'e' ^? charHeXaDeCiMaLNoZero :: Maybe Digit+-- Just e+--+-- >>> 'f' ^? charHeXaDeCiMaLNoZero :: Maybe Digit+-- Just f+--+-- >>> 'A' ^? charHeXaDeCiMaLNoZero :: Maybe Digit+-- Just A+--+-- >>> 'B' ^? charHeXaDeCiMaLNoZero :: Maybe Digit+-- Just B+--+-- >>> 'C' ^? charHeXaDeCiMaLNoZero :: Maybe Digit+-- Just C+--+-- >>> 'D' ^? charHeXaDeCiMaLNoZero :: Maybe Digit+-- Just D+--+-- >>> 'E' ^? charHeXaDeCiMaLNoZero :: Maybe Digit+-- Just E+--+-- >>> 'F' ^? charHeXaDeCiMaLNoZero :: Maybe Digit+-- Just F+--+-- >>> charHeXaDeCiMaLNoZero # Digit1 :: Char+-- '1'+--+-- >>> charHeXaDeCiMaLNoZero # Digit2 :: Char+-- '2'+--+-- >>> charHeXaDeCiMaLNoZero # Digit3 :: Char+-- '3'+--+-- >>> charHeXaDeCiMaLNoZero # Digit4 :: Char+-- '4'+--+-- >>> charHeXaDeCiMaLNoZero # Digit5 :: Char+-- '5'+--+-- >>> charHeXaDeCiMaLNoZero # Digit6 :: Char+-- '6'+--+-- >>> charHeXaDeCiMaLNoZero # Digit7 :: Char+-- '7'+--+-- >>> charHeXaDeCiMaLNoZero # Digit8 :: Char+-- '8'+--+-- >>> charHeXaDeCiMaLNoZero # Digit9 :: Char+-- '9'+--+-- >>> charHeXaDeCiMaLNoZero # Digita :: Char+-- 'a'+--+-- >>> charHeXaDeCiMaLNoZero # Digitb :: Char+-- 'b'+--+-- >>> charHeXaDeCiMaLNoZero # Digitc :: Char+-- 'c'+--+-- >>> charHeXaDeCiMaLNoZero # Digitd :: Char+-- 'd'+--+-- >>> charHeXaDeCiMaLNoZero # Digite :: Char+-- 'e'+--+-- >>> charHeXaDeCiMaLNoZero # Digitf :: Char+-- 'f'+--+-- >>> charHeXaDeCiMaLNoZero # DigitA :: Char+-- 'A'+--+-- >>> charHeXaDeCiMaLNoZero # DigitB :: Char+-- 'B'+--+-- >>> charHeXaDeCiMaLNoZero # DigitC :: Char+-- 'C'+--+-- >>> charHeXaDeCiMaLNoZero # DigitD :: Char+-- 'D'+--+-- >>> charHeXaDeCiMaLNoZero # DigitE :: Char+-- 'E'+--+-- >>> charHeXaDeCiMaLNoZero # DigitF :: Char+-- 'F'+--+-- prop> \c -> (c `notElem` "123456789abcdefABCDEF") ==> (c ^? charHeXaDeCiMaLNoZero == Nothing)+charHeXaDeCiMaLNoZero ::+  HeXaDeCiMaLNoZero d =>+  Prism'+    Char+    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)]+  ++-- |+--+-- >>> '0' ^? charHeXaDeCiMaL :: Maybe Digit+-- Just 0+--+-- >>> '1' ^? charHeXaDeCiMaL :: Maybe Digit+-- Just 1+--+-- >>> '2' ^? charHeXaDeCiMaL :: Maybe Digit+-- Just 2+--+-- >>> '3' ^? charHeXaDeCiMaL :: Maybe Digit+-- Just 3+--+-- >>> '4' ^? charHeXaDeCiMaL :: Maybe Digit+-- Just 4+--+-- >>> '5' ^? charHeXaDeCiMaL :: Maybe Digit+-- Just 5+--+-- >>> '6' ^? charHeXaDeCiMaL :: Maybe Digit+-- Just 6+--+-- >>> '7' ^? charHeXaDeCiMaL :: Maybe Digit+-- Just 7+--+-- >>> '8' ^? charHeXaDeCiMaL :: Maybe Digit+-- Just 8+--+-- >>> '9' ^? charHeXaDeCiMaL :: Maybe Digit+-- Just 9+--+-- >>> 'a' ^? charHeXaDeCiMaL :: Maybe Digit+-- Just a+--+-- >>> 'b' ^? charHeXaDeCiMaL :: Maybe Digit+-- Just b+--+-- >>> 'c' ^? charHeXaDeCiMaL :: Maybe Digit+-- Just c+--+-- >>> 'd' ^? charHeXaDeCiMaL :: Maybe Digit+-- Just d+--+-- >>> 'e' ^? charHeXaDeCiMaL :: Maybe Digit+-- Just e+--+-- >>> 'f' ^? charHeXaDeCiMaL :: Maybe Digit+-- Just f+--+-- >>> 'A' ^? charHeXaDeCiMaL :: Maybe Digit+-- Just A+--+-- >>> 'B' ^? charHeXaDeCiMaL :: Maybe Digit+-- Just B+--+-- >>> 'C' ^? charHeXaDeCiMaL :: Maybe Digit+-- Just C+--+-- >>> 'D' ^? charHeXaDeCiMaL :: Maybe Digit+-- Just D+--+-- >>> 'E' ^? charHeXaDeCiMaL :: Maybe Digit+-- Just E+--+-- >>> 'F' ^? charHeXaDeCiMaL :: Maybe Digit+-- Just F+--+-- >>> charHeXaDeCiMaL # Digit0 :: Char+-- '0'+--+-- >>> charHeXaDeCiMaL # Digit1 :: Char+-- '1'+--+-- >>> charHeXaDeCiMaL # Digit2 :: Char+-- '2'+--+-- >>> charHeXaDeCiMaL # Digit3 :: Char+-- '3'+--+-- >>> charHeXaDeCiMaL # Digit4 :: Char+-- '4'+--+-- >>> charHeXaDeCiMaL # Digit5 :: Char+-- '5'+--+-- >>> charHeXaDeCiMaL # Digit6 :: Char+-- '6'+--+-- >>> charHeXaDeCiMaL # Digit7 :: Char+-- '7'+--+-- >>> charHeXaDeCiMaL # Digit8 :: Char+-- '8'+--+-- >>> charHeXaDeCiMaL # Digit9 :: Char+-- '9'+--+-- >>> charHeXaDeCiMaL # Digita :: Char+-- 'a'+--+-- >>> charHeXaDeCiMaL # Digitb :: Char+-- 'b'+--+-- >>> charHeXaDeCiMaL # Digitc :: Char+-- 'c'+--+-- >>> charHeXaDeCiMaL # Digitd :: Char+-- 'd'+--+-- >>> charHeXaDeCiMaL # Digite :: Char+-- 'e'+--+-- >>> charHeXaDeCiMaL # Digitf :: Char+-- 'f'+--+-- >>> charHeXaDeCiMaL # DigitA :: Char+-- 'A'+--+-- >>> charHeXaDeCiMaL # DigitB :: Char+-- 'B'+--+-- >>> charHeXaDeCiMaL # DigitC :: Char+-- 'C'+--+-- >>> charHeXaDeCiMaL # DigitD :: Char+-- 'D'+--+-- >>> charHeXaDeCiMaL # DigitE :: Char+-- 'E'+--+-- >>> charHeXaDeCiMaL # DigitF :: Char+-- 'F'+--+-- prop> \c -> (c `notElem` "0123456789abcdefABCDEF") ==> (c ^? charHeXaDeCiMaL == Nothing)+charHeXaDeCiMaL ::+  HeXaDeCiMaL d =>+  Prism'+    Char+    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), ('A', dA), ('B', dB), ('C', dC), ('D', dD), ('E', dE), ('F', dF)]+  +---- not exported+associatePrism ::+  (Eq b, Choice p, Applicative f) =>+  (b, APrism a a () ())+  -> [(b, APrism a a () ())]+  -> p a (f a)+  -> p b (f b)+associatePrism def z =+  prism'+    (\d -> fst (fromMaybe def (find (\(_, w) -> is w d) z)))+    (\i -> (\p -> clonePrism p # ()) <$> lookup i (def:z))

@@ -1,10 +1,12 @@ {-# LANGUAGE NoImplicitPrelude #-}+{-# LANGUAGE FlexibleInstances #-}  module Data.Digit.D0(   D0(..) , parse0 ) where   +import Data.Digit.Digit(Digit(Digit0)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))@@ -12,7 +14,6 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)--- >>> import Data.Digit.Digit0  class D0 d where   d0 ::@@ -30,22 +31,28 @@  -- | ----- >>> parse (parse0 <* eof) "test" "0" :: Either ParseError (Digit0 ())--- Right (Digit0 ())+-- >>> parse (parse0 <* eof) "test" "0" :: Either ParseError Digit+-- Right 0 ----- >>> parse parse0 "test" "0xyz" :: Either ParseError (Digit0 ())--- Right (Digit0 ())+-- >>> parse parse0 "test" "0xyz" :: Either ParseError Digit+-- Right 0 ----- >>> isn't _Right (parse parse0 "test" "xyz" :: Either ParseError (Digit0 ()))+-- >>> isn't _Right (parse parse0 "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> c /= '0' ==> isn't _Right (parse parse0 "test" [c] :: Either ParseError (Digit0 ()))+-- prop> \c -> c /= '0' ==> isn't _Right (parse parse0 "test" [c] :: Either ParseError Digit) parse0 ::   (D0 d, CharParsing p) =>   p d parse0 =   x0 <$ char '0' <?> "0" -instance D0 d => D0 (Either d x) where+instance D0 Digit where   d0 =-    _Left . d0+    prism'+      (\() -> Digit0)+      (\d ->  case d of+                Digit0 ->+                  Just ()+                _ ->+                  Nothing)

@@ -5,6 +5,7 @@ , parse1 ) where +import Data.Digit.Digit(Digit(Digit1)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))@@ -12,7 +13,6 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)--- >>> import Data.Digit.Digit1  class D1 d where   d1 ::@@ -30,22 +30,28 @@  -- | ----- >>> parse (parse1 <* eof) "test" "1" :: Either ParseError (Digit1 ())--- Right (Digit1 ())+-- >>> parse (parse1 <* eof) "test" "1" :: Either ParseError Digit+-- Right 1 ----- >>> parse parse1 "test" "1xyz" :: Either ParseError (Digit1 ())--- Right (Digit1 ())+-- >>> parse parse1 "test" "1xyz" :: Either ParseError Digit+-- Right 1 ----- >>> isn't _Right (parse parse1 "test" "xyz" :: Either ParseError (Digit1 ()))+-- >>> isn't _Right (parse parse1 "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> c /= '1' ==> isn't _Right (parse parse1 "test" [c] :: Either ParseError (Digit1 ()))+-- prop> \c -> c /= '1' ==> isn't _Right (parse parse1 "test" [c] :: Either ParseError Digit) parse1 ::   (D1 d, CharParsing p) =>   p d parse1 =   x1 <$ char '1' <?> "1"-    -instance D1 d => D1 (Either d x) where+  +instance D1 Digit where   d1 =-    _Left . d1+    prism'+      (\() -> Digit1)+      (\d ->  case d of+                Digit1 ->+                  Just ()+                _ ->+                  Nothing)

@@ -5,6 +5,7 @@ , parse2 ) where +import Data.Digit.Digit(Digit(Digit2)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))@@ -12,7 +13,6 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)--- >>> import Data.Digit.Digit2  class D2 d where   d2 ::@@ -30,22 +30,29 @@      -- | ----- >>> parse (parse2 <* eof) "test" "2" :: Either ParseError (Digit2 ())--- Right (Digit2 ())+-- >>> parse (parse2 <* eof) "test" "2" :: Either ParseError Digit+-- Right 2 ----- >>> parse parse2 "test" "2xyz" :: Either ParseError (Digit2 ())--- Right (Digit2 ())+-- >>> parse parse2 "test" "2xyz" :: Either ParseError Digit+-- Right 2 ----- >>> isn't _Right (parse parse2 "test" "xyz" :: Either ParseError (Digit2 ()))+-- >>> isn't _Right (parse parse2 "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> c /= '2' ==> isn't _Right (parse parse2 "test" [c] :: Either ParseError (Digit2 ()))+-- prop> \c -> c /= '2' ==> isn't _Right (parse parse2 "test" [c] :: Either ParseError Digit) parse2 ::   (D2 d, CharParsing p) =>   p d parse2 =   x2 <$ char '2' <?> "2" -instance D2 d => D2 (Either d x) where+instance D2 Digit where   d2 =-    _Left . d2+    prism'+      (\() -> Digit2)+      (\d ->  case d of+                Digit2 ->+                  Just ()+                _ ->+                  Nothing)+

@@ -5,6 +5,7 @@ , parse3 ) where +import Data.Digit.Digit(Digit(Digit3)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))@@ -12,7 +13,6 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)--- >>> import Data.Digit.Digit3  class D3 d where   d3 ::@@ -30,22 +30,28 @@  -- | ----- >>> parse (parse3 <* eof) "test" "3" :: Either ParseError (Digit3 ())--- Right (Digit3 ())+-- >>> parse (parse3 <* eof) "test" "3" :: Either ParseError Digit+-- Right 3 ----- >>> parse parse3 "test" "3xyz" :: Either ParseError (Digit3 ())--- Right (Digit3 ())+-- >>> parse parse3 "test" "3xyz" :: Either ParseError Digit+-- Right 3 ----- >>> isn't _Right (parse parse3 "test" "xyz" :: Either ParseError (Digit3 ()))+-- >>> isn't _Right (parse parse3 "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> c /= '3' ==> isn't _Right (parse parse3 "test" [c] :: Either ParseError (Digit3 ()))+-- prop> \c -> c /= '3' ==> isn't _Right (parse parse3 "test" [c] :: Either ParseError Digit) parse3 ::   (D3 d, CharParsing p) =>   p d parse3 =   x3 <$ char '3' <?> "3" -instance D3 d => D3 (Either d x) where+instance D3 Digit where   d3 =-    _Left . d3+    prism'+      (\() -> Digit3)+      (\d ->  case d of+                Digit3 ->+                  Just ()+                _ ->+                  Nothing)

@@ -5,6 +5,7 @@ , parse4 ) where +import Data.Digit.Digit(Digit(Digit4)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))@@ -12,7 +13,6 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)--- >>> import Data.Digit.Digit4  class D4 d where   d4 ::@@ -30,22 +30,28 @@     -- | ----- >>> parse (parse4 <* eof) "test" "4" :: Either ParseError (Digit4 ())--- Right (Digit4 ())+-- >>> parse (parse4 <* eof) "test" "4" :: Either ParseError Digit+-- Right 4 ----- >>> parse parse4 "test" "4xyz" :: Either ParseError (Digit4 ())--- Right (Digit4 ())+-- >>> parse parse4 "test" "4xyz" :: Either ParseError Digit+-- Right 4 ----- >>> isn't _Right (parse parse4 "test" "xyz" :: Either ParseError (Digit4 ()))+-- >>> isn't _Right (parse parse4 "test" "xyz" :: Either ParseError Digit) -- True  ----- prop> \c -> c /= '4' ==> isn't _Right (parse parse4 "test" [c] :: Either ParseError (Digit4 ()))+-- prop> \c -> c /= '4' ==> isn't _Right (parse parse4 "test" [c] :: Either ParseError Digit) parse4 ::   (D4 d, CharParsing p) =>   p d parse4 =   x4 <$ char '4' <?> "4" -instance D4 d => D4 (Either d x) where+instance D4 Digit where   d4 =-    _Left . d4+    prism'+      (\() -> Digit4)+      (\d ->  case d of+                Digit4 ->+                  Just ()+                _ ->+                  Nothing)

@@ -5,6 +5,7 @@ , parse5 ) where +import Data.Digit.Digit(Digit(Digit5)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))@@ -12,7 +13,6 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)--- >>> import Data.Digit.Digit5  class D5 d where   d5 ::@@ -30,22 +30,28 @@      -- | ----- >>> parse (parse5 <* eof) "test" "5" :: Either ParseError (Digit5 ())--- Right (Digit5 ())+-- >>> parse (parse5 <* eof) "test" "5" :: Either ParseError Digit+-- Right 5 ----- >>> parse parse5 "test" "5xyz" :: Either ParseError (Digit5 ())--- Right (Digit5 ())+-- >>> parse parse5 "test" "5xyz" :: Either ParseError Digit+-- Right 5 ----- >>> isn't _Right (parse parse5 "test" "xyz" :: Either ParseError (Digit5 ()))+-- >>> isn't _Right (parse parse5 "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> c /= '5' ==> isn't _Right (parse parse5 "test" [c] :: Either ParseError (Digit5 ()))+-- prop> \c -> c /= '5' ==> isn't _Right (parse parse5 "test" [c] :: Either ParseError Digit) parse5 ::   (D5 d, CharParsing p) =>   p d parse5 =   x5 <$ char '5' <?> "5" -instance D5 d => D5 (Either d x) where+instance D5 Digit where   d5 =-    _Left . d5+    prism'+      (\() -> Digit5)+      (\d ->  case d of+                Digit5 ->+                  Just ()+                _ ->+                  Nothing)

@@ -5,6 +5,7 @@ , parse6 ) where +import Data.Digit.Digit(Digit(Digit6)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))@@ -12,7 +13,6 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)--- >>> import Data.Digit.Digit6  class D6 d where   d6 ::@@ -30,22 +30,28 @@      -- | ----- >>> parse (parse6 <* eof) "test" "6" :: Either ParseError (Digit6 ())--- Right (Digit6 ())+-- >>> parse (parse6 <* eof) "test" "6" :: Either ParseError Digit+-- Right 6 ----- >>> parse parse6 "test" "6xyz" :: Either ParseError (Digit6 ())--- Right (Digit6 ())+-- >>> parse parse6 "test" "6xyz" :: Either ParseError Digit+-- Right 6 ----- >>> isn't _Right (parse parse6 "test" "xyz" :: Either ParseError (Digit6 ()))+-- >>> isn't _Right (parse parse6 "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> c /= '6' ==> isn't _Right (parse parse6 "test" [c] :: Either ParseError (Digit6 ()))+-- prop> \c -> c /= '6' ==> isn't _Right (parse parse6 "test" [c] :: Either ParseError Digit) parse6 ::   (D6 d, CharParsing p) =>   p d parse6 =   x6 <$ char '6' <?> "6" -instance D6 d => D6 (Either d x) where+instance D6 Digit where   d6 =-    _Left . d6+    prism'+      (\() -> Digit6)+      (\d ->  case d of+                Digit6 ->+                  Just ()+                _ ->+                  Nothing)

@@ -5,6 +5,7 @@ , parse7 ) where +import Data.Digit.Digit(Digit(Digit7)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))@@ -12,7 +13,6 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)--- >>> import Data.Digit.Digit7  class D7 d where   d7 ::@@ -30,22 +30,28 @@      -- | ----- >>> parse (parse7 <* eof) "test" "7" :: Either ParseError (Digit7 ())--- Right (Digit7 ())+-- >>> parse (parse7 <* eof) "test" "7" :: Either ParseError Digit+-- Right 7 ----- >>> parse parse7 "test" "7xyz" :: Either ParseError (Digit7 ())--- Right (Digit7 ())+-- >>> parse parse7 "test" "7xyz" :: Either ParseError Digit+-- Right 7 ----- >>> isn't _Right (parse parse7 "test" "xyz" :: Either ParseError (Digit7 ()))+-- >>> isn't _Right (parse parse7 "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> c /= '7' ==> isn't _Right (parse parse7 "test" [c] :: Either ParseError (Digit7 ()))+-- prop> \c -> c /= '7' ==> isn't _Right (parse parse7 "test" [c] :: Either ParseError Digit) parse7 ::   (D7 d, CharParsing p) =>   p d parse7 =   x7 <$ char '7' <?> "7" -instance D7 d => D7 (Either d x) where+instance D7 Digit where   d7 =-    _Left . d7+    prism'+      (\() -> Digit7)+      (\d ->  case d of+                Digit7 ->+                  Just ()+                _ ->+                  Nothing)

@@ -5,6 +5,7 @@ , parse8 ) where +import Data.Digit.Digit(Digit(Digit8)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))@@ -12,7 +13,6 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)--- >>> import Data.Digit.Digit8  class D8 d where   d8 ::@@ -30,22 +30,28 @@      -- | ----- >>> parse (parse8 <* eof) "test" "8" :: Either ParseError (Digit8 ())--- Right (Digit8 ())+-- >>> parse (parse8 <* eof) "test" "8" :: Either ParseError Digit+-- Right 8 ----- >>> parse parse8 "test" "8xyz" :: Either ParseError (Digit8 ())--- Right (Digit8 ())+-- >>> parse parse8 "test" "8xyz" :: Either ParseError Digit+-- Right 8 ----- >>> isn't _Right (parse parse8 "test" "xyz" :: Either ParseError (Digit8 ()))+-- >>> isn't _Right (parse parse8 "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> c /= '8' ==> isn't _Right (parse parse8 "test" [c] :: Either ParseError (Digit8 ()))+-- prop> \c -> c /= '8' ==> isn't _Right (parse parse8 "test" [c] :: Either ParseError Digit) parse8 ::   (D8 d, CharParsing p) =>   p d parse8 =   x8 <$ char '8' <?> "8" -instance D8 d => D8 (Either d x) where+instance D8 Digit where   d8 =-    _Left . d8+    prism'+      (\() -> Digit8)+      (\d ->  case d of+                Digit8 ->+                  Just ()+                _ ->+                  Nothing)

@@ -5,6 +5,7 @@ , parse9 ) where +import Data.Digit.Digit(Digit(Digit9)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))@@ -12,7 +13,6 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)--- >>> import Data.Digit.Digit9  class D9 d where   d9 ::@@ -30,22 +30,28 @@      -- | ----- >>> parse (parse9 <* eof) "test" "9" :: Either ParseError (Digit9 ())--- Right (Digit9 ())+-- >>> parse (parse9 <* eof) "test" "9" :: Either ParseError Digit+-- Right 9 ----- >>> parse parse9 "test" "9xyz" :: Either ParseError (Digit9 ())--- Right (Digit9 ())+-- >>> parse parse9 "test" "9xyz" :: Either ParseError Digit+-- Right 9 ----- >>> isn't _Right (parse parse9 "test" "xyz" :: Either ParseError (Digit9 ()))+-- >>> isn't _Right (parse parse9 "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> c /= '9' ==> isn't _Right (parse parse9 "test" [c] :: Either ParseError (Digit9 ()))+-- prop> \c -> c /= '9' ==> isn't _Right (parse parse9 "test" [c] :: Either ParseError Digit) parse9 ::   (D9 d, CharParsing p) =>   p d parse9 =   x9 <$ char '9' <?> "9" -instance D9 d => D9 (Either d x) where+instance D9 Digit where   d9 =-    _Left . d9+    prism'+      (\() -> Digit9)+      (\d ->  case d of+                Digit9 ->+                  Just ()+                _ ->+                  Nothing)

@@ -5,6 +5,7 @@ , parseA ) where +import Data.Digit.Digit(Digit(DigitA)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))@@ -12,7 +13,6 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)--- >>> import Data.Digit.DigitA  class DA d where   dA ::@@ -30,22 +30,28 @@  -- | ----- >>> parse (parseA <* eof) "test" "A" :: Either ParseError (DigitA ())--- Right (DigitA ())+-- >>> parse (parseA <* eof) "test" "A" :: Either ParseError Digit+-- Right A ----- >>> parse parseA "test" "Axyz" :: Either ParseError (DigitA ())--- Right (DigitA ())+-- >>> parse parseA "test" "Axyz" :: Either ParseError Digit+-- Right A ----- >>> isn't _Right (parse parseA "test" "xyz" :: Either ParseError (DigitA ()))+-- >>> isn't _Right (parse parseA "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> c /= 'A' ==> isn't _Right (parse parseA "test" [c] :: Either ParseError (DigitA ()))+-- prop> \c -> c /= 'A' ==> isn't _Right (parse parseA "test" [c] :: Either ParseError Digit) parseA ::   (DA d, CharParsing p) =>   p d parseA =   xA <$ char 'A' <?> "A" -instance DA d => DA (Either d x) where+instance DA Digit where   dA =-    _Left . dA+    prism'+      (\() -> DigitA)+      (\d ->  case d of+                DigitA ->+                  Just ()+                _ ->+                  Nothing)

@@ -19,7 +19,7 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)--- >>> import Data.Digit.HeXaDeCiMaL+-- >>> import Data.Digit.Digit -- >>> import Papa  type DAa a =@@ -27,22 +27,22 @@    -- | ----- >>> parse (parseAa <* eof) "test" "A" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseAa <* eof) "test" "A" :: Either ParseError Digit+-- Right A ----- >>> parse (parseAa <* eof) "test" "a" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseAa "test" "Axyz" :: Either ParseError Digit+-- Right A ----- >>> parse parseAa "test" "Axyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseAa <* eof) "test" "a" :: Either ParseError Digit+-- Right a ----- >>> parse parseAa "test" "axyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseAa "test" "axyz" :: Either ParseError Digit+-- Right a ----- >>> isn't _Right (parse parseAa "test" "xyz" :: Either ParseError (HeXaDeCiMaLDigit' ()))+-- >>> isn't _Right (parse parseAa "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> (c `notElem` "Aa") ==> isn't _Right (parse parseAa "test" [c] :: Either ParseError (HeXaDeCiMaLDigit' ()))+-- prop> \c -> (c `notElem` "Aa") ==> isn't _Right (parse parseAa "test" [c] :: Either ParseError Digit) parseAa ::   (DAa d, CharParsing p) =>   p d

@@ -5,6 +5,7 @@ , parseB ) where +import Data.Digit.Digit(Digit(DigitB)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))@@ -12,7 +13,6 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)--- >>> import Data.Digit.DigitB  class DB d where   dB ::@@ -30,22 +30,28 @@      -- | ----- >>> parse (parseB <* eof) "test" "B" :: Either ParseError (DigitB ())--- Right (DigitB ())+-- >>> parse (parseB <* eof) "test" "B" :: Either ParseError Digit+-- Right B ----- >>> parse parseB "test" "Bxyz" :: Either ParseError (DigitB ())--- Right (DigitB ())+-- >>> parse parseB "test" "Bxyz" :: Either ParseError Digit+-- Right B ----- >>> isn't _Right (parse parseB "test" "xyz" :: Either ParseError (DigitB ()))+-- >>> isn't _Right (parse parseB "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> c /= 'B' ==> isn't _Right (parse parseB "test" [c] :: Either ParseError (DigitB ()))+-- prop> \c -> c /= 'B' ==> isn't _Right (parse parseB "test" [c] :: Either ParseError Digit) parseB ::   (DB d, CharParsing p) =>   p d parseB =   xB <$ char 'B' <?> "B" -instance DB d => DB (Either d x) where+instance DB Digit where   dB =-    _Left . dB+    prism'+      (\() -> DigitB)+      (\d ->  case d of+                DigitB ->+                  Just ()+                _ ->+                  Nothing)

@@ -14,7 +14,7 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)--- >>> import Data.Digit.HeXaDeCiMaL+-- >>> import Data.Digit.Digit -- >>> import Papa  type DBb a =@@ -22,25 +22,24 @@    -- | ----- >>> parse (parseBb <* eof) "test" "B" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseBb <* eof) "test" "B" :: Either ParseError Digit+-- Right B ----- >>> parse (parseBb <* eof) "test" "b" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseBb "test" "Bxyz" :: Either ParseError Digit+-- Right B ----- >>> parse parseBb "test" "Bxyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseBb <* eof) "test" "b" :: Either ParseError Digit+-- Right b ----- >>> parse parseBb "test" "bxyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseBb "test" "bxyz" :: Either ParseError Digit+-- Right b ----- >>> isn't _Right (parse parseBb "test" "xyz" :: Either ParseError (HeXaDeCiMaLDigit' ()))+-- >>> isn't _Right (parse parseBb "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> (c `notElem` "Bb") ==> isn't _Right (parse parseBb "test" [c] :: Either ParseError (HeXaDeCiMaLDigit' ()))+-- prop> \c -> (c `notElem` "Bb") ==> isn't _Right (parse parseBb "test" [c] :: Either ParseError Digit) parseBb ::   (DBb d, CharParsing p) =>   p d parseBb =   choice [parseB, parseb] <?> "Bb"-

@@ -5,6 +5,7 @@ , parseC ) where +import Data.Digit.Digit(Digit(DigitC)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))@@ -12,7 +13,6 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)--- >>> import Data.Digit.DigitC  class DC d where   dC ::@@ -30,22 +30,28 @@      -- | ----- >>> parse (parseC <* eof) "test" "C" :: Either ParseError (DigitC ())--- Right (DigitC ())+-- >>> parse (parseC <* eof) "test" "C" :: Either ParseError Digit+-- Right C ----- >>> parse parseC "test" "Cxyz" :: Either ParseError (DigitC ())--- Right (DigitC ())+-- >>> parse parseC "test" "Cxyz" :: Either ParseError Digit+-- Right C ----- >>> isn't _Right (parse parseC "test" "xyz" :: Either ParseError (DigitC ()))+-- >>> isn't _Right (parse parseC "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> c /= 'C' ==> isn't _Right (parse parseC "test" [c] :: Either ParseError (DigitC ()))+-- prop> \c -> c /= 'C' ==> isn't _Right (parse parseC "test" [c] :: Either ParseError Digit) parseC ::   (DC d, CharParsing p) =>   p d parseC =   xC <$ char 'C' <?> "C" -instance DC d => DC (Either d x) where+instance DC Digit where   dC =-    _Left . dC+    prism'+      (\() -> DigitC)+      (\d ->  case d of+                DigitC ->+                  Just ()+                _ ->+                  Nothing)

@@ -14,7 +14,7 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)--- >>> import Data.Digit.HeXaDeCiMaL+-- >>> import Data.Digit.Digit -- >>> import Papa  type DCc a =@@ -22,22 +22,22 @@    -- | ----- >>> parse (parseCc <* eof) "test" "C" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseCc <* eof) "test" "C" :: Either ParseError Digit+-- Right C ----- >>> parse (parseCc <* eof) "test" "c" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseCc "test" "Cxyz" :: Either ParseError Digit+-- Right C ----- >>> parse parseCc "test" "Cxyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseCc <* eof) "test" "c" :: Either ParseError Digit+-- Right c ----- >>> parse parseCc "test" "cxyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseCc "test" "cxyz" :: Either ParseError Digit+-- Right c ----- >>> isn't _Right (parse parseCc "test" "xyz" :: Either ParseError (HeXaDeCiMaLDigit' ()))+-- >>> isn't _Right (parse parseCc "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> (c `notElem` "Cc") ==> isn't _Right (parse parseCc "test" [c] :: Either ParseError (HeXaDeCiMaLDigit' ()))+-- prop> \c -> (c `notElem` "Cc") ==> isn't _Right (parse parseCc "test" [c] :: Either ParseError Digit) parseCc ::   (DCc d, CharParsing p) =>   p d

@@ -5,6 +5,7 @@ , parseD ) where +import Data.Digit.Digit(Digit(DigitD)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))@@ -12,7 +13,6 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)--- >>> import Data.Digit.DigitD  class DD d where   dD ::@@ -30,22 +30,28 @@      -- | ----- >>> parse (parseD <* eof) "test" "D" :: Either ParseError (DigitD ())--- Right (DigitD ())+-- >>> parse (parseD <* eof) "test" "D" :: Either ParseError Digit+-- Right D ----- >>> parse parseD "test" "Dxyz" :: Either ParseError (DigitD ())--- Right (DigitD ())+-- >>> parse parseD "test" "Dxyz" :: Either ParseError Digit+-- Right D ----- >>> isn't _Right (parse parseD "test" "xyz" :: Either ParseError (DigitD ()))+-- >>> isn't _Right (parse parseD "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> c /= 'D' ==> isn't _Right (parse parseD "test" [c] :: Either ParseError (DigitD ()))+-- prop> \c -> c /= 'D' ==> isn't _Right (parse parseD "test" [c] :: Either ParseError Digit) parseD ::   (DD d, CharParsing p) =>   p d parseD =   xD <$ char 'D' <?> "D" -instance DD d => DD (Either d x) where+instance DD Digit where   dD =-    _Left . dD+    prism'+      (\() -> DigitD)+      (\d ->  case d of+                DigitD ->+                  Just ()+                _ ->+                  Nothing)

@@ -14,7 +14,7 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)--- >>> import Data.Digit.HeXaDeCiMaL+-- >>> import Data.Digit.Digit -- >>> import Papa  type DDd a =@@ -22,22 +22,22 @@    -- | ----- >>> parse (parseDd <* eof) "test" "D" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseDd <* eof) "test" "D" :: Either ParseError Digit+-- Right D ----- >>> parse (parseDd <* eof) "test" "d" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseDd "test" "Dxyz" :: Either ParseError Digit+-- Right D ----- >>> parse parseDd "test" "Dxyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseDd <* eof) "test" "d" :: Either ParseError Digit+-- Right d ----- >>> parse parseDd "test" "dxyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseDd "test" "dxyz" :: Either ParseError Digit+-- Right d ----- >>> isn't _Right (parse parseDd "test" "xyz" :: Either ParseError (HeXaDeCiMaLDigit' ()))+-- >>> isn't _Right (parse parseDd "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> (c `notElem` "Dd") ==> isn't _Right (parse parseDd "test" [c] :: Either ParseError (HeXaDeCiMaLDigit' ()))+-- prop> \c -> (c `notElem` "Dd") ==> isn't _Right (parse parseDd "test" [c] :: Either ParseError Digit) parseDd ::   (DDd d, CharParsing p) =>   p d

@@ -5,6 +5,7 @@ , parseE ) where +import Data.Digit.Digit(Digit(DigitE)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))@@ -12,7 +13,6 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)--- >>> import Data.Digit.DigitE  class DE d where   dE ::@@ -30,22 +30,28 @@      -- | ----- >>> parse (parseE <* eof) "test" "E" :: Either ParseError (DigitE ())--- Right (DigitE ())+-- >>> parse (parseE <* eof) "test" "E" :: Either ParseError Digit+-- Right E ----- >>> parse parseE "test" "Exyz" :: Either ParseError (DigitE ())--- Right (DigitE ())+-- >>> parse parseE "test" "Exyz" :: Either ParseError Digit+-- Right E ----- >>> isn't _Right (parse parseE "test" "xyz" :: Either ParseError (DigitE ()))+-- >>> isn't _Right (parse parseE "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> c /= 'E' ==> isn't _Right (parse parseE "test" [c] :: Either ParseError (DigitE ()))+-- prop> \c -> c /= 'E' ==> isn't _Right (parse parseE "test" [c] :: Either ParseError Digit) parseE ::   (DE d, CharParsing p) =>   p d parseE =   xE <$ char 'E' <?> "E" -instance DE d => DE (Either d x) where+instance DE Digit where   dE =-    _Left . dE+    prism'+      (\() -> DigitE)+      (\d ->  case d of+                DigitE ->+                  Just ()+                _ ->+                  Nothing)

@@ -14,7 +14,7 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)--- >>> import Data.Digit.HeXaDeCiMaL+-- >>> import Data.Digit.Digit -- >>> import Papa  type DEe a =@@ -22,22 +22,22 @@    -- | ----- >>> parse (parseEe <* eof) "test" "E" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseEe <* eof) "test" "E" :: Either ParseError Digit+-- Right E ----- >>> parse (parseEe <* eof) "test" "e" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseEe "test" "Exyz" :: Either ParseError Digit+-- Right E ----- >>> parse parseEe "test" "Exyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseEe <* eof) "test" "e" :: Either ParseError Digit+-- Right e ----- >>> parse parseEe "test" "exyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseEe "test" "exyz" :: Either ParseError Digit+-- Right e ----- >>> isn't _Right (parse parseEe "test" "xyz" :: Either ParseError (HeXaDeCiMaLDigit' ()))+-- >>> isn't _Right (parse parseEe "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> (c `notElem` "Ee") ==> isn't _Right (parse parseEe "test" [c] :: Either ParseError (HeXaDeCiMaLDigit' ()))+-- prop> \c -> (c `notElem` "Ee") ==> isn't _Right (parse parseEe "test" [c] :: Either ParseError Digit) parseEe ::   (DEe d, CharParsing p) =>   p d

@@ -5,6 +5,7 @@ , parseF ) where +import Data.Digit.Digit(Digit(DigitF)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))@@ -12,7 +13,6 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)--- >>> import Data.Digit.DigitF  class DF d where   dF ::@@ -30,22 +30,28 @@      -- | ----- >>> parse (parseF <* eof) "test" "F" :: Either ParseError (DigitF ())--- Right (DigitF ())+-- >>> parse (parseF <* eof) "test" "F" :: Either ParseError Digit+-- Right F ----- >>> parse parseF "test" "Fxyz" :: Either ParseError (DigitF ())--- Right (DigitF ())+-- >>> parse parseF "test" "Fxyz" :: Either ParseError Digit+-- Right F ----- >>> isn't _Right (parse parseF "test" "xyz" :: Either ParseError (DigitF ()))+-- >>> isn't _Right (parse parseF "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> c /= 'F' ==> isn't _Right (parse parseF "test" [c] :: Either ParseError (DigitF ()))+-- prop> \c -> c /= 'F' ==> isn't _Right (parse parseF "test" [c] :: Either ParseError Digit) parseF ::   (DF d, CharParsing p) =>   p d parseF =   xF <$ char 'F' <?> "F" -instance DF d => DF (Either d x) where+instance DF Digit where   dF =-    _Left . dF+    prism'+      (\() -> DigitF)+      (\d ->  case d of+                DigitF ->+                  Just ()+                _ ->+                  Nothing)

@@ -14,7 +14,7 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)--- >>> import Data.Digit.HeXaDeCiMaL+-- >>> import Data.Digit.Digit -- >>> import Papa  type DFf a =@@ -22,22 +22,22 @@    -- | ----- >>> parse (parseFf <* eof) "test" "F" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseFf <* eof) "test" "F" :: Either ParseError Digit+-- Right F ----- >>> parse (parseFf <* eof) "test" "f" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseFf "test" "Fxyz" :: Either ParseError Digit+-- Right F ----- >>> parse parseFf "test" "Fxyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseFf <* eof) "test" "f" :: Either ParseError Digit+-- Right f ----- >>> parse parseFf "test" "fxyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseFf "test" "fxyz" :: Either ParseError Digit+-- Right f ----- >>> isn't _Right (parse parseFf "test" "xyz" :: Either ParseError (HeXaDeCiMaLDigit' ()))+-- >>> isn't _Right (parse parseFf "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> (c `notElem` "Ff") ==> isn't _Right (parse parseFf "test" [c] :: Either ParseError (HeXaDeCiMaLDigit' ()))+-- prop> \c -> (c `notElem` "Ff") ==> isn't _Right (parse parseFf "test" [c] :: Either ParseError Digit) parseFf ::   (DFf d, CharParsing p) =>   p d

@@ -5,6 +5,7 @@ , parsea ) where +import Data.Digit.Digit(Digit(Digita)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))@@ -12,7 +13,6 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)--- >>> import Data.Digit.Digita  class Da d where   da ::@@ -30,22 +30,28 @@      -- | ----- >>> parse (parsea <* eof) "test" "a" :: Either ParseError (Digita ())--- Right (Digita ())+-- >>> parse (parsea <* eof) "test" "a" :: Either ParseError Digit+-- Right a ----- >>> parse parsea "test" "axyz" :: Either ParseError (Digita ())--- Right (Digita ())+-- >>> parse parsea "test" "axyz" :: Either ParseError Digit+-- Right a ----- >>> isn't _Right (parse parsea "test" "xyz" :: Either ParseError (Digita ()))+-- >>> isn't _Right (parse parsea "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> c /= 'a' ==> isn't _Right (parse parsea "test" [c] :: Either ParseError (Digita ()))+-- prop> \c -> c /= 'a' ==> isn't _Right (parse parsea "test" [c] :: Either ParseError Digit) parsea ::   (Da d, CharParsing p) =>   p d parsea =   xa <$ char 'a' <?> "a" -instance Da d => Da (Either d x) where+instance Da Digit where   da =-    _Left . da+    prism'+      (\() -> Digita)+      (\d ->  case d of+                Digita ->+                  Just ()+                _ ->+                  Nothing)

@@ -5,6 +5,7 @@ , parseb ) where +import Data.Digit.Digit(Digit(Digitb)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))@@ -12,7 +13,6 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)--- >>> import Data.Digit.Digitb  class Db d where   db ::@@ -30,22 +30,28 @@      -- | ----- >>> parse (parseb <* eof) "test" "b" :: Either ParseError (Digitb ())--- Right (Digitb ())+-- >>> parse (parseb <* eof) "test" "b" :: Either ParseError Digit+-- Right b ----- >>> parse parseb "test" "bxyz" :: Either ParseError (Digitb ())--- Right (Digitb ())+-- >>> parse parseb "test" "bxyz" :: Either ParseError Digit+-- Right b ----- >>> isn't _Right (parse parseb "test" "xyz" :: Either ParseError (Digitb ()))+-- >>> isn't _Right (parse parseb "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> c /= 'b' ==> isn't _Right (parse parseb "test" [c] :: Either ParseError (Digitb ()))+-- prop> \c -> c /= 'b' ==> isn't _Right (parse parseb "test" [c] :: Either ParseError Digit) parseb ::   (Db d, CharParsing p) =>   p d parseb =   xb <$ char 'b' <?> "b" -instance Db d => Db (Either d x) where+instance Db Digit where   db =-    _Left . db+    prism'+      (\() -> Digitb)+      (\d ->  case d of+                Digitb ->+                  Just ()+                _ ->+                  Nothing)

@@ -5,6 +5,7 @@ , parsec ) where +import Data.Digit.Digit(Digit(Digitc)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))@@ -12,7 +13,6 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)--- >>> import Data.Digit.Digitc  class Dc d where   dc ::@@ -30,22 +30,28 @@     -- | ----- >>> parse (parsec <* eof) "test" "c" :: Either ParseError (Digitc ())--- Right (Digitc ())+-- >>> parse (parsec <* eof) "test" "c" :: Either ParseError Digit+-- Right c ----- >>> parse parsec "test" "cxyz" :: Either ParseError (Digitc ())--- Right (Digitc ())+-- >>> parse parsec "test" "cxyz" :: Either ParseError Digit+-- Right c ----- >>> isn't _Right (parse parsec "test" "xyz" :: Either ParseError (Digitc ()))+-- >>> isn't _Right (parse parsec "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> c /= 'c' ==> isn't _Right (parse parsec "test" [c] :: Either ParseError (Digitc ()))+-- prop> \c -> c /= 'c' ==> isn't _Right (parse parsec "test" [c] :: Either ParseError Digit) parsec ::   (Dc d, CharParsing p) =>   p d parsec =   xc <$ char 'c' <?> "c" -instance Dc d => Dc (Either d x) where+instance Dc Digit where   dc =-    _Left . dc+    prism'+      (\() -> Digitc)+      (\d ->  case d of+                Digitc ->+                  Just ()+                _ ->+                  Nothing)

@@ -5,6 +5,7 @@ , parsed ) where +import Data.Digit.Digit(Digit(Digitd)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))@@ -12,7 +13,6 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)--- >>> import Data.Digit.Digitd  class Dd d where   dd ::@@ -30,22 +30,29 @@      -- | ----- >>> parse (parsed <* eof) "test" "d" :: Either ParseError (Digitd ())--- Right (Digitd ())+-- >>> parse (parsed <* eof) "test" "d" :: Either ParseError Digit+-- Right d ----- >>> parse parsed "test" "dxyz" :: Either ParseError (Digitd ())--- Right (Digitd ())+-- >>> parse parsed "test" "dxyz" :: Either ParseError Digit+-- Right d ----- >>> isn't _Right (parse parsed "test" "xyz" :: Either ParseError (Digitd ()))+-- >>> isn't _Right (parse parsed "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> c /= 'd' ==> isn't _Right (parse parsed "test" [c] :: Either ParseError (Digitd ()))+-- prop> \c -> c /= 'd' ==> isn't _Right (parse parsed "test" [c] :: Either ParseError Digit) parsed ::   (Dd d, CharParsing p) =>   p d parsed =   xd <$ char 'd' <?> "d" -instance Dd d => Dd (Either d x) where+instance Dd Digit where   dd =-    _Left . dd+    prism'+      (\() -> Digitd)+      (\d ->  case d of+                Digitd ->+                  Just ()+                _ ->+                  Nothing)+

@@ -5,6 +5,7 @@ , parsee ) where +import Data.Digit.Digit(Digit(Digite)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))@@ -12,7 +13,6 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)--- >>> import Data.Digit.Digite  class De d where   de ::@@ -30,22 +30,28 @@      -- | ----- >>> parse (parsee <* eof) "test" "e" :: Either ParseError (Digite ())--- Right (Digite ())+-- >>> parse (parsee <* eof) "test" "e" :: Either ParseError Digit+-- Right e ----- >>> parse parsee "test" "exyz" :: Either ParseError (Digite ())--- Right (Digite ())+-- >>> parse parsee "test" "exyz" :: Either ParseError Digit+-- Right e ----- >>> isn't _Right (parse parsee "test" "xyz" :: Either ParseError (Digite ()))+-- >>> isn't _Right (parse parsee "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> c /= 'e' ==> isn't _Right (parse parsee "test" [c] :: Either ParseError (Digite ()))+-- prop> \c -> c /= 'e' ==> isn't _Right (parse parsee "test" [c] :: Either ParseError Digit) parsee ::   (De d, CharParsing p) =>   p d parsee =   xe <$ char 'e' <?> "e" -instance De d => De (Either d x) where+instance De Digit where   de =-    _Left . de+    prism'+      (\() -> Digite)+      (\d ->  case d of+                Digite ->+                  Just ()+                _ ->+                  Nothing)

@@ -6,14 +6,8 @@ , Decimal , parseDecimalNoZero , parseDecimal-, DecimalNoZeroDigit-, DecimalNoZeroDigit'-, DecimalDigit-, DecimalDigit' ) where -import Papa-import Data.Void(Void) import Text.Parser.Char(CharParsing) import Text.Parser.Combinators((<?>), choice) import Data.Digit.D0(D0, parse0)@@ -30,70 +24,72 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)+-- >>> import Data.Digit.Digit+-- >>> import Papa  type DecimalNoZero d =   (D1 d, D2 d, D3 d, D4 d, D5 d, D6 d, D7 d, D8 d, D9 d)  -- | ----- >>> parse (parseDecimalNoZero <* eof) "test" "1" :: Either ParseError (DecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseDecimalNoZero <* eof) "test" "1" :: Either ParseError Digit+-- Right 1 ----- >>> parse parseDecimalNoZero "test" "1xyz" :: Either ParseError (DecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseDecimalNoZero "test" "1xyz" :: Either ParseError Digit+-- Right 1 ----- >>> parse (parseDecimalNoZero <* eof) "test" "2" :: Either ParseError (DecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseDecimalNoZero <* eof) "test" "2" :: Either ParseError Digit+-- Right 2 ----- >>> parse parseDecimalNoZero "test" "2xyz" :: Either ParseError (DecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseDecimalNoZero "test" "2xyz" :: Either ParseError Digit+-- Right 2 ----- >>> parse (parseDecimalNoZero <* eof) "test" "3" :: Either ParseError (DecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseDecimalNoZero <* eof) "test" "3" :: Either ParseError Digit+-- Right 3 ----- >>> parse parseDecimalNoZero "test" "3xyz" :: Either ParseError (DecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseDecimalNoZero "test" "3xyz" :: Either ParseError Digit+-- Right 3 ----- >>> parse (parseDecimalNoZero <* eof) "test" "4" :: Either ParseError (DecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseDecimalNoZero <* eof) "test" "4" :: Either ParseError Digit+-- Right 4 ----- >>> parse parseDecimalNoZero "test" "4xyz" :: Either ParseError (DecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseDecimalNoZero "test" "4xyz" :: Either ParseError Digit+-- Right 4 ----- >>> parse (parseDecimalNoZero <* eof) "test" "5" :: Either ParseError (DecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseDecimalNoZero <* eof) "test" "5" :: Either ParseError Digit+-- Right 5 ----- >>> parse parseDecimalNoZero "test" "5xyz" :: Either ParseError (DecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseDecimalNoZero "test" "5xyz" :: Either ParseError Digit+-- Right 5 ----- >>> parse (parseDecimalNoZero <* eof) "test" "6" :: Either ParseError (DecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseDecimalNoZero <* eof) "test" "6" :: Either ParseError Digit+-- Right 6 ----- >>> parse parseDecimalNoZero "test" "6xyz" :: Either ParseError (DecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseDecimalNoZero "test" "6xyz" :: Either ParseError Digit+-- Right 6 ----- >>> parse (parseDecimalNoZero <* eof) "test" "7" :: Either ParseError (DecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseDecimalNoZero <* eof) "test" "7" :: Either ParseError Digit+-- Right 7 ----- >>> parse parseDecimalNoZero "test" "7xyz" :: Either ParseError (DecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseDecimalNoZero "test" "7xyz" :: Either ParseError Digit+-- Right 7 ----- >>> parse (parseDecimalNoZero <* eof) "test" "8" :: Either ParseError (DecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseDecimalNoZero <* eof) "test" "8" :: Either ParseError Digit+-- Right 8 ----- >>> parse parseDecimalNoZero "test" "8xyz" :: Either ParseError (DecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseDecimalNoZero "test" "8xyz" :: Either ParseError Digit+-- Right 8 ----- >>> parse (parseDecimalNoZero <* eof) "test" "9" :: Either ParseError (DecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseDecimalNoZero <* eof) "test" "9" :: Either ParseError Digit+-- Right 9 ----- >>> parse parseDecimalNoZero "test" "9xyz" :: Either ParseError (DecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseDecimalNoZero "test" "9xyz" :: Either ParseError Digit+-- Right 9 ----- >>> isn't _Right (parse parseDecimalNoZero "test" "xyz" :: Either ParseError (DecimalNoZeroDigit' ()))+-- >>> isn't _Right (parse parseDecimalNoZero "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> (c `notElem` "123456789") ==> isn't _Right (parse parseDecimalNoZero "test" [c] :: Either ParseError (DecimalNoZeroDigit' ()))+-- prop> \c -> (c `notElem` "123456789") ==> isn't _Right (parse parseDecimalNoZero "test" [c] :: Either ParseError Digit) parseDecimalNoZero ::   (DecimalNoZero d, CharParsing p) =>   p d@@ -111,81 +107,75 @@     , parse9     ] <?> "DecimalNoZero" -type DecimalNoZeroDigit d1 d2 d3 d4 d5 d6 d7 d8 d9 =-  Either d1 (Either d2 (Either d3 (Either d4 (Either d5 (Either d5 (Either d6 (Either d7 (Either d8 (Either d9 Void)))))))))--type DecimalNoZeroDigit' d =-  DecimalNoZeroDigit d d d d d d d d d- type Decimal d =   (D0 d, DecimalNoZero d)  -- | ----- >>> parse (parseDecimal <* eof) "test" "0" :: Either ParseError (DecimalDigit' ())--- Right (Left ())+-- >>> parse (parseDecimal <* eof) "test" "0" :: Either ParseError Digit+-- Right 0 ----- >>> parse parseDecimal "test" "0xyz" :: Either ParseError (DecimalDigit' ())--- Right (Left ())+-- >>> parse parseDecimal "test" "0xyz" :: Either ParseError Digit+-- Right 0 ----- >>> parse (parseDecimal <* eof) "test" "1" :: Either ParseError (DecimalDigit' ())--- Right (Left ())+-- >>> parse (parseDecimal <* eof) "test" "1" :: Either ParseError Digit+-- Right 1 ----- >>> parse parseDecimal "test" "1xyz" :: Either ParseError (DecimalDigit' ())--- Right (Left ())+-- >>> parse parseDecimal "test" "1xyz" :: Either ParseError Digit+-- Right 1 ----- >>> parse (parseDecimal <* eof) "test" "2" :: Either ParseError (DecimalDigit' ())--- Right (Left ())+-- >>> parse (parseDecimal <* eof) "test" "2" :: Either ParseError Digit+-- Right 2 ----- >>> parse parseDecimal "test" "2xyz" :: Either ParseError (DecimalDigit' ())--- Right (Left ())+-- >>> parse parseDecimal "test" "2xyz" :: Either ParseError Digit+-- Right 2 ----- >>> parse (parseDecimal <* eof) "test" "3" :: Either ParseError (DecimalDigit' ())--- Right (Left ())+-- >>> parse (parseDecimal <* eof) "test" "3" :: Either ParseError Digit+-- Right 3 ----- >>> parse parseDecimal "test" "3xyz" :: Either ParseError (DecimalDigit' ())--- Right (Left ())+-- >>> parse parseDecimal "test" "3xyz" :: Either ParseError Digit+-- Right 3 ----- >>> parse (parseDecimal <* eof) "test" "4" :: Either ParseError (DecimalDigit' ())--- Right (Left ())+-- >>> parse (parseDecimal <* eof) "test" "4" :: Either ParseError Digit+-- Right 4 ----- >>> parse parseDecimal "test" "4xyz" :: Either ParseError (DecimalDigit' ())--- Right (Left ())+-- >>> parse parseDecimal "test" "4xyz" :: Either ParseError Digit+-- Right 4 ----- >>> parse (parseDecimal <* eof) "test" "5" :: Either ParseError (DecimalDigit' ())--- Right (Left ())+-- >>> parse (parseDecimal <* eof) "test" "5" :: Either ParseError Digit+-- Right 5 ----- >>> parse parseDecimal "test" "5xyz" :: Either ParseError (DecimalDigit' ())--- Right (Left ())+-- >>> parse parseDecimal "test" "5xyz" :: Either ParseError Digit+-- Right 5 ----- >>> parse (parseDecimal <* eof) "test" "6" :: Either ParseError (DecimalDigit' ())--- Right (Left ())+-- >>> parse (parseDecimal <* eof) "test" "6" :: Either ParseError Digit+-- Right 6 ----- >>> parse parseDecimal "test" "6xyz" :: Either ParseError (DecimalDigit' ())--- Right (Left ())+-- >>> parse parseDecimal "test" "6xyz" :: Either ParseError Digit+-- Right 6 ----- >>> parse (parseDecimal <* eof) "test" "7" :: Either ParseError (DecimalDigit' ())--- Right (Left ())+-- >>> parse (parseDecimal <* eof) "test" "7" :: Either ParseError Digit+-- Right 7 ----- >>> parse parseDecimal "test" "7xyz" :: Either ParseError (DecimalDigit' ())--- Right (Left ())+-- >>> parse parseDecimal "test" "7xyz" :: Either ParseError Digit+-- Right 7 ----- >>> parse (parseDecimal <* eof) "test" "8" :: Either ParseError (DecimalDigit' ())--- Right (Left ())+-- >>> parse (parseDecimal <* eof) "test" "8" :: Either ParseError Digit+-- Right 8 ----- >>> parse parseDecimal "test" "8xyz" :: Either ParseError (DecimalDigit' ())--- Right (Left ())+-- >>> parse parseDecimal "test" "8xyz" :: Either ParseError Digit+-- Right 8 ----- >>> parse (parseDecimal <* eof) "test" "9" :: Either ParseError (DecimalDigit' ())--- Right (Left ())+-- >>> parse (parseDecimal <* eof) "test" "9" :: Either ParseError Digit+-- Right 9 ----- >>> parse parseDecimal "test" "9xyz" :: Either ParseError (DecimalDigit' ())--- Right (Left ())+-- >>> parse parseDecimal "test" "9xyz" :: Either ParseError Digit+-- Right 9 ----- >>> isn't _Right (parse parseDecimal "test" "xyz" :: Either ParseError (DecimalDigit' ()))+-- >>> isn't _Right (parse parseDecimal "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> (c `notElem` "0123456789") ==> isn't _Right (parse parseDecimal "test" [c] :: Either ParseError (DecimalDigit' ()))+-- prop> \c -> (c `notElem` "0123456789") ==> isn't _Right (parse parseDecimal "test" [c] :: Either ParseError Digit) parseDecimal ::   (Decimal d, CharParsing p) =>   p d@@ -195,10 +185,3 @@       parse0     , parseDecimalNoZero     ] <?> "Decimal"--type DecimalDigit d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 =-  Either d0 (DecimalNoZeroDigit d1 d2 d3 d4 d5 d6 d7 d8 d9)--type DecimalDigit' d =-  DecimalDigit d d d d d d d d d d-  

@@ -5,6 +5,7 @@ , parsef ) where +import Data.Digit.Digit(Digit(Digitf)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))@@ -12,7 +13,6 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)--- >>> import Data.Digit.Digitf  class Df d where   df ::@@ -30,22 +30,28 @@      -- | ----- >>> parse (parsef <* eof) "test" "f" :: Either ParseError (Digitf ())--- Right (Digitf ())+-- >>> parse (parsef <* eof) "test" "f" :: Either ParseError Digit+-- Right f ----- >>> parse parsef "test" "fxyz" :: Either ParseError (Digitf ())--- Right (Digitf ())+-- >>> parse parsef "test" "fxyz" :: Either ParseError Digit+-- Right f ----- >>> isn't _Right (parse parsef "test" "xyz" :: Either ParseError (Digitf ()))+-- >>> isn't _Right (parse parsef "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> c /= 'f' ==> isn't _Right (parse parsef "test" [c] :: Either ParseError (Digitf ()))+-- prop> \c -> c /= 'f' ==> isn't _Right (parse parsef "test" [c] :: Either ParseError Digit) parsef ::   (Df d, CharParsing p) =>   p d parsef =   xf <$ char 'f' <?> "f" -instance Df d => Df (Either d x) where+instance Df Digit where   df =-    _Left . df+    prism'+      (\() -> Digitf)+      (\d ->  case d of+                Digitf ->+                  Just ()+                _ ->+                  Nothing)

@@ -0,0 +1,78 @@+{-# LANGUAGE NoImplicitPrelude #-}++module Data.Digit.Digit(+  Digit(..)+) where++import Papa++data Digit =+  Digit0+  | Digit1+  | Digit2+  | Digit3+  | Digit4+  | Digit5+  | Digit6+  | Digit7+  | Digit8+  | Digit9+  | Digita+  | Digitb+  | Digitc+  | Digitd+  | Digite+  | Digitf+  | DigitA+  | DigitB+  | DigitC+  | DigitD+  | DigitE+  | DigitF+  deriving (Eq, Ord)++instance Show Digit where+  show Digit0 =+    "0"+  show Digit1 =+    "1"+  show Digit2 =+    "2"+  show Digit3 =+    "3"+  show Digit4 =+    "4"+  show Digit5 =+    "5"+  show Digit6 =+    "6"+  show Digit7 =+    "7"+  show Digit8 =+    "8"+  show Digit9 =+    "9"+  show Digita =+    "a"+  show Digitb =+    "b"+  show Digitc =+    "c"+  show Digitd =+    "d"+  show Digite =+    "e"+  show Digitf =+    "f"+  show DigitA =+    "A"+  show DigitB =+    "B"+  show DigitC =+    "C"+  show DigitD =+    "D"+  show DigitE =+    "E"+  show DigitF =+    "F"

@@ -1,102 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}--module Data.Digit.Digit0(-  Digit0(..)-) where--import Papa-import Data.Digit.D0(D0(d0))-import Prelude(Bounded, RealFrac)--newtype Digit0 a =-  Digit0 a-  deriving (Eq, Ord, Bounded, Show, Enum, Floating, Fractional, Num, Integral, Real, RealFloat, RealFrac)--instance D0 a => D0 (Digit0 a) where-  d0 =-    _Wrapped . d0--instance Functor Digit0 where-  fmap f (Digit0 a) =-    Digit0 (f a)-    -instance Apply Digit0 where-  Digit0 f <.> Digit0 a =-    Digit0 (f a)--instance Applicative Digit0 where-  pure =-    Digit0-  (<*>) =-    (<.>)--instance Bind Digit0 where-  Digit0 a >>- f =-    f a--instance Monad Digit0 where-  return = -    pure-  (>>=) =-    (>>-)--instance Foldable Digit0 where-  foldMap f (Digit0 a) = -    f a--instance Foldable1 Digit0 where-  foldMap1 f (Digit0 a) = -    f a--instance Traversable Digit0 where-  traverse f (Digit0 a) = -    Digit0 <$> f a--instance Traversable1 Digit0 where-  traverse1 f (Digit0 a) = -    Digit0 <$> f a--instance Semigroup a => Semigroup (Digit0 a) where-  Digit0 x <> Digit0 y =-    Digit0 (x <> y)--instance Monoid a => Monoid (Digit0 a) where-  Digit0 x `mappend` Digit0 y =-    Digit0 (x `mappend` y)-  mempty =-    Digit0 mempty--instance Field1 (Digit0 a) (Digit0 b) a b where-  _1 =-    _Wrapped--instance FunctorWithIndex () Digit0 where-  imap f =-    fmap (f ())-    -instance FoldableWithIndex () Digit0 where-  ifoldMap f =-    foldMap (f ())-    -instance TraversableWithIndex () Digit0 where-  itraverse f =-    traverse (f ())--instance Each (Digit0 a) (Digit0 b) a b where-  each =-    traverse--type instance Index (Digit0 a) = -  ()-type instance IxValue (Digit0 a) =-  a-instance Ixed (Digit0 a) where-  ix () f (Digit0 a) =-    Digit0 <$> f a--makeWrapped ''Digit0

@@ -1,102 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}--module Data.Digit.Digit1(-  Digit1(..)-) where--import Papa-import Data.Digit.D1(D1(d1))-import Prelude(Bounded, RealFrac)--newtype Digit1 a =-  Digit1 a-  deriving (Eq, Ord, Bounded, Show, Enum, Floating, Fractional, Num, Integral, Real, RealFloat, RealFrac)--instance D1 a => D1 (Digit1 a) where-  d1 =-    _Wrapped . d1--instance Functor Digit1 where-  fmap f (Digit1 a) =-    Digit1 (f a)-    -instance Apply Digit1 where-  Digit1 f <.> Digit1 a =-    Digit1 (f a)--instance Applicative Digit1 where-  pure =-    Digit1-  (<*>) =-    (<.>)--instance Bind Digit1 where-  Digit1 a >>- f =-    f a--instance Monad Digit1 where-  return = -    pure-  (>>=) =-    (>>-)--instance Foldable Digit1 where-  foldMap f (Digit1 a) = -    f a--instance Foldable1 Digit1 where-  foldMap1 f (Digit1 a) = -    f a--instance Traversable Digit1 where-  traverse f (Digit1 a) = -    Digit1 <$> f a--instance Traversable1 Digit1 where-  traverse1 f (Digit1 a) = -    Digit1 <$> f a--instance Semigroup a => Semigroup (Digit1 a) where-  Digit1 x <> Digit1 y =-    Digit1 (x <> y)--instance Monoid a => Monoid (Digit1 a) where-  Digit1 x `mappend` Digit1 y =-    Digit1 (x `mappend` y)-  mempty =-    Digit1 mempty--instance Field1 (Digit1 a) (Digit1 b) a b where-  _1 =-    _Wrapped--instance FunctorWithIndex () Digit1 where-  imap f =-    fmap (f ())-    -instance FoldableWithIndex () Digit1 where-  ifoldMap f =-    foldMap (f ())-    -instance TraversableWithIndex () Digit1 where-  itraverse f =-    traverse (f ())--instance Each (Digit1 a) (Digit1 b) a b where-  each =-    traverse--type instance Index (Digit1 a) = -  ()-type instance IxValue (Digit1 a) =-  a-instance Ixed (Digit1 a) where-  ix () f (Digit1 a) =-    Digit1 <$> f a--makeWrapped ''Digit1

@@ -1,102 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}--module Data.Digit.Digit2(-  Digit2(..)-) where--import Papa-import Data.Digit.D2(D2(d2))-import Prelude(Bounded, RealFrac)--newtype Digit2 a =-  Digit2 a-  deriving (Eq, Ord, Bounded, Show, Enum, Floating, Fractional, Num, Integral, Real, RealFloat, RealFrac)--instance D2 a => D2 (Digit2 a) where-  d2 =-    _Wrapped . d2--instance Functor Digit2 where-  fmap f (Digit2 a) =-    Digit2 (f a)-    -instance Apply Digit2 where-  Digit2 f <.> Digit2 a =-    Digit2 (f a)--instance Applicative Digit2 where-  pure =-    Digit2-  (<*>) =-    (<.>)--instance Bind Digit2 where-  Digit2 a >>- f =-    f a--instance Monad Digit2 where-  return = -    pure-  (>>=) =-    (>>-)--instance Foldable Digit2 where-  foldMap f (Digit2 a) = -    f a--instance Foldable1 Digit2 where-  foldMap1 f (Digit2 a) = -    f a--instance Traversable Digit2 where-  traverse f (Digit2 a) = -    Digit2 <$> f a--instance Traversable1 Digit2 where-  traverse1 f (Digit2 a) = -    Digit2 <$> f a--instance Semigroup a => Semigroup (Digit2 a) where-  Digit2 x <> Digit2 y =-    Digit2 (x <> y)--instance Monoid a => Monoid (Digit2 a) where-  Digit2 x `mappend` Digit2 y =-    Digit2 (x `mappend` y)-  mempty =-    Digit2 mempty--instance Field1 (Digit2 a) (Digit2 b) a b where-  _1 =-    _Wrapped--instance FunctorWithIndex () Digit2 where-  imap f =-    fmap (f ())-    -instance FoldableWithIndex () Digit2 where-  ifoldMap f =-    foldMap (f ())-    -instance TraversableWithIndex () Digit2 where-  itraverse f =-    traverse (f ())--instance Each (Digit2 a) (Digit2 b) a b where-  each =-    traverse--type instance Index (Digit2 a) = -  ()-type instance IxValue (Digit2 a) =-  a-instance Ixed (Digit2 a) where-  ix () f (Digit2 a) =-    Digit2 <$> f a--makeWrapped ''Digit2

@@ -1,102 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}--module Data.Digit.Digit3(-  Digit3(..)-) where--import Papa-import Data.Digit.D3(D3(d3))-import Prelude(Bounded, RealFrac)--newtype Digit3 a =-  Digit3 a-  deriving (Eq, Ord, Bounded, Show, Enum, Floating, Fractional, Num, Integral, Real, RealFloat, RealFrac)--instance D3 a => D3 (Digit3 a) where-  d3 =-    _Wrapped . d3--instance Functor Digit3 where-  fmap f (Digit3 a) =-    Digit3 (f a)-    -instance Apply Digit3 where-  Digit3 f <.> Digit3 a =-    Digit3 (f a)--instance Applicative Digit3 where-  pure =-    Digit3-  (<*>) =-    (<.>)--instance Bind Digit3 where-  Digit3 a >>- f =-    f a--instance Monad Digit3 where-  return = -    pure-  (>>=) =-    (>>-)--instance Foldable Digit3 where-  foldMap f (Digit3 a) = -    f a--instance Foldable1 Digit3 where-  foldMap1 f (Digit3 a) = -    f a--instance Traversable Digit3 where-  traverse f (Digit3 a) = -    Digit3 <$> f a--instance Traversable1 Digit3 where-  traverse1 f (Digit3 a) = -    Digit3 <$> f a--instance Semigroup a => Semigroup (Digit3 a) where-  Digit3 x <> Digit3 y =-    Digit3 (x <> y)--instance Monoid a => Monoid (Digit3 a) where-  Digit3 x `mappend` Digit3 y =-    Digit3 (x `mappend` y)-  mempty =-    Digit3 mempty--instance Field1 (Digit3 a) (Digit3 b) a b where-  _1 =-    _Wrapped--instance FunctorWithIndex () Digit3 where-  imap f =-    fmap (f ())-    -instance FoldableWithIndex () Digit3 where-  ifoldMap f =-    foldMap (f ())-    -instance TraversableWithIndex () Digit3 where-  itraverse f =-    traverse (f ())--instance Each (Digit3 a) (Digit3 b) a b where-  each =-    traverse--type instance Index (Digit3 a) = -  ()-type instance IxValue (Digit3 a) =-  a-instance Ixed (Digit3 a) where-  ix () f (Digit3 a) =-    Digit3 <$> f a--makeWrapped ''Digit3

@@ -1,102 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}--module Data.Digit.Digit4(-  Digit4(..)-) where--import Papa-import Data.Digit.D4(D4(d4))-import Prelude(Bounded, RealFrac)--newtype Digit4 a =-  Digit4 a-  deriving (Eq, Ord, Bounded, Show, Enum, Floating, Fractional, Num, Integral, Real, RealFloat, RealFrac)--instance D4 a => D4 (Digit4 a) where-  d4 =-    _Wrapped . d4--instance Functor Digit4 where-  fmap f (Digit4 a) =-    Digit4 (f a)-    -instance Apply Digit4 where-  Digit4 f <.> Digit4 a =-    Digit4 (f a)--instance Applicative Digit4 where-  pure =-    Digit4-  (<*>) =-    (<.>)--instance Bind Digit4 where-  Digit4 a >>- f =-    f a--instance Monad Digit4 where-  return = -    pure-  (>>=) =-    (>>-)--instance Foldable Digit4 where-  foldMap f (Digit4 a) = -    f a--instance Foldable1 Digit4 where-  foldMap1 f (Digit4 a) = -    f a--instance Traversable Digit4 where-  traverse f (Digit4 a) = -    Digit4 <$> f a--instance Traversable1 Digit4 where-  traverse1 f (Digit4 a) = -    Digit4 <$> f a--instance Semigroup a => Semigroup (Digit4 a) where-  Digit4 x <> Digit4 y =-    Digit4 (x <> y)--instance Monoid a => Monoid (Digit4 a) where-  Digit4 x `mappend` Digit4 y =-    Digit4 (x `mappend` y)-  mempty =-    Digit4 mempty--instance Field1 (Digit4 a) (Digit4 b) a b where-  _1 =-    _Wrapped--instance FunctorWithIndex () Digit4 where-  imap f =-    fmap (f ())-    -instance FoldableWithIndex () Digit4 where-  ifoldMap f =-    foldMap (f ())-    -instance TraversableWithIndex () Digit4 where-  itraverse f =-    traverse (f ())--instance Each (Digit4 a) (Digit4 b) a b where-  each =-    traverse--type instance Index (Digit4 a) = -  ()-type instance IxValue (Digit4 a) =-  a-instance Ixed (Digit4 a) where-  ix () f (Digit4 a) =-    Digit4 <$> f a--makeWrapped ''Digit4

@@ -1,103 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}--module Data.Digit.Digit5(-  Digit5(..)-) where--import Papa-import Data.Digit.D5(D5(d5))-import Prelude(Bounded, RealFrac)--newtype Digit5 a =-  Digit5 a-  deriving (Eq, Ord, Bounded, Show, Enum, Floating, Fractional, Num, Integral, Real, RealFloat, RealFrac)--instance D5 a => D5 (Digit5 a) where-  d5 =-    _Wrapped . d5--instance Functor Digit5 where-  fmap f (Digit5 a) =-    Digit5 (f a)-    -instance Apply Digit5 where-  Digit5 f <.> Digit5 a =-    Digit5 (f a)--instance Applicative Digit5 where-  pure =-    Digit5-  (<*>) =-    (<.>)--instance Bind Digit5 where-  Digit5 a >>- f =-    f a--instance Monad Digit5 where-  return = -    pure-  (>>=) =-    (>>-)--instance Foldable Digit5 where-  foldMap f (Digit5 a) = -    f a--instance Foldable1 Digit5 where-  foldMap1 f (Digit5 a) = -    f a--instance Traversable Digit5 where-  traverse f (Digit5 a) = -    Digit5 <$> f a--instance Traversable1 Digit5 where-  traverse1 f (Digit5 a) = -    Digit5 <$> f a--instance Semigroup a => Semigroup (Digit5 a) where-  Digit5 x <> Digit5 y =-    Digit5 (x <> y)--instance Monoid a => Monoid (Digit5 a) where-  Digit5 x `mappend` Digit5 y =-    Digit5 (x `mappend` y)-  mempty =-    Digit5 mempty--instance Field1 (Digit5 a) (Digit5 b) a b where-  _1 =-    _Wrapped--instance FunctorWithIndex () Digit5 where-  imap f =-    fmap (f ())-    -instance FoldableWithIndex () Digit5 where-  ifoldMap f =-    foldMap (f ())-    -instance TraversableWithIndex () Digit5 where-  itraverse f =-    traverse (f ())--instance Each (Digit5 a) (Digit5 b) a b where-  each =-    traverse--type instance Index (Digit5 a) = -  ()-type instance IxValue (Digit5 a) =-  a-instance Ixed (Digit5 a) where-  ix () f (Digit5 a) =-    Digit5 <$> f a--makeWrapped ''Digit5-

@@ -1,102 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}--module Data.Digit.Digit6(-  Digit6(..)-) where--import Papa-import Data.Digit.D6(D6(d6))-import Prelude(Bounded, RealFrac)--newtype Digit6 a =-  Digit6 a-  deriving (Eq, Ord, Bounded, Show, Enum, Floating, Fractional, Num, Integral, Real, RealFloat, RealFrac)--instance D6 a => D6 (Digit6 a) where-  d6  =-    _Wrapped . d6--instance Functor Digit6 where-  fmap f (Digit6 a) =-    Digit6 (f a)-    -instance Apply Digit6 where-  Digit6 f <.> Digit6 a =-    Digit6 (f a)--instance Applicative Digit6 where-  pure =-    Digit6-  (<*>) =-    (<.>)--instance Bind Digit6 where-  Digit6 a >>- f =-    f a--instance Monad Digit6 where-  return = -    pure-  (>>=) =-    (>>-)--instance Foldable Digit6 where-  foldMap f (Digit6 a) = -    f a--instance Foldable1 Digit6 where-  foldMap1 f (Digit6 a) = -    f a--instance Traversable Digit6 where-  traverse f (Digit6 a) = -    Digit6 <$> f a--instance Traversable1 Digit6 where-  traverse1 f (Digit6 a) = -    Digit6 <$> f a--instance Semigroup a => Semigroup (Digit6 a) where-  Digit6 x <> Digit6 y =-    Digit6 (x <> y)--instance Monoid a => Monoid (Digit6 a) where-  Digit6 x `mappend` Digit6 y =-    Digit6 (x `mappend` y)-  mempty =-    Digit6 mempty--instance Field1 (Digit6 a) (Digit6 b) a b where-  _1 =-    _Wrapped--instance FunctorWithIndex () Digit6 where-  imap f =-    fmap (f ())-    -instance FoldableWithIndex () Digit6 where-  ifoldMap f =-    foldMap (f ())-    -instance TraversableWithIndex () Digit6 where-  itraverse f =-    traverse (f ())--instance Each (Digit6 a) (Digit6 b) a b where-  each =-    traverse--type instance Index (Digit6 a) = -  ()-type instance IxValue (Digit6 a) =-  a-instance Ixed (Digit6 a) where-  ix () f (Digit6 a) =-    Digit6 <$> f a--makeWrapped ''Digit6

@@ -1,102 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}--module Data.Digit.Digit7(-  Digit7(..)-) where--import Papa-import Data.Digit.D7(D7(d7))-import Prelude(Bounded, RealFrac)--newtype Digit7 a =-  Digit7 a-  deriving (Eq, Ord, Bounded, Show, Enum, Floating, Fractional, Num, Integral, Real, RealFloat, RealFrac)--instance D7 a => D7 (Digit7 a) where-  d7  =-    _Wrapped . d7--instance Functor Digit7 where-  fmap f (Digit7 a) =-    Digit7 (f a)-    -instance Apply Digit7 where-  Digit7 f <.> Digit7 a =-    Digit7 (f a)--instance Applicative Digit7 where-  pure =-    Digit7-  (<*>) =-    (<.>)--instance Bind Digit7 where-  Digit7 a >>- f =-    f a--instance Monad Digit7 where-  return = -    pure-  (>>=) =-    (>>-)--instance Foldable Digit7 where-  foldMap f (Digit7 a) = -    f a--instance Foldable1 Digit7 where-  foldMap1 f (Digit7 a) = -    f a--instance Traversable Digit7 where-  traverse f (Digit7 a) = -    Digit7 <$> f a--instance Traversable1 Digit7 where-  traverse1 f (Digit7 a) = -    Digit7 <$> f a--instance Semigroup a => Semigroup (Digit7 a) where-  Digit7 x <> Digit7 y =-    Digit7 (x <> y)--instance Monoid a => Monoid (Digit7 a) where-  Digit7 x `mappend` Digit7 y =-    Digit7 (x `mappend` y)-  mempty =-    Digit7 mempty--instance Field1 (Digit7 a) (Digit7 b) a b where-  _1 =-    _Wrapped--instance FunctorWithIndex () Digit7 where-  imap f =-    fmap (f ())-    -instance FoldableWithIndex () Digit7 where-  ifoldMap f =-    foldMap (f ())-    -instance TraversableWithIndex () Digit7 where-  itraverse f =-    traverse (f ())--instance Each (Digit7 a) (Digit7 b) a b where-  each =-    traverse--type instance Index (Digit7 a) = -  ()-type instance IxValue (Digit7 a) =-  a-instance Ixed (Digit7 a) where-  ix () f (Digit7 a) =-    Digit7 <$> f a--makeWrapped ''Digit7

@@ -1,102 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}--module Data.Digit.Digit8(-  Digit8(..)-) where--import Papa-import Data.Digit.D8(D8(d8))-import Prelude(Bounded, RealFrac)--newtype Digit8 a =-  Digit8 a-  deriving (Eq, Ord, Bounded, Show, Enum, Floating, Fractional, Num, Integral, Real, RealFloat, RealFrac)--instance D8 a => D8 (Digit8 a) where-  d8  =-    _Wrapped . d8--instance Functor Digit8 where-  fmap f (Digit8 a) =-    Digit8 (f a)-    -instance Apply Digit8 where-  Digit8 f <.> Digit8 a =-    Digit8 (f a)--instance Applicative Digit8 where-  pure =-    Digit8-  (<*>) =-    (<.>)--instance Bind Digit8 where-  Digit8 a >>- f =-    f a--instance Monad Digit8 where-  return = -    pure-  (>>=) =-    (>>-)--instance Foldable Digit8 where-  foldMap f (Digit8 a) = -    f a--instance Foldable1 Digit8 where-  foldMap1 f (Digit8 a) = -    f a--instance Traversable Digit8 where-  traverse f (Digit8 a) = -    Digit8 <$> f a--instance Traversable1 Digit8 where-  traverse1 f (Digit8 a) = -    Digit8 <$> f a--instance Semigroup a => Semigroup (Digit8 a) where-  Digit8 x <> Digit8 y =-    Digit8 (x <> y)--instance Monoid a => Monoid (Digit8 a) where-  Digit8 x `mappend` Digit8 y =-    Digit8 (x `mappend` y)-  mempty =-    Digit8 mempty--instance Field1 (Digit8 a) (Digit8 b) a b where-  _1 =-    _Wrapped--instance FunctorWithIndex () Digit8 where-  imap f =-    fmap (f ())-    -instance FoldableWithIndex () Digit8 where-  ifoldMap f =-    foldMap (f ())-    -instance TraversableWithIndex () Digit8 where-  itraverse f =-    traverse (f ())--instance Each (Digit8 a) (Digit8 b) a b where-  each =-    traverse--type instance Index (Digit8 a) = -  ()-type instance IxValue (Digit8 a) =-  a-instance Ixed (Digit8 a) where-  ix () f (Digit8 a) =-    Digit8 <$> f a--makeWrapped ''Digit8

@@ -1,102 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}--module Data.Digit.Digit9(-  Digit9(..)-) where--import Papa-import Data.Digit.D9(D9(d9))-import Prelude(Bounded, RealFrac)--newtype Digit9 a =-  Digit9 a-  deriving (Eq, Ord, Bounded, Show, Enum, Floating, Fractional, Num, Integral, Real, RealFloat, RealFrac)--instance D9 a => D9 (Digit9 a) where-  d9  =-    _Wrapped . d9--instance Functor Digit9 where-  fmap f (Digit9 a) =-    Digit9 (f a)-    -instance Apply Digit9 where-  Digit9 f <.> Digit9 a =-    Digit9 (f a)--instance Applicative Digit9 where-  pure =-    Digit9-  (<*>) =-    (<.>)--instance Bind Digit9 where-  Digit9 a >>- f =-    f a--instance Monad Digit9 where-  return = -    pure-  (>>=) =-    (>>-)--instance Foldable Digit9 where-  foldMap f (Digit9 a) = -    f a--instance Foldable1 Digit9 where-  foldMap1 f (Digit9 a) = -    f a--instance Traversable Digit9 where-  traverse f (Digit9 a) = -    Digit9 <$> f a--instance Traversable1 Digit9 where-  traverse1 f (Digit9 a) = -    Digit9 <$> f a--instance Semigroup a => Semigroup (Digit9 a) where-  Digit9 x <> Digit9 y =-    Digit9 (x <> y)--instance Monoid a => Monoid (Digit9 a) where-  Digit9 x `mappend` Digit9 y =-    Digit9 (x `mappend` y)-  mempty =-    Digit9 mempty--instance Field1 (Digit9 a) (Digit9 b) a b where-  _1 =-    _Wrapped--instance FunctorWithIndex () Digit9 where-  imap f =-    fmap (f ())-    -instance FoldableWithIndex () Digit9 where-  ifoldMap f =-    foldMap (f ())-    -instance TraversableWithIndex () Digit9 where-  itraverse f =-    traverse (f ())--instance Each (Digit9 a) (Digit9 b) a b where-  each =-    traverse--type instance Index (Digit9 a) = -  ()-type instance IxValue (Digit9 a) =-  a-instance Ixed (Digit9 a) where-  ix () f (Digit9 a) =-    Digit9 <$> f a--makeWrapped ''Digit9

@@ -1,102 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}--module Data.Digit.DigitA(-  DigitA(..)-) where--import Papa-import Data.Digit.DA(DA(dA))-import Prelude(Bounded, RealFrac)--newtype DigitA a =-  DigitA a-  deriving (Eq, Ord, Bounded, Show, Enum, Floating, Fractional, Num, Integral, Real, RealFloat, RealFrac)--instance DA a => DA (DigitA a) where-  dA  =-    _Wrapped . dA--instance Functor DigitA where-  fmap f (DigitA a) =-    DigitA (f a)-    -instance Apply DigitA where-  DigitA f <.> DigitA a =-    DigitA (f a)--instance Applicative DigitA where-  pure =-    DigitA-  (<*>) =-    (<.>)--instance Bind DigitA where-  DigitA a >>- f =-    f a--instance Monad DigitA where-  return = -    pure-  (>>=) =-    (>>-)--instance Foldable DigitA where-  foldMap f (DigitA a) = -    f a--instance Foldable1 DigitA where-  foldMap1 f (DigitA a) = -    f a--instance Traversable DigitA where-  traverse f (DigitA a) = -    DigitA <$> f a--instance Traversable1 DigitA where-  traverse1 f (DigitA a) = -    DigitA <$> f a--instance Semigroup a => Semigroup (DigitA a) where-  DigitA x <> DigitA y =-    DigitA (x <> y)--instance Monoid a => Monoid (DigitA a) where-  DigitA x `mappend` DigitA y =-    DigitA (x `mappend` y)-  mempty =-    DigitA mempty--instance Field1 (DigitA a) (DigitA b) a b where-  _1 =-    _Wrapped--instance FunctorWithIndex () DigitA where-  imap f =-    fmap (f ())-    -instance FoldableWithIndex () DigitA where-  ifoldMap f =-    foldMap (f ())-    -instance TraversableWithIndex () DigitA where-  itraverse f =-    traverse (f ())--instance Each (DigitA a) (DigitA b) a b where-  each =-    traverse--type instance Index (DigitA a) = -  ()-type instance IxValue (DigitA a) =-  a-instance Ixed (DigitA a) where-  ix () f (DigitA a) =-    DigitA <$> f a--makeWrapped ''DigitA

@@ -1,102 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}--module Data.Digit.DigitB(-  DigitB(..)-) where--import Papa-import Data.Digit.DB(DB(dB))-import Prelude(Bounded, RealFrac)--newtype DigitB a =-  DigitB a-  deriving (Eq, Ord, Bounded, Show, Enum, Floating, Fractional, Num, Integral, Real, RealFloat, RealFrac)--instance DB a => DB (DigitB a) where-  dB  =-    _Wrapped . dB--instance Functor DigitB where-  fmap f (DigitB a) =-    DigitB (f a)-    -instance Apply DigitB where-  DigitB f <.> DigitB a =-    DigitB (f a)--instance Applicative DigitB where-  pure =-    DigitB-  (<*>) =-    (<.>)--instance Bind DigitB where-  DigitB a >>- f =-    f a--instance Monad DigitB where-  return = -    pure-  (>>=) =-    (>>-)--instance Foldable DigitB where-  foldMap f (DigitB a) = -    f a--instance Foldable1 DigitB where-  foldMap1 f (DigitB a) = -    f a--instance Traversable DigitB where-  traverse f (DigitB a) = -    DigitB <$> f a--instance Traversable1 DigitB where-  traverse1 f (DigitB a) = -    DigitB <$> f a--instance Semigroup a => Semigroup (DigitB a) where-  DigitB x <> DigitB y =-    DigitB (x <> y)--instance Monoid a => Monoid (DigitB a) where-  DigitB x `mappend` DigitB y =-    DigitB (x `mappend` y)-  mempty =-    DigitB mempty--instance Field1 (DigitB a) (DigitB b) a b where-  _1 =-    _Wrapped--instance FunctorWithIndex () DigitB where-  imap f =-    fmap (f ())-    -instance FoldableWithIndex () DigitB where-  ifoldMap f =-    foldMap (f ())-    -instance TraversableWithIndex () DigitB where-  itraverse f =-    traverse (f ())--instance Each (DigitB a) (DigitB b) a b where-  each =-    traverse--type instance Index (DigitB a) = -  ()-type instance IxValue (DigitB a) =-  a-instance Ixed (DigitB a) where-  ix () f (DigitB a) =-    DigitB <$> f a--makeWrapped ''DigitB

@@ -1,102 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}--module Data.Digit.DigitC(-  DigitC(..)-) where--import Papa-import Data.Digit.DC(DC(dC))-import Prelude(Bounded, RealFrac)--newtype DigitC a =-  DigitC a-  deriving (Eq, Ord, Bounded, Show, Enum, Floating, Fractional, Num, Integral, Real, RealFloat, RealFrac)--instance DC a => DC (DigitC a) where-  dC  =-    _Wrapped . dC--instance Functor DigitC where-  fmap f (DigitC a) =-    DigitC (f a)-    -instance Apply DigitC where-  DigitC f <.> DigitC a =-    DigitC (f a)--instance Applicative DigitC where-  pure =-    DigitC-  (<*>) =-    (<.>)--instance Bind DigitC where-  DigitC a >>- f =-    f a--instance Monad DigitC where-  return = -    pure-  (>>=) =-    (>>-)--instance Foldable DigitC where-  foldMap f (DigitC a) = -    f a--instance Foldable1 DigitC where-  foldMap1 f (DigitC a) = -    f a--instance Traversable DigitC where-  traverse f (DigitC a) = -    DigitC <$> f a--instance Traversable1 DigitC where-  traverse1 f (DigitC a) = -    DigitC <$> f a--instance Semigroup a => Semigroup (DigitC a) where-  DigitC x <> DigitC y =-    DigitC (x <> y)--instance Monoid a => Monoid (DigitC a) where-  DigitC x `mappend` DigitC y =-    DigitC (x `mappend` y)-  mempty =-    DigitC mempty--instance Field1 (DigitC a) (DigitC b) a b where-  _1 =-    _Wrapped--instance FunctorWithIndex () DigitC where-  imap f =-    fmap (f ())-    -instance FoldableWithIndex () DigitC where-  ifoldMap f =-    foldMap (f ())-    -instance TraversableWithIndex () DigitC where-  itraverse f =-    traverse (f ())--instance Each (DigitC a) (DigitC b) a b where-  each =-    traverse--type instance Index (DigitC a) = -  ()-type instance IxValue (DigitC a) =-  a-instance Ixed (DigitC a) where-  ix () f (DigitC a) =-    DigitC <$> f a--makeWrapped ''DigitC

@@ -1,102 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}--module Data.Digit.DigitD(-  DigitD(..)-) where--import Papa-import Data.Digit.DD(DD(dD))-import Prelude(Bounded, RealFrac)--newtype DigitD a =-  DigitD a-  deriving (Eq, Ord, Bounded, Show, Enum, Floating, Fractional, Num, Integral, Real, RealFloat, RealFrac)--instance DD a => DD (DigitD a) where-  dD  =-    _Wrapped . dD--instance Functor DigitD where-  fmap f (DigitD a) =-    DigitD (f a)-    -instance Apply DigitD where-  DigitD f <.> DigitD a =-    DigitD (f a)--instance Applicative DigitD where-  pure =-    DigitD-  (<*>) =-    (<.>)--instance Bind DigitD where-  DigitD a >>- f =-    f a--instance Monad DigitD where-  return = -    pure-  (>>=) =-    (>>-)--instance Foldable DigitD where-  foldMap f (DigitD a) = -    f a--instance Foldable1 DigitD where-  foldMap1 f (DigitD a) = -    f a--instance Traversable DigitD where-  traverse f (DigitD a) = -    DigitD <$> f a--instance Traversable1 DigitD where-  traverse1 f (DigitD a) = -    DigitD <$> f a--instance Semigroup a => Semigroup (DigitD a) where-  DigitD x <> DigitD y =-    DigitD (x <> y)--instance Monoid a => Monoid (DigitD a) where-  DigitD x `mappend` DigitD y =-    DigitD (x `mappend` y)-  mempty =-    DigitD mempty--instance Field1 (DigitD a) (DigitD b) a b where-  _1 =-    _Wrapped--instance FunctorWithIndex () DigitD where-  imap f =-    fmap (f ())-    -instance FoldableWithIndex () DigitD where-  ifoldMap f =-    foldMap (f ())-    -instance TraversableWithIndex () DigitD where-  itraverse f =-    traverse (f ())--instance Each (DigitD a) (DigitD b) a b where-  each =-    traverse--type instance Index (DigitD a) = -  ()-type instance IxValue (DigitD a) =-  a-instance Ixed (DigitD a) where-  ix () f (DigitD a) =-    DigitD <$> f a--makeWrapped ''DigitD

@@ -1,102 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}--module Data.Digit.DigitE(-  DigitE(..)-) where--import Papa-import Data.Digit.DE(DE(dE))-import Prelude(Bounded, RealFrac)--newtype DigitE a =-  DigitE a-  deriving (Eq, Ord, Bounded, Show, Enum, Floating, Fractional, Num, Integral, Real, RealFloat, RealFrac)--instance DE a => DE (DigitE a) where-  dE  =-    _Wrapped . dE--instance Functor DigitE where-  fmap f (DigitE a) =-    DigitE (f a)-    -instance Apply DigitE where-  DigitE f <.> DigitE a =-    DigitE (f a)--instance Applicative DigitE where-  pure =-    DigitE-  (<*>) =-    (<.>)--instance Bind DigitE where-  DigitE a >>- f =-    f a--instance Monad DigitE where-  return = -    pure-  (>>=) =-    (>>-)--instance Foldable DigitE where-  foldMap f (DigitE a) = -    f a--instance Foldable1 DigitE where-  foldMap1 f (DigitE a) = -    f a--instance Traversable DigitE where-  traverse f (DigitE a) = -    DigitE <$> f a--instance Traversable1 DigitE where-  traverse1 f (DigitE a) = -    DigitE <$> f a--instance Semigroup a => Semigroup (DigitE a) where-  DigitE x <> DigitE y =-    DigitE (x <> y)--instance Monoid a => Monoid (DigitE a) where-  DigitE x `mappend` DigitE y =-    DigitE (x `mappend` y)-  mempty =-    DigitE mempty--instance Field1 (DigitE a) (DigitE b) a b where-  _1 =-    _Wrapped--instance FunctorWithIndex () DigitE where-  imap f =-    fmap (f ())-    -instance FoldableWithIndex () DigitE where-  ifoldMap f =-    foldMap (f ())-    -instance TraversableWithIndex () DigitE where-  itraverse f =-    traverse (f ())--instance Each (DigitE a) (DigitE b) a b where-  each =-    traverse--type instance Index (DigitE a) = -  ()-type instance IxValue (DigitE a) =-  a-instance Ixed (DigitE a) where-  ix () f (DigitE a) =-    DigitE <$> f a--makeWrapped ''DigitE

@@ -1,102 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}--module Data.Digit.DigitF(-  DigitF(..)-) where--import Papa-import Data.Digit.DF(DF(dF))-import Prelude(Bounded, RealFrac)--newtype DigitF a =-  DigitF a-  deriving (Eq, Ord, Bounded, Show, Enum, Floating, Fractional, Num, Integral, Real, RealFloat, RealFrac)--instance DF a => DF (DigitF a) where-  dF  =-    _Wrapped . dF--instance Functor DigitF where-  fmap f (DigitF a) =-    DigitF (f a)-    -instance Apply DigitF where-  DigitF f <.> DigitF a =-    DigitF (f a)--instance Applicative DigitF where-  pure =-    DigitF-  (<*>) =-    (<.>)--instance Bind DigitF where-  DigitF a >>- f =-    f a--instance Monad DigitF where-  return = -    pure-  (>>=) =-    (>>-)--instance Foldable DigitF where-  foldMap f (DigitF a) = -    f a--instance Foldable1 DigitF where-  foldMap1 f (DigitF a) = -    f a--instance Traversable DigitF where-  traverse f (DigitF a) = -    DigitF <$> f a--instance Traversable1 DigitF where-  traverse1 f (DigitF a) = -    DigitF <$> f a--instance Semigroup a => Semigroup (DigitF a) where-  DigitF x <> DigitF y =-    DigitF (x <> y)--instance Monoid a => Monoid (DigitF a) where-  DigitF x `mappend` DigitF y =-    DigitF (x `mappend` y)-  mempty =-    DigitF mempty--instance Field1 (DigitF a) (DigitF b) a b where-  _1 =-    _Wrapped--instance FunctorWithIndex () DigitF where-  imap f =-    fmap (f ())-    -instance FoldableWithIndex () DigitF where-  ifoldMap f =-    foldMap (f ())-    -instance TraversableWithIndex () DigitF where-  itraverse f =-    traverse (f ())--instance Each (DigitF a) (DigitF b) a b where-  each =-    traverse--type instance Index (DigitF a) = -  ()-type instance IxValue (DigitF a) =-  a-instance Ixed (DigitF a) where-  ix () f (DigitF a) =-    DigitF <$> f a--makeWrapped ''DigitF

@@ -1,102 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}--module Data.Digit.Digita(-  Digita(..)-) where--import Papa-import Data.Digit.Da(Da(da))-import Prelude(Bounded, RealFrac)--newtype Digita a =-  Digita a-  deriving (Eq, Ord, Bounded, Show, Enum, Floating, Fractional, Num, Integral, Real, RealFloat, RealFrac)--instance Da a => Da (Digita a) where-  da  =-    _Wrapped . da--instance Functor Digita where-  fmap f (Digita a) =-    Digita (f a)-    -instance Apply Digita where-  Digita f <.> Digita a =-    Digita (f a)--instance Applicative Digita where-  pure =-    Digita-  (<*>) =-    (<.>)--instance Bind Digita where-  Digita a >>- f =-    f a--instance Monad Digita where-  return = -    pure-  (>>=) =-    (>>-)--instance Foldable Digita where-  foldMap f (Digita a) = -    f a--instance Foldable1 Digita where-  foldMap1 f (Digita a) = -    f a--instance Traversable Digita where-  traverse f (Digita a) = -    Digita <$> f a--instance Traversable1 Digita where-  traverse1 f (Digita a) = -    Digita <$> f a--instance Semigroup a => Semigroup (Digita a) where-  Digita x <> Digita y =-    Digita (x <> y)--instance Monoid a => Monoid (Digita a) where-  Digita x `mappend` Digita y =-    Digita (x `mappend` y)-  mempty =-    Digita mempty--instance Field1 (Digita a) (Digita b) a b where-  _1 =-    _Wrapped--instance FunctorWithIndex () Digita where-  imap f =-    fmap (f ())-    -instance FoldableWithIndex () Digita where-  ifoldMap f =-    foldMap (f ())-    -instance TraversableWithIndex () Digita where-  itraverse f =-    traverse (f ())--instance Each (Digita a) (Digita b) a b where-  each =-    traverse--type instance Index (Digita a) = -  ()-type instance IxValue (Digita a) =-  a-instance Ixed (Digita a) where-  ix () f (Digita a) =-    Digita <$> f a--makeWrapped ''Digita

@@ -1,102 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}--module Data.Digit.Digitb(-  Digitb(..)-) where--import Papa-import Data.Digit.Db(Db(db))-import Prelude(Bounded, RealFrac)--newtype Digitb a =-  Digitb a-  deriving (Eq, Ord, Bounded, Show, Enum, Floating, Fractional, Num, Integral, Real, RealFloat, RealFrac)--instance Db a => Db (Digitb a) where-  db  =-    _Wrapped . db--instance Functor Digitb where-  fmap f (Digitb a) =-    Digitb (f a)-    -instance Apply Digitb where-  Digitb f <.> Digitb a =-    Digitb (f a)--instance Applicative Digitb where-  pure =-    Digitb-  (<*>) =-    (<.>)--instance Bind Digitb where-  Digitb a >>- f =-    f a--instance Monad Digitb where-  return = -    pure-  (>>=) =-    (>>-)--instance Foldable Digitb where-  foldMap f (Digitb a) = -    f a--instance Foldable1 Digitb where-  foldMap1 f (Digitb a) = -    f a--instance Traversable Digitb where-  traverse f (Digitb a) = -    Digitb <$> f a--instance Traversable1 Digitb where-  traverse1 f (Digitb a) = -    Digitb <$> f a--instance Semigroup a => Semigroup (Digitb a) where-  Digitb x <> Digitb y =-    Digitb (x <> y)--instance Monoid a => Monoid (Digitb a) where-  Digitb x `mappend` Digitb y =-    Digitb (x `mappend` y)-  mempty =-    Digitb mempty--instance Field1 (Digitb a) (Digitb b) a b where-  _1 =-    _Wrapped--instance FunctorWithIndex () Digitb where-  imap f =-    fmap (f ())-    -instance FoldableWithIndex () Digitb where-  ifoldMap f =-    foldMap (f ())-    -instance TraversableWithIndex () Digitb where-  itraverse f =-    traverse (f ())--instance Each (Digitb a) (Digitb b) a b where-  each =-    traverse--type instance Index (Digitb a) = -  ()-type instance IxValue (Digitb a) =-  a-instance Ixed (Digitb a) where-  ix () f (Digitb a) =-    Digitb <$> f a--makeWrapped ''Digitb

@@ -1,102 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}--module Data.Digit.Digitc(-  Digitc(..)-) where--import Papa-import Data.Digit.Dc(Dc(dc))-import Prelude(Bounded, RealFrac)--newtype Digitc a =-  Digitc a-  deriving (Eq, Ord, Bounded, Show, Enum, Floating, Fractional, Num, Integral, Real, RealFloat, RealFrac)--instance Dc a => Dc (Digitc a) where-  dc  =-    _Wrapped . dc--instance Functor Digitc where-  fmap f (Digitc a) =-    Digitc (f a)-    -instance Apply Digitc where-  Digitc f <.> Digitc a =-    Digitc (f a)--instance Applicative Digitc where-  pure =-    Digitc-  (<*>) =-    (<.>)--instance Bind Digitc where-  Digitc a >>- f =-    f a--instance Monad Digitc where-  return = -    pure-  (>>=) =-    (>>-)--instance Foldable Digitc where-  foldMap f (Digitc a) = -    f a--instance Foldable1 Digitc where-  foldMap1 f (Digitc a) = -    f a--instance Traversable Digitc where-  traverse f (Digitc a) = -    Digitc <$> f a--instance Traversable1 Digitc where-  traverse1 f (Digitc a) = -    Digitc <$> f a--instance Semigroup a => Semigroup (Digitc a) where-  Digitc x <> Digitc y =-    Digitc (x <> y)--instance Monoid a => Monoid (Digitc a) where-  Digitc x `mappend` Digitc y =-    Digitc (x `mappend` y)-  mempty =-    Digitc mempty--instance Field1 (Digitc a) (Digitc b) a b where-  _1 =-    _Wrapped--instance FunctorWithIndex () Digitc where-  imap f =-    fmap (f ())-    -instance FoldableWithIndex () Digitc where-  ifoldMap f =-    foldMap (f ())-    -instance TraversableWithIndex () Digitc where-  itraverse f =-    traverse (f ())--instance Each (Digitc a) (Digitc b) a b where-  each =-    traverse--type instance Index (Digitc a) = -  ()-type instance IxValue (Digitc a) =-  a-instance Ixed (Digitc a) where-  ix () f (Digitc a) =-    Digitc <$> f a--makeWrapped ''Digitc

@@ -1,102 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}--module Data.Digit.Digitd(-  Digitd(..)-) where--import Papa-import Data.Digit.Dd(Dd(dd))-import Prelude(Bounded, RealFrac)--newtype Digitd a =-  Digitd a-  deriving (Eq, Ord, Bounded, Show, Enum, Floating, Fractional, Num, Integral, Real, RealFloat, RealFrac)--instance Dd a => Dd (Digitd a) where-  dd  =-    _Wrapped . dd--instance Functor Digitd where-  fmap f (Digitd a) =-    Digitd (f a)-    -instance Apply Digitd where-  Digitd f <.> Digitd a =-    Digitd (f a)--instance Applicative Digitd where-  pure =-    Digitd-  (<*>) =-    (<.>)--instance Bind Digitd where-  Digitd a >>- f =-    f a--instance Monad Digitd where-  return = -    pure-  (>>=) =-    (>>-)--instance Foldable Digitd where-  foldMap f (Digitd a) = -    f a--instance Foldable1 Digitd where-  foldMap1 f (Digitd a) = -    f a--instance Traversable Digitd where-  traverse f (Digitd a) = -    Digitd <$> f a--instance Traversable1 Digitd where-  traverse1 f (Digitd a) = -    Digitd <$> f a--instance Semigroup a => Semigroup (Digitd a) where-  Digitd x <> Digitd y =-    Digitd (x <> y)--instance Monoid a => Monoid (Digitd a) where-  Digitd x `mappend` Digitd y =-    Digitd (x `mappend` y)-  mempty =-    Digitd mempty--instance Field1 (Digitd a) (Digitd b) a b where-  _1 =-    _Wrapped--instance FunctorWithIndex () Digitd where-  imap f =-    fmap (f ())-    -instance FoldableWithIndex () Digitd where-  ifoldMap f =-    foldMap (f ())-    -instance TraversableWithIndex () Digitd where-  itraverse f =-    traverse (f ())--instance Each (Digitd a) (Digitd b) a b where-  each =-    traverse--type instance Index (Digitd a) = -  ()-type instance IxValue (Digitd a) =-  a-instance Ixed (Digitd a) where-  ix () f (Digitd a) =-    Digitd <$> f a--makeWrapped ''Digitd

@@ -1,102 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}--module Data.Digit.Digite(-  Digite(..)-) where--import Papa-import Data.Digit.De(De(de))-import Prelude(Bounded, RealFrac)--newtype Digite a =-  Digite a-  deriving (Eq, Ord, Bounded, Show, Enum, Floating, Fractional, Num, Integral, Real, RealFloat, RealFrac)--instance De a => De (Digite a) where-  de  =-    _Wrapped . de--instance Functor Digite where-  fmap f (Digite a) =-    Digite (f a)-    -instance Apply Digite where-  Digite f <.> Digite a =-    Digite (f a)--instance Applicative Digite where-  pure =-    Digite-  (<*>) =-    (<.>)--instance Bind Digite where-  Digite a >>- f =-    f a--instance Monad Digite where-  return = -    pure-  (>>=) =-    (>>-)--instance Foldable Digite where-  foldMap f (Digite a) = -    f a--instance Foldable1 Digite where-  foldMap1 f (Digite a) = -    f a--instance Traversable Digite where-  traverse f (Digite a) = -    Digite <$> f a--instance Traversable1 Digite where-  traverse1 f (Digite a) = -    Digite <$> f a--instance Semigroup a => Semigroup (Digite a) where-  Digite x <> Digite y =-    Digite (x <> y)--instance Monoid a => Monoid (Digite a) where-  Digite x `mappend` Digite y =-    Digite (x `mappend` y)-  mempty =-    Digite mempty--instance Field1 (Digite a) (Digite b) a b where-  _1 =-    _Wrapped--instance FunctorWithIndex () Digite where-  imap f =-    fmap (f ())-    -instance FoldableWithIndex () Digite where-  ifoldMap f =-    foldMap (f ())-    -instance TraversableWithIndex () Digite where-  itraverse f =-    traverse (f ())--instance Each (Digite a) (Digite b) a b where-  each =-    traverse--type instance Index (Digite a) = -  ()-type instance IxValue (Digite a) =-  a-instance Ixed (Digite a) where-  ix () f (Digite a) =-    Digite <$> f a--makeWrapped ''Digite

@@ -1,102 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}--module Data.Digit.Digitf(-  Digitf(..)-) where--import Papa-import Data.Digit.Df(Df(df))-import Prelude(Bounded, RealFrac)--newtype Digitf a =-  Digitf a-  deriving (Eq, Ord, Bounded, Show, Enum, Floating, Fractional, Num, Integral, Real, RealFloat, RealFrac)--instance Df a => Df (Digitf a) where-  df  =-    _Wrapped . df--instance Functor Digitf where-  fmap f (Digitf a) =-    Digitf (f a)-    -instance Apply Digitf where-  Digitf f <.> Digitf a =-    Digitf (f a)--instance Applicative Digitf where-  pure =-    Digitf-  (<*>) =-    (<.>)--instance Bind Digitf where-  Digitf a >>- f =-    f a--instance Monad Digitf where-  return = -    pure-  (>>=) =-    (>>-)--instance Foldable Digitf where-  foldMap f (Digitf a) = -    f a--instance Foldable1 Digitf where-  foldMap1 f (Digitf a) = -    f a--instance Traversable Digitf where-  traverse f (Digitf a) = -    Digitf <$> f a--instance Traversable1 Digitf where-  traverse1 f (Digitf a) = -    Digitf <$> f a--instance Semigroup a => Semigroup (Digitf a) where-  Digitf x <> Digitf y =-    Digitf (x <> y)--instance Monoid a => Monoid (Digitf a) where-  Digitf x `mappend` Digitf y =-    Digitf (x `mappend` y)-  mempty =-    Digitf mempty--instance Field1 (Digitf a) (Digitf b) a b where-  _1 =-    _Wrapped--instance FunctorWithIndex () Digitf where-  imap f =-    fmap (f ())-    -instance FoldableWithIndex () Digitf where-  ifoldMap f =-    foldMap (f ())-    -instance TraversableWithIndex () Digitf where-  itraverse f =-    traverse (f ())--instance Each (Digitf a) (Digitf b) a b where-  each =-    traverse--type instance Index (Digitf a) = -  ()-type instance IxValue (Digitf a) =-  a-instance Ixed (Digitf a) where-  ix () f (Digitf a) =-    Digitf <$> f a--makeWrapped ''Digitf

@@ -6,14 +6,8 @@ , HEXADECIMAL , parseHEXADECIMALNoZero , parseHEXADECIMAL-, HEXADECIMALNoZeroDigit-, HEXADECIMALNoZeroDigit'-, HEXADECIMALDigit-, HEXADECIMALDigit' ) where -import Papa-import Data.Void(Void) import Text.Parser.Char(CharParsing) import Text.Parser.Combinators((<?>), choice) import Data.Digit.D0(D0, parse0)@@ -37,106 +31,108 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)+-- >>> import Data.Digit.Digit+-- >>> import Papa  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)  -- | ----- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "1" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "1" :: Either ParseError Digit+-- Right 1 ----- >>> parse parseHEXADECIMALNoZero "test" "1xyz" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMALNoZero "test" "1xyz" :: Either ParseError Digit+-- Right 1 ----- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "2" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "2" :: Either ParseError Digit+-- Right 2 ----- >>> parse parseHEXADECIMALNoZero "test" "2xyz" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMALNoZero "test" "2xyz" :: Either ParseError Digit+-- Right 2 ----- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "3" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "3" :: Either ParseError Digit+-- Right 3 ----- >>> parse parseHEXADECIMALNoZero "test" "3xyz" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMALNoZero "test" "3xyz" :: Either ParseError Digit+-- Right 3 ----- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "4" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "4" :: Either ParseError Digit+-- Right 4 ----- >>> parse parseHEXADECIMALNoZero "test" "4xyz" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMALNoZero "test" "4xyz" :: Either ParseError Digit+-- Right 4 ----- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "5" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "5" :: Either ParseError Digit+-- Right 5 ----- >>> parse parseHEXADECIMALNoZero "test" "5xyz" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMALNoZero "test" "5xyz" :: Either ParseError Digit+-- Right 5 ----- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "6" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "6" :: Either ParseError Digit+-- Right 6 ----- >>> parse parseHEXADECIMALNoZero "test" "6xyz" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMALNoZero "test" "6xyz" :: Either ParseError Digit+-- Right 6 ----- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "7" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "7" :: Either ParseError Digit+-- Right 7 ----- >>> parse parseHEXADECIMALNoZero "test" "7xyz" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMALNoZero "test" "7xyz" :: Either ParseError Digit+-- Right 7 ----- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "8" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "8" :: Either ParseError Digit+-- Right 8 ----- >>> parse parseHEXADECIMALNoZero "test" "8xyz" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMALNoZero "test" "8xyz" :: Either ParseError Digit+-- Right 8 ----- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "9" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "9" :: Either ParseError Digit+-- Right 9 ----- >>> parse parseHEXADECIMALNoZero "test" "9xyz" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMALNoZero "test" "9xyz" :: Either ParseError Digit+-- Right 9 ----- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "A" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "A" :: Either ParseError Digit+-- Right A ----- >>> parse parseHEXADECIMALNoZero "test" "Axyz" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMALNoZero "test" "Axyz" :: Either ParseError Digit+-- Right A ----- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "B" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "B" :: Either ParseError Digit+-- Right B ----- >>> parse parseHEXADECIMALNoZero "test" "Bxyz" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMALNoZero "test" "Bxyz" :: Either ParseError Digit+-- Right B ----- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "C" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "C" :: Either ParseError Digit+-- Right C ----- >>> parse parseHEXADECIMALNoZero "test" "Cxyz" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMALNoZero "test" "Cxyz" :: Either ParseError Digit+-- Right C ----- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "D" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "D" :: Either ParseError Digit+-- Right D ----- >>> parse parseHEXADECIMALNoZero "test" "Dxyz" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMALNoZero "test" "Dxyz" :: Either ParseError Digit+-- Right D ----- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "E" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "E" :: Either ParseError Digit+-- Right E ----- >>> parse parseHEXADECIMALNoZero "test" "Exyz" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMALNoZero "test" "Exyz" :: Either ParseError Digit+-- Right E ----- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "F" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMALNoZero <* eof) "test" "F" :: Either ParseError Digit+-- Right F ----- >>> parse parseHEXADECIMALNoZero "test" "Fxyz" :: Either ParseError (HEXADECIMALNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMALNoZero "test" "Fxyz" :: Either ParseError Digit+-- Right F ----- >>> isn't _Right (parse parseHEXADECIMALNoZero "test" "xyz" :: Either ParseError (HEXADECIMALNoZeroDigit' ()))+-- >>> isn't _Right (parse parseHEXADECIMALNoZero "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> (c `notElem` "123456789ABCDEF") ==> isn't _Right (parse parseHEXADECIMALNoZero "test" [c] :: Either ParseError (HEXADECIMALNoZeroDigit' ()))+-- prop> \c -> (c `notElem` "123456789ABCDEF") ==> isn't _Right (parse parseHEXADECIMALNoZero "test" [c] :: Either ParseError Digit) parseHEXADECIMALNoZero ::   (HEXADECIMALNoZero d, CharParsing p) =>   p d@@ -152,118 +148,111 @@     , parseF     ] <?> "HEXADECIMALNoZero" -type HEXADECIMALNoZeroDigit d1 d2 d3 d4 d5 d6 d7 d8 d9 dA dB dC dD dE dF =-  Either d1 (Either d2 (Either d3 (Either d4 (Either d5 (Either d5 (Either d6 (Either d7 (Either d8 (Either d9 (Either dA (Either dB (Either dC (Either dD (Either dE (Either dF Void)))))))))))))))--type HEXADECIMALNoZeroDigit' d =-  HEXADECIMALNoZeroDigit d d d d d d d d d d d d d d d-  - type HEXADECIMAL d =   (D0 d, HEXADECIMALNoZero d)  -- | ----- >>> parse (parseHEXADECIMAL <* eof) "test" "0" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMAL <* eof) "test" "0" :: Either ParseError Digit+-- Right 0 ----- >>> parse parseHEXADECIMAL "test" "0xyz" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMAL "test" "0xyz" :: Either ParseError Digit+-- Right 0 ----- >>> parse (parseHEXADECIMAL <* eof) "test" "1" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMAL <* eof) "test" "1" :: Either ParseError Digit+-- Right 1 ----- >>> parse parseHEXADECIMAL "test" "1xyz" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMAL "test" "1xyz" :: Either ParseError Digit+-- Right 1 ----- >>> parse (parseHEXADECIMAL <* eof) "test" "2" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMAL <* eof) "test" "2" :: Either ParseError Digit+-- Right 2 ----- >>> parse parseHEXADECIMAL "test" "2xyz" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMAL "test" "2xyz" :: Either ParseError Digit+-- Right 2 ----- >>> parse (parseHEXADECIMAL <* eof) "test" "3" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMAL <* eof) "test" "3" :: Either ParseError Digit+-- Right 3 ----- >>> parse parseHEXADECIMAL "test" "3xyz" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMAL "test" "3xyz" :: Either ParseError Digit+-- Right 3 ----- >>> parse (parseHEXADECIMAL <* eof) "test" "4" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMAL <* eof) "test" "4" :: Either ParseError Digit+-- Right 4 ----- >>> parse parseHEXADECIMAL "test" "4xyz" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMAL "test" "4xyz" :: Either ParseError Digit+-- Right 4 ----- >>> parse (parseHEXADECIMAL <* eof) "test" "5" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMAL <* eof) "test" "5" :: Either ParseError Digit+-- Right 5 ----- >>> parse parseHEXADECIMAL "test" "5xyz" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMAL "test" "5xyz" :: Either ParseError Digit+-- Right 5 ----- >>> parse (parseHEXADECIMAL <* eof) "test" "6" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMAL <* eof) "test" "6" :: Either ParseError Digit+-- Right 6 ----- >>> parse parseHEXADECIMAL "test" "6xyz" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMAL "test" "6xyz" :: Either ParseError Digit+-- Right 6 ----- >>> parse (parseHEXADECIMAL <* eof) "test" "7" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMAL <* eof) "test" "7" :: Either ParseError Digit+-- Right 7 ----- >>> parse parseHEXADECIMAL "test" "7xyz" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMAL "test" "7xyz" :: Either ParseError Digit+-- Right 7 ----- >>> parse (parseHEXADECIMAL <* eof) "test" "8" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMAL <* eof) "test" "8" :: Either ParseError Digit+-- Right 8 ----- >>> parse parseHEXADECIMAL "test" "8xyz" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMAL "test" "8xyz" :: Either ParseError Digit+-- Right 8 ----- >>> parse (parseHEXADECIMAL <* eof) "test" "9" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMAL <* eof) "test" "9" :: Either ParseError Digit+-- Right 9 ----- >>> parse parseHEXADECIMAL "test" "9xyz" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMAL "test" "9xyz" :: Either ParseError Digit+-- Right 9 ----- >>> parse (parseHEXADECIMAL <* eof) "test" "A" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMAL <* eof) "test" "A" :: Either ParseError Digit+-- Right A ----- >>> parse parseHEXADECIMAL "test" "Axyz" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMAL "test" "Axyz" :: Either ParseError Digit+-- Right A ----- >>> parse (parseHEXADECIMAL <* eof) "test" "B" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMAL <* eof) "test" "B" :: Either ParseError Digit+-- Right B ----- >>> parse parseHEXADECIMAL "test" "Bxyz" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMAL "test" "Bxyz" :: Either ParseError Digit+-- Right B ----- >>> parse (parseHEXADECIMAL <* eof) "test" "C" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMAL <* eof) "test" "C" :: Either ParseError Digit+-- Right C ----- >>> parse parseHEXADECIMAL "test" "Cxyz" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMAL "test" "Cxyz" :: Either ParseError Digit+-- Right C ----- >>> parse (parseHEXADECIMAL <* eof) "test" "D" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMAL <* eof) "test" "D" :: Either ParseError Digit+-- Right D ----- >>> parse parseHEXADECIMAL "test" "Dxyz" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMAL "test" "Dxyz" :: Either ParseError Digit+-- Right D ----- >>> parse (parseHEXADECIMAL <* eof) "test" "E" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMAL <* eof) "test" "E" :: Either ParseError Digit+-- Right E ----- >>> parse parseHEXADECIMAL "test" "Exyz" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMAL "test" "Exyz" :: Either ParseError Digit+-- Right E ----- >>> parse (parseHEXADECIMAL <* eof) "test" "F" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse (parseHEXADECIMAL <* eof) "test" "F" :: Either ParseError Digit+-- Right F ----- >>> parse parseHEXADECIMAL "test" "Fxyz" :: Either ParseError (HEXADECIMALDigit' ())--- Right (Left ())+-- >>> parse parseHEXADECIMAL "test" "Fxyz" :: Either ParseError Digit+-- Right F ----- >>> isn't _Right (parse parseHEXADECIMAL "test" "xyz" :: Either ParseError (HEXADECIMALDigit' ()))+-- >>> isn't _Right (parse parseHEXADECIMAL "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> (c `notElem` "0123456789ABCDEF") ==> isn't _Right (parse parseHEXADECIMAL "test" [c] :: Either ParseError (HEXADECIMALDigit' ()))+-- prop> \c -> (c `notElem` "0123456789ABCDEF") ==> isn't _Right (parse parseHEXADECIMAL "test" [c] :: Either ParseError Digit) parseHEXADECIMAL ::   (HEXADECIMAL d, CharParsing p) =>   p d@@ -273,9 +262,3 @@       parse0     , parseHEXADECIMALNoZero     ] <?> "HEXADECIMAL"--type HEXADECIMALDigit d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 dA dB dC dD dE dF =-  Either d0 (HEXADECIMALNoZeroDigit d1 d2 d3 d4 d5 d6 d7 d8 d9 dA dB dC dD dE dF)--type HEXADECIMALDigit' d =-  HEXADECIMALDigit d d d d d d d d d d d d d d d d

@@ -6,14 +6,8 @@ , HeXaDeCiMaL , parseHeXaDeCiMaLNoZero , parseHeXaDeCiMaL-, HeXaDeCiMaLNoZeroDigit-, HeXaDeCiMaLNoZeroDigit'-, HeXaDeCiMaLDigit-, HeXaDeCiMaLDigit' ) where -import Papa-import Data.Void(Void) import Text.Parser.Char(CharParsing) import Text.Parser.Combinators((<?>), choice) import Data.Digit.D0(D0, parse0)@@ -49,142 +43,144 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)+-- >>> import Data.Digit.Digit+-- >>> import Papa  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)  -- | ----- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "1" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "1" :: Either ParseError Digit+-- Right 1 ----- >>> parse parseHeXaDeCiMaLNoZero "test" "1xyz" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaLNoZero "test" "1xyz" :: Either ParseError Digit+-- Right 1 ----- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "2" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "2" :: Either ParseError Digit+-- Right 2 ----- >>> parse parseHeXaDeCiMaLNoZero "test" "2xyz" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaLNoZero "test" "2xyz" :: Either ParseError Digit+-- Right 2 ----- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "3" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "3" :: Either ParseError Digit+-- Right 3 ----- >>> parse parseHeXaDeCiMaLNoZero "test" "3xyz" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaLNoZero "test" "3xyz" :: Either ParseError Digit+-- Right 3 ----- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "4" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "4" :: Either ParseError Digit+-- Right 4 ----- >>> parse parseHeXaDeCiMaLNoZero "test" "4xyz" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaLNoZero "test" "4xyz" :: Either ParseError Digit+-- Right 4 ----- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "5" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "5" :: Either ParseError Digit+-- Right 5 ----- >>> parse parseHeXaDeCiMaLNoZero "test" "5xyz" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaLNoZero "test" "5xyz" :: Either ParseError Digit+-- Right 5 ----- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "6" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "6" :: Either ParseError Digit+-- Right 6 ----- >>> parse parseHeXaDeCiMaLNoZero "test" "6xyz" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaLNoZero "test" "6xyz" :: Either ParseError Digit+-- Right 6 ----- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "7" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "7" :: Either ParseError Digit+-- Right 7 ----- >>> parse parseHeXaDeCiMaLNoZero "test" "7xyz" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaLNoZero "test" "7xyz" :: Either ParseError Digit+-- Right 7 ----- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "8" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "8" :: Either ParseError Digit+-- Right 8 ----- >>> parse parseHeXaDeCiMaLNoZero "test" "8xyz" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaLNoZero "test" "8xyz" :: Either ParseError Digit+-- Right 8 ----- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "9" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "9" :: Either ParseError Digit+-- Right 9 ----- >>> parse parseHeXaDeCiMaLNoZero "test" "9xyz" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaLNoZero "test" "9xyz" :: Either ParseError Digit+-- Right 9 ----- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "a" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "a" :: Either ParseError Digit+-- Right a ----- >>> parse parseHeXaDeCiMaLNoZero "test" "axyz" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaLNoZero "test" "axyz" :: Either ParseError Digit+-- Right a ----- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "b" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "b" :: Either ParseError Digit+-- Right b ----- >>> parse parseHeXaDeCiMaLNoZero "test" "bxyz" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaLNoZero "test" "bxyz" :: Either ParseError Digit+-- Right b ----- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "c" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "c" :: Either ParseError Digit+-- Right c ----- >>> parse parseHeXaDeCiMaLNoZero "test" "cxyz" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaLNoZero "test" "cxyz" :: Either ParseError Digit+-- Right c ----- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "d" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "d" :: Either ParseError Digit+-- Right d ----- >>> parse parseHeXaDeCiMaLNoZero "test" "dxyz" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaLNoZero "test" "dxyz" :: Either ParseError Digit+-- Right d ----- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "e" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "e" :: Either ParseError Digit+-- Right e ----- >>> parse parseHeXaDeCiMaLNoZero "test" "exyz" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaLNoZero "test" "exyz" :: Either ParseError Digit+-- Right e ----- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "f" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "f" :: Either ParseError Digit+-- Right f ----- >>> parse parseHeXaDeCiMaLNoZero "test" "fxyz" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaLNoZero "test" "fxyz" :: Either ParseError Digit+-- Right f ----- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "A" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "A" :: Either ParseError Digit+-- Right A ----- >>> parse parseHeXaDeCiMaLNoZero "test" "Axyz" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaLNoZero "test" "Axyz" :: Either ParseError Digit+-- Right A ----- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "B" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "B" :: Either ParseError Digit+-- Right B ----- >>> parse parseHeXaDeCiMaLNoZero "test" "Bxyz" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaLNoZero "test" "Bxyz" :: Either ParseError Digit+-- Right B ----- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "C" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "C" :: Either ParseError Digit+-- Right C ----- >>> parse parseHeXaDeCiMaLNoZero "test" "Cxyz" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaLNoZero "test" "Cxyz" :: Either ParseError Digit+-- Right C ----- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "D" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "D" :: Either ParseError Digit+-- Right D ----- >>> parse parseHeXaDeCiMaLNoZero "test" "Dxyz" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaLNoZero "test" "Dxyz" :: Either ParseError Digit+-- Right D ----- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "E" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "E" :: Either ParseError Digit+-- Right E ----- >>> parse parseHeXaDeCiMaLNoZero "test" "Exyz" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaLNoZero "test" "Exyz" :: Either ParseError Digit+-- Right E ----- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "F" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "F" :: Either ParseError Digit+-- Right F ----- >>> parse parseHeXaDeCiMaLNoZero "test" "Fxyz" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaLNoZero "test" "Fxyz" :: Either ParseError Digit+-- Right F ----- >>> isn't _Right (parse parseHeXaDeCiMaLNoZero "test" "xyz" :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ()))+-- >>> isn't _Right (parse parseHeXaDeCiMaLNoZero "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> (c `notElem` "123456789abcdefABCDEF") ==> isn't _Right (parse parseHeXaDeCiMaLNoZero "test" [c] :: Either ParseError (HeXaDeCiMaLNoZeroDigit' ()))+-- prop> \c -> (c `notElem` "123456789abcdefABCDEF") ==> isn't _Right (parse parseHeXaDeCiMaLNoZero "test" [c] :: Either ParseError Digit) parseHeXaDeCiMaLNoZero ::   (HeXaDeCiMaLNoZero d, CharParsing p) =>   p d@@ -200,147 +196,147 @@     , parseFf     ] <?> "HeXaDeCiMaLNoZero" -type HeXaDeCiMaLNoZeroDigit d1 d2 d3 d4 d5 d6 d7 d8 d9 da db dc dd de df dA dB dC dD dE dF =-  Either d1 (Either d2 (Either d3 (Either d4 (Either d5 (Either d5 (Either d6 (Either d7 (Either d8 (Either d9 (Either da (Either db (Either dc (Either dd (Either de (Either df (Either dA (Either dB (Either dC (Either dD (Either dE (Either dF Void)))))))))))))))))))))--type HeXaDeCiMaLNoZeroDigit' d =-  HeXaDeCiMaLNoZeroDigit d d d d d d d d d d d d d d d d d d d d d-   type HeXaDeCiMaL d =   (D0 d, HeXaDeCiMaLNoZero d)  -- | ----- >>> parse (parseHeXaDeCiMaL <* eof) "test" "1" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaL <* eof) "test" "0" :: Either ParseError Digit+-- Right 0 ----- >>> parse parseHeXaDeCiMaL "test" "1xyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaL "test" "0xyz" :: Either ParseError Digit+-- Right 0 ----- >>> parse (parseHeXaDeCiMaL <* eof) "test" "2" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaL <* eof) "test" "1" :: Either ParseError Digit+-- Right 1 ----- >>> parse parseHeXaDeCiMaL "test" "2xyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaL "test" "1xyz" :: Either ParseError Digit+-- Right 1 ----- >>> parse (parseHeXaDeCiMaL <* eof) "test" "3" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaL <* eof) "test" "2" :: Either ParseError Digit+-- Right 2 ----- >>> parse parseHeXaDeCiMaL "test" "3xyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaL "test" "2xyz" :: Either ParseError Digit+-- Right 2 ----- >>> parse (parseHeXaDeCiMaL <* eof) "test" "4" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaL <* eof) "test" "3" :: Either ParseError Digit+-- Right 3 ----- >>> parse parseHeXaDeCiMaL "test" "4xyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaL "test" "3xyz" :: Either ParseError Digit+-- Right 3 ----- >>> parse (parseHeXaDeCiMaL <* eof) "test" "5" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaL <* eof) "test" "4" :: Either ParseError Digit+-- Right 4 ----- >>> parse parseHeXaDeCiMaL "test" "5xyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaL "test" "4xyz" :: Either ParseError Digit+-- Right 4 ----- >>> parse (parseHeXaDeCiMaL <* eof) "test" "6" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaL <* eof) "test" "5" :: Either ParseError Digit+-- Right 5 ----- >>> parse parseHeXaDeCiMaL "test" "6xyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaL "test" "5xyz" :: Either ParseError Digit+-- Right 5 ----- >>> parse (parseHeXaDeCiMaL <* eof) "test" "7" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaL <* eof) "test" "6" :: Either ParseError Digit+-- Right 6 ----- >>> parse parseHeXaDeCiMaL "test" "7xyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaL "test" "6xyz" :: Either ParseError Digit+-- Right 6 ----- >>> parse (parseHeXaDeCiMaL <* eof) "test" "8" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaL <* eof) "test" "7" :: Either ParseError Digit+-- Right 7 ----- >>> parse parseHeXaDeCiMaL "test" "8xyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaL "test" "7xyz" :: Either ParseError Digit+-- Right 7 ----- >>> parse (parseHeXaDeCiMaL <* eof) "test" "9" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaL <* eof) "test" "8" :: Either ParseError Digit+-- Right 8 ----- >>> parse parseHeXaDeCiMaL "test" "9xyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaL "test" "8xyz" :: Either ParseError Digit+-- Right 8 ----- >>> parse (parseHeXaDeCiMaL <* eof) "test" "a" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaL <* eof) "test" "9" :: Either ParseError Digit+-- Right 9 ----- >>> parse parseHeXaDeCiMaL "test" "axyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaL "test" "9xyz" :: Either ParseError Digit+-- Right 9 ----- >>> parse (parseHeXaDeCiMaL <* eof) "test" "b" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaL <* eof) "test" "a" :: Either ParseError Digit+-- Right a ----- >>> parse parseHeXaDeCiMaL "test" "bxyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaL "test" "axyz" :: Either ParseError Digit+-- Right a ----- >>> parse (parseHeXaDeCiMaL <* eof) "test" "c" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaL <* eof) "test" "b" :: Either ParseError Digit+-- Right b ----- >>> parse parseHeXaDeCiMaL "test" "cxyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaL "test" "bxyz" :: Either ParseError Digit+-- Right b ----- >>> parse (parseHeXaDeCiMaL <* eof) "test" "d" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaL <* eof) "test" "c" :: Either ParseError Digit+-- Right c ----- >>> parse parseHeXaDeCiMaL "test" "dxyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaL "test" "cxyz" :: Either ParseError Digit+-- Right c ----- >>> parse (parseHeXaDeCiMaL <* eof) "test" "e" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaL <* eof) "test" "d" :: Either ParseError Digit+-- Right d ----- >>> parse parseHeXaDeCiMaL "test" "exyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaL "test" "dxyz" :: Either ParseError Digit+-- Right d ----- >>> parse (parseHeXaDeCiMaL <* eof) "test" "f" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaL <* eof) "test" "e" :: Either ParseError Digit+-- Right e ----- >>> parse parseHeXaDeCiMaL "test" "fxyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaL "test" "exyz" :: Either ParseError Digit+-- Right e ----- >>> parse (parseHeXaDeCiMaL <* eof) "test" "A" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaL <* eof) "test" "f" :: Either ParseError Digit+-- Right f ----- >>> parse parseHeXaDeCiMaL "test" "Axyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaL "test" "fxyz" :: Either ParseError Digit+-- Right f ----- >>> parse (parseHeXaDeCiMaL <* eof) "test" "B" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaL <* eof) "test" "A" :: Either ParseError Digit+-- Right A ----- >>> parse parseHeXaDeCiMaL "test" "Bxyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaL "test" "Axyz" :: Either ParseError Digit+-- Right A ----- >>> parse (parseHeXaDeCiMaL <* eof) "test" "C" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaL <* eof) "test" "B" :: Either ParseError Digit+-- Right B ----- >>> parse parseHeXaDeCiMaL "test" "Cxyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaL "test" "Bxyz" :: Either ParseError Digit+-- Right B ----- >>> parse (parseHeXaDeCiMaL <* eof) "test" "D" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaL <* eof) "test" "C" :: Either ParseError Digit+-- Right C ----- >>> parse parseHeXaDeCiMaL "test" "Dxyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaL "test" "Cxyz" :: Either ParseError Digit+-- Right C ----- >>> parse (parseHeXaDeCiMaL <* eof) "test" "E" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaL <* eof) "test" "D" :: Either ParseError Digit+-- Right D ----- >>> parse parseHeXaDeCiMaL "test" "Exyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaL "test" "Dxyz" :: Either ParseError Digit+-- Right D ----- >>> parse (parseHeXaDeCiMaL <* eof) "test" "F" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse (parseHeXaDeCiMaL <* eof) "test" "E" :: Either ParseError Digit+-- Right E ----- >>> parse parseHeXaDeCiMaL "test" "Fxyz" :: Either ParseError (HeXaDeCiMaLDigit' ())--- Right (Left ())+-- >>> parse parseHeXaDeCiMaL "test" "Exyz" :: Either ParseError Digit+-- Right E ----- >>> isn't _Right (parse parseHeXaDeCiMaL "test" "xyz" :: Either ParseError (HeXaDeCiMaLDigit' ()))+-- >>> parse (parseHeXaDeCiMaL <* eof) "test" "F" :: Either ParseError Digit+-- Right F+--+-- >>> parse parseHeXaDeCiMaL "test" "Fxyz" :: Either ParseError Digit+-- Right F+--+-- >>> isn't _Right (parse parseHeXaDeCiMaL "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> (c `notElem` "0123456789abcdefABCDEF") ==> isn't _Right (parse parseHeXaDeCiMaL "test" [c] :: Either ParseError (HeXaDeCiMaLDigit' ()))+-- prop> \c -> (c `notElem` "0123456789abcdefABCDEF") ==> isn't _Right (parse parseHeXaDeCiMaL "test" [c] :: Either ParseError Digit) parseHeXaDeCiMaL ::   (HeXaDeCiMaL d, CharParsing p) =>   p d@@ -350,10 +346,3 @@       parse0     , parseHeXaDeCiMaLNoZero     ] <?> "HeXaDeCiMaL"--type HeXaDeCiMaLDigit d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 da db dc dd de df dA dB dC dD dE dF =-  Either d0 (HeXaDeCiMaLNoZeroDigit d1 d2 d3 d4 d5 d6 d7 d8 d9 da db dc dd de df dA dB dC dD dE dF)--type HeXaDeCiMaLDigit' d =-  HeXaDeCiMaLDigit d d d d d d d d d d d d d d d d d d d d d d-

@@ -6,14 +6,8 @@ , Hexadecimal , parseHexadecimalNoZero , parseHexadecimal-, HexadecimalNoZeroDigit-, HexadecimalNoZeroDigit'-, HexadecimalDigit-, HexadecimalDigit' ) where -import Papa-import Data.Void(Void) import Text.Parser.Char(CharParsing) import Text.Parser.Combinators((<?>), choice) import Data.Digit.D0(D0, parse0)@@ -37,106 +31,108 @@ -- $setup -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void)+-- >>> import Data.Digit.Digit+-- >>> import Papa  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)  -- | ----- >>> parse (parseHexadecimalNoZero <* eof) "test" "1" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimalNoZero <* eof) "test" "1" :: Either ParseError Digit+-- Right 1 ----- >>> parse parseHexadecimalNoZero "test" "1xyz" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimalNoZero "test" "1xyz" :: Either ParseError Digit+-- Right 1 ----- >>> parse (parseHexadecimalNoZero <* eof) "test" "2" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimalNoZero <* eof) "test" "2" :: Either ParseError Digit+-- Right 2 ----- >>> parse parseHexadecimalNoZero "test" "2xyz" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimalNoZero "test" "2xyz" :: Either ParseError Digit+-- Right 2 ----- >>> parse (parseHexadecimalNoZero <* eof) "test" "3" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimalNoZero <* eof) "test" "3" :: Either ParseError Digit+-- Right 3 ----- >>> parse parseHexadecimalNoZero "test" "3xyz" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimalNoZero "test" "3xyz" :: Either ParseError Digit+-- Right 3 ----- >>> parse (parseHexadecimalNoZero <* eof) "test" "4" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimalNoZero <* eof) "test" "4" :: Either ParseError Digit+-- Right 4 ----- >>> parse parseHexadecimalNoZero "test" "4xyz" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimalNoZero "test" "4xyz" :: Either ParseError Digit+-- Right 4 ----- >>> parse (parseHexadecimalNoZero <* eof) "test" "5" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimalNoZero <* eof) "test" "5" :: Either ParseError Digit+-- Right 5 ----- >>> parse parseHexadecimalNoZero "test" "5xyz" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimalNoZero "test" "5xyz" :: Either ParseError Digit+-- Right 5 ----- >>> parse (parseHexadecimalNoZero <* eof) "test" "6" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimalNoZero <* eof) "test" "6" :: Either ParseError Digit+-- Right 6 ----- >>> parse parseHexadecimalNoZero "test" "6xyz" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimalNoZero "test" "6xyz" :: Either ParseError Digit+-- Right 6 ----- >>> parse (parseHexadecimalNoZero <* eof) "test" "7" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimalNoZero <* eof) "test" "7" :: Either ParseError Digit+-- Right 7 ----- >>> parse parseHexadecimalNoZero "test" "7xyz" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimalNoZero "test" "7xyz" :: Either ParseError Digit+-- Right 7 ----- >>> parse (parseHexadecimalNoZero <* eof) "test" "8" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimalNoZero <* eof) "test" "8" :: Either ParseError Digit+-- Right 8 ----- >>> parse parseHexadecimalNoZero "test" "8xyz" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimalNoZero "test" "8xyz" :: Either ParseError Digit+-- Right 8 ----- >>> parse (parseHexadecimalNoZero <* eof) "test" "9" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimalNoZero <* eof) "test" "9" :: Either ParseError Digit+-- Right 9 ----- >>> parse parseHexadecimalNoZero "test" "9xyz" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimalNoZero "test" "9xyz" :: Either ParseError Digit+-- Right 9 ----- >>> parse (parseHexadecimalNoZero <* eof) "test" "a" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimalNoZero <* eof) "test" "a" :: Either ParseError Digit+-- Right a ----- >>> parse parseHexadecimalNoZero "test" "axyz" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimalNoZero "test" "axyz" :: Either ParseError Digit+-- Right a ----- >>> parse (parseHexadecimalNoZero <* eof) "test" "b" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimalNoZero <* eof) "test" "b" :: Either ParseError Digit+-- Right b ----- >>> parse parseHexadecimalNoZero "test" "bxyz" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimalNoZero "test" "bxyz" :: Either ParseError Digit+-- Right b ----- >>> parse (parseHexadecimalNoZero <* eof) "test" "c" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimalNoZero <* eof) "test" "c" :: Either ParseError Digit+-- Right c ----- >>> parse parseHexadecimalNoZero "test" "cxyz" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimalNoZero "test" "cxyz" :: Either ParseError Digit+-- Right c ----- >>> parse (parseHexadecimalNoZero <* eof) "test" "d" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimalNoZero <* eof) "test" "d" :: Either ParseError Digit+-- Right d ----- >>> parse parseHexadecimalNoZero "test" "dxyz" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimalNoZero "test" "dxyz" :: Either ParseError Digit+-- Right d ----- >>> parse (parseHexadecimalNoZero <* eof) "test" "e" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimalNoZero <* eof) "test" "e" :: Either ParseError Digit+-- Right e ----- >>> parse parseHexadecimalNoZero "test" "exyz" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimalNoZero "test" "exyz" :: Either ParseError Digit+-- Right e ----- >>> parse (parseHexadecimalNoZero <* eof) "test" "f" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimalNoZero <* eof) "test" "f" :: Either ParseError Digit+-- Right f ----- >>> parse parseHexadecimalNoZero "test" "fxyz" :: Either ParseError (HexadecimalNoZeroDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimalNoZero "test" "fxyz" :: Either ParseError Digit+-- Right f ----- >>> isn't _Right (parse parseHexadecimalNoZero "test" "xyz" :: Either ParseError (HexadecimalNoZeroDigit' ()))+-- >>> isn't _Right (parse parseHexadecimalNoZero "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> (c `notElem` "123456789abcdef") ==> isn't _Right (parse parseHexadecimalNoZero "test" [c] :: Either ParseError (HexadecimalNoZeroDigit' ()))+-- prop> \c -> (c `notElem` "123456789abcdef") ==> isn't _Right (parse parseHexadecimalNoZero "test" [c] :: Either ParseError Digit) parseHexadecimalNoZero ::   (HexadecimalNoZero d, CharParsing p) =>   p d@@ -152,118 +148,111 @@     , parsef     ] <?> "HexadecimalNoZero" -type HexadecimalNoZeroDigit d1 d2 d3 d4 d5 d6 d7 d8 d9 da db dc dd de df =-  Either d1 (Either d2 (Either d3 (Either d4 (Either d5 (Either d5 (Either d6 (Either d7 (Either d8 (Either d9 (Either da (Either db (Either dc (Either dd (Either de (Either df Void)))))))))))))))--type HexadecimalNoZeroDigit' d =-  HexadecimalNoZeroDigit d d d d d d d d d d d d d d d-  - type Hexadecimal d =   (D0 d, HexadecimalNoZero d)  -- | ----- >>> parse (parseHexadecimal <* eof) "test" "0" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimal <* eof) "test" "0" :: Either ParseError Digit+-- Right 0 ----- >>> parse parseHexadecimal "test" "0xyz" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimal "test" "0xyz" :: Either ParseError Digit+-- Right 0 ----- >>> parse (parseHexadecimal <* eof) "test" "0" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimal <* eof) "test" "1" :: Either ParseError Digit+-- Right 1 ----- >>> parse parseHexadecimal "test" "0xyz" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimal "test" "1xyz" :: Either ParseError Digit+-- Right 1 ----- >>> parse (parseHexadecimal <* eof) "test" "2" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimal <* eof) "test" "2" :: Either ParseError Digit+-- Right 2 ----- >>> parse parseHexadecimal "test" "2xyz" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimal "test" "2xyz" :: Either ParseError Digit+-- Right 2 ----- >>> parse (parseHexadecimal <* eof) "test" "3" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimal <* eof) "test" "3" :: Either ParseError Digit+-- Right 3 ----- >>> parse parseHexadecimal "test" "3xyz" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimal "test" "3xyz" :: Either ParseError Digit+-- Right 3 ----- >>> parse (parseHexadecimal <* eof) "test" "4" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimal <* eof) "test" "4" :: Either ParseError Digit+-- Right 4 ----- >>> parse parseHexadecimal "test" "4xyz" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimal "test" "4xyz" :: Either ParseError Digit+-- Right 4 ----- >>> parse (parseHexadecimal <* eof) "test" "5" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimal <* eof) "test" "5" :: Either ParseError Digit+-- Right 5 ----- >>> parse parseHexadecimal "test" "5xyz" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimal "test" "5xyz" :: Either ParseError Digit+-- Right 5 ----- >>> parse (parseHexadecimal <* eof) "test" "6" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimal <* eof) "test" "6" :: Either ParseError Digit+-- Right 6 ----- >>> parse parseHexadecimal "test" "6xyz" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimal "test" "6xyz" :: Either ParseError Digit+-- Right 6 ----- >>> parse (parseHexadecimal <* eof) "test" "7" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimal <* eof) "test" "7" :: Either ParseError Digit+-- Right 7 ----- >>> parse parseHexadecimal "test" "7xyz" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimal "test" "7xyz" :: Either ParseError Digit+-- Right 7 ----- >>> parse (parseHexadecimal <* eof) "test" "8" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimal <* eof) "test" "8" :: Either ParseError Digit+-- Right 8 ----- >>> parse parseHexadecimal "test" "8xyz" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimal "test" "8xyz" :: Either ParseError Digit+-- Right 8 ----- >>> parse (parseHexadecimal <* eof) "test" "9" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimal <* eof) "test" "9" :: Either ParseError Digit+-- Right 9 ----- >>> parse parseHexadecimal "test" "9xyz" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimal "test" "9xyz" :: Either ParseError Digit+-- Right 9 ----- >>> parse (parseHexadecimal <* eof) "test" "a" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimal <* eof) "test" "a" :: Either ParseError Digit+-- Right a ----- >>> parse parseHexadecimal "test" "axyz" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimal "test" "axyz" :: Either ParseError Digit+-- Right a ----- >>> parse (parseHexadecimal <* eof) "test" "b" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimal <* eof) "test" "b" :: Either ParseError Digit+-- Right b ----- >>> parse parseHexadecimal "test" "bxyz" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimal "test" "bxyz" :: Either ParseError Digit+-- Right b ----- >>> parse (parseHexadecimal <* eof) "test" "c" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimal <* eof) "test" "c" :: Either ParseError Digit+-- Right c ----- >>> parse parseHexadecimal "test" "cxyz" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimal "test" "cxyz" :: Either ParseError Digit+-- Right c ----- >>> parse (parseHexadecimal <* eof) "test" "d" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimal <* eof) "test" "d" :: Either ParseError Digit+-- Right d ----- >>> parse parseHexadecimal "test" "dxyz" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimal "test" "dxyz" :: Either ParseError Digit+-- Right d ----- >>> parse (parseHexadecimal <* eof) "test" "e" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimal <* eof) "test" "e" :: Either ParseError Digit+-- Right e ----- >>> parse parseHexadecimal "test" "exyz" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimal "test" "exyz" :: Either ParseError Digit+-- Right e ----- >>> parse (parseHexadecimal <* eof) "test" "f" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse (parseHexadecimal <* eof) "test" "f" :: Either ParseError Digit+-- Right f ----- >>> parse parseHexadecimal "test" "fxyz" :: Either ParseError (HexadecimalDigit' ())--- Right (Left ())+-- >>> parse parseHexadecimal "test" "fxyz" :: Either ParseError Digit+-- Right f ----- >>> isn't _Right (parse parseHexadecimal "test" "xyz" :: Either ParseError (HexadecimalDigit' ()))+-- >>> isn't _Right (parse parseHexadecimal "test" "xyz" :: Either ParseError Digit) -- True ----- prop> \c -> (c `notElem` "0123456789abcdef") ==> isn't _Right (parse parseHexadecimal "test" [c] :: Either ParseError (HexadecimalDigit' ()))+-- prop> \c -> (c `notElem` "0123456789abcdef") ==> isn't _Right (parse parseHexadecimal "test" [c] :: Either ParseError Digit) parseHexadecimal ::   (Hexadecimal d, CharParsing p) =>   p d@@ -273,9 +262,3 @@       parse0     , parseHexadecimalNoZero     ] <?> "Hexadecimal"--type HexadecimalDigit d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 da db dc dd de df =-  Either d0 (HexadecimalNoZeroDigit d1 d2 d3 d4 d5 d6 d7 d8 d9 da db dc dd de df)--type HexadecimalDigit' d =-  HexadecimalDigit d d d d d d d d d d d d d d d d

@@ -0,0 +1,764 @@+{-# LANGUAGE NoImplicitPrelude #-}++module Data.Digit.Integral(+  integralBinaryNoZero+, integralBinary+, integralOctalNoZero+, integralOctal+, integralDecimal+, integralDecimalNoZero+, integralHexadecimalNoZero+, integralHexadecimal+, integralHEXADECIMALNoZero+, integralHEXADECIMAL+) 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.D0 as D+import Data.Digit.D1 as D+import Data.Digit.D2 as D+import Data.Digit.D3 as D+import Data.Digit.D4 as D+import Data.Digit.D5 as D+import Data.Digit.D6 as D+import Data.Digit.D7 as D+import Data.Digit.D8 as D+import Data.Digit.D9 as D+import Data.Digit.Da as D+import Data.Digit.DA as D+import Data.Digit.Db as D+import Data.Digit.DB as D+import Data.Digit.Dc as D+import Data.Digit.DC as D+import Data.Digit.Dd as D+import Data.Digit.DD as D+import Data.Digit.De as D+import Data.Digit.DE as D+import Data.Digit.Df as D+import Data.Digit.DF as D+import Papa++-- $setup+-- >>> import Data.Digit.Digit++-- |+--+-- >>> 1 ^? integralBinaryNoZero+-- Just ()+--+-- >>> integralBinaryNoZero # Digit1 :: Integer+-- 1+--+-- prop> \c -> c /= 1 ==> (c ^? integralBinaryNoZero == Nothing)+integralBinaryNoZero ::+  (Integral a, BinaryNoZero d) =>+  Prism'+    a+    d+integralBinaryNoZero =+  associatePrism (1, d1) []+  +-- |+--+-- >>> 0 ^? integralBinary :: Maybe Digit+-- Just 0+--+-- >>> 1 ^? integralBinary :: Maybe Digit+-- Just 1+--+-- >>> integralBinary # Digit0 :: Integer+-- 0+--+-- >>> integralBinary # Digit1 :: Integer+-- 1+--+-- prop> \c -> (c `notElem` [0, 1]) ==> (c ^? integralBinary == Nothing)+integralBinary ::+  (Integral a, Binary d) =>+  Prism'+    a+    d+integralBinary =+  associatePrism (0, d0) [(1, d1)]+  +-- |+--+-- >>> 1 ^? integralOctalNoZero :: Maybe Digit+-- Just 1+--+-- >>> 2 ^? integralOctalNoZero :: Maybe Digit+-- Just 2+--+-- >>> 3 ^? integralOctalNoZero :: Maybe Digit+-- Just 3+--+-- >>> 4 ^? integralOctalNoZero :: Maybe Digit+-- Just 4+--+-- >>> 5 ^? integralOctalNoZero :: Maybe Digit+-- Just 5+--+-- >>> 6 ^? integralOctalNoZero :: Maybe Digit+-- Just 6+--+-- >>> 7 ^? integralOctalNoZero :: Maybe Digit+-- Just 7+--+-- >>> integralOctalNoZero # Digit1 :: Integer+-- 1+--+-- >>> integralOctalNoZero # Digit2 :: Integer+-- 2+--+-- >>> integralOctalNoZero # Digit3 :: Integer+-- 3+--+-- >>> integralOctalNoZero # Digit4 :: Integer+-- 4+--+-- >>> integralOctalNoZero # Digit5 :: Integer+-- 5+--+-- >>> integralOctalNoZero # Digit6 :: Integer+-- 6+--+-- >>> integralOctalNoZero # Digit7 :: Integer+-- 7+--+-- prop> \c -> (c `notElem` [1..7]) ==> (c ^? integralOctalNoZero == Nothing)+integralOctalNoZero ::+  (Integral a, OctalNoZero d) =>+  Prism'+    a+    d+integralOctalNoZero =+  associatePrism (1, d1) [(2, d2), (3, d3), (4, d4), (5, d5), (6, d6), (7, d7)]++-- |+--+-- >>> 0 ^? integralOctal :: Maybe Digit+-- Just 0+--+-- >>> 1 ^? integralOctal :: Maybe Digit+-- Just 1+--+-- >>> 2 ^? integralOctal :: Maybe Digit+-- Just 2+--+-- >>> 3 ^? integralOctal :: Maybe Digit+-- Just 3+--+-- >>> 4 ^? integralOctal :: Maybe Digit+-- Just 4+--+-- >>> 5 ^? integralOctal :: Maybe Digit+-- Just 5+--+-- >>> 6 ^? integralOctal :: Maybe Digit+-- Just 6+--+-- >>> 7 ^? integralOctal :: Maybe Digit+-- Just 7+--+-- >>> integralOctal # Digit0 :: Integer+-- 0+--+-- >>> integralOctal # Digit1 :: Integer+-- 1+--+-- >>> integralOctal # Digit2 :: Integer+-- 2+--+-- >>> integralOctal # Digit3 :: Integer+-- 3+--+-- >>> integralOctal # Digit4 :: Integer+-- 4+--+-- >>> integralOctal # Digit5 :: Integer+-- 5+--+-- >>> integralOctal # Digit6 :: Integer+-- 6+--+-- >>> integralOctal # Digit7 :: Integer+-- 7+--+-- prop> \c -> (c `notElem` [0..7]) ==> (c ^? integralOctal == Nothing)+integralOctal ::+  (Integral a, Octal d) =>+  Prism'+    a+    d+integralOctal =+  associatePrism (0, d0) [(1, d1), (2, d2), (3, d3), (4, d4), (5, d5), (6, d6), (7, d7)]+  +-- |+--+-- >>> 1 ^? integralDecimalNoZero :: Maybe Digit+-- Just 1+--+-- >>> 2 ^? integralDecimalNoZero :: Maybe Digit+-- Just 2+--+-- >>> 3 ^? integralDecimalNoZero :: Maybe Digit+-- Just 3+--+-- >>> 4 ^? integralDecimalNoZero :: Maybe Digit+-- Just 4+--+-- >>> 5 ^? integralDecimalNoZero :: Maybe Digit+-- Just 5+--+-- >>> 6 ^? integralDecimalNoZero :: Maybe Digit+-- Just 6+--+-- >>> 7 ^? integralDecimalNoZero :: Maybe Digit+-- Just 7+--+-- >>> 8 ^? integralDecimalNoZero :: Maybe Digit+-- Just 8+--+-- >>> 9 ^? integralDecimalNoZero :: Maybe Digit+-- Just 9+--+-- >>> integralDecimalNoZero # Digit1 :: Integer+-- 1+--+-- >>> integralDecimalNoZero # Digit2 :: Integer+-- 2+--+-- >>> integralDecimalNoZero # Digit3 :: Integer+-- 3+--+-- >>> integralDecimalNoZero # Digit4 :: Integer+-- 4+--+-- >>> integralDecimalNoZero # Digit5 :: Integer+-- 5+--+-- >>> integralDecimalNoZero # Digit6 :: Integer+-- 6+--+-- >>> integralDecimalNoZero # Digit7 :: Integer+-- 7+--+-- >>> integralDecimalNoZero # Digit8 :: Integer+-- 8+--+-- >>> integralDecimalNoZero # Digit9 :: Integer+-- 9+--+-- prop> \c -> (c `notElem` [1..9]) ==> (c ^? integralDecimalNoZero == Nothing)+integralDecimalNoZero ::+  (Integral a, DecimalNoZero d) =>+  Prism'+    a+    d+integralDecimalNoZero =+  associatePrism (1, d1) [(2, d2), (3, d3), (4, d4), (5, d5), (6, d6), (7, d7), (8, d8), (9, d9)]+  +-- |+--+-- >>> 0 ^? integralDecimal :: Maybe Digit+-- Just 0+--+-- >>> 1 ^? integralDecimal :: Maybe Digit+-- Just 1+--+-- >>> 2 ^? integralDecimal :: Maybe Digit+-- Just 2+--+-- >>> 3 ^? integralDecimal :: Maybe Digit+-- Just 3+--+-- >>> 4 ^? integralDecimal :: Maybe Digit+-- Just 4+--+-- >>> 5 ^? integralDecimal :: Maybe Digit+-- Just 5+--+-- >>> 6 ^? integralDecimal :: Maybe Digit+-- Just 6+--+-- >>> 7 ^? integralDecimal :: Maybe Digit+-- Just 7+--+-- >>> 8 ^? integralDecimal :: Maybe Digit+-- Just 8+--+-- >>> 9 ^? integralDecimal :: Maybe Digit+-- Just 9+--+-- >>> integralDecimal # Digit0 :: Integer+-- 0+--+-- >>> integralDecimal # Digit1 :: Integer+-- 1+--+-- >>> integralDecimal # Digit2 :: Integer+-- 2+--+-- >>> integralDecimal # Digit3 :: Integer+-- 3+--+-- >>> integralDecimal # Digit4 :: Integer+-- 4+--+-- >>> integralDecimal # Digit5 :: Integer+-- 5+--+-- >>> integralDecimal # Digit6 :: Integer+-- 6+--+-- >>> integralDecimal # Digit7 :: Integer+-- 7+--+-- >>> integralDecimal # Digit8 :: Integer+-- 8+--+-- >>> integralDecimal # Digit9 :: Integer+-- 9+--+-- prop> \c -> (c `notElem` [0..9]) ==> (c ^? integralDecimal == Nothing)+integralDecimal ::+  (Integral a, Decimal d) =>+  Prism'+    a+    d+integralDecimal =+  associatePrism (0, d0) [(1, d1), (2, d2), (3, d3), (4, d4), (5, d5), (6, d6), (7, d7), (8, d8), (9, d9)]+  +-- |+--+-- >>> 1 ^? integralHexadecimalNoZero :: Maybe Digit+-- Just 1+--+-- >>> 2 ^? integralHexadecimalNoZero :: Maybe Digit+-- Just 2+--+-- >>> 3 ^? integralHexadecimalNoZero :: Maybe Digit+-- Just 3+--+-- >>> 4 ^? integralHexadecimalNoZero :: Maybe Digit+-- Just 4+--+-- >>> 5 ^? integralHexadecimalNoZero :: Maybe Digit+-- Just 5+--+-- >>> 6 ^? integralHexadecimalNoZero :: Maybe Digit+-- Just 6+--+-- >>> 7 ^? integralHexadecimalNoZero :: Maybe Digit+-- Just 7+--+-- >>> 8 ^? integralHexadecimalNoZero :: Maybe Digit+-- Just 8+--+-- >>> 9 ^? integralHexadecimalNoZero :: Maybe Digit+-- Just 9+--+-- >>> 10 ^? integralHexadecimalNoZero :: Maybe Digit+-- Just a+--+-- >>> 11 ^? integralHexadecimalNoZero :: Maybe Digit+-- Just b+--+-- >>> 12 ^? integralHexadecimalNoZero :: Maybe Digit+-- Just c+--+-- >>> 13 ^? integralHexadecimalNoZero :: Maybe Digit+-- Just d+--+-- >>> 14 ^? integralHexadecimalNoZero :: Maybe Digit+-- Just e+--+-- >>> 15 ^? integralHexadecimalNoZero :: Maybe Digit+-- Just f+--+-- >>> integralHexadecimalNoZero # Digit1 :: Integer+-- 1+--+-- >>> integralHexadecimalNoZero # Digit2 :: Integer+-- 2+--+-- >>> integralHexadecimalNoZero # Digit3 :: Integer+-- 3+--+-- >>> integralHexadecimalNoZero # Digit4 :: Integer+-- 4+--+-- >>> integralHexadecimalNoZero # Digit5 :: Integer+-- 5+--+-- >>> integralHexadecimalNoZero # Digit6 :: Integer+-- 6+--+-- >>> integralHexadecimalNoZero # Digit7 :: Integer+-- 7+--+-- >>> integralHexadecimalNoZero # Digit8 :: Integer+-- 8+--+-- >>> integralHexadecimalNoZero # Digit9 :: Integer+-- 9+--+-- >>> integralHexadecimalNoZero # Digita :: Integer+-- 10+--+-- >>> integralHexadecimalNoZero # Digitb :: Integer+-- 11+--+-- >>> integralHexadecimalNoZero # Digitc :: Integer+-- 12+--+-- >>> integralHexadecimalNoZero # Digitd :: Integer+-- 13+--+-- >>> integralHexadecimalNoZero # Digite :: Integer+-- 14+--+-- >>> integralHexadecimalNoZero # Digitf :: Integer+-- 15+--+-- prop> \c -> (c `notElem` [1..15]) ==> (c ^? integralHexadecimalNoZero == Nothing)+integralHexadecimalNoZero ::+  (Integral a, HexadecimalNoZero d) =>+  Prism'+    a+    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)]+  +-- |+--+-- >>> 0 ^? integralHexadecimal :: Maybe Digit+-- Just 0+--+-- >>> 1 ^? integralHexadecimal :: Maybe Digit+-- Just 1+--+-- >>> 2 ^? integralHexadecimal :: Maybe Digit+-- Just 2+--+-- >>> 3 ^? integralHexadecimal :: Maybe Digit+-- Just 3+--+-- >>> 4 ^? integralHexadecimal :: Maybe Digit+-- Just 4+--+-- >>> 5 ^? integralHexadecimal :: Maybe Digit+-- Just 5+--+-- >>> 6 ^? integralHexadecimal :: Maybe Digit+-- Just 6+--+-- >>> 7 ^? integralHexadecimal :: Maybe Digit+-- Just 7+--+-- >>> 8 ^? integralHexadecimal :: Maybe Digit+-- Just 8+--+-- >>> 9 ^? integralHexadecimal :: Maybe Digit+-- Just 9+--+-- >>> 10 ^? integralHexadecimal :: Maybe Digit+-- Just a+--+-- >>> 11 ^? integralHexadecimal :: Maybe Digit+-- Just b+--+-- >>> 12 ^? integralHexadecimal :: Maybe Digit+-- Just c+--+-- >>> 13 ^? integralHexadecimal :: Maybe Digit+-- Just d+--+-- >>> 14 ^? integralHexadecimal :: Maybe Digit+-- Just e+--+-- >>> 15 ^? integralHexadecimal :: Maybe Digit+-- Just f+--+-- >>> integralHexadecimal # Digit0 :: Integer+-- 0+--+-- >>> integralHexadecimal # Digit1 :: Integer+-- 1+--+-- >>> integralHexadecimal # Digit2 :: Integer+-- 2+--+-- >>> integralHexadecimal # Digit3 :: Integer+-- 3+--+-- >>> integralHexadecimal # Digit4 :: Integer+-- 4+--+-- >>> integralHexadecimal # Digit5 :: Integer+-- 5+--+-- >>> integralHexadecimal # Digit6 :: Integer+-- 6+--+-- >>> integralHexadecimal # Digit7 :: Integer+-- 7+--+-- >>> integralHexadecimal # Digit8 :: Integer+-- 8+--+-- >>> integralHexadecimal # Digit9 :: Integer+-- 9+--+-- >>> integralHexadecimal # Digita :: Integer+-- 10+--+-- >>> integralHexadecimal # Digitb :: Integer+-- 11+--+-- >>> integralHexadecimal # Digitc :: Integer+-- 12+--+-- >>> integralHexadecimal # Digitd :: Integer+-- 13+--+-- >>> integralHexadecimal # Digite :: Integer+-- 14+--+-- >>> integralHexadecimal # Digitf :: Integer+-- 15+--+-- prop> \c -> (c `notElem` [0..15]) ==> (c ^? integralHexadecimal == Nothing)+integralHexadecimal ::+  (Integral a, Hexadecimal d) =>+  Prism'+    a+    d+integralHexadecimal =+  associatePrism (0, d0) [(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)]++-- |+--+-- >>> 1 ^? integralHEXADECIMALNoZero :: Maybe Digit+-- Just 1+--+-- >>> 2 ^? integralHEXADECIMALNoZero :: Maybe Digit+-- Just 2+--+-- >>> 3 ^? integralHEXADECIMALNoZero :: Maybe Digit+-- Just 3+--+-- >>> 4 ^? integralHEXADECIMALNoZero :: Maybe Digit+-- Just 4+--+-- >>> 5 ^? integralHEXADECIMALNoZero :: Maybe Digit+-- Just 5+--+-- >>> 6 ^? integralHEXADECIMALNoZero :: Maybe Digit+-- Just 6+--+-- >>> 7 ^? integralHEXADECIMALNoZero :: Maybe Digit+-- Just 7+--+-- >>> 8 ^? integralHEXADECIMALNoZero :: Maybe Digit+-- Just 8+--+-- >>> 9 ^? integralHEXADECIMALNoZero :: Maybe Digit+-- Just 9+--+-- >>> 10 ^? integralHEXADECIMALNoZero :: Maybe Digit+-- Just A+--+-- >>> 11 ^? integralHEXADECIMALNoZero :: Maybe Digit+-- Just B+--+-- >>> 12 ^? integralHEXADECIMALNoZero :: Maybe Digit+-- Just C+--+-- >>> 13 ^? integralHEXADECIMALNoZero :: Maybe Digit+-- Just D+--+-- >>> 14 ^? integralHEXADECIMALNoZero :: Maybe Digit+-- Just E+--+-- >>> 15 ^? integralHEXADECIMALNoZero :: Maybe Digit+-- Just F+--+-- >>> integralHEXADECIMALNoZero # Digit1 :: Integer+-- 1+--+-- >>> integralHEXADECIMALNoZero # Digit2 :: Integer+-- 2+--+-- >>> integralHEXADECIMALNoZero # Digit3 :: Integer+-- 3+--+-- >>> integralHEXADECIMALNoZero # Digit4 :: Integer+-- 4+--+-- >>> integralHEXADECIMALNoZero # Digit5 :: Integer+-- 5+--+-- >>> integralHEXADECIMALNoZero # Digit6 :: Integer+-- 6+--+-- >>> integralHEXADECIMALNoZero # Digit7 :: Integer+-- 7+--+-- >>> integralHEXADECIMALNoZero # Digit8 :: Integer+-- 8+--+-- >>> integralHEXADECIMALNoZero # Digit9 :: Integer+-- 9+--+-- >>> integralHEXADECIMALNoZero # DigitA :: Integer+-- 10+--+-- >>> integralHEXADECIMALNoZero # DigitB :: Integer+-- 11+--+-- >>> integralHEXADECIMALNoZero # DigitC :: Integer+-- 12+--+-- >>> integralHEXADECIMALNoZero # DigitD :: Integer+-- 13+--+-- >>> integralHEXADECIMALNoZero # DigitE :: Integer+-- 14+--+-- >>> integralHEXADECIMALNoZero # DigitF :: Integer+-- 15+--+-- prop> \c -> (c `notElem` [1..15]) ==> (c ^? integralHEXADECIMALNoZero == Nothing)+integralHEXADECIMALNoZero ::+  (Integral a, HEXADECIMALNoZero d) =>+  Prism'+    a+    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)]+  ++-- |+--+-- >>> 0 ^? integralHEXADECIMAL :: Maybe Digit+-- Just 0+--+-- >>> 1 ^? integralHEXADECIMAL :: Maybe Digit+-- Just 1+--+-- >>> 2 ^? integralHEXADECIMAL :: Maybe Digit+-- Just 2+--+-- >>> 3 ^? integralHEXADECIMAL :: Maybe Digit+-- Just 3+--+-- >>> 4 ^? integralHEXADECIMAL :: Maybe Digit+-- Just 4+--+-- >>> 5 ^? integralHEXADECIMAL :: Maybe Digit+-- Just 5+--+-- >>> 6 ^? integralHEXADECIMAL :: Maybe Digit+-- Just 6+--+-- >>> 7 ^? integralHEXADECIMAL :: Maybe Digit+-- Just 7+--+-- >>> 8 ^? integralHEXADECIMAL :: Maybe Digit+-- Just 8+--+-- >>> 9 ^? integralHEXADECIMAL :: Maybe Digit+-- Just 9+--+-- >>> 10 ^? integralHEXADECIMAL :: Maybe Digit+-- Just A+--+-- >>> 11 ^? integralHEXADECIMAL :: Maybe Digit+-- Just B+--+-- >>> 12 ^? integralHEXADECIMAL :: Maybe Digit+-- Just C+--+-- >>> 13 ^? integralHEXADECIMAL :: Maybe Digit+-- Just D+--+-- >>> 14 ^? integralHEXADECIMAL :: Maybe Digit+-- Just E+--+-- >>> 15 ^? integralHEXADECIMAL :: Maybe Digit+-- Just F+--+-- >>> integralHEXADECIMAL # Digit0 :: Integer+-- 0+--+-- >>> integralHEXADECIMAL # Digit1 :: Integer+-- 1+--+-- >>> integralHEXADECIMAL # Digit2 :: Integer+-- 2+--+-- >>> integralHEXADECIMAL # Digit3 :: Integer+-- 3+--+-- >>> integralHEXADECIMAL # Digit4 :: Integer+-- 4+--+-- >>> integralHEXADECIMAL # Digit5 :: Integer+-- 5+--+-- >>> integralHEXADECIMAL # Digit6 :: Integer+-- 6+--+-- >>> integralHEXADECIMAL # Digit7 :: Integer+-- 7+--+-- >>> integralHEXADECIMAL # Digit8 :: Integer+-- 8+--+-- >>> integralHEXADECIMAL # Digit9 :: Integer+-- 9+--+-- >>> integralHEXADECIMAL # DigitA :: Integer+-- 10+--+-- >>> integralHEXADECIMAL # DigitB :: Integer+-- 11+--+-- >>> integralHEXADECIMAL # DigitC :: Integer+-- 12+--+-- >>> integralHEXADECIMAL # DigitD :: Integer+-- 13+--+-- >>> integralHEXADECIMAL # DigitE :: Integer+-- 14+--+-- >>> integralHEXADECIMAL # DigitF :: Integer+-- 15+--+-- prop> \c -> (c `notElem` [0..15]) ==> (c ^? integralHEXADECIMAL == Nothing)+integralHEXADECIMAL ::+  (Integral a, HEXADECIMAL d) =>+  Prism'+    a+    d+integralHEXADECIMAL =+  associatePrism (0, d0) [(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)]++---- not exported+associatePrism ::+  (Eq b, Choice p, Applicative f) =>+  (b, APrism a a () ())+  -> [(b, APrism a a () ())]+  -> p a (f a)+  -> p b (f b)+associatePrism def z =+  prism'+    (\d -> fst (fromMaybe def (find (\(_, w) -> is w d) z)))+    (\i -> (\p -> clonePrism p # ()) <$> lookup i (def:z))