digit 0.5.2 → 0.6

raw patch · 43 files changed

+1410/−3230 lines, 43 filesdep ~basedep ~hedgehogdep ~papaPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: base, hedgehog, papa, tasty

API changes (from Hackage documentation)

Files

• changelog.md +21/−0
• digit.cabal +8/−7
• src/Data/Digit.hs +21/−39
• src/Data/Digit/Binary.hs +22/−38
• src/Data/Digit/Char.hs +50/−867
• src/Data/Digit/D0.hs +6/−18
• src/Data/Digit/D1.hs +6/−18
• src/Data/Digit/D2.hs +6/−19
• src/Data/Digit/D3.hs +6/−18
• src/Data/Digit/D4.hs +7/−19
• src/Data/Digit/D5.hs +6/−18
• src/Data/Digit/D6.hs +6/−18
• src/Data/Digit/D7.hs +6/−18
• src/Data/Digit/D8.hs +6/−18
• src/Data/Digit/D9.hs +6/−18
• src/Data/Digit/DA.hs +6/−18
• src/Data/Digit/DAa.hs +15/−17
• src/Data/Digit/DB.hs +6/−18
• src/Data/Digit/DBb.hs +15/−15
• src/Data/Digit/DC.hs +6/−18
• src/Data/Digit/DCc.hs +15/−15
• src/Data/Digit/DD.hs +6/−18
• src/Data/Digit/DDd.hs +15/−15
• src/Data/Digit/DE.hs +6/−18
• src/Data/Digit/DEe.hs +14/−14
• src/Data/Digit/DF.hs +6/−18
• src/Data/Digit/DFf.hs +15/−15
• src/Data/Digit/Da.hs +6/−18
• src/Data/Digit/Db.hs +6/−18
• src/Data/Digit/Dc.hs +6/−18
• src/Data/Digit/Dd.hs +6/−19
• src/Data/Digit/De.hs +6/−18
• src/Data/Digit/Decimal.hs +62/−142
• src/Data/Digit/Df.hs +6/−18
• src/Data/Digit/Digit.hs +0/−78
• src/Data/Digit/Enum.hs +169/−0
• src/Data/Digit/HEXADECIMAL.hs +92/−220
• src/Data/Digit/HeXaDeCiMaL.hs +110/−304
• src/Data/Digit/Hexadecimal.hs +92/−220
• src/Data/Digit/Integral.hs +327/−586
• src/Data/Digit/Natural.hs +32/−41
• src/Data/Digit/Octal.hs +52/−116
• test/Main.hs +130/−82

@@ -1,3 +1,24 @@+0.6++* Removed the `Digit` datatype+* Added new datatypes with appropriate `D*` instances+  * `BinDigit`+  * `OctDigit`+  * `DecDigit`+  * `HexDigit`+  * `HeXDigit`+  * `HEXDigit`+* Culled most of the doctests, and leaving one or two per function to illustrate+  usage+* Juggled re-exports to make the library easier to use and to improve documentation+* Added `Data.Digit.Enum`, which contains ascending-order enumerations of the new datatypes+* Added integral conversion functions for the new datatypes++0.5.3++* Bump version of [tasty-hedgehog, hedgehog, papa]+* Updated default.nix+ 0.5.2  * Add `Data.Digit.Natural (_NaturalDigits, naturalToDigits, digitsToNatural)`

@@ -1,5 +1,5 @@ name:               digit-version:            0.5.2+version:            0.6 license:            BSD3 license-file:       LICENCE author:             Queensland Functional Programming Lab <oᴉ˙ldɟb@llǝʞsɐɥ>@@ -13,6 +13,7 @@ cabal-version:      >= 1.10 build-type:         Simple extra-source-files: CONTRIBUTORS, changelog.md+tested-with:        GHC == 8.4.1, GHC == 8.2.2, GHC == 8.0.2, GHC == 7.10.3 description:   <<http://i.imgur.com/uZnp9ke.png>>   .@@ -32,7 +33,7 @@                     , parsers          >= 0.12.3 && < 0.13                     , semigroups       >= 0.12 && < 1.0                     , template-haskell >= 2.8 && < 3-                    , papa             >= 0.3 && < 0.4+                    , papa             >= 0.3.1 && < 0.4                     , semigroupoids    >= 5 && < 6                     , scientific       >= 0.3 && < 0.4 @@ -82,8 +83,8 @@                     Data.Digit.DDd                     Data.Digit.DEe                     Data.Digit.DFf-                    Data.Digit.Digit                     Data.Digit.Char+                    Data.Digit.Enum                     Data.Digit.Integral  @@ -98,13 +99,13 @@                     Haskell2010    build-depends:-                    base             >=4.9    && <4.12+                    base             >=4.8    && <4.12                     , lens           >=4.0    && <5                     , ansi-wl-pprint >=0.6    && <0.7-                    , hedgehog       >=0.5    && <0.6-                    , tasty          >=0.11   && <1.1+                    , hedgehog       >=0.5    && <0.7+                    , tasty          >=0.11   && <1.2                     , tasty-hspec    >=1.1    && <1.2-                    , papa           >=0.3    && <0.4+                    , papa           >= 0.3.1 && < 0.4                     , parsec         >=3.1    && <3.2                     , parsers        >=0.12.3 && <0.13                     , pretty         >=1.1    && <1.2

@@ -1,44 +1,26 @@ {-# LANGUAGE NoImplicitPrelude #-}  module Data.Digit (-  module D+  module Data.Digit.Binary+, module Data.Digit.Decimal+, module Data.Digit.Octal+, module Data.Digit.Hexadecimal+, module Data.Digit.HeXaDeCiMaL+, module Data.Digit.HEXADECIMAL+-- * Utilities+, module Data.Digit.Char+, module Data.Digit.Enum+, module Data.Digit.Integral+, module Data.Digit.Natural ) where -import Data.Digit.Binary as D-import Data.Digit.Decimal as D-import Data.Digit.Natural 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 Data.Digit.DAa as D-import Data.Digit.DBb as D-import Data.Digit.DCc as D-import Data.Digit.DDd as D-import Data.Digit.DEe as D-import Data.Digit.DFf as D-import Data.Digit.Digit as D-import Data.Digit.Integral as D-import Data.Digit.Char as D+import Data.Digit.Binary+import Data.Digit.Decimal+import Data.Digit.Octal+import Data.Digit.Hexadecimal+import Data.Digit.HeXaDeCiMaL+import Data.Digit.HEXADECIMAL+import Data.Digit.Char+import Data.Digit.Enum+import Data.Digit.Integral+import Data.Digit.Natural

@@ -1,39 +1,41 @@ {-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE TemplateHaskell #-}  module Data.Digit.Binary(-  BinaryNoZero+  BinDigit(..)+, BinaryNoZero , Binary , parseBinaryNoZero , parseBinary+-- * Prisms+, _BinDigit0+, _BinDigit1+-- * Re-exports+, module Data.Digit.D0+, module Data.Digit.D1 ) where +import Prelude (Eq, Show, Ord)+import Control.Lens.TH (makePrisms) import Text.Parser.Char(CharParsing) import Text.Parser.Combinators((<?>), choice)-import Data.Digit.D0(D0, parse0)-import Data.Digit.D1(D1, parse1)+import Data.Digit.D0+import Data.Digit.D1 --- $setup--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--- >>> import Data.Digit.Digit--- >>> import Papa+data BinDigit+  = BinDigit0+  | BinDigit1+  deriving (Show, Eq, Ord) +makePrisms ''BinDigit++instance D0 BinDigit where; d0 = _BinDigit0+instance D1 BinDigit where; d1 = _BinDigit1+ type BinaryNoZero d =   D1 d --- |------ >>> parse (parseBinaryNoZero <* eof) "test" "1" :: Either ParseError Digit--- Right 1------ >>> parse parseBinaryNoZero "test" "1xyz" :: Either ParseError Digit--- Right 1------ >>> 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 Digit) parseBinaryNoZero ::   (BinaryNoZero d, CharParsing p) =>   p d@@ -43,24 +45,6 @@ type Binary d =   (D0 d, BinaryNoZero d) --- |------ >>> parse (parseBinary <* eof) "test" "0" :: Either ParseError Digit--- Right 0------ >>> parse parseBinary "test" "0xyz" :: Either ParseError Digit--- Right 0------ >>> parse (parseBinary <* eof) "test" "1" :: Either ParseError Digit--- Right 1------ >>> parse parseBinary "test" "1xyz" :: Either ParseError Digit--- Right 1------ >>> 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 Digit) parseBinary ::   (Binary d, CharParsing p) =>   p d

@@ -1,16 +1,22 @@ {-# LANGUAGE NoImplicitPrelude #-}  module Data.Digit.Char(+-- * Binary   charBinaryNoZero , charBinary+-- * Octal , charOctalNoZero , charOctal+-- * Decimal , charDecimalNoZero , charDecimal+-- * Hexadecimal , charHexadecimalNoZero , charHexadecimal+-- * HEXADECIMAL , charHEXADECIMALNoZero , charHEXADECIMAL+-- * HeXaDeCiMaL , charHeXaDeCiMaLNoZero , charHeXaDeCiMaL ) where@@ -22,43 +28,19 @@ 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+-- >>> import Data.Digit  -- | ----- >>> '1' ^? charBinaryNoZero :: Maybe Digit--- Just 1+-- >>> '1' ^? charBinaryNoZero :: Maybe BinDigit+-- Just BinDigit1 ----- >>> charBinaryNoZero # Digit1+-- >>> charBinaryNoZero # BinDigit1 -- '1'------ prop> \c -> c /= '1' ==> (c ^? charBinaryNoZero == Nothing) charBinaryNoZero ::   BinaryNoZero d =>   Prism'@@ -69,19 +51,11 @@    -- | ----- >>> '0' ^? charBinary :: Maybe Digit--- Just 0------ >>> '1' ^? charBinary :: Maybe Digit--- Just 1+-- >>> '0' ^? charBinary :: Maybe BinDigit+-- Just BinDigit0 ----- >>> charBinary # Digit0 :: Char+-- >>> charBinary # BinDigit0 :: Char -- '0'------ >>> charBinary # Digit1 :: Char--- '1'------ prop> \c -> (c `notElem` "01") ==> (c ^? charBinary == Nothing) charBinary ::   Binary d =>   Prism'@@ -92,49 +66,11 @@    -- | ----- >>> '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'+-- >>> '6' ^? charOctalNoZero :: Maybe OctDigit+-- Just OctDigit6 ----- >>> charOctalNoZero # Digit5 :: Char+-- >>> charOctalNoZero # OctDigit5 :: Char -- '5'------ >>> charOctalNoZero # Digit6 :: Char--- '6'------ >>> charOctalNoZero # Digit7 :: Char--- '7'------ prop> \c -> (c `notElem` "1234567") ==> (c ^? charOctalNoZero == Nothing) charOctalNoZero ::   OctalNoZero d =>   Prism'@@ -144,56 +80,11 @@   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'+-- >>> '7' ^? charOctal :: Maybe OctDigit+-- Just OctDigit7 ----- >>> charOctal # Digit7 :: Char+-- >>> charOctal # OctDigit7 :: Char -- '7'------ prop> \c -> (c `notElem` "01234567") ==> (c ^? charOctal == Nothing) charOctal ::   Octal d =>   Prism'@@ -203,62 +94,11 @@   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'+-- >>> '9' ^? charDecimalNoZero :: Maybe DecDigit+-- Just DecDigit9 ----- >>> charDecimalNoZero # Digit9 :: Char+-- >>> charDecimalNoZero # DecDigit9 :: Char -- '9'------ prop> \c -> (c `notElem` "123456789") ==> (c ^? charDecimalNoZero == Nothing) charDecimalNoZero ::   DecimalNoZero d =>   Prism'@@ -268,68 +108,11 @@   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'+-- >>> '9' ^? charDecimal :: Maybe DecDigit+-- Just DecDigit9 ----- >>> charDecimal # Digit9 :: Char+-- >>> charDecimal # DecDigit9 :: Char -- '9'------ prop> \c -> (c `notElem` "0123456789") ==> (c ^? charDecimal == Nothing) charDecimal ::   Decimal d =>   Prism'@@ -339,98 +122,11 @@   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'+-- >>> 'f' ^? charHexadecimalNoZero :: Maybe HexDigit+-- Just HexDigitf ----- >>> charHexadecimalNoZero # Digitf :: Char+-- >>> charHexadecimalNoZero # HexDigitf :: Char -- 'f'------ prop> \c -> (c `notElem` "123456789abcdef") ==> (c ^? charHexadecimalNoZero == Nothing) charHexadecimalNoZero ::   HexadecimalNoZero d =>   Prism'@@ -440,104 +136,11 @@   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'+-- >>> 'f' ^? charHexadecimal :: Maybe HexDigit+-- Just HexDigitf ----- >>> charHexadecimal # Digitf :: Char+-- >>> charHexadecimal # HexDigitf :: Char -- 'f'------ prop> \c -> (c `notElem` "0123456789abcdef") ==> (c ^? charHexadecimal == Nothing) charHexadecimal ::   Hexadecimal d =>   Prism'@@ -547,98 +150,11 @@   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'+-- >>> 'F' ^? charHEXADECIMALNoZero :: Maybe HEXDigit+-- Just HEXDigitF ----- >>> charHEXADECIMALNoZero # DigitF :: Char+-- >>> charHEXADECIMALNoZero # HEXDigitF :: Char -- 'F'------ prop> \c -> (c `notElem` "123456789ABCDEF") ==> (c ^? charHEXADECIMALNoZero == Nothing) charHEXADECIMALNoZero ::   HEXADECIMALNoZero d =>   Prism'@@ -648,104 +164,11 @@   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'+-- >>> 'F' ^? charHEXADECIMAL :: Maybe HEXDigit+-- Just HEXDigitF ----- >>> charHEXADECIMAL # DigitF :: Char+-- >>> charHEXADECIMAL # HEXDigitF :: Char -- 'F'------ prop> \c -> (c `notElem` "0123456789ABCDEF") ==> (c ^? charHEXADECIMAL == Nothing) charHEXADECIMAL ::   HEXADECIMAL d =>   Prism'@@ -755,134 +178,17 @@   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'+-- >>> 'f' ^? charHeXaDeCiMaLNoZero :: Maybe HeXDigit+-- Just HeXDigitf ----- >>> charHeXaDeCiMaLNoZero # Digite :: Char--- 'e'+-- >>> 'F' ^? charHeXaDeCiMaLNoZero :: Maybe HeXDigit+-- Just HeXDigitF ----- >>> charHeXaDeCiMaLNoZero # Digitf :: Char+-- >>> charHeXaDeCiMaLNoZero # HeXDigitf :: 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+-- >>> charHeXaDeCiMaLNoZero # HeXDigitF :: Char -- 'F'------ prop> \c -> (c `notElem` "123456789abcdefABCDEF") ==> (c ^? charHeXaDeCiMaLNoZero == Nothing) charHeXaDeCiMaLNoZero ::   HeXaDeCiMaLNoZero d =>   Prism'@@ -893,140 +199,17 @@     -- |------ >>> '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'+-- >>> 'f' ^? charHeXaDeCiMaL :: Maybe HeXDigit+-- Just HeXDigitf ----- >>> charHeXaDeCiMaL # Digite :: Char--- 'e'+-- >>> 'F' ^? charHeXaDeCiMaL :: Maybe HeXDigit+-- Just HeXDigitF ----- >>> charHeXaDeCiMaL # Digitf :: Char+-- >>> charHeXaDeCiMaL # HeXDigitf :: 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+-- >>> charHeXaDeCiMaL # HeXDigitF :: Char -- 'F'------ prop> \c -> (c `notElem` "0123456789abcdefABCDEF") ==> (c ^? charHeXaDeCiMaL == Nothing) charHeXaDeCiMaL ::   HeXaDeCiMaL d =>   Prism'@@ -1034,7 +217,7 @@     d charHeXaDeCiMaL =   associatePrism ('0', d0) [('1', d1), ('2', d2), ('3', d3), ('4', d4), ('5', d5), ('6', d6), ('7', d7), ('8', d8), ('9', d9), ('a', da), ('b', db), ('c', dc), ('d', dd), ('e', de), ('f', df), ('A', dA), ('B', dB), ('C', dC), ('D', dD), ('E', dE), ('F', dF)]-  + ---- not exported associatePrism ::   (Eq b, Choice p, Applicative f) =>

@@ -6,12 +6,12 @@ , parse0 ) where   -import Data.Digit.Digit(Digit(Digit0)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))  -- $setup+-- >>> import Data.Digit -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void) @@ -31,28 +31,16 @@  -- | ----- >>> parse (parse0 <* eof) "test" "0" :: Either ParseError Digit--- Right 0+-- >>> parse (parse0 <* eof) "test" "0" :: Either ParseError BinDigit+-- Right BinDigit0 ----- >>> parse parse0 "test" "0xyz" :: Either ParseError Digit--- Right 0+-- >>> parse parse0 "test" "0xyz" :: Either ParseError BinDigit+-- Right BinDigit0 ----- >>> isn't _Right (parse parse0 "test" "xyz" :: Either ParseError Digit)+-- >>> isn't _Right (parse parse0 "test" "xyz" :: Either ParseError BinDigit) -- True------ 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 Digit where-  d0 =-    prism'-      (\() -> Digit0)-      (\d ->  case d of-                Digit0 ->-                  Just ()-                _ ->-                  Nothing)

@@ -5,12 +5,12 @@ , parse1 ) where -import Data.Digit.Digit(Digit(Digit1)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))  -- $setup+-- >>> import Data.Digit -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void) @@ -30,28 +30,16 @@  -- | ----- >>> parse (parse1 <* eof) "test" "1" :: Either ParseError Digit--- Right 1+-- >>> parse (parse1 <* eof) "test" "1" :: Either ParseError BinDigit+-- Right BinDigit1 ----- >>> parse parse1 "test" "1xyz" :: Either ParseError Digit--- Right 1+-- >>> parse parse1 "test" "1xyz" :: Either ParseError BinDigit+-- Right BinDigit1 ----- >>> isn't _Right (parse parse1 "test" "xyz" :: Either ParseError Digit)+-- >>> isn't _Right (parse parse1 "test" "xyz" :: Either ParseError BinDigit) -- True------ 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 Digit where-  d1 =-    prism'-      (\() -> Digit1)-      (\d ->  case d of-                Digit1 ->-                  Just ()-                _ ->-                  Nothing)

@@ -5,12 +5,12 @@ , parse2 ) where -import Data.Digit.Digit(Digit(Digit2)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))  -- $setup+-- >>> import Data.Digit -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void) @@ -30,29 +30,16 @@      -- | ----- >>> parse (parse2 <* eof) "test" "2" :: Either ParseError Digit--- Right 2+-- >>> parse (parse2 <* eof) "test" "2" :: Either ParseError DecDigit+-- Right DecDigit2 ----- >>> parse parse2 "test" "2xyz" :: Either ParseError Digit--- Right 2+-- >>> parse parse2 "test" "2xyz" :: Either ParseError DecDigit+-- Right DecDigit2 ----- >>> isn't _Right (parse parse2 "test" "xyz" :: Either ParseError Digit)+-- >>> isn't _Right (parse parse2 "test" "xyz" :: Either ParseError DecDigit) -- True------ 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 Digit where-  d2 =-    prism'-      (\() -> Digit2)-      (\d ->  case d of-                Digit2 ->-                  Just ()-                _ ->-                  Nothing)-

@@ -5,12 +5,12 @@ , parse3 ) where -import Data.Digit.Digit(Digit(Digit3)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))  -- $setup+-- >>> import Data.Digit -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void) @@ -30,28 +30,16 @@  -- | ----- >>> parse (parse3 <* eof) "test" "3" :: Either ParseError Digit--- Right 3+-- >>> parse (parse3 <* eof) "test" "3" :: Either ParseError DecDigit+-- Right DecDigit3 ----- >>> parse parse3 "test" "3xyz" :: Either ParseError Digit--- Right 3+-- >>> parse parse3 "test" "3xyz" :: Either ParseError DecDigit+-- Right DecDigit3 ----- >>> isn't _Right (parse parse3 "test" "xyz" :: Either ParseError Digit)+-- >>> isn't _Right (parse parse3 "test" "xyz" :: Either ParseError DecDigit) -- True------ 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 Digit where-  d3 =-    prism'-      (\() -> Digit3)-      (\d ->  case d of-                Digit3 ->-                  Just ()-                _ ->-                  Nothing)

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

@@ -5,12 +5,12 @@ , parse5 ) where -import Data.Digit.Digit(Digit(Digit5)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))  -- $setup+-- >>> import Data.Digit -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void) @@ -30,28 +30,16 @@      -- | ----- >>> parse (parse5 <* eof) "test" "5" :: Either ParseError Digit--- Right 5+-- >>> parse (parse5 <* eof) "test" "5" :: Either ParseError DecDigit+-- Right DecDigit5 ----- >>> parse parse5 "test" "5xyz" :: Either ParseError Digit--- Right 5+-- >>> parse parse5 "test" "5xyz" :: Either ParseError DecDigit+-- Right DecDigit5 ----- >>> isn't _Right (parse parse5 "test" "xyz" :: Either ParseError Digit)+-- >>> isn't _Right (parse parse5 "test" "xyz" :: Either ParseError DecDigit) -- True------ 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 Digit where-  d5 =-    prism'-      (\() -> Digit5)-      (\d ->  case d of-                Digit5 ->-                  Just ()-                _ ->-                  Nothing)

@@ -5,12 +5,12 @@ , parse6 ) where -import Data.Digit.Digit(Digit(Digit6)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))  -- $setup+-- >>> import Data.Digit -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void) @@ -30,28 +30,16 @@      -- | ----- >>> parse (parse6 <* eof) "test" "6" :: Either ParseError Digit--- Right 6+-- >>> parse (parse6 <* eof) "test" "6" :: Either ParseError DecDigit+-- Right DecDigit6 ----- >>> parse parse6 "test" "6xyz" :: Either ParseError Digit--- Right 6+-- >>> parse parse6 "test" "6xyz" :: Either ParseError DecDigit+-- Right DecDigit6 ----- >>> isn't _Right (parse parse6 "test" "xyz" :: Either ParseError Digit)+-- >>> isn't _Right (parse parse6 "test" "xyz" :: Either ParseError DecDigit) -- True------ 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 Digit where-  d6 =-    prism'-      (\() -> Digit6)-      (\d ->  case d of-                Digit6 ->-                  Just ()-                _ ->-                  Nothing)

@@ -5,12 +5,12 @@ , parse7 ) where -import Data.Digit.Digit(Digit(Digit7)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))  -- $setup+-- >>> import Data.Digit -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void) @@ -30,28 +30,16 @@      -- | ----- >>> parse (parse7 <* eof) "test" "7" :: Either ParseError Digit--- Right 7+-- >>> parse (parse7 <* eof) "test" "7" :: Either ParseError DecDigit+-- Right DecDigit7 ----- >>> parse parse7 "test" "7xyz" :: Either ParseError Digit--- Right 7+-- >>> parse parse7 "test" "7xyz" :: Either ParseError DecDigit+-- Right DecDigit7 ----- >>> isn't _Right (parse parse7 "test" "xyz" :: Either ParseError Digit)+-- >>> isn't _Right (parse parse7 "test" "xyz" :: Either ParseError DecDigit) -- True------ 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 Digit where-  d7 =-    prism'-      (\() -> Digit7)-      (\d ->  case d of-                Digit7 ->-                  Just ()-                _ ->-                  Nothing)

@@ -5,12 +5,12 @@ , parse8 ) where -import Data.Digit.Digit(Digit(Digit8)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))  -- $setup+-- >>> import Data.Digit -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void) @@ -30,28 +30,16 @@      -- | ----- >>> parse (parse8 <* eof) "test" "8" :: Either ParseError Digit--- Right 8+-- >>> parse (parse8 <* eof) "test" "8" :: Either ParseError DecDigit+-- Right DecDigit8 ----- >>> parse parse8 "test" "8xyz" :: Either ParseError Digit--- Right 8+-- >>> parse parse8 "test" "8xyz" :: Either ParseError DecDigit+-- Right DecDigit8 ----- >>> isn't _Right (parse parse8 "test" "xyz" :: Either ParseError Digit)+-- >>> isn't _Right (parse parse8 "test" "xyz" :: Either ParseError DecDigit) -- True------ 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 Digit where-  d8 =-    prism'-      (\() -> Digit8)-      (\d ->  case d of-                Digit8 ->-                  Just ()-                _ ->-                  Nothing)

@@ -5,12 +5,12 @@ , parse9 ) where -import Data.Digit.Digit(Digit(Digit9)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))  -- $setup+-- >>> import Data.Digit -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void) @@ -30,28 +30,16 @@      -- | ----- >>> parse (parse9 <* eof) "test" "9" :: Either ParseError Digit--- Right 9+-- >>> parse (parse9 <* eof) "test" "9" :: Either ParseError DecDigit+-- Right DecDigit9 ----- >>> parse parse9 "test" "9xyz" :: Either ParseError Digit--- Right 9+-- >>> parse parse9 "test" "9xyz" :: Either ParseError DecDigit+-- Right DecDigit9 ----- >>> isn't _Right (parse parse9 "test" "xyz" :: Either ParseError Digit)+-- >>> isn't _Right (parse parse9 "test" "xyz" :: Either ParseError DecDigit) -- True------ 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 Digit where-  d9 =-    prism'-      (\() -> Digit9)-      (\d ->  case d of-                Digit9 ->-                  Just ()-                _ ->-                  Nothing)

@@ -5,12 +5,12 @@ , parseA ) where -import Data.Digit.Digit(Digit(DigitA)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))  -- $setup+-- >>> import Data.Digit -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void) @@ -30,28 +30,16 @@  -- | ----- >>> parse (parseA <* eof) "test" "A" :: Either ParseError Digit--- Right A+-- >>> parse (parseA <* eof) "test" "A" :: Either ParseError HEXDigit+-- Right HEXDigitA ----- >>> parse parseA "test" "Axyz" :: Either ParseError Digit--- Right A+-- >>> parse parseA "test" "Axyz" :: Either ParseError HEXDigit+-- Right HEXDigitA ----- >>> isn't _Right (parse parseA "test" "xyz" :: Either ParseError Digit)+-- >>> isn't _Right (parse parseA "test" "xyz" :: Either ParseError HEXDigit) -- True------ 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 Digit where-  dA =-    prism'-      (\() -> DigitA)-      (\d ->  case d of-                DigitA ->-                  Just ()-                _ ->-                  Nothing)

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

@@ -5,12 +5,12 @@ , parseB ) where -import Data.Digit.Digit(Digit(DigitB)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))  -- $setup+-- >>> import Data.Digit -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void) @@ -30,28 +30,16 @@      -- | ----- >>> parse (parseB <* eof) "test" "B" :: Either ParseError Digit--- Right B+-- >>> parse (parseB <* eof) "test" "B" :: Either ParseError HEXDigit+-- Right HEXDigitB ----- >>> parse parseB "test" "Bxyz" :: Either ParseError Digit--- Right B+-- >>> parse parseB "test" "Bxyz" :: Either ParseError HEXDigit+-- Right HEXDigitB ----- >>> isn't _Right (parse parseB "test" "xyz" :: Either ParseError Digit)+-- >>> isn't _Right (parse parseB "test" "xyz" :: Either ParseError HEXDigit) -- True------ 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 Digit where-  dB =-    prism'-      (\() -> DigitB)-      (\d ->  case d of-                DigitB ->-                  Just ()-                _ ->-                  Nothing)

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

@@ -5,12 +5,12 @@ , parseC ) where -import Data.Digit.Digit(Digit(DigitC)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))  -- $setup+-- >>> import Data.Digit -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void) @@ -30,28 +30,16 @@      -- | ----- >>> parse (parseC <* eof) "test" "C" :: Either ParseError Digit--- Right C+-- >>> parse (parseC <* eof) "test" "C" :: Either ParseError HEXDigit+-- Right HEXDigitC ----- >>> parse parseC "test" "Cxyz" :: Either ParseError Digit--- Right C+-- >>> parse parseC "test" "Cxyz" :: Either ParseError HEXDigit+-- Right HEXDigitC ----- >>> isn't _Right (parse parseC "test" "xyz" :: Either ParseError Digit)+-- >>> isn't _Right (parse parseC "test" "xyz" :: Either ParseError HEXDigit) -- True------ 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 Digit where-  dC =-    prism'-      (\() -> DigitC)-      (\d ->  case d of-                DigitC ->-                  Just ()-                _ ->-                  Nothing)

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

@@ -5,12 +5,12 @@ , parseD ) where -import Data.Digit.Digit(Digit(DigitD)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))  -- $setup+-- >>> import Data.Digit -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void) @@ -30,28 +30,16 @@      -- | ----- >>> parse (parseD <* eof) "test" "D" :: Either ParseError Digit--- Right D+-- >>> parse (parseD <* eof) "test" "D" :: Either ParseError HEXDigit+-- Right HEXDigitD ----- >>> parse parseD "test" "Dxyz" :: Either ParseError Digit--- Right D+-- >>> parse parseD "test" "Dxyz" :: Either ParseError HEXDigit+-- Right HEXDigitD ----- >>> isn't _Right (parse parseD "test" "xyz" :: Either ParseError Digit)+-- >>> isn't _Right (parse parseD "test" "xyz" :: Either ParseError HEXDigit) -- True------ 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 Digit where-  dD =-    prism'-      (\() -> DigitD)-      (\d ->  case d of-                DigitD ->-                  Just ()-                _ ->-                  Nothing)

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

@@ -5,12 +5,12 @@ , parseE ) where -import Data.Digit.Digit(Digit(DigitE)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))  -- $setup+-- >>> import Data.Digit -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void) @@ -30,28 +30,16 @@      -- | ----- >>> parse (parseE <* eof) "test" "E" :: Either ParseError Digit--- Right E+-- >>> parse (parseE <* eof) "test" "E" :: Either ParseError HEXDigit+-- Right HEXDigitE ----- >>> parse parseE "test" "Exyz" :: Either ParseError Digit--- Right E+-- >>> parse parseE "test" "Exyz" :: Either ParseError HEXDigit+-- Right HEXDigitE ----- >>> isn't _Right (parse parseE "test" "xyz" :: Either ParseError Digit)+-- >>> isn't _Right (parse parseE "test" "xyz" :: Either ParseError HEXDigit) -- True------ 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 Digit where-  dE =-    prism'-      (\() -> DigitE)-      (\d ->  case d of-                DigitE ->-                  Just ()-                _ ->-                  Nothing)

@@ -2,14 +2,16 @@ {-# LANGUAGE ConstraintKinds #-}  module Data.Digit.DEe(-  DEe+  module Data.Digit.DE+, module Data.Digit.De+, DEe , parseEe ) where  import Text.Parser.Char(CharParsing) import Text.Parser.Combinators((<?>), choice)-import Data.Digit.DE(DE, parseE)-import Data.Digit.De(De, parsee)+import Data.Digit.DE+import Data.Digit.De  -- $setup -- >>> import Text.Parsec(parse, ParseError, eof)@@ -22,22 +24,20 @@    -- | ----- >>> parse (parseEe <* eof) "test" "E" :: Either ParseError Digit--- Right E+-- >>> parse (parseEe <* eof) "test" "E" :: Either ParseError HeXDigit+-- Right HeXDigitE ----- >>> parse parseEe "test" "Exyz" :: Either ParseError Digit--- Right E+-- >>> parse parseEe "test" "Exyz" :: Either ParseError HeXDigit+-- Right HeXDigitE ----- >>> parse (parseEe <* eof) "test" "e" :: Either ParseError Digit--- Right e+-- >>> parse (parseEe <* eof) "test" "e" :: Either ParseError HeXDigit+-- Right HeXDigite ----- >>> parse parseEe "test" "exyz" :: Either ParseError Digit--- Right e+-- >>> parse parseEe "test" "exyz" :: Either ParseError HeXDigit+-- Right HeXDigite ----- >>> isn't _Right (parse parseEe "test" "xyz" :: Either ParseError Digit)+-- >>> isn't _Right (parse parseEe "test" "xyz" :: Either ParseError HeXDigit) -- True------ prop> \c -> (c `notElem` "Ee") ==> isn't _Right (parse parseEe "test" [c] :: Either ParseError Digit) parseEe ::   (DEe d, CharParsing p) =>   p d

@@ -5,12 +5,12 @@ , parseF ) where -import Data.Digit.Digit(Digit(DigitF)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))  -- $setup+-- >>> import Data.Digit -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void) @@ -30,28 +30,16 @@      -- | ----- >>> parse (parseF <* eof) "test" "F" :: Either ParseError Digit--- Right F+-- >>> parse (parseF <* eof) "test" "F" :: Either ParseError HEXDigit+-- Right HEXDigitF ----- >>> parse parseF "test" "Fxyz" :: Either ParseError Digit--- Right F+-- >>> parse parseF "test" "Fxyz" :: Either ParseError HEXDigit+-- Right HEXDigitF ----- >>> isn't _Right (parse parseF "test" "xyz" :: Either ParseError Digit)+-- >>> isn't _Right (parse parseF "test" "xyz" :: Either ParseError HEXDigit) -- True------ 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 Digit where-  dF =-    prism'-      (\() -> DigitF)-      (\d ->  case d of-                DigitF ->-                  Just ()-                _ ->-                  Nothing)

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

@@ -5,12 +5,12 @@ , parsea ) where -import Data.Digit.Digit(Digit(Digita)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))  -- $setup+-- >>> import Data.Digit -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void) @@ -30,28 +30,16 @@      -- | ----- >>> parse (parsea <* eof) "test" "a" :: Either ParseError Digit--- Right a+-- >>> parse (parsea <* eof) "test" "a" :: Either ParseError HexDigit+-- Right HexDigita ----- >>> parse parsea "test" "axyz" :: Either ParseError Digit--- Right a+-- >>> parse parsea "test" "axyz" :: Either ParseError HexDigit+-- Right HexDigita ----- >>> isn't _Right (parse parsea "test" "xyz" :: Either ParseError Digit)+-- >>> isn't _Right (parse parsea "test" "xyz" :: Either ParseError HexDigit) -- True------ 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 Digit where-  da =-    prism'-      (\() -> Digita)-      (\d ->  case d of-                Digita ->-                  Just ()-                _ ->-                  Nothing)

@@ -5,12 +5,12 @@ , parseb ) where -import Data.Digit.Digit(Digit(Digitb)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))  -- $setup+-- >>> import Data.Digit -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void) @@ -30,28 +30,16 @@      -- | ----- >>> parse (parseb <* eof) "test" "b" :: Either ParseError Digit--- Right b+-- >>> parse (parseb <* eof) "test" "b" :: Either ParseError HexDigit+-- Right HexDigitb ----- >>> parse parseb "test" "bxyz" :: Either ParseError Digit--- Right b+-- >>> parse parseb "test" "bxyz" :: Either ParseError HexDigit+-- Right HexDigitb ----- >>> isn't _Right (parse parseb "test" "xyz" :: Either ParseError Digit)+-- >>> isn't _Right (parse parseb "test" "xyz" :: Either ParseError HexDigit) -- True------ 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 Digit where-  db =-    prism'-      (\() -> Digitb)-      (\d ->  case d of-                Digitb ->-                  Just ()-                _ ->-                  Nothing)

@@ -5,12 +5,12 @@ , parsec ) where -import Data.Digit.Digit(Digit(Digitc)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))  -- $setup+-- >>> import Data.Digit -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void) @@ -30,28 +30,16 @@     -- | ----- >>> parse (parsec <* eof) "test" "c" :: Either ParseError Digit--- Right c+-- >>> parse (parsec <* eof) "test" "c" :: Either ParseError HexDigit+-- Right HexDigitc ----- >>> parse parsec "test" "cxyz" :: Either ParseError Digit--- Right c+-- >>> parse parsec "test" "cxyz" :: Either ParseError HexDigit+-- Right HexDigitc ----- >>> isn't _Right (parse parsec "test" "xyz" :: Either ParseError Digit)+-- >>> isn't _Right (parse parsec "test" "xyz" :: Either ParseError HexDigit) -- True------ 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 Digit where-  dc =-    prism'-      (\() -> Digitc)-      (\d ->  case d of-                Digitc ->-                  Just ()-                _ ->-                  Nothing)

@@ -5,12 +5,12 @@ , parsed ) where -import Data.Digit.Digit(Digit(Digitd)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))  -- $setup+-- >>> import Data.Digit -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void) @@ -30,29 +30,16 @@      -- | ----- >>> parse (parsed <* eof) "test" "d" :: Either ParseError Digit--- Right d+-- >>> parse (parsed <* eof) "test" "d" :: Either ParseError HexDigit+-- Right HexDigitd ----- >>> parse parsed "test" "dxyz" :: Either ParseError Digit--- Right d+-- >>> parse parsed "test" "dxyz" :: Either ParseError HexDigit+-- Right HexDigitd ----- >>> isn't _Right (parse parsed "test" "xyz" :: Either ParseError Digit)+-- >>> isn't _Right (parse parsed "test" "xyz" :: Either ParseError HexDigit) -- True------ 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 Digit where-  dd =-    prism'-      (\() -> Digitd)-      (\d ->  case d of-                Digitd ->-                  Just ()-                _ ->-                  Nothing)-

@@ -5,12 +5,12 @@ , parsee ) where -import Data.Digit.Digit(Digit(Digite)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))  -- $setup+-- >>> import Data.Digit -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void) @@ -30,28 +30,16 @@      -- | ----- >>> parse (parsee <* eof) "test" "e" :: Either ParseError Digit--- Right e+-- >>> parse (parsee <* eof) "test" "e" :: Either ParseError HexDigit+-- Right HexDigite ----- >>> parse parsee "test" "exyz" :: Either ParseError Digit--- Right e+-- >>> parse parsee "test" "exyz" :: Either ParseError HexDigit+-- Right HexDigite ----- >>> isn't _Right (parse parsee "test" "xyz" :: Either ParseError Digit)+-- >>> isn't _Right (parse parsee "test" "xyz" :: Either ParseError HexDigit) -- True------ 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 Digit where-  de =-    prism'-      (\() -> Digite)-      (\d ->  case d of-                Digite ->-                  Just ()-                _ ->-                  Nothing)

@@ -1,95 +1,81 @@ {-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE TemplateHaskell #-}  module Data.Digit.Decimal(-  DecimalNoZero+  DecDigit(..)+, DecimalNoZero , Decimal , parseDecimalNoZero , parseDecimal+-- * Prisms+, _DecDigit0+, _DecDigit1+, _DecDigit2+, _DecDigit3+, _DecDigit4+, _DecDigit5+, _DecDigit6+, _DecDigit7+, _DecDigit8+, _DecDigit9+-- * Re-exports+, module Data.Digit.D0+, module Data.Digit.D1+, module Data.Digit.D2+, module Data.Digit.D3+, module Data.Digit.D4+, module Data.Digit.D5+, module Data.Digit.D6+, module Data.Digit.D7+, module Data.Digit.D8+, module Data.Digit.D9 ) where +import Prelude (Eq, Show, Ord, Enum, Bounded)+import Control.Lens.TH (makePrisms) import Text.Parser.Char(CharParsing) import Text.Parser.Combinators((<?>), choice)-import Data.Digit.D0(D0, parse0)-import Data.Digit.D1(D1, parse1)-import Data.Digit.D2(D2, parse2)-import Data.Digit.D3(D3, parse3)-import Data.Digit.D4(D4, parse4)-import Data.Digit.D5(D5, parse5)-import Data.Digit.D6(D6, parse6)-import Data.Digit.D7(D7, parse7)-import Data.Digit.D8(D8, parse8)-import Data.Digit.D9(D9, parse9)+import Data.Digit.D0+import Data.Digit.D1+import Data.Digit.D2+import Data.Digit.D3+import Data.Digit.D4+import Data.Digit.D5+import Data.Digit.D6+import Data.Digit.D7+import Data.Digit.D8+import Data.Digit.D9 --- $setup--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--- >>> import Data.Digit.Digit--- >>> import Papa+data DecDigit+  = DecDigit0+  | DecDigit1+  | DecDigit2+  | DecDigit3+  | DecDigit4+  | DecDigit5+  | DecDigit6+  | DecDigit7+  | DecDigit8+  | DecDigit9+  deriving (Show, Eq, Ord, Enum, Bounded) +makePrisms ''DecDigit++instance D0 DecDigit where; d0 = _DecDigit0+instance D1 DecDigit where; d1 = _DecDigit1+instance D2 DecDigit where; d2 = _DecDigit2+instance D3 DecDigit where; d3 = _DecDigit3+instance D4 DecDigit where; d4 = _DecDigit4+instance D5 DecDigit where; d5 = _DecDigit5+instance D6 DecDigit where; d6 = _DecDigit6+instance D7 DecDigit where; d7 = _DecDigit7+instance D8 DecDigit where; d8 = _DecDigit8+instance D9 DecDigit where; d9 = _DecDigit9+ 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 Digit--- Right 1------ >>> parse parseDecimalNoZero "test" "1xyz" :: Either ParseError Digit--- Right 1------ >>> parse (parseDecimalNoZero <* eof) "test" "2" :: Either ParseError Digit--- Right 2------ >>> parse parseDecimalNoZero "test" "2xyz" :: Either ParseError Digit--- Right 2------ >>> parse (parseDecimalNoZero <* eof) "test" "3" :: Either ParseError Digit--- Right 3------ >>> parse parseDecimalNoZero "test" "3xyz" :: Either ParseError Digit--- Right 3------ >>> parse (parseDecimalNoZero <* eof) "test" "4" :: Either ParseError Digit--- Right 4------ >>> parse parseDecimalNoZero "test" "4xyz" :: Either ParseError Digit--- Right 4------ >>> parse (parseDecimalNoZero <* eof) "test" "5" :: Either ParseError Digit--- Right 5------ >>> parse parseDecimalNoZero "test" "5xyz" :: Either ParseError Digit--- Right 5------ >>> parse (parseDecimalNoZero <* eof) "test" "6" :: Either ParseError Digit--- Right 6------ >>> parse parseDecimalNoZero "test" "6xyz" :: Either ParseError Digit--- Right 6------ >>> parse (parseDecimalNoZero <* eof) "test" "7" :: Either ParseError Digit--- Right 7------ >>> parse parseDecimalNoZero "test" "7xyz" :: Either ParseError Digit--- Right 7------ >>> parse (parseDecimalNoZero <* eof) "test" "8" :: Either ParseError Digit--- Right 8------ >>> parse parseDecimalNoZero "test" "8xyz" :: Either ParseError Digit--- Right 8------ >>> parse (parseDecimalNoZero <* eof) "test" "9" :: Either ParseError Digit--- Right 9------ >>> parse parseDecimalNoZero "test" "9xyz" :: Either ParseError Digit--- Right 9------ >>> 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 Digit) parseDecimalNoZero ::   (DecimalNoZero d, CharParsing p) =>   p d@@ -110,72 +96,6 @@ type Decimal d =   (D0 d, DecimalNoZero d) --- |------ >>> parse (parseDecimal <* eof) "test" "0" :: Either ParseError Digit--- Right 0------ >>> parse parseDecimal "test" "0xyz" :: Either ParseError Digit--- Right 0------ >>> parse (parseDecimal <* eof) "test" "1" :: Either ParseError Digit--- Right 1------ >>> parse parseDecimal "test" "1xyz" :: Either ParseError Digit--- Right 1------ >>> parse (parseDecimal <* eof) "test" "2" :: Either ParseError Digit--- Right 2------ >>> parse parseDecimal "test" "2xyz" :: Either ParseError Digit--- Right 2------ >>> parse (parseDecimal <* eof) "test" "3" :: Either ParseError Digit--- Right 3------ >>> parse parseDecimal "test" "3xyz" :: Either ParseError Digit--- Right 3------ >>> parse (parseDecimal <* eof) "test" "4" :: Either ParseError Digit--- Right 4------ >>> parse parseDecimal "test" "4xyz" :: Either ParseError Digit--- Right 4------ >>> parse (parseDecimal <* eof) "test" "5" :: Either ParseError Digit--- Right 5------ >>> parse parseDecimal "test" "5xyz" :: Either ParseError Digit--- Right 5------ >>> parse (parseDecimal <* eof) "test" "6" :: Either ParseError Digit--- Right 6------ >>> parse parseDecimal "test" "6xyz" :: Either ParseError Digit--- Right 6------ >>> parse (parseDecimal <* eof) "test" "7" :: Either ParseError Digit--- Right 7------ >>> parse parseDecimal "test" "7xyz" :: Either ParseError Digit--- Right 7------ >>> parse (parseDecimal <* eof) "test" "8" :: Either ParseError Digit--- Right 8------ >>> parse parseDecimal "test" "8xyz" :: Either ParseError Digit--- Right 8------ >>> parse (parseDecimal <* eof) "test" "9" :: Either ParseError Digit--- Right 9------ >>> parse parseDecimal "test" "9xyz" :: Either ParseError Digit--- Right 9------ >>> 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 Digit) parseDecimal ::   (Decimal d, CharParsing p) =>   p d

@@ -5,12 +5,12 @@ , parsef ) where -import Data.Digit.Digit(Digit(Digitf)) import Papa import Text.Parser.Char(CharParsing, char) import Text.Parser.Combinators((<?>))  -- $setup+-- >>> import Data.Digit -- >>> import Text.Parsec(parse, ParseError, eof) -- >>> import Data.Void(Void) @@ -30,28 +30,16 @@      -- | ----- >>> parse (parsef <* eof) "test" "f" :: Either ParseError Digit--- Right f+-- >>> parse (parsef <* eof) "test" "f" :: Either ParseError HexDigit+-- Right HexDigitf ----- >>> parse parsef "test" "fxyz" :: Either ParseError Digit--- Right f+-- >>> parse parsef "test" "fxyz" :: Either ParseError HexDigit+-- Right HexDigitf ----- >>> isn't _Right (parse parsef "test" "xyz" :: Either ParseError Digit)+-- >>> isn't _Right (parse parsef "test" "xyz" :: Either ParseError HexDigit) -- True------ 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 Digit where-  df =-    prism'-      (\() -> Digitf)-      (\d ->  case d of-                Digitf ->-                  Just ()-                _ ->-                  Nothing)

@@ -1,78 +0,0 @@-{-# 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"

@@ -0,0 +1,169 @@+module Data.Digit.Enum+  ( -- * Binary+    enumBinaryNoZero+  , enumBinary+    -- * Octal+  , enumOctalNoZero+  , enumOctal+    -- * Decimal+  , enumDecimalNoZero+  , enumDecimal+    -- * Hexadecimal+  , enumHexadecimalNoZero+  , enumHexadecimal+    -- * HEXADECIMAL+  , enumHEXADECIMALNoZero+  , enumHEXADECIMAL+  )+where++import Control.Lens.Review ((#))+import Data.Digit.Binary+import Data.Digit.Decimal+import Data.Digit.Hexadecimal+import Data.Digit.HEXADECIMAL+import Data.Digit.Octal++-- | @[1]@+enumBinaryNoZero :: BinaryNoZero d => [d]+enumBinaryNoZero = [d1 # ()]++-- | @[0, 1]@+enumBinary :: Binary d => [d]+enumBinary = [d0 # (), d1 # ()]++-- | @[1..7]@+enumOctalNoZero :: OctalNoZero d => [d]+enumOctalNoZero =+  [ d1 # ()+  , d2 # ()+  , d3 # ()+  , d4 # ()+  , d5 # ()+  , d6 # ()+  , d7 # ()+  ]++-- | @[0..7]@+enumOctal :: Octal d => [d]+enumOctal =+  [ d0 # ()+  , d1 # ()+  , d2 # ()+  , d3 # ()+  , d4 # ()+  , d5 # ()+  , d6 # ()+  , d7 # ()+  ]++-- | @[1..9]@+enumDecimalNoZero :: DecimalNoZero d => [d]+enumDecimalNoZero =+  [ d1 # ()+  , d2 # ()+  , d3 # ()+  , d4 # ()+  , d5 # ()+  , d6 # ()+  , d7 # ()+  , d8 # ()+  , d9 # ()+  ]++-- | @[0..9]@+enumDecimal :: Decimal d => [d]+enumDecimal =+  [ d0 # ()+  , d1 # ()+  , d2 # ()+  , d3 # ()+  , d4 # ()+  , d5 # ()+  , d6 # ()+  , d7 # ()+  , d8 # ()+  , d9 # ()+  ]++-- | @[1..9] ++ [a..f]@+enumHexadecimalNoZero :: HexadecimalNoZero d => [d]+enumHexadecimalNoZero =+  [ d1 # ()+  , d2 # ()+  , d3 # ()+  , d4 # ()+  , d5 # ()+  , d6 # ()+  , d7 # ()+  , d8 # ()+  , d9 # ()+  , da # ()+  , db # ()+  , dc # ()+  , dd # ()+  , de # ()+  , df # ()+  ]++-- | @[0..9] ++ [a..f]@+enumHexadecimal :: Hexadecimal d => [d]+enumHexadecimal =+  [ d0 # ()+  , d1 # ()+  , d2 # ()+  , d3 # ()+  , d4 # ()+  , d5 # ()+  , d6 # ()+  , d7 # ()+  , d8 # ()+  , d9 # ()+  , da # ()+  , db # ()+  , dc # ()+  , dd # ()+  , de # ()+  , df # ()+  ]++-- | @[1..9] ++ [A..F]@+enumHEXADECIMALNoZero :: HEXADECIMALNoZero d => [d]+enumHEXADECIMALNoZero =+  [ d1 # ()+  , d2 # ()+  , d3 # ()+  , d4 # ()+  , d5 # ()+  , d6 # ()+  , d7 # ()+  , d8 # ()+  , d9 # ()+  , dA # ()+  , dB # ()+  , dC # ()+  , dD # ()+  , dE # ()+  , dF # ()+  ]++-- | @[0..9] ++ [A..F]@+enumHEXADECIMAL :: HEXADECIMAL d => [d]+enumHEXADECIMAL =+  [ d0 # ()+  , d1 # ()+  , d2 # ()+  , d3 # ()+  , d4 # ()+  , d5 # ()+  , d6 # ()+  , d7 # ()+  , d8 # ()+  , d9 # ()+  , dA # ()+  , dB # ()+  , dC # ()+  , dD # ()+  , dE # ()+  , dF # ()+  ]

@@ -1,138 +1,112 @@ {-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE TemplateHaskell #-}  module Data.Digit.HEXADECIMAL(-  HEXADECIMALNoZero+  HEXDigit(..)+, HEXADECIMALNoZero , HEXADECIMAL , parseHEXADECIMALNoZero , parseHEXADECIMAL+-- * Prisms+, _HEXDigit0+, _HEXDigit1+, _HEXDigit2+, _HEXDigit3+, _HEXDigit4+, _HEXDigit5+, _HEXDigit6+, _HEXDigit7+, _HEXDigit8+, _HEXDigit9+, _HEXDigitA+, _HEXDigitB+, _HEXDigitC+, _HEXDigitD+, _HEXDigitE+, _HEXDigitF+-- * Re-exports+, module Data.Digit.D0+, module Data.Digit.D1+, module Data.Digit.D2+, module Data.Digit.D3+, module Data.Digit.D4+, module Data.Digit.D5+, module Data.Digit.D6+, module Data.Digit.D7+, module Data.Digit.D8+, module Data.Digit.D9+, module Data.Digit.DA+, module Data.Digit.DB+, module Data.Digit.DC+, module Data.Digit.DD+, module Data.Digit.DE+, module Data.Digit.DF ) where +import Prelude (Eq, Show, Ord)+import Control.Lens.TH (makePrisms) import Text.Parser.Char(CharParsing) import Text.Parser.Combinators((<?>), choice)-import Data.Digit.D0(D0, parse0)-import Data.Digit.D1(D1)-import Data.Digit.D2(D2)-import Data.Digit.D3(D3)-import Data.Digit.D4(D4)-import Data.Digit.D5(D5)-import Data.Digit.D6(D6)-import Data.Digit.D7(D7)-import Data.Digit.D8(D8)-import Data.Digit.D9(D9)-import Data.Digit.DA(DA, parseA)-import Data.Digit.DB(DB, parseB)-import Data.Digit.DC(DC, parseC)-import Data.Digit.DD(DD, parseD)-import Data.Digit.DE(DE, parseE)-import Data.Digit.DF(DF, parseF)+import Data.Digit.D0+import Data.Digit.D1+import Data.Digit.D2+import Data.Digit.D3+import Data.Digit.D4+import Data.Digit.D5+import Data.Digit.D6+import Data.Digit.D7+import Data.Digit.D8+import Data.Digit.D9+import Data.Digit.DA+import Data.Digit.DB+import Data.Digit.DC+import Data.Digit.DD+import Data.Digit.DE+import Data.Digit.DF import Data.Digit.Decimal(parseDecimalNoZero) --- $setup--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--- >>> import Data.Digit.Digit--- >>> import Papa+data HEXDigit+  = HEXDigit0+  | HEXDigit1+  | HEXDigit2+  | HEXDigit3+  | HEXDigit4+  | HEXDigit5+  | HEXDigit6+  | HEXDigit7+  | HEXDigit8+  | HEXDigit9+  | HEXDigitA+  | HEXDigitB+  | HEXDigitC+  | HEXDigitD+  | HEXDigitE+  | HEXDigitF+  deriving (Show, Eq, Ord) +makePrisms ''HEXDigit++instance D0 HEXDigit where; d0 = _HEXDigit0+instance D1 HEXDigit where; d1 = _HEXDigit1+instance D2 HEXDigit where; d2 = _HEXDigit2+instance D3 HEXDigit where; d3 = _HEXDigit3+instance D4 HEXDigit where; d4 = _HEXDigit4+instance D5 HEXDigit where; d5 = _HEXDigit5+instance D6 HEXDigit where; d6 = _HEXDigit6+instance D7 HEXDigit where; d7 = _HEXDigit7+instance D8 HEXDigit where; d8 = _HEXDigit8+instance D9 HEXDigit where; d9 = _HEXDigit9+instance DA HEXDigit where; dA = _HEXDigitA+instance DB HEXDigit where; dB = _HEXDigitB+instance DC HEXDigit where; dC = _HEXDigitC+instance DD HEXDigit where; dD = _HEXDigitD+instance DE HEXDigit where; dE = _HEXDigitE+instance DF HEXDigit where; dF = _HEXDigitF+ type HEXADECIMALNoZero d =   (D1 d, D2 d, D3 d, D4 d, D5 d, D6 d, D7 d, D8 d, D9 d, DA d, DB d, DC d, DD d, DE d, DF d) --- |------ >>> parse (parseHEXADECIMALNoZero <* eof) "test" "1" :: Either ParseError Digit--- Right 1------ >>> parse parseHEXADECIMALNoZero "test" "1xyz" :: Either ParseError Digit--- Right 1------ >>> parse (parseHEXADECIMALNoZero <* eof) "test" "2" :: Either ParseError Digit--- Right 2------ >>> parse parseHEXADECIMALNoZero "test" "2xyz" :: Either ParseError Digit--- Right 2------ >>> parse (parseHEXADECIMALNoZero <* eof) "test" "3" :: Either ParseError Digit--- Right 3------ >>> parse parseHEXADECIMALNoZero "test" "3xyz" :: Either ParseError Digit--- Right 3------ >>> parse (parseHEXADECIMALNoZero <* eof) "test" "4" :: Either ParseError Digit--- Right 4------ >>> parse parseHEXADECIMALNoZero "test" "4xyz" :: Either ParseError Digit--- Right 4------ >>> parse (parseHEXADECIMALNoZero <* eof) "test" "5" :: Either ParseError Digit--- Right 5------ >>> parse parseHEXADECIMALNoZero "test" "5xyz" :: Either ParseError Digit--- Right 5------ >>> parse (parseHEXADECIMALNoZero <* eof) "test" "6" :: Either ParseError Digit--- Right 6------ >>> parse parseHEXADECIMALNoZero "test" "6xyz" :: Either ParseError Digit--- Right 6------ >>> parse (parseHEXADECIMALNoZero <* eof) "test" "7" :: Either ParseError Digit--- Right 7------ >>> parse parseHEXADECIMALNoZero "test" "7xyz" :: Either ParseError Digit--- Right 7------ >>> parse (parseHEXADECIMALNoZero <* eof) "test" "8" :: Either ParseError Digit--- Right 8------ >>> parse parseHEXADECIMALNoZero "test" "8xyz" :: Either ParseError Digit--- Right 8------ >>> parse (parseHEXADECIMALNoZero <* eof) "test" "9" :: Either ParseError Digit--- Right 9------ >>> parse parseHEXADECIMALNoZero "test" "9xyz" :: Either ParseError Digit--- Right 9------ >>> parse (parseHEXADECIMALNoZero <* eof) "test" "A" :: Either ParseError Digit--- Right A------ >>> parse parseHEXADECIMALNoZero "test" "Axyz" :: Either ParseError Digit--- Right A------ >>> parse (parseHEXADECIMALNoZero <* eof) "test" "B" :: Either ParseError Digit--- Right B------ >>> parse parseHEXADECIMALNoZero "test" "Bxyz" :: Either ParseError Digit--- Right B------ >>> parse (parseHEXADECIMALNoZero <* eof) "test" "C" :: Either ParseError Digit--- Right C------ >>> parse parseHEXADECIMALNoZero "test" "Cxyz" :: Either ParseError Digit--- Right C------ >>> parse (parseHEXADECIMALNoZero <* eof) "test" "D" :: Either ParseError Digit--- Right D------ >>> parse parseHEXADECIMALNoZero "test" "Dxyz" :: Either ParseError Digit--- Right D------ >>> parse (parseHEXADECIMALNoZero <* eof) "test" "E" :: Either ParseError Digit--- Right E------ >>> parse parseHEXADECIMALNoZero "test" "Exyz" :: Either ParseError Digit--- Right E------ >>> parse (parseHEXADECIMALNoZero <* eof) "test" "F" :: Either ParseError Digit--- Right F------ >>> parse parseHEXADECIMALNoZero "test" "Fxyz" :: Either ParseError Digit--- Right F------ >>> 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 Digit) parseHEXADECIMALNoZero ::   (HEXADECIMALNoZero d, CharParsing p) =>   p d@@ -151,108 +125,6 @@ type HEXADECIMAL d =   (D0 d, HEXADECIMALNoZero d) --- |------ >>> parse (parseHEXADECIMAL <* eof) "test" "0" :: Either ParseError Digit--- Right 0------ >>> parse parseHEXADECIMAL "test" "0xyz" :: Either ParseError Digit--- Right 0------ >>> parse (parseHEXADECIMAL <* eof) "test" "1" :: Either ParseError Digit--- Right 1------ >>> parse parseHEXADECIMAL "test" "1xyz" :: Either ParseError Digit--- Right 1------ >>> parse (parseHEXADECIMAL <* eof) "test" "2" :: Either ParseError Digit--- Right 2------ >>> parse parseHEXADECIMAL "test" "2xyz" :: Either ParseError Digit--- Right 2------ >>> parse (parseHEXADECIMAL <* eof) "test" "3" :: Either ParseError Digit--- Right 3------ >>> parse parseHEXADECIMAL "test" "3xyz" :: Either ParseError Digit--- Right 3------ >>> parse (parseHEXADECIMAL <* eof) "test" "4" :: Either ParseError Digit--- Right 4------ >>> parse parseHEXADECIMAL "test" "4xyz" :: Either ParseError Digit--- Right 4------ >>> parse (parseHEXADECIMAL <* eof) "test" "5" :: Either ParseError Digit--- Right 5------ >>> parse parseHEXADECIMAL "test" "5xyz" :: Either ParseError Digit--- Right 5------ >>> parse (parseHEXADECIMAL <* eof) "test" "6" :: Either ParseError Digit--- Right 6------ >>> parse parseHEXADECIMAL "test" "6xyz" :: Either ParseError Digit--- Right 6------ >>> parse (parseHEXADECIMAL <* eof) "test" "7" :: Either ParseError Digit--- Right 7------ >>> parse parseHEXADECIMAL "test" "7xyz" :: Either ParseError Digit--- Right 7------ >>> parse (parseHEXADECIMAL <* eof) "test" "8" :: Either ParseError Digit--- Right 8------ >>> parse parseHEXADECIMAL "test" "8xyz" :: Either ParseError Digit--- Right 8------ >>> parse (parseHEXADECIMAL <* eof) "test" "9" :: Either ParseError Digit--- Right 9------ >>> parse parseHEXADECIMAL "test" "9xyz" :: Either ParseError Digit--- Right 9------ >>> parse (parseHEXADECIMAL <* eof) "test" "A" :: Either ParseError Digit--- Right A------ >>> parse parseHEXADECIMAL "test" "Axyz" :: Either ParseError Digit--- Right A------ >>> parse (parseHEXADECIMAL <* eof) "test" "B" :: Either ParseError Digit--- Right B------ >>> parse parseHEXADECIMAL "test" "Bxyz" :: Either ParseError Digit--- Right B------ >>> parse (parseHEXADECIMAL <* eof) "test" "C" :: Either ParseError Digit--- Right C------ >>> parse parseHEXADECIMAL "test" "Cxyz" :: Either ParseError Digit--- Right C------ >>> parse (parseHEXADECIMAL <* eof) "test" "D" :: Either ParseError Digit--- Right D------ >>> parse parseHEXADECIMAL "test" "Dxyz" :: Either ParseError Digit--- Right D------ >>> parse (parseHEXADECIMAL <* eof) "test" "E" :: Either ParseError Digit--- Right E------ >>> parse parseHEXADECIMAL "test" "Exyz" :: Either ParseError Digit--- Right E------ >>> 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` "0123456789ABCDEF") ==> isn't _Right (parse parseHEXADECIMAL "test" [c] :: Either ParseError Digit) parseHEXADECIMAL ::   (HEXADECIMAL d, CharParsing p) =>   p d

@@ -1,186 +1,130 @@ {-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE TemplateHaskell #-}  module Data.Digit.HeXaDeCiMaL(-  HeXaDeCiMaLNoZero+  HeXDigit(..)+, HeXaDeCiMaLNoZero , HeXaDeCiMaL , parseHeXaDeCiMaLNoZero , parseHeXaDeCiMaL+-- * Prisms+, _HeXDigit0+, _HeXDigit1+, _HeXDigit2+, _HeXDigit3+, _HeXDigit4+, _HeXDigit5+, _HeXDigit6+, _HeXDigit7+, _HeXDigit8+, _HeXDigit9+, _HeXDigita+, _HeXDigitb+, _HeXDigitc+, _HeXDigitd+, _HeXDigite+, _HeXDigitf+, _HeXDigitA+, _HeXDigitB+, _HeXDigitC+, _HeXDigitD+, _HeXDigitE+, _HeXDigitF+-- * Re-exports+, module Data.Digit.D0+, module Data.Digit.D1+, module Data.Digit.D2+, module Data.Digit.D3+, module Data.Digit.D4+, module Data.Digit.D5+, module Data.Digit.D6+, module Data.Digit.D7+, module Data.Digit.D8+, module Data.Digit.D9+, module Data.Digit.DAa+, module Data.Digit.DBb+, module Data.Digit.DCc+, module Data.Digit.DDd+, module Data.Digit.DEe+, module Data.Digit.DFf ) where +import Prelude (Eq, Show, Ord)+import Control.Lens.TH (makePrisms) import Text.Parser.Char(CharParsing) import Text.Parser.Combinators((<?>), choice)-import Data.Digit.D0(D0, parse0)-import Data.Digit.D1(D1)-import Data.Digit.D2(D2)-import Data.Digit.D3(D3)-import Data.Digit.D4(D4)-import Data.Digit.D5(D5)-import Data.Digit.D6(D6)-import Data.Digit.D7(D7)-import Data.Digit.D8(D8)-import Data.Digit.D9(D9)-import Data.Digit.DA(DA)-import Data.Digit.DB(DB)-import Data.Digit.DC(DC)-import Data.Digit.DD(DD)-import Data.Digit.DE(DE)-import Data.Digit.DF(DF)-import Data.Digit.Da(Da)-import Data.Digit.Db(Db)-import Data.Digit.Dc(Dc)-import Data.Digit.Dd(Dd)-import Data.Digit.De(De)-import Data.Digit.Df(Df)+import Data.Digit.D0+import Data.Digit.D1+import Data.Digit.D2+import Data.Digit.D3+import Data.Digit.D4+import Data.Digit.D5+import Data.Digit.D6+import Data.Digit.D7+import Data.Digit.D8+import Data.Digit.D9 import Data.Digit.Decimal(parseDecimalNoZero)-import Data.Digit.DAa(parseAa)-import Data.Digit.DBb(parseBb)-import Data.Digit.DCc(parseCc)-import Data.Digit.DDd(parseDd)-import Data.Digit.DEe(parseEe)-import Data.Digit.DFf(parseFf)+import Data.Digit.DAa+import Data.Digit.DBb+import Data.Digit.DCc+import Data.Digit.DDd+import Data.Digit.DEe+import Data.Digit.DFf --- $setup--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--- >>> import Data.Digit.Digit--- >>> import Papa+data HeXDigit+  = HeXDigit0+  | HeXDigit1+  | HeXDigit2+  | HeXDigit3+  | HeXDigit4+  | HeXDigit5+  | HeXDigit6+  | HeXDigit7+  | HeXDigit8+  | HeXDigit9+  | HeXDigita+  | HeXDigitb+  | HeXDigitc+  | HeXDigitd+  | HeXDigite+  | HeXDigitf+  | HeXDigitA+  | HeXDigitB+  | HeXDigitC+  | HeXDigitD+  | HeXDigitE+  | HeXDigitF+  deriving (Show, Eq, Ord) +makePrisms ''HeXDigit++instance D0 HeXDigit where; d0 = _HeXDigit0+instance D1 HeXDigit where; d1 = _HeXDigit1+instance D2 HeXDigit where; d2 = _HeXDigit2+instance D3 HeXDigit where; d3 = _HeXDigit3+instance D4 HeXDigit where; d4 = _HeXDigit4+instance D5 HeXDigit where; d5 = _HeXDigit5+instance D6 HeXDigit where; d6 = _HeXDigit6+instance D7 HeXDigit where; d7 = _HeXDigit7+instance D8 HeXDigit where; d8 = _HeXDigit8+instance D9 HeXDigit where; d9 = _HeXDigit9+instance DA HeXDigit where; dA = _HeXDigitA+instance Da HeXDigit where; da = _HeXDigita+instance DB HeXDigit where; dB = _HeXDigitB+instance Db HeXDigit where; db = _HeXDigitb+instance DC HeXDigit where; dC = _HeXDigitC+instance Dc HeXDigit where; dc = _HeXDigitc+instance DD HeXDigit where; dD = _HeXDigitD+instance Dd HeXDigit where; dd = _HeXDigitd+instance DE HeXDigit where; dE = _HeXDigitE+instance De HeXDigit where; de = _HeXDigite+instance DF HeXDigit where; dF = _HeXDigitF+instance Df HeXDigit where; df = _HeXDigitf+ type HeXaDeCiMaLNoZero d =   (D1 d, D2 d, D3 d, D4 d, D5 d, D6 d, D7 d, D8 d, D9 d, DA d, DB d, DC d, DD d, DE d, DF d, Da d, Db d, Dc d, Dd d, De d, De d, Df d) --- |------ >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "1" :: Either ParseError Digit--- Right 1------ >>> parse parseHeXaDeCiMaLNoZero "test" "1xyz" :: Either ParseError Digit--- Right 1------ >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "2" :: Either ParseError Digit--- Right 2------ >>> parse parseHeXaDeCiMaLNoZero "test" "2xyz" :: Either ParseError Digit--- Right 2------ >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "3" :: Either ParseError Digit--- Right 3------ >>> parse parseHeXaDeCiMaLNoZero "test" "3xyz" :: Either ParseError Digit--- Right 3------ >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "4" :: Either ParseError Digit--- Right 4------ >>> parse parseHeXaDeCiMaLNoZero "test" "4xyz" :: Either ParseError Digit--- Right 4------ >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "5" :: Either ParseError Digit--- Right 5------ >>> parse parseHeXaDeCiMaLNoZero "test" "5xyz" :: Either ParseError Digit--- Right 5------ >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "6" :: Either ParseError Digit--- Right 6------ >>> parse parseHeXaDeCiMaLNoZero "test" "6xyz" :: Either ParseError Digit--- Right 6------ >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "7" :: Either ParseError Digit--- Right 7------ >>> parse parseHeXaDeCiMaLNoZero "test" "7xyz" :: Either ParseError Digit--- Right 7------ >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "8" :: Either ParseError Digit--- Right 8------ >>> parse parseHeXaDeCiMaLNoZero "test" "8xyz" :: Either ParseError Digit--- Right 8------ >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "9" :: Either ParseError Digit--- Right 9------ >>> parse parseHeXaDeCiMaLNoZero "test" "9xyz" :: Either ParseError Digit--- Right 9------ >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "a" :: Either ParseError Digit--- Right a------ >>> parse parseHeXaDeCiMaLNoZero "test" "axyz" :: Either ParseError Digit--- Right a------ >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "b" :: Either ParseError Digit--- Right b------ >>> parse parseHeXaDeCiMaLNoZero "test" "bxyz" :: Either ParseError Digit--- Right b------ >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "c" :: Either ParseError Digit--- Right c------ >>> parse parseHeXaDeCiMaLNoZero "test" "cxyz" :: Either ParseError Digit--- Right c------ >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "d" :: Either ParseError Digit--- Right d------ >>> parse parseHeXaDeCiMaLNoZero "test" "dxyz" :: Either ParseError Digit--- Right d------ >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "e" :: Either ParseError Digit--- Right e------ >>> parse parseHeXaDeCiMaLNoZero "test" "exyz" :: Either ParseError Digit--- Right e------ >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "f" :: Either ParseError Digit--- Right f------ >>> parse parseHeXaDeCiMaLNoZero "test" "fxyz" :: Either ParseError Digit--- Right f------ >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "A" :: Either ParseError Digit--- Right A------ >>> parse parseHeXaDeCiMaLNoZero "test" "Axyz" :: Either ParseError Digit--- Right A------ >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "B" :: Either ParseError Digit--- Right B------ >>> parse parseHeXaDeCiMaLNoZero "test" "Bxyz" :: Either ParseError Digit--- Right B------ >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "C" :: Either ParseError Digit--- Right C------ >>> parse parseHeXaDeCiMaLNoZero "test" "Cxyz" :: Either ParseError Digit--- Right C------ >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "D" :: Either ParseError Digit--- Right D------ >>> parse parseHeXaDeCiMaLNoZero "test" "Dxyz" :: Either ParseError Digit--- Right D------ >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "E" :: Either ParseError Digit--- Right E------ >>> parse parseHeXaDeCiMaLNoZero "test" "Exyz" :: Either ParseError Digit--- Right E------ >>> parse (parseHeXaDeCiMaLNoZero <* eof) "test" "F" :: Either ParseError Digit--- Right F------ >>> parse parseHeXaDeCiMaLNoZero "test" "Fxyz" :: Either ParseError Digit--- Right F------ >>> 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 Digit) parseHeXaDeCiMaLNoZero ::   (HeXaDeCiMaLNoZero d, CharParsing p) =>   p d@@ -199,144 +143,6 @@ type HeXaDeCiMaL d =   (D0 d, HeXaDeCiMaLNoZero d) --- |------ >>> parse (parseHeXaDeCiMaL <* eof) "test" "0" :: Either ParseError Digit--- Right 0------ >>> parse parseHeXaDeCiMaL "test" "0xyz" :: Either ParseError Digit--- Right 0------ >>> parse (parseHeXaDeCiMaL <* eof) "test" "1" :: Either ParseError Digit--- Right 1------ >>> parse parseHeXaDeCiMaL "test" "1xyz" :: Either ParseError Digit--- Right 1------ >>> parse (parseHeXaDeCiMaL <* eof) "test" "2" :: Either ParseError Digit--- Right 2------ >>> parse parseHeXaDeCiMaL "test" "2xyz" :: Either ParseError Digit--- Right 2------ >>> parse (parseHeXaDeCiMaL <* eof) "test" "3" :: Either ParseError Digit--- Right 3------ >>> parse parseHeXaDeCiMaL "test" "3xyz" :: Either ParseError Digit--- Right 3------ >>> parse (parseHeXaDeCiMaL <* eof) "test" "4" :: Either ParseError Digit--- Right 4------ >>> parse parseHeXaDeCiMaL "test" "4xyz" :: Either ParseError Digit--- Right 4------ >>> parse (parseHeXaDeCiMaL <* eof) "test" "5" :: Either ParseError Digit--- Right 5------ >>> parse parseHeXaDeCiMaL "test" "5xyz" :: Either ParseError Digit--- Right 5------ >>> parse (parseHeXaDeCiMaL <* eof) "test" "6" :: Either ParseError Digit--- Right 6------ >>> parse parseHeXaDeCiMaL "test" "6xyz" :: Either ParseError Digit--- Right 6------ >>> parse (parseHeXaDeCiMaL <* eof) "test" "7" :: Either ParseError Digit--- Right 7------ >>> parse parseHeXaDeCiMaL "test" "7xyz" :: Either ParseError Digit--- Right 7------ >>> parse (parseHeXaDeCiMaL <* eof) "test" "8" :: Either ParseError Digit--- Right 8------ >>> parse parseHeXaDeCiMaL "test" "8xyz" :: Either ParseError Digit--- Right 8------ >>> parse (parseHeXaDeCiMaL <* eof) "test" "9" :: Either ParseError Digit--- Right 9------ >>> parse parseHeXaDeCiMaL "test" "9xyz" :: Either ParseError Digit--- Right 9------ >>> parse (parseHeXaDeCiMaL <* eof) "test" "a" :: Either ParseError Digit--- Right a------ >>> parse parseHeXaDeCiMaL "test" "axyz" :: Either ParseError Digit--- Right a------ >>> parse (parseHeXaDeCiMaL <* eof) "test" "b" :: Either ParseError Digit--- Right b------ >>> parse parseHeXaDeCiMaL "test" "bxyz" :: Either ParseError Digit--- Right b------ >>> parse (parseHeXaDeCiMaL <* eof) "test" "c" :: Either ParseError Digit--- Right c------ >>> parse parseHeXaDeCiMaL "test" "cxyz" :: Either ParseError Digit--- Right c------ >>> parse (parseHeXaDeCiMaL <* eof) "test" "d" :: Either ParseError Digit--- Right d------ >>> parse parseHeXaDeCiMaL "test" "dxyz" :: Either ParseError Digit--- Right d------ >>> parse (parseHeXaDeCiMaL <* eof) "test" "e" :: Either ParseError Digit--- Right e------ >>> parse parseHeXaDeCiMaL "test" "exyz" :: Either ParseError Digit--- Right e------ >>> parse (parseHeXaDeCiMaL <* eof) "test" "f" :: Either ParseError Digit--- Right f------ >>> parse parseHeXaDeCiMaL "test" "fxyz" :: Either ParseError Digit--- Right f------ >>> parse (parseHeXaDeCiMaL <* eof) "test" "A" :: Either ParseError Digit--- Right A------ >>> parse parseHeXaDeCiMaL "test" "Axyz" :: Either ParseError Digit--- Right A------ >>> parse (parseHeXaDeCiMaL <* eof) "test" "B" :: Either ParseError Digit--- Right B------ >>> parse parseHeXaDeCiMaL "test" "Bxyz" :: Either ParseError Digit--- Right B------ >>> parse (parseHeXaDeCiMaL <* eof) "test" "C" :: Either ParseError Digit--- Right C------ >>> parse parseHeXaDeCiMaL "test" "Cxyz" :: Either ParseError Digit--- Right C------ >>> parse (parseHeXaDeCiMaL <* eof) "test" "D" :: Either ParseError Digit--- Right D------ >>> parse parseHeXaDeCiMaL "test" "Dxyz" :: Either ParseError Digit--- Right D------ >>> parse (parseHeXaDeCiMaL <* eof) "test" "E" :: Either ParseError Digit--- Right E------ >>> parse parseHeXaDeCiMaL "test" "Exyz" :: Either ParseError Digit--- Right E------ >>> 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 Digit) parseHeXaDeCiMaL ::   (HeXaDeCiMaL d, CharParsing p) =>   p d

@@ -1,138 +1,112 @@ {-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE TemplateHaskell #-}  module Data.Digit.Hexadecimal(-  HexadecimalNoZero+  HexDigit(..)+, HexadecimalNoZero , Hexadecimal , parseHexadecimalNoZero , parseHexadecimal+-- * Prisms+, _HexDigit0+, _HexDigit1+, _HexDigit2+, _HexDigit3+, _HexDigit4+, _HexDigit5+, _HexDigit6+, _HexDigit7+, _HexDigit8+, _HexDigit9+, _HexDigita+, _HexDigitb+, _HexDigitc+, _HexDigitd+, _HexDigite+, _HexDigitf+-- * Re-exports+, module Data.Digit.D0+, module Data.Digit.D1+, module Data.Digit.D2+, module Data.Digit.D3+, module Data.Digit.D4+, module Data.Digit.D5+, module Data.Digit.D6+, module Data.Digit.D7+, module Data.Digit.D8+, module Data.Digit.D9+, module Data.Digit.Da+, module Data.Digit.Db+, module Data.Digit.Dc+, module Data.Digit.Dd+, module Data.Digit.De+, module Data.Digit.Df ) where +import Prelude (Eq, Show, Ord)+import Control.Lens.TH (makePrisms) import Text.Parser.Char(CharParsing) import Text.Parser.Combinators((<?>), choice)-import Data.Digit.D0(D0, parse0)-import Data.Digit.D1(D1)-import Data.Digit.D2(D2)-import Data.Digit.D3(D3)-import Data.Digit.D4(D4)-import Data.Digit.D5(D5)-import Data.Digit.D6(D6)-import Data.Digit.D7(D7)-import Data.Digit.D8(D8)-import Data.Digit.D9(D9)-import Data.Digit.Da(Da, parsea)-import Data.Digit.Db(Db, parseb)-import Data.Digit.Dc(Dc, parsec)-import Data.Digit.Dd(Dd, parsed)-import Data.Digit.De(De, parsee)-import Data.Digit.Df(Df, parsef)+import Data.Digit.D0+import Data.Digit.D1+import Data.Digit.D2+import Data.Digit.D3+import Data.Digit.D4+import Data.Digit.D5+import Data.Digit.D6+import Data.Digit.D7+import Data.Digit.D8+import Data.Digit.D9+import Data.Digit.Da+import Data.Digit.Db+import Data.Digit.Dc+import Data.Digit.Dd+import Data.Digit.De+import Data.Digit.Df import Data.Digit.Decimal(parseDecimalNoZero) --- $setup--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--- >>> import Data.Digit.Digit--- >>> import Papa+data HexDigit+  = HexDigit0+  | HexDigit1+  | HexDigit2+  | HexDigit3+  | HexDigit4+  | HexDigit5+  | HexDigit6+  | HexDigit7+  | HexDigit8+  | HexDigit9+  | HexDigita+  | HexDigitb+  | HexDigitc+  | HexDigitd+  | HexDigite+  | HexDigitf+  deriving (Show, Eq, Ord) +makePrisms ''HexDigit++instance D0 HexDigit where; d0 = _HexDigit0+instance D1 HexDigit where; d1 = _HexDigit1+instance D2 HexDigit where; d2 = _HexDigit2+instance D3 HexDigit where; d3 = _HexDigit3+instance D4 HexDigit where; d4 = _HexDigit4+instance D5 HexDigit where; d5 = _HexDigit5+instance D6 HexDigit where; d6 = _HexDigit6+instance D7 HexDigit where; d7 = _HexDigit7+instance D8 HexDigit where; d8 = _HexDigit8+instance D9 HexDigit where; d9 = _HexDigit9+instance Da HexDigit where; da = _HexDigita+instance Db HexDigit where; db = _HexDigitb+instance Dc HexDigit where; dc = _HexDigitc+instance Dd HexDigit where; dd = _HexDigitd+instance De HexDigit where; de = _HexDigite+instance Df HexDigit where; df = _HexDigitf+ type HexadecimalNoZero d =   (D1 d, D2 d, D3 d, D4 d, D5 d, D6 d, D7 d, D8 d, D9 d, Da d, Db d, Dc d, Dd d, De d, De d, Df d) --- |------ >>> parse (parseHexadecimalNoZero <* eof) "test" "1" :: Either ParseError Digit--- Right 1------ >>> parse parseHexadecimalNoZero "test" "1xyz" :: Either ParseError Digit--- Right 1------ >>> parse (parseHexadecimalNoZero <* eof) "test" "2" :: Either ParseError Digit--- Right 2------ >>> parse parseHexadecimalNoZero "test" "2xyz" :: Either ParseError Digit--- Right 2------ >>> parse (parseHexadecimalNoZero <* eof) "test" "3" :: Either ParseError Digit--- Right 3------ >>> parse parseHexadecimalNoZero "test" "3xyz" :: Either ParseError Digit--- Right 3------ >>> parse (parseHexadecimalNoZero <* eof) "test" "4" :: Either ParseError Digit--- Right 4------ >>> parse parseHexadecimalNoZero "test" "4xyz" :: Either ParseError Digit--- Right 4------ >>> parse (parseHexadecimalNoZero <* eof) "test" "5" :: Either ParseError Digit--- Right 5------ >>> parse parseHexadecimalNoZero "test" "5xyz" :: Either ParseError Digit--- Right 5------ >>> parse (parseHexadecimalNoZero <* eof) "test" "6" :: Either ParseError Digit--- Right 6------ >>> parse parseHexadecimalNoZero "test" "6xyz" :: Either ParseError Digit--- Right 6------ >>> parse (parseHexadecimalNoZero <* eof) "test" "7" :: Either ParseError Digit--- Right 7------ >>> parse parseHexadecimalNoZero "test" "7xyz" :: Either ParseError Digit--- Right 7------ >>> parse (parseHexadecimalNoZero <* eof) "test" "8" :: Either ParseError Digit--- Right 8------ >>> parse parseHexadecimalNoZero "test" "8xyz" :: Either ParseError Digit--- Right 8------ >>> parse (parseHexadecimalNoZero <* eof) "test" "9" :: Either ParseError Digit--- Right 9------ >>> parse parseHexadecimalNoZero "test" "9xyz" :: Either ParseError Digit--- Right 9------ >>> parse (parseHexadecimalNoZero <* eof) "test" "a" :: Either ParseError Digit--- Right a------ >>> parse parseHexadecimalNoZero "test" "axyz" :: Either ParseError Digit--- Right a------ >>> parse (parseHexadecimalNoZero <* eof) "test" "b" :: Either ParseError Digit--- Right b------ >>> parse parseHexadecimalNoZero "test" "bxyz" :: Either ParseError Digit--- Right b------ >>> parse (parseHexadecimalNoZero <* eof) "test" "c" :: Either ParseError Digit--- Right c------ >>> parse parseHexadecimalNoZero "test" "cxyz" :: Either ParseError Digit--- Right c------ >>> parse (parseHexadecimalNoZero <* eof) "test" "d" :: Either ParseError Digit--- Right d------ >>> parse parseHexadecimalNoZero "test" "dxyz" :: Either ParseError Digit--- Right d------ >>> parse (parseHexadecimalNoZero <* eof) "test" "e" :: Either ParseError Digit--- Right e------ >>> parse parseHexadecimalNoZero "test" "exyz" :: Either ParseError Digit--- Right e------ >>> parse (parseHexadecimalNoZero <* eof) "test" "f" :: Either ParseError Digit--- Right f------ >>> parse parseHexadecimalNoZero "test" "fxyz" :: Either ParseError Digit--- Right f------ >>> 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 Digit) parseHexadecimalNoZero ::   (HexadecimalNoZero d, CharParsing p) =>   p d@@ -151,108 +125,6 @@ type Hexadecimal d =   (D0 d, HexadecimalNoZero d) --- |------ >>> parse (parseHexadecimal <* eof) "test" "0" :: Either ParseError Digit--- Right 0------ >>> parse parseHexadecimal "test" "0xyz" :: Either ParseError Digit--- Right 0------ >>> parse (parseHexadecimal <* eof) "test" "1" :: Either ParseError Digit--- Right 1------ >>> parse parseHexadecimal "test" "1xyz" :: Either ParseError Digit--- Right 1------ >>> parse (parseHexadecimal <* eof) "test" "2" :: Either ParseError Digit--- Right 2------ >>> parse parseHexadecimal "test" "2xyz" :: Either ParseError Digit--- Right 2------ >>> parse (parseHexadecimal <* eof) "test" "3" :: Either ParseError Digit--- Right 3------ >>> parse parseHexadecimal "test" "3xyz" :: Either ParseError Digit--- Right 3------ >>> parse (parseHexadecimal <* eof) "test" "4" :: Either ParseError Digit--- Right 4------ >>> parse parseHexadecimal "test" "4xyz" :: Either ParseError Digit--- Right 4------ >>> parse (parseHexadecimal <* eof) "test" "5" :: Either ParseError Digit--- Right 5------ >>> parse parseHexadecimal "test" "5xyz" :: Either ParseError Digit--- Right 5------ >>> parse (parseHexadecimal <* eof) "test" "6" :: Either ParseError Digit--- Right 6------ >>> parse parseHexadecimal "test" "6xyz" :: Either ParseError Digit--- Right 6------ >>> parse (parseHexadecimal <* eof) "test" "7" :: Either ParseError Digit--- Right 7------ >>> parse parseHexadecimal "test" "7xyz" :: Either ParseError Digit--- Right 7------ >>> parse (parseHexadecimal <* eof) "test" "8" :: Either ParseError Digit--- Right 8------ >>> parse parseHexadecimal "test" "8xyz" :: Either ParseError Digit--- Right 8------ >>> parse (parseHexadecimal <* eof) "test" "9" :: Either ParseError Digit--- Right 9------ >>> parse parseHexadecimal "test" "9xyz" :: Either ParseError Digit--- Right 9------ >>> parse (parseHexadecimal <* eof) "test" "a" :: Either ParseError Digit--- Right a------ >>> parse parseHexadecimal "test" "axyz" :: Either ParseError Digit--- Right a------ >>> parse (parseHexadecimal <* eof) "test" "b" :: Either ParseError Digit--- Right b------ >>> parse parseHexadecimal "test" "bxyz" :: Either ParseError Digit--- Right b------ >>> parse (parseHexadecimal <* eof) "test" "c" :: Either ParseError Digit--- Right c------ >>> parse parseHexadecimal "test" "cxyz" :: Either ParseError Digit--- Right c------ >>> parse (parseHexadecimal <* eof) "test" "d" :: Either ParseError Digit--- Right d------ >>> parse parseHexadecimal "test" "dxyz" :: Either ParseError Digit--- Right d------ >>> parse (parseHexadecimal <* eof) "test" "e" :: Either ParseError Digit--- Right e------ >>> parse parseHexadecimal "test" "exyz" :: Either ParseError Digit--- Right e------ >>> 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` "0123456789abcdef") ==> isn't _Right (parse parseHexadecimal "test" [c] :: Either ParseError Digit) parseHexadecimal ::   (Hexadecimal d, CharParsing p) =>   p d

@@ -1,60 +1,58 @@ {-# LANGUAGE NoImplicitPrelude #-}  module Data.Digit.Integral(+-- * Binary   integralBinaryNoZero , integralBinary+, integralBinDigits+, binDigitsIntegral+-- * Octal , integralOctalNoZero , integralOctal+, integralOctDigits+, octDigitsIntegral+-- * Decimal , integralDecimal , integralDecimalNoZero+, integralDecDigits+, decDigitsIntegral+-- * Hexadecimal , integralHexadecimalNoZero , integralHexadecimal+, integralHexDigits+, hexDigitsIntegral+-- * HEXADECIMAL , integralHEXADECIMALNoZero , integralHEXADECIMAL+, integralHEXDigits+, _HEXDigitsIntegral+-- * HeXaDeCiMaL+, integralHeXaDeCiMaLNoZero+, integralHeXaDeCiMaL+, _HeXDigitsIntegral ) where +import Prelude (error) 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 Data.Digit.Binary+import Data.Digit.Decimal+import Data.Digit.Octal+import Data.Digit.Hexadecimal+import Data.Digit.HEXADECIMAL+import Data.Digit.HeXaDeCiMaL+import qualified Data.List.NonEmpty as NonEmpty import Papa  -- $setup--- >>> import Data.Digit.Digit+-- >>> import Data.Digit  -- | -- -- >>> 1 ^? integralBinaryNoZero--- Just ()+-- Just BinDigit1 ----- >>> integralBinaryNoZero # Digit1 :: Integer+-- >>> integralBinaryNoZero # BinDigit1 :: Integer -- 1------ prop> \c -> c /= 1 ==> (c ^? integralBinaryNoZero == Nothing) integralBinaryNoZero ::   (Integral a, BinaryNoZero d) =>   Prism'@@ -65,19 +63,11 @@    -- | ----- >>> 0 ^? integralBinary :: Maybe Digit--- Just 0------ >>> 1 ^? integralBinary :: Maybe Digit--- Just 1+-- >>> 0 ^? integralBinary :: Maybe BinDigit+-- Just BinDigit0 ----- >>> integralBinary # Digit0 :: Integer+-- >>> integralBinary # BinDigit0 :: Integer -- 0------ >>> integralBinary # Digit1 :: Integer--- 1------ prop> \c -> (c `notElem` [0, 1]) ==> (c ^? integralBinary == Nothing) integralBinary ::   (Integral a, Binary d) =>   Prism'@@ -85,52 +75,55 @@     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+-- >>> integralBinDigits (4 :: Int)+-- Right (BinDigit1 :| [BinDigit0, BinDigit0]) ----- >>> 7 ^? integralOctalNoZero :: Maybe Digit--- Just 7+-- >>> integralBinDigits (0 :: Int)+-- Right (BinDigit0 :| []) ----- >>> integralOctalNoZero # Digit1 :: Integer--- 1+-- >>> integralBinDigits (-1 :: Int)+-- Left (BinDigit0 :| []) ----- >>> integralOctalNoZero # Digit2 :: Integer--- 2+-- >>> integralBinDigits (-4 :: Int)+-- Left (BinDigit1 :| [BinDigit1])+integralBinDigits :: Integral a => a -> Either (NonEmpty BinDigit) (NonEmpty BinDigit)+integralBinDigits n =+  if n >= 0+  then Right . NonEmpty.fromList $ go n []+  else Left . NonEmpty.fromList $ go (-n - 1) []+  where+    go k =+      let+        (q, r) = quotRem k 2+      in+        (if q == 0 then id else go q) . ((r ^?! integralBinary) :)++-- |+-- >>> binDigitsIntegral (Right (BinDigit1 :| [BinDigit0, BinDigit0])) :: Int+-- 4 ----- >>> integralOctalNoZero # Digit3 :: Integer--- 3+-- >>> binDigitsIntegral (Right (BinDigit0 :| [])) :: Int+-- 0 ----- >>> integralOctalNoZero # Digit4 :: Integer--- 4+-- >>> binDigitsIntegral (Left (BinDigit0 :| [])) :: Int+-- -1 ----- >>> integralOctalNoZero # Digit5 :: Integer--- 5+-- >>> binDigitsIntegral (Left (BinDigit1 :| [BinDigit1])) :: Int+-- -4+binDigitsIntegral :: Integral a => Either (NonEmpty BinDigit) (NonEmpty BinDigit) -> a+binDigitsIntegral = either (\n -> -(go n) - 1) go+  where+    go = foldl' (\b a -> (integralBinary # a) + 2 * b) 0++-- | ----- >>> integralOctalNoZero # Digit6 :: Integer--- 6+-- >>> 7 ^? integralOctalNoZero :: Maybe OctDigit+-- Just OctDigit7 ----- >>> integralOctalNoZero # Digit7 :: Integer+-- >>> integralOctalNoZero # OctDigit7 :: Integer -- 7------ prop> \c -> (c `notElem` [1..7]) ==> (c ^? integralOctalNoZero == Nothing) integralOctalNoZero ::   (Integral a, OctalNoZero d) =>   Prism'@@ -141,55 +134,11 @@  -- | ----- >>> 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+-- >>> 7 ^? integralOctal :: Maybe OctDigit+-- Just OctDigit7 ----- >>> integralOctal # Digit7 :: Integer+-- >>> integralOctal # OctDigit7 :: Integer -- 7------ prop> \c -> (c `notElem` [0..7]) ==> (c ^? integralOctal == Nothing) integralOctal ::   (Integral a, Octal d) =>   Prism'@@ -197,64 +146,54 @@     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+-- >>> integralOctDigits (64 :: Int)+-- Right (OctDigit1 :| [OctDigit0, OctDigit0]) ----- >>> integralDecimalNoZero # Digit3 :: Integer--- 3+-- >>> integralOctDigits (0 :: Int)+-- Right (OctDigit0 :| []) ----- >>> integralDecimalNoZero # Digit4 :: Integer--- 4+-- >>> integralOctDigits (-1 :: Int)+-- Left (OctDigit0 :| []) ----- >>> integralDecimalNoZero # Digit5 :: Integer--- 5+-- >>> integralOctDigits (-64 :: Int)+-- Left (OctDigit7 :| [OctDigit7])+integralOctDigits :: Integral a => a -> Either (NonEmpty OctDigit) (NonEmpty OctDigit)+integralOctDigits n =+  if n >= 0+  then Right . NonEmpty.fromList $ go n []+  else Left . NonEmpty.fromList $ go (-n - 1) []+  where+    go k =+      let+        (q, r) = quotRem k 8+      in+        (if q == 0 then id else go q) . ((r ^?! integralOctal) :)++-- |+-- >>> octDigitsIntegral (Right (OctDigit1 :| [OctDigit0, OctDigit0])) :: Int+-- 64 ----- >>> integralDecimalNoZero # Digit6 :: Integer--- 6+-- >>> octDigitsIntegral (Right (OctDigit0 :| [])) :: Int+-- 0 ----- >>> integralDecimalNoZero # Digit7 :: Integer--- 7+-- >>> octDigitsIntegral (Left (OctDigit0 :| [])) :: Int+-- -1 ----- >>> integralDecimalNoZero # Digit8 :: Integer--- 8+-- >>> octDigitsIntegral (Left (OctDigit7 :| [OctDigit7])) :: Int+-- -64+octDigitsIntegral :: Integral a => Either (NonEmpty OctDigit) (NonEmpty OctDigit) -> a+octDigitsIntegral = either (\n -> -(go n) - 1) go+  where+    go = foldl' (\b a -> (integralOctal # a) + 8 * b) 0++-- |+-- >>> 9 ^? integralDecimalNoZero :: Maybe DecDigit+-- Just DecDigit9 ----- >>> integralDecimalNoZero # Digit9 :: Integer+-- >>> integralDecimalNoZero # DecDigit9 :: Integer -- 9------ prop> \c -> (c `notElem` [1..9]) ==> (c ^? integralDecimalNoZero == Nothing) integralDecimalNoZero ::   (Integral a, DecimalNoZero d) =>   Prism'@@ -264,68 +203,11 @@   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+-- >>> 9 ^? integralDecimal :: Maybe DecDigit+-- Just DecDigit9 ----- >>> integralDecimal # Digit9 :: Integer+-- >>> integralDecimal # DecDigit9 :: Integer -- 9------ prop> \c -> (c `notElem` [0..9]) ==> (c ^? integralDecimal == Nothing) integralDecimal ::   (Integral a, Decimal d) =>   Prism'@@ -333,100 +215,55 @@     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+-- >>> integralDecDigits (100 :: Int)+-- Right (DecDigit1 :| [DecDigit0, DecDigit0]) ----- >>> integralHexadecimalNoZero # Digit8 :: Integer--- 8+-- >>> integralDecDigits (0 :: Int)+-- Right (DecDigit0 :| []) ----- >>> integralHexadecimalNoZero # Digit9 :: Integer--- 9+-- >>> integralDecDigits (-1 :: Int)+-- Left (DecDigit0 :| []) ----- >>> integralHexadecimalNoZero # Digita :: Integer--- 10+-- >>> integralDecDigits (-100 :: Int)+-- Left (DecDigit9 :| [DecDigit9])+integralDecDigits :: Integral a => a -> Either (NonEmpty DecDigit) (NonEmpty DecDigit)+integralDecDigits n =+  if n >= 0+  then Right . NonEmpty.fromList $ go n []+  else Left . NonEmpty.fromList $ go (-n - 1) []+  where+    go k =+      let+        (q, r) = quotRem k 10+      in+        (if q == 0 then id else go q) . ((r ^?! integralDecimal) :)++-- |+-- >>> decDigitsIntegral (Right (DecDigit1 :| [DecDigit0, DecDigit0])) :: Int+-- 100 ----- >>> integralHexadecimalNoZero # Digitb :: Integer--- 11+-- >>> decDigitsIntegral (Right (DecDigit0 :| [])) :: Int+-- 0 ----- >>> integralHexadecimalNoZero # Digitc :: Integer--- 12+-- >>> decDigitsIntegral (Left (DecDigit0 :| [])) :: Int+-- -1 ----- >>> integralHexadecimalNoZero # Digitd :: Integer--- 13+-- >>> decDigitsIntegral (Left (DecDigit9 :| [DecDigit9])) :: Int+-- -100+decDigitsIntegral :: Integral a => Either (NonEmpty DecDigit) (NonEmpty DecDigit) -> a+decDigitsIntegral = either (\n -> -(go n) - 1) go+  where+    go = foldl' (\b a -> (integralDecimal # a) + 10 * b) 0++-- | ----- >>> integralHexadecimalNoZero # Digite :: Integer--- 14+-- >>> 15 ^? integralHexadecimalNoZero :: Maybe HexDigit+-- Just HexDigitf ----- >>> integralHexadecimalNoZero # Digitf :: Integer+-- >>> integralHexadecimalNoZero # HexDigitf :: Integer -- 15------ prop> \c -> (c `notElem` [1..15]) ==> (c ^? integralHexadecimalNoZero == Nothing) integralHexadecimalNoZero ::   (Integral a, HexadecimalNoZero d) =>   Prism'@@ -437,103 +274,11 @@    -- | ----- >>> 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+-- >>> 15 ^? integralHexadecimal :: Maybe HexDigit+-- Just HexDigitf ----- >>> integralHexadecimal # Digitf :: Integer+-- >>> integralHexadecimal # HexDigitf :: Integer -- 15------ prop> \c -> (c `notElem` [0..15]) ==> (c ^? integralHexadecimal == Nothing) integralHexadecimal ::   (Integral a, Hexadecimal d) =>   Prism'@@ -543,98 +288,53 @@   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+-- >>> integralHexDigits (256 :: Int)+-- Right (HexDigit1 :| [HexDigit0, HexDigit0]) ----- >>> integralHEXADECIMALNoZero # Digit8 :: Integer--- 8+-- >>> integralHexDigits (0 :: Int)+-- Right (HexDigit0 :| []) ----- >>> integralHEXADECIMALNoZero # Digit9 :: Integer--- 9+-- >>> integralHexDigits (-1 :: Int)+-- Left (HexDigit0 :| []) ----- >>> integralHEXADECIMALNoZero # DigitA :: Integer--- 10+-- >>> integralHexDigits (-256 :: Int)+-- Left (HexDigitf :| [HexDigitf])+integralHexDigits :: Integral a => a -> Either (NonEmpty HexDigit) (NonEmpty HexDigit)+integralHexDigits n =+  if n >= 0+  then Right . NonEmpty.fromList $ go n []+  else Left . NonEmpty.fromList $ go (-n - 1) []+  where+    go k =+      let+        (q, r) = quotRem k 16+      in+        (if q == 0 then id else go q) . ((r ^?! integralHexadecimal) :)++-- |+-- >>> hexDigitsIntegral (Right (HexDigit1 :| [HexDigit0, HexDigit0])) :: Int+-- 256 ----- >>> integralHEXADECIMALNoZero # DigitB :: Integer--- 11+-- >>> hexDigitsIntegral (Right (HexDigit0 :| [])) :: Int+-- 0 ----- >>> integralHEXADECIMALNoZero # DigitC :: Integer--- 12+-- >>> hexDigitsIntegral (Left (HexDigit0 :| [])) :: Int+-- -1 ----- >>> integralHEXADECIMALNoZero # DigitD :: Integer--- 13+-- >>> hexDigitsIntegral (Left (HexDigitf :| [HexDigitf])) :: Int+-- -256+hexDigitsIntegral :: Integral a => Either (NonEmpty HexDigit) (NonEmpty HexDigit) -> a+hexDigitsIntegral = either (\n -> -(go n) - 1) go+  where+    go = foldl' (\b a -> (integralHexadecimal # a) + 16 * b) 0++-- | ----- >>> integralHEXADECIMALNoZero # DigitE :: Integer--- 14+-- >>> 15 ^? integralHEXADECIMALNoZero :: Maybe HEXDigit+-- Just HEXDigitF ----- >>> integralHEXADECIMALNoZero # DigitF :: Integer+-- >>> integralHEXADECIMALNoZero # HEXDigitF :: Integer -- 15------ prop> \c -> (c `notElem` [1..15]) ==> (c ^? integralHEXADECIMALNoZero == Nothing) integralHEXADECIMALNoZero ::   (Integral a, HEXADECIMALNoZero d) =>   Prism'@@ -646,110 +346,151 @@  -- | ----- >>> 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+-- >>> 15 ^? integralHEXADECIMAL :: Maybe HEXDigit+-- Just HEXDigitF ----- >>> 12 ^? integralHEXADECIMAL :: Maybe Digit--- Just C+-- >>> integralHEXADECIMAL # HEXDigitF :: Integer+-- 15+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)]++-- |+-- >>> integralHEXDigits (256 :: Int)+-- Right (HEXDigit1 :| [HEXDigit0, HEXDigit0]) ----- >>> 13 ^? integralHEXADECIMAL :: Maybe Digit--- Just D+-- >>> integralHEXDigits (0 :: Int)+-- Right (HEXDigit0 :| []) ----- >>> 14 ^? integralHEXADECIMAL :: Maybe Digit--- Just E+-- >>> integralHEXDigits (-1 :: Int)+-- Left (HEXDigit0 :| []) ----- >>> 15 ^? integralHEXADECIMAL :: Maybe Digit--- Just F+-- >>> integralHEXDigits (-256 :: Int)+-- Left (HEXDigitF :| [HEXDigitF])+integralHEXDigits :: Integral a => a -> Either (NonEmpty HEXDigit) (NonEmpty HEXDigit)+integralHEXDigits n =+  if n >= 0+  then Right . NonEmpty.fromList $ go n []+  else Left . NonEmpty.fromList $ go (-n - 1) []+  where+    go k =+      let+        (q, r) = quotRem k 16+      in+        (if q == 0 then id else go q) . ((r ^?! integralHEXADECIMAL) :)++-- |+-- >>> HEXDigitsIntegral (Right (HEXDigit1 :| [HEXDigit0, HEXDigit0])) :: Int+-- 256 ----- >>> integralHEXADECIMAL # Digit0 :: Integer+-- >>> HEXDigitsIntegral (Right (HEXDigit0 :| [])) :: Int -- 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+-- >>> HEXDigitsIntegral (Left (HEXDigit0 :| [])) :: Int+-- -1 ----- >>> integralHEXADECIMAL # DigitB :: Integer--- 11+-- >>> HEXDigitsIntegral (Left (HEXDigitF :| [HEXDigitF])) :: Int+-- -256+_HEXDigitsIntegral :: Integral a => Either (NonEmpty HEXDigit) (NonEmpty HEXDigit) -> a+_HEXDigitsIntegral = either (\n -> -(go n) - 1) go+  where+    go = foldl' (\b a -> (integralHEXADECIMAL # a) + 16 * b) 0++-- | ----- >>> integralHEXADECIMAL # DigitC :: Integer--- 12+-- >>> 15 ^? integralHeXaDeCiMaLNoZero :: Maybe HeXDigit+-- Just HeXDigitF ----- >>> integralHEXADECIMAL # DigitD :: Integer--- 13+-- >>> integralHeXaDeCiMaLNoZero # HeXDigitF :: Integer+-- 15+integralHeXaDeCiMaLNoZero ::+  (Integral a, HeXaDeCiMaLNoZero d) =>+  Review+    a+    d+integralHeXaDeCiMaLNoZero =+  unto+    (outside d1 .~ (\_ -> 1) $+     outside d2 .~ (\_ -> 2) $+     outside d3 .~ (\_ -> 3) $+     outside d4 .~ (\_ -> 4) $+     outside d5 .~ (\_ -> 5) $+     outside d6 .~ (\_ -> 6) $+     outside d7 .~ (\_ -> 7) $+     outside d8 .~ (\_ -> 8) $+     outside d9 .~ (\_ -> 9) $+     outside da .~ (\_ -> 10) $+     outside dA .~ (\_ -> 10) $+     outside db .~ (\_ -> 11) $+     outside dB .~ (\_ -> 11) $+     outside dc .~ (\_ -> 12) $+     outside dC .~ (\_ -> 12) $+     outside dd .~ (\_ -> 13) $+     outside dD .~ (\_ -> 13) $+     outside de .~ (\_ -> 14) $+     outside dE .~ (\_ -> 14) $+     outside df .~ (\_ -> 15) $+     outside dF .~ (\_ -> 15) $+     error "incomplete pattern")++-- | ----- >>> integralHEXADECIMAL # DigitE :: Integer--- 14+-- >>> 15 ^? integralHeXaDeCiMaL :: Maybe HeXDigit+-- Just HeXDigitF ----- >>> integralHEXADECIMAL # DigitF :: Integer+-- >>> integralHeXaDeCiMaL # HeXDigitF :: Integer -- 15------ prop> \c -> (c `notElem` [0..15]) ==> (c ^? integralHEXADECIMAL == Nothing)-integralHEXADECIMAL ::-  (Integral a, HEXADECIMAL d) =>-  Prism'+integralHeXaDeCiMaL ::+  (Integral a, HeXaDeCiMaL d) =>+  Review     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)]+integralHeXaDeCiMaL =+  unto+    (outside d0 .~ (\_ -> 0) $+     outside d1 .~ (\_ -> 1) $+     outside d2 .~ (\_ -> 2) $+     outside d3 .~ (\_ -> 3) $+     outside d4 .~ (\_ -> 4) $+     outside d5 .~ (\_ -> 5) $+     outside d6 .~ (\_ -> 6) $+     outside d7 .~ (\_ -> 7) $+     outside d8 .~ (\_ -> 8) $+     outside d9 .~ (\_ -> 9) $+     outside da .~ (\_ -> 10) $+     outside dA .~ (\_ -> 10) $+     outside db .~ (\_ -> 11) $+     outside dB .~ (\_ -> 11) $+     outside dc .~ (\_ -> 12) $+     outside dC .~ (\_ -> 12) $+     outside dd .~ (\_ -> 13) $+     outside dD .~ (\_ -> 13) $+     outside de .~ (\_ -> 14) $+     outside dE .~ (\_ -> 14) $+     outside df .~ (\_ -> 15) $+     outside dF .~ (\_ -> 15) $+     error "incomplete pattern")++-- |+-- >>> HeXDigitsIntegral (Right (HeXDigit1 :| [HeXDigit0, HeXDigit0])) :: Int+-- 256+--+-- >>> HeXDigitsIntegral (Right (HeXDigit0 :| [])) :: Int+-- 0+--+-- >>> HeXDigitsIntegral (Left (HeXDigit0 :| [])) :: Int+-- -1+--+-- >>> HeXDigitsIntegral (Left (HeXDigitF :| [HeXDigitF])) :: Int+-- -256+_HeXDigitsIntegral :: Integral a => Either (NonEmpty HeXDigit) (NonEmpty HeXDigit) -> a+_HeXDigitsIntegral = either (\n -> -(go n) - 1) go+  where+    go = foldl' (\b a -> (integralHeXaDeCiMaL # a) + 16 * b) 0  ---- not exported associatePrism ::

@@ -22,7 +22,7 @@  import           Data.Maybe          (Maybe (..)) -import           Data.Digit.Digit+import           Data.Digit.Decimal import           Data.Digit.Integral (integralDecimal)  import           Numeric.Natural     (Natural)@@ -32,40 +32,37 @@ -- | -- -- >>> _NaturalDigits # 0--- 0 :| []+-- DecDigit0 :| [] -- -- >>> _NaturalDigits # 1--- 1 :| []+-- DecDigit1 :| [] ----- >>> _NaturalDigits # 9223372036854775807--- 9 :| [2,2,3,3,7,2,0,3,6,8,5,4,7,7,5,8,0,7]+-- >>> _NaturalDigits # 922+-- DecDigit9 :| [DecDigit2,DecDigit2] ----- >>> (9 :| [2,2,3,3,7,2,0,3,6,8,5,4,7,7,5,8,0,7]) ^? _NaturalDigits--- Just 9223372036854775807+-- >>> (DecDigit9 :| [DecDigit2,DecDigit2]) ^? _NaturalDigits+-- Just 922 ----- >>> (1 :| []) ^? _NaturalDigits+-- >>> (DecDigit1 :| []) ^? _NaturalDigits -- Just 1 -- -- prop> \x -> digitsToNatural ( naturalToDigits x ) == Just x ---_NaturalDigits :: Prism' (NonEmpty Digit) Natural+_NaturalDigits :: Prism' (NonEmpty DecDigit) Natural _NaturalDigits = prism' naturalToDigits digitsToNatural --- | NonEmpty Digits from a Natural number+-- | -- -- >>> naturalDigits 0--- 0 :| []+-- DecDigit0 :| [] -- -- >>> naturalDigits 9--- 9 :| []------ >>> naturalDigits 393564--- 3 :| [9,3,5,6,4]+-- DecDigit9 :| [] ----- >>> naturalDigits 9223372036854775807--- 9 :| [2,2,3,3,7,2,0,3,6,8,5,4,7,7,5,8,0,7]+-- >>> naturalDigits 393+-- DecDigit3 :| [DecDigit9,DecDigit3] ---naturalToDigits :: Natural -> NonEmpty Digit+naturalToDigits :: Natural -> NonEmpty DecDigit naturalToDigits n =   case toDecimalDigits $ fromIntegral n of     -- toDecimalDigits :: n -> ([n],n)@@ -77,45 +74,39 @@    where     t allDigs eXP =-      replicate (eXP - length allDigs) Digit0+      replicate (eXP - length allDigs) (d0 # ())      -- EWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW!     -- But you can't reach this point unless you have a non-zero absolute integral value. So... I dunno.-    g 0 = Digit0-    g 1 = Digit1-    g 2 = Digit2-    g 3 = Digit3-    g 4 = Digit4-    g 5 = Digit5-    g 6 = Digit6-    g 7 = Digit7-    g 8 = Digit8-    g 9 = Digit9+    g 0 = d0 # ()+    g 1 = d1 # ()+    g 2 = d2 # ()+    g 3 = d3 # ()+    g 4 = d4 # ()+    g 5 = d5 # ()+    g 6 = d6 # ()+    g 7 = d7 # ()+    g 8 = d8 # ()+    g 9 = d9 # ()     g _ = error "The universe now has more than ten digits."  -- | Create a number from a list of digits with the integer bounds of the machine. ----- >>> naturalFromDigits (D.x3 :| [D.x4])+-- >>> digitsToNatural (DecDigit3 :| [DecDigit4]) -- Just 34 ----- >>> naturalFromDigits (D.Digit3 :| [D.Digit9,D.Digit3,D.Digit5,D.Digit6,D.Digit4])--- Just 393564------ >>> naturalFromDigits (D.x0 :| [])+-- >>> digitsToNatural (DecDigit0 :| []) -- Just 0 ----- Int maxBound for Int64--- >>> naturalFromDigits (D.x9 :| [D.x2,D.x2,D.x3,D.x3,D.x7,D.x2,D.x0,D.x3,D.x6,D.x8,D.x5,D.x4,D.x7,D.x7,D.x5,D.x8,D.x0,D.x7])+-- >>> digitsToNatural (naturalToDigits (maxBound :: Natural)) -- Just 9223372036854775807 ----- Int maxBound + 1 for Int64--- >>> naturalFromDigits (D.x9 :| [D.x2,D.x2,D.x3,D.x3,D.x7,D.x2,D.x0,D.x3,D.x6,D.x8,D.x5,D.x4,D.x7,D.x7,D.x5,D.x8,D.x0,D.x8])+-- >>> digitsToNatural (naturalToDigits $ (maxBound :: Natural) + 1) -- Nothing----digitsToNatural :: NonEmpty Digit -> Maybe Natural+digitsToNatural :: NonEmpty DecDigit -> Maybe Natural digitsToNatural = fmap fromIntegral . ifoldrM f 0 . NE.reverse   where-    f :: Int -> Digit -> Int -> Maybe Int+    f :: Int -> DecDigit -> Int -> Maybe Int     f i d curr =       let         next = (integralDecimal # d) * (10 ^ i)

@@ -1,81 +1,71 @@ {-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE TemplateHaskell #-}  module Data.Digit.Octal(-  OctalNoZero+  OctDigit(..)+, OctalNoZero , Octal , parseOctalNoZero , parseOctal+-- * Prisms+, _OctDigit0+, _OctDigit1+, _OctDigit2+, _OctDigit3+, _OctDigit4+, _OctDigit5+, _OctDigit6+, _OctDigit7+-- * Re-exports+, module Data.Digit.D0+, module Data.Digit.D1+, module Data.Digit.D2+, module Data.Digit.D3+, module Data.Digit.D4+, module Data.Digit.D5+, module Data.Digit.D6+, module Data.Digit.D7 ) where +import Prelude (Eq, Show, Ord, Enum, Bounded)+import Control.Lens.TH (makePrisms) import Text.Parser.Char(CharParsing) import Text.Parser.Combinators((<?>), choice)-import Data.Digit.D0(D0, parse0)-import Data.Digit.D1(D1, parse1)-import Data.Digit.D2(D2, parse2)-import Data.Digit.D3(D3, parse3)-import Data.Digit.D4(D4, parse4)-import Data.Digit.D5(D5, parse5)-import Data.Digit.D6(D6, parse6)-import Data.Digit.D7(D7, parse7)+import Data.Digit.D0+import Data.Digit.D1+import Data.Digit.D2+import Data.Digit.D3+import Data.Digit.D4+import Data.Digit.D5+import Data.Digit.D6+import Data.Digit.D7 --- $setup--- >>> import Text.Parsec(parse, ParseError, eof)--- >>> import Data.Void(Void)--- >>> import Data.Digit.Digit--- >>> import Papa+data OctDigit+  = OctDigit0+  | OctDigit1+  | OctDigit2+  | OctDigit3+  | OctDigit4+  | OctDigit5+  | OctDigit6+  | OctDigit7+  deriving (Show, Eq, Ord, Enum, Bounded) +makePrisms ''OctDigit++instance D0 OctDigit where; d0 = _OctDigit0+instance D1 OctDigit where; d1 = _OctDigit1+instance D2 OctDigit where; d2 = _OctDigit2+instance D3 OctDigit where; d3 = _OctDigit3+instance D4 OctDigit where; d4 = _OctDigit4+instance D5 OctDigit where; d5 = _OctDigit5+instance D6 OctDigit where; d6 = _OctDigit6+instance D7 OctDigit where; d7 = _OctDigit7+ type OctalNoZero d =   (D1 d, D2 d, D3 d, D4 d, D5 d, D6 d, D7 d) --- |------ >>> parse (parseOctalNoZero <* eof) "test" "1" :: Either ParseError Digit--- Right 1------ >>> parse parseOctalNoZero "test" "1xyz" :: Either ParseError Digit--- Right 1------ >>> parse (parseOctalNoZero <* eof) "test" "2" :: Either ParseError Digit--- Right 2------ >>> parse parseOctalNoZero "test" "2xyz" :: Either ParseError Digit--- Right 2------ >>> parse (parseOctalNoZero <* eof) "test" "3" :: Either ParseError Digit--- Right 3------ >>> parse parseOctalNoZero "test" "3xyz" :: Either ParseError Digit--- Right 3------ >>> parse (parseOctalNoZero <* eof) "test" "4" :: Either ParseError Digit--- Right 4------ >>> parse parseOctalNoZero "test" "4xyz" :: Either ParseError Digit--- Right 4------ >>> parse (parseOctalNoZero <* eof) "test" "5" :: Either ParseError Digit--- Right 5------ >>> parse parseOctalNoZero "test" "5xyz" :: Either ParseError Digit--- Right 5------ >>> parse (parseOctalNoZero <* eof) "test" "6" :: Either ParseError Digit--- Right 6------ >>> parse parseOctalNoZero "test" "6xyz" :: Either ParseError Digit--- Right 6------ >>> parse (parseOctalNoZero <* eof) "test" "7" :: Either ParseError Digit--- Right 7------ >>> parse parseOctalNoZero "test" "7xyz" :: Either ParseError Digit--- Right 7------ >>> isn't _Right (parse parseOctalNoZero "test" "xyz" :: Either ParseError Digit)--- True------ prop> \c -> (c `notElem` "1234567") ==> isn't _Right (parse parseOctalNoZero "test" [c] :: Either ParseError Digit) parseOctalNoZero ::   (OctalNoZero d, CharParsing p) =>   p d@@ -94,60 +84,6 @@ type Octal d =   (D0 d, OctalNoZero d) --- |------ >>> parse (parseOctal <* eof) "test" "0" :: Either ParseError Digit--- Right 0------ >>> parse (parseOctal <* eof) "test" "0" :: Either ParseError Digit--- Right 0------ >>> parse parseOctal "test" "1xyz" :: Either ParseError Digit--- Right 1------ >>> parse parseOctal "test" "1xyz" :: Either ParseError Digit--- Right 1------ >>> parse (parseOctal <* eof) "test" "2" :: Either ParseError Digit--- Right 2------ >>> parse parseOctal "test" "2xyz" :: Either ParseError Digit--- Right 2------ >>> parse (parseOctal <* eof) "test" "3" :: Either ParseError Digit--- Right 3------ >>> parse parseOctal "test" "3xyz" :: Either ParseError Digit--- Right 3------ >>> parse (parseOctal <* eof) "test" "4" :: Either ParseError Digit--- Right 4------ >>> parse parseOctal "test" "4xyz" :: Either ParseError Digit--- Right 4------ >>> parse (parseOctal <* eof) "test" "5" :: Either ParseError Digit--- Right 5------ >>> parse parseOctal "test" "5xyz" :: Either ParseError Digit--- Right 5------ >>> parse (parseOctal <* eof) "test" "6" :: Either ParseError Digit--- Right 6------ >>> parse parseOctal "test" "6xyz" :: Either ParseError Digit--- Right 6------ >>> parse (parseOctal <* eof) "test" "7" :: Either ParseError Digit--- Right 7------ >>> parse parseOctal "test" "7xyz" :: Either ParseError Digit--- Right 7------ >>> isn't _Right (parse parseOctal "test" "xyz" :: Either ParseError Digit)--- True------ prop> \c -> (c `notElem` "01234567") ==> isn't _Right (parse parseOctal "test" [c] :: Either ParseError Digit) parseOctal ::   (Octal d, CharParsing p) =>   p d

@@ -6,22 +6,22 @@  import Data.Digit import Numeric.Natural (Natural)-import Prelude (maxBound)+import Prelude (minBound, maxBound) import Papa hiding (re) import Hedgehog(Property, Gen, forAll, property, assert, (===)) import Test.Tasty(TestTree, defaultMain, testGroup) import Test.Tasty.Hedgehog(testProperty) import Test.Tasty.HUnit(testCase, (@?=))-import qualified Hedgehog.Gen as Gen(choice, integral, unicode, hexit, filter)-import qualified Hedgehog.Range as Range(linear)+import qualified Hedgehog.Gen as Gen+import qualified Hedgehog.Range as Range import Text.Parsec(parse, ParseError, Parsec, eof)  testPrism ::   (Show x, Eq x) =>   Gen x   -> String-  -> Prism' x Digit-  -> [(x, Digit)]+  -> Prism' x HeXDigit+  -> [(x, HeXDigit)]   -> [TestTree] testPrism g n p x =   testProperty@@ -29,14 +29,14 @@     (       property $         do  c <- forAll . Gen.filter (`notElem` (map fst x)) $ g-            (c ^? p :: Maybe Digit) === Nothing+            (c ^? p :: Maybe HeXDigit) === Nothing     ) :     (       x >>= \(c, d) ->         [           testCase             (n ++ " prism ->")-            ((c ^? p :: Maybe Digit) @?= Just d)+            ((c ^? p :: Maybe HeXDigit) @?= Just d)         , testCase             (n ++ " prism <-")             (p # d @?= c)@@ -45,8 +45,8 @@  testParser ::   String-  -> Parsec String () Digit-  -> [(Char, Digit)]+  -> Parsec String () HeXDigit+  -> [(Char, HeXDigit)]   -> [TestTree] testParser n p x =     (@@ -56,7 +56,7 @@             (               property $                 do  c <- forAll . Gen.filter (`notElem` (map fst x)) . Gen.choice $ [Gen.hexit, Gen.unicode]-                    assert (isLeft (parse p (n' ++ " test") [c] :: Either ParseError Digit))+                    assert (isLeft (parse p (n' ++ " test") [c] :: Either ParseError HeXDigit))             )     ) :     (@@ -65,27 +65,27 @@           let n' = n ++ " parses exactly one character"           in  testCase                 n'-                ((parse (p <* eof) (n' ++ " test") [c] :: Either ParseError Digit) @?= Right d)+                ((parse (p <* eof) (n' ++ " test") [c] :: Either ParseError HeXDigit) @?= Right d)         , let n' = n ++ " parses the correct digit"           in  testCase                 n'-                ((parse p (n' ++ "test") (c:"xyz") :: Either ParseError Digit) @?= Right d)+                ((parse p (n' ++ "test") (c:"xyz") :: Either ParseError HeXDigit) @?= Right d)             ]     )  integralPrism ::   (Show n, Integral n) =>   String-  -> Prism' n Digit-  -> [(n, Digit)]+  -> Prism' n HeXDigit+  -> [(n, HeXDigit)]   -> [TestTree] integralPrism =   testPrism (Gen.choice [Gen.integral (Range.linear 0 9), Gen.integral (Range.linear 10 99999), Gen.integral (Range.linear (-1) (-99999))])  charPrism ::   String-  -> Prism' Char Digit-  -> [(Char, Digit)]+  -> Prism' Char HeXDigit+  -> [(Char, HeXDigit)]   -> [TestTree] charPrism =   testPrism (Gen.choice [Gen.hexit, Gen.unicode])@@ -103,83 +103,131 @@   [ testProperty "Natural <-> NonEmpty Digit" prop_natural_digits_roundtrip   ] +prop_integer_X :: (Integer -> a) -> (a -> Integer) -> Property+prop_integer_X iToX xToI =+  property $ do+    n <- forAll .+      Gen.integral $+        Range.constant+          (fromIntegral (minBound :: Int))+          (fromIntegral (maxBound :: Int))+    xToI (iToX n) === n++prop_X_integer+  :: (Eq a, Show a)+  => Gen a+  -> (Integer -> Either (NonEmpty a) (NonEmpty a))+  -> (Either (NonEmpty a) (NonEmpty a) -> Integer)+  -> Property+prop_X_integer genX iToX xToI =+  property $ do+    let digits = Gen.nonEmpty (Range.constant 1 50) genX+    ds <- forAll $ Gen.choice [Left <$> digits, Right <$> digits]+    xToI (iToX (xToI ds)) === xToI ds++toFromIntegralTests :: TestTree+toFromIntegralTests =+  testGroup "To and from integers"+  [ testProperty "Integer <-> BinDigit" $+      prop_integer_X integralBinDigits binDigitsIntegral+  , testProperty "BinDigit <-> Integer" $+      prop_X_integer (Gen.element enumBinary) integralBinDigits binDigitsIntegral+  , testProperty "Integer <-> OctDigit" $+      prop_integer_X integralOctDigits octDigitsIntegral+  , testProperty "OctDigit <-> Integer" $+      prop_X_integer (Gen.element enumOctal) integralOctDigits octDigitsIntegral+  , testProperty "Integer <-> DecDigit" $+      prop_integer_X integralDecDigits decDigitsIntegral+  , testProperty "DecDigit <-> Integer" $+      prop_X_integer (Gen.element enumDecimal) integralDecDigits decDigitsIntegral+  , testProperty "Integer <-> HexDigit" $+      prop_integer_X integralHexDigits hexDigitsIntegral+  , testProperty "HexDigit <-> Integer" $+      prop_X_integer (Gen.element enumHexadecimal) integralHexDigits hexDigitsIntegral+  , testProperty "Integer <-> HEXDigit" $+      prop_integer_X integralHEXDigits _HEXDigitsIntegral+  , testProperty "HEXDigit <-> Integer" $+      prop_X_integer (Gen.element enumHEXADECIMAL) integralHEXDigits _HEXDigitsIntegral+  ]+ main ::   IO () main = defaultMain $   testGroup "All Digit Tests"     [ digitBaseTests     , digitNaturalTests+    , toFromIntegralTests     ]  digitBaseTests :: TestTree digitBaseTests =   testGroup "digit parser/prism tests" $-    let q0  = ('0', Digit0)-        q1  = ('1', Digit1)-        q2  = ('2', Digit2)-        q3  = ('3', Digit3)-        q4  = ('4', Digit4)-        q5  = ('5', Digit5)-        q6  = ('6', Digit6)-        q7  = ('7', Digit7)-        q8  = ('8', Digit8)-        q9  = ('9', Digit9)-        qa  = ('a', Digita)-        qb  = ('b', Digitb)-        qc  = ('c', Digitc)-        qd  = ('d', Digitd)-        qe  = ('e', Digite)-        qf  = ('f', Digitf)-        qA  = ('A', DigitA)-        qB  = ('B', DigitB)-        qC  = ('C', DigitC)-        qD  = ('D', DigitD)-        qE  = ('E', DigitE)-        qF  = ('F', DigitF)-        r0 :: (Integer, Digit)-        r0  = (0  , Digit0)-        r1 :: (Integer, Digit)-        r1  = (1  , Digit1)-        r2 :: (Integer, Digit)-        r2  = (2  , Digit2)-        r3 :: (Integer, Digit)-        r3  = (3  , Digit3)-        r4 :: (Integer, Digit)-        r4  = (4  , Digit4)-        r5 :: (Integer, Digit)-        r5  = (5  , Digit5)-        r6 :: (Integer, Digit)-        r6  = (6  , Digit6)-        r7 :: (Integer, Digit)-        r7  = (7  , Digit7)-        r8 :: (Integer, Digit)-        r8  = (8  , Digit8)-        r9 :: (Integer, Digit)-        r9  = (9  , Digit9)-        ra :: (Integer, Digit)-        ra =  (10 , Digita)-        rb :: (Integer, Digit)-        rb =  (11 , Digitb)-        rc :: (Integer, Digit)-        rc =  (12 , Digitc)-        rd :: (Integer, Digit)-        rd =  (13 , Digitd)-        re :: (Integer, Digit)-        re =  (14 , Digite)-        rf :: (Integer, Digit)-        rf =  (15 , Digitf)-        rA :: (Integer, Digit)-        rA =  (10 , DigitA)-        rB :: (Integer, Digit)-        rB =  (11 , DigitB)-        rC :: (Integer, Digit)-        rC =  (12 , DigitC)-        rD :: (Integer, Digit)-        rD =  (13 , DigitD)-        rE :: (Integer, Digit)-        rE =  (14 , DigitE)-        rF :: (Integer, Digit)-        rF =  (15 , DigitF)+    let q0  = ('0', HeXDigit0)+        q1  = ('1', HeXDigit1)+        q2  = ('2', HeXDigit2)+        q3  = ('3', HeXDigit3)+        q4  = ('4', HeXDigit4)+        q5  = ('5', HeXDigit5)+        q6  = ('6', HeXDigit6)+        q7  = ('7', HeXDigit7)+        q8  = ('8', HeXDigit8)+        q9  = ('9', HeXDigit9)+        qa  = ('a', HeXDigita)+        qb  = ('b', HeXDigitb)+        qc  = ('c', HeXDigitc)+        qd  = ('d', HeXDigitd)+        qe  = ('e', HeXDigite)+        qf  = ('f', HeXDigitf)+        qA  = ('A', HeXDigitA)+        qB  = ('B', HeXDigitB)+        qC  = ('C', HeXDigitC)+        qD  = ('D', HeXDigitD)+        qE  = ('E', HeXDigitE)+        qF  = ('F', HeXDigitF)+        r0 :: (Integer, HeXDigit)+        r0  = (0  , HeXDigit0)+        r1 :: (Integer, HeXDigit)+        r1  = (1  , HeXDigit1)+        r2 :: (Integer, HeXDigit)+        r2  = (2  , HeXDigit2)+        r3 :: (Integer, HeXDigit)+        r3  = (3  , HeXDigit3)+        r4 :: (Integer, HeXDigit)+        r4  = (4  , HeXDigit4)+        r5 :: (Integer, HeXDigit)+        r5  = (5  , HeXDigit5)+        r6 :: (Integer, HeXDigit)+        r6  = (6  , HeXDigit6)+        r7 :: (Integer, HeXDigit)+        r7  = (7  , HeXDigit7)+        r8 :: (Integer, HeXDigit)+        r8  = (8  , HeXDigit8)+        r9 :: (Integer, HeXDigit)+        r9  = (9  , HeXDigit9)+        ra :: (Integer, HeXDigit)+        ra =  (10 , HeXDigita)+        rb :: (Integer, HeXDigit)+        rb =  (11 , HeXDigitb)+        rc :: (Integer, HeXDigit)+        rc =  (12 , HeXDigitc)+        rd :: (Integer, HeXDigit)+        rd =  (13 , HeXDigitd)+        re :: (Integer, HeXDigit)+        re =  (14 , HeXDigite)+        rf :: (Integer, HeXDigit)+        rf =  (15 , HeXDigitf)+        rA :: (Integer, HeXDigit)+        rA =  (10 , HeXDigitA)+        rB :: (Integer, HeXDigit)+        rB =  (11 , HeXDigitB)+        rC :: (Integer, HeXDigit)+        rC =  (12 , HeXDigitC)+        rD :: (Integer, HeXDigit)+        rD =  (13 , HeXDigitD)+        rE :: (Integer, HeXDigit)+        rE =  (14 , HeXDigitE)+        rF :: (Integer, HeXDigit)+        rF =  (15 , HeXDigitF)     in  concat [           charPrism "charBinaryNoZero" charBinaryNoZero [q1]         , charPrism "charBinary" charBinary [q0, q1]