diff --git a/changelog.md b/changelog.md --- a/changelog.md +++ b/changelog.md @@ -1,3 +1,11 @@ +0.5.2 + +* Add `Data.Digit.Natural (_NaturalDigits, naturalToDigits, digitsToNatural)` + +0.5.1 + +* Replace doctest with hunit and hedgehog via tasty + 0.5.0 * Data types for other bases (binary, octal, hexadecimal). diff --git a/digit.cabal b/digit.cabal --- a/digit.cabal +++ b/digit.cabal @@ -1,17 +1,17 @@ name: digit -version: 0.5.1 +version: 0.5.2 license: BSD3 license-file: LICENCE author: Queensland Functional Programming Lab maintainer: Queensland Functional Programming Lab copyright: Copyright (C) 2010-2016 NICTA Limited -copyright: Copyright (c) 2017, Commonwealth Scientific and Industrial Research Organisation (CSIRO) ABN 41 687 119 230. + Copyright (c) 2017, Commonwealth Scientific and Industrial Research Organisation (CSIRO) ABN 41 687 119 230. synopsis: A data-type representing digits 0-9 and other combinations category: Data homepage: https://github.com/qfpl/digit bug-reports: https://github.com/qfpl/digit/issues cabal-version: >= 1.10 -build-type: Custom +build-type: Simple extra-source-files: CONTRIBUTORS, changelog.md description: <> @@ -22,9 +22,6 @@ type: git location: git@github.com:qfpl/digit.git -flag small_base - description: Choose the new, split-up base package. - library default-language: Haskell2010 @@ -37,11 +34,12 @@ , template-haskell >= 2.8 && < 3 , papa >= 0.3 && < 0.4 , semigroupoids >= 5 && < 6 + , scientific >= 0.3 && < 0.4 ghc-options: -Wall - - default-extensions: + + default-extensions: NoImplicitPrelude hs-source-dirs: @@ -50,6 +48,7 @@ exposed-modules: Data.Digit Data.Digit.Binary + Data.Digit.Natural Data.Digit.Decimal Data.Digit.Octal Data.Digit.Hexadecimal @@ -99,26 +98,26 @@ Haskell2010 build-depends: - base >=4.9 && <4.10 + base >=4.9 && <4.12 , lens >=4.0 && <5 , ansi-wl-pprint >=0.6 && <0.7 , hedgehog >=0.5 && <0.6 - , tasty >=0.11 && <0.12 + , tasty >=0.11 && <1.1 , tasty-hspec >=1.1 && <1.2 , papa >=0.3 && <0.4 , parsec >=3.1 && <3.2 , parsers >=0.12.3 && <0.13 , pretty >=1.1 && <1.2 , text >=1.2 && <1.3 - , tasty-hedgehog >=0.1 && <0.2 - , tasty-hunit >=0.9 && <0.10 + , tasty-hedgehog >=0.1 && <0.3 + , tasty-hunit >=0.9 && <0.11 , digit ghc-options: -Wall -threaded - default-extensions: + default-extensions: NoImplicitPrelude hs-source-dirs: diff --git a/src/Data/Digit.hs b/src/Data/Digit.hs --- a/src/Data/Digit.hs +++ b/src/Data/Digit.hs @@ -6,6 +6,7 @@ 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 diff --git a/src/Data/Digit/Natural.hs b/src/Data/Digit/Natural.hs new file mode 100644 --- /dev/null +++ b/src/Data/Digit/Natural.hs @@ -0,0 +1,125 @@ +module Data.Digit.Natural + ( _NaturalDigits + , naturalToDigits + , digitsToNatural + ) where + +import Prelude (Int, error, fromIntegral, maxBound, (*), + (+), (-), (>), (^)) + +import Control.Category ((.)) +import Control.Lens (Prism', ifoldrM, prism', ( # )) + +import Data.Foldable (length) +import Data.Function (($)) +import Data.Functor (fmap, (<$>)) +import Data.Semigroup ((<>)) + +import Data.List (replicate) + +import Data.List.NonEmpty (NonEmpty ((:|))) +import qualified Data.List.NonEmpty as NE + +import Data.Maybe (Maybe (..)) + +import Data.Digit.Digit +import Data.Digit.Integral (integralDecimal) + +import Numeric.Natural (Natural) + +import Data.Scientific (toDecimalDigits) + +-- | +-- +-- >>> _NaturalDigits # 0 +-- 0 :| [] +-- +-- >>> _NaturalDigits # 1 +-- 1 :| [] +-- +-- >>> _NaturalDigits # 9223372036854775807 +-- 9 :| [2,2,3,3,7,2,0,3,6,8,5,4,7,7,5,8,0,7] +-- +-- >>> (9 :| [2,2,3,3,7,2,0,3,6,8,5,4,7,7,5,8,0,7]) ^? _NaturalDigits +-- Just 9223372036854775807 +-- +-- >>> (1 :| []) ^? _NaturalDigits +-- Just 1 +-- +-- prop> \x -> digitsToNatural ( naturalToDigits x ) == Just x +-- +_NaturalDigits :: Prism' (NonEmpty Digit) Natural +_NaturalDigits = prism' naturalToDigits digitsToNatural + +-- | NonEmpty Digits from a Natural number +-- +-- >>> naturalDigits 0 +-- 0 :| [] +-- +-- >>> naturalDigits 9 +-- 9 :| [] +-- +-- >>> naturalDigits 393564 +-- 3 :| [9,3,5,6,4] +-- +-- >>> naturalDigits 9223372036854775807 +-- 9 :| [2,2,3,3,7,2,0,3,6,8,5,4,7,7,5,8,0,7] +-- +naturalToDigits :: Natural -> NonEmpty Digit +naturalToDigits n = + case toDecimalDigits $ fromIntegral n of + -- toDecimalDigits :: n -> ([n],n) + -- toDecimalDigits 0 = ([0],0) + -- toDecimalDigits (-0) = ([0],0) + -- toDecimalDigits (-1) = ([-1],1) + ([], _ ) -> error "Data.Scientific.toDecimalDigits is no longer correct!" + (x:xs, eXP) -> g x :| (g <$> xs) <> t (x:xs) eXP + + where + t allDigs eXP = + replicate (eXP - length allDigs) Digit0 + + -- 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 _ = 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]) +-- Just 34 +-- +-- >>> naturalFromDigits (D.Digit3 :| [D.Digit9,D.Digit3,D.Digit5,D.Digit6,D.Digit4]) +-- Just 393564 +-- +-- >>> naturalFromDigits (D.x0 :| []) +-- 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]) +-- 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]) +-- Nothing +-- +digitsToNatural :: NonEmpty Digit -> Maybe Natural +digitsToNatural = fmap fromIntegral . ifoldrM f 0 . NE.reverse + where + f :: Int -> Digit -> Int -> Maybe Int + f i d curr = + let + next = (integralDecimal # d) * (10 ^ i) + in + if curr > maxBound - next + then Nothing + else Just (curr + next) diff --git a/test/Main.hs b/test/Main.hs --- a/test/Main.hs +++ b/test/Main.hs @@ -5,8 +5,10 @@ ) where import Data.Digit +import Numeric.Natural (Natural) +import Prelude (maxBound) import Papa hiding (re) -import Hedgehog(Gen, forAll, property, assert, (===)) +import Hedgehog(Property, Gen, forAll, property, assert, (===)) import Test.Tasty(TestTree, defaultMain, testGroup) import Test.Tasty.Hedgehog(testProperty) import Test.Tasty.HUnit(testCase, (@?=)) @@ -69,7 +71,7 @@ n' ((parse p (n' ++ "test") (c:"xyz") :: Either ParseError Digit) @?= Right d) ] - ) + ) integralPrism :: (Show n, Integral n) => @@ -79,7 +81,7 @@ -> [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 @@ -88,137 +90,156 @@ charPrism = testPrism (Gen.choice [Gen.hexit, Gen.unicode]) +genNatural :: Gen Natural +genNatural = fromIntegral <$> Gen.integral (Range.linear 0 (maxBound :: Int)) + +prop_natural_digits_roundtrip :: Property +prop_natural_digits_roundtrip = property $ do + n <- forAll genNatural + digitsToNatural (naturalToDigits n) === Just n + +digitNaturalTests :: TestTree +digitNaturalTests = testGroup "digit Natural tests" + [ testProperty "Natural <-> NonEmpty Digit" prop_natural_digits_roundtrip + ] + main :: IO () -main = - defaultMain $ - testGroup "digit 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) - in concat [ - charPrism "charBinaryNoZero" charBinaryNoZero [q1] - , charPrism "charBinary" charBinary [q0, q1] - , charPrism "charOctalNoZero" charOctalNoZero [q1, q2, q3, q4, q5, q6, q7] - , charPrism "charOctal" charOctal [q0, q1, q2, q3, q4, q5, q6, q7] - , charPrism "charDecimalNoZero" charDecimalNoZero [q1, q2, q3, q4, q5, q6, q7, q8, q9] - , charPrism "charDecimal" charDecimal [q0, q1, q2, q3, q4, q5, q6, q7, q8, q9] - , charPrism "charHexadecimalNoZero" charHexadecimalNoZero [q1, q2, q3, q4, q5, q6, q7, q8, q9, qa, qb, qc, qd, qe, qf] - , charPrism "charHexadecimal" charHexadecimal [q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, qa, qb, qc, qd, qe, qf] - , charPrism "charHEXADECIMALNoZero" charHEXADECIMALNoZero [q1, q2, q3, q4, q5, q6, q7, q8, q9, qA, qB, qC, qD, qE, qF] - , charPrism "charHEXADECIMAL" charHEXADECIMAL [q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, qA, qB, qC, qD, qE, qF] - , charPrism "charHeXaDeCiMaLNoZero" charHeXaDeCiMaLNoZero [q1, q2, q3, q4, q5, q6, q7, q8, q9, qa, qb, qc, qd, qe, qf, qA, qB, qC, qD, qE, qF] - , charPrism "charHeXaDeCiMaL" charHeXaDeCiMaL [q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, qa, qb, qc, qd, qe, qf, qA, qB, qC, qD, qE, qF] - , integralPrism "integralBinaryNoZero" integralBinaryNoZero [r1] - , integralPrism "integralBinary" integralBinary [r0, r1] - , integralPrism "integralOctalNoZero" integralOctalNoZero [r1, r2, r3, r4, r5, r6, r7] - , integralPrism "integralOctal" integralOctal [r0, r1, r2, r3, r4, r5, r6, r7] - , integralPrism "integralDecimalNoZero" integralDecimalNoZero [r1, r2, r3, r4, r5, r6, r7, r8, r9] - , integralPrism "integralDecimal" integralDecimal [r0, r1, r2, r3, r4, r5, r6, r7, r8, r9] - , integralPrism "integralHexadecimalNoZero" integralHexadecimalNoZero [r1, r2, r3, r4, r5, r6, r7, r8, r9, ra, rb, rc, rd, re, rf] - , integralPrism "integralHexadecimal" integralHexadecimal [r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, ra, rb, rc, rd, re, rf] - , integralPrism "integralHEXADECIMALNoZero" integralHEXADECIMALNoZero [r1, r2, r3, r4, r5, r6, r7, r8, r9, rA, rB, rC, rD, rE, rF] - , integralPrism "integralHEXADECIMAL" integralHEXADECIMAL [r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, rA, rB, rC, rD, rE, rF] , testParser "parseBinaryNoZero" parseBinaryNoZero [q1] - , testParser "parseBinary" parseBinary [q0, q1] - , testParser "parseOctalNoZero" parseOctalNoZero [q1, q2, q3, q4, q5, q6, q7] - , testParser "parseOctal" parseOctal [q0, q1, q2, q3, q4, q5, q6, q7] - , testParser "parseDecimalNoZero" parseDecimalNoZero [q1, q2, q3, q4, q5, q6, q7, q8, q9] - , testParser "parseDecimal" parseDecimal [q0, q1, q2, q3, q4, q5, q6, q7, q8, q9] - , testParser "parseHexadecimalNoZero" parseHexadecimalNoZero [q1, q2, q3, q4, q5, q6, q7, q8, q9, qa, qb, qc, qd, qe, qf] - , testParser "parseHexadecimal" parseHexadecimal [q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, qa, qb, qc, qd, qe, qf] - , testParser "parseHEXADECIMALNoZero" parseHEXADECIMALNoZero [q1, q2, q3, q4, q5, q6, q7, q8, q9, qA, qB, qC, qD, qE, qF] - , testParser "parseHEXADECIMALDecimal" parseHEXADECIMAL [q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, qA, qB, qC, qD, qE, qF] - , testParser "parseHeXaDeCiMaLNoZero" parseHeXaDeCiMaLNoZero [q1, q2, q3, q4, q5, q6, q7, q8, q9, qa, qb, qc, qd, qe, qf, qA, qB, qC, qD, qE, qF] - , testParser "parseHeXaDeCiMaLDecimal" parseHeXaDeCiMaL [q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, qa, qb, qc, qd, qe, qf, qA, qB, qC, qD, qE, qF] - , testParser "parse0" parse0 [q0] - , testParser "parse1" parse1 [q1] - , testParser "parse2" parse2 [q2] - , testParser "parse3" parse3 [q3] - , testParser "parse4" parse4 [q4] - , testParser "parse5" parse5 [q5] - , testParser "parse6" parse6 [q6] - , testParser "parse7" parse7 [q7] - , testParser "parse8" parse8 [q8] - , testParser "parse9" parse9 [q9] - , testParser "parsea" parsea [qa] - , testParser "parseb" parseb [qb] - , testParser "parsec" parsec [qc] - , testParser "parsed" parsed [qd] - , testParser "parsee" parsee [qe] - , testParser "parsef" parsef [qf] - , testParser "parseA" parseA [qA] - , testParser "parseB" parseB [qB] - , testParser "parseC" parseC [qC] - , testParser "parseD" parseD [qD] - , testParser "parseE" parseE [qE] - , testParser "parseF" parseF [qF] - , testParser "parseAa" parseAa [qA, qa] - , testParser "parseBb" parseBb [qB, qb] - , testParser "parseCc" parseCc [qC, qc] - , testParser "parseDd" parseDd [qD, qd] - , testParser "parseEe" parseEe [qE, qe] - , testParser "parseFf" parseFf [qF, qf] - ] +main = defaultMain $ + testGroup "All Digit Tests" + [ digitBaseTests + , digitNaturalTests + ] + +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) + in concat [ + charPrism "charBinaryNoZero" charBinaryNoZero [q1] + , charPrism "charBinary" charBinary [q0, q1] + , charPrism "charOctalNoZero" charOctalNoZero [q1, q2, q3, q4, q5, q6, q7] + , charPrism "charOctal" charOctal [q0, q1, q2, q3, q4, q5, q6, q7] + , charPrism "charDecimalNoZero" charDecimalNoZero [q1, q2, q3, q4, q5, q6, q7, q8, q9] + , charPrism "charDecimal" charDecimal [q0, q1, q2, q3, q4, q5, q6, q7, q8, q9] + , charPrism "charHexadecimalNoZero" charHexadecimalNoZero [q1, q2, q3, q4, q5, q6, q7, q8, q9, qa, qb, qc, qd, qe, qf] + , charPrism "charHexadecimal" charHexadecimal [q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, qa, qb, qc, qd, qe, qf] + , charPrism "charHEXADECIMALNoZero" charHEXADECIMALNoZero [q1, q2, q3, q4, q5, q6, q7, q8, q9, qA, qB, qC, qD, qE, qF] + , charPrism "charHEXADECIMAL" charHEXADECIMAL [q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, qA, qB, qC, qD, qE, qF] + , charPrism "charHeXaDeCiMaLNoZero" charHeXaDeCiMaLNoZero [q1, q2, q3, q4, q5, q6, q7, q8, q9, qa, qb, qc, qd, qe, qf, qA, qB, qC, qD, qE, qF] + , charPrism "charHeXaDeCiMaL" charHeXaDeCiMaL [q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, qa, qb, qc, qd, qe, qf, qA, qB, qC, qD, qE, qF] + , integralPrism "integralBinaryNoZero" integralBinaryNoZero [r1] + , integralPrism "integralBinary" integralBinary [r0, r1] + , integralPrism "integralOctalNoZero" integralOctalNoZero [r1, r2, r3, r4, r5, r6, r7] + , integralPrism "integralOctal" integralOctal [r0, r1, r2, r3, r4, r5, r6, r7] + , integralPrism "integralDecimalNoZero" integralDecimalNoZero [r1, r2, r3, r4, r5, r6, r7, r8, r9] + , integralPrism "integralDecimal" integralDecimal [r0, r1, r2, r3, r4, r5, r6, r7, r8, r9] + , integralPrism "integralHexadecimalNoZero" integralHexadecimalNoZero [r1, r2, r3, r4, r5, r6, r7, r8, r9, ra, rb, rc, rd, re, rf] + , integralPrism "integralHexadecimal" integralHexadecimal [r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, ra, rb, rc, rd, re, rf] + , integralPrism "integralHEXADECIMALNoZero" integralHEXADECIMALNoZero [r1, r2, r3, r4, r5, r6, r7, r8, r9, rA, rB, rC, rD, rE, rF] + , integralPrism "integralHEXADECIMAL" integralHEXADECIMAL [r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, rA, rB, rC, rD, rE, rF] , testParser "parseBinaryNoZero" parseBinaryNoZero [q1] + , testParser "parseBinary" parseBinary [q0, q1] + , testParser "parseOctalNoZero" parseOctalNoZero [q1, q2, q3, q4, q5, q6, q7] + , testParser "parseOctal" parseOctal [q0, q1, q2, q3, q4, q5, q6, q7] + , testParser "parseDecimalNoZero" parseDecimalNoZero [q1, q2, q3, q4, q5, q6, q7, q8, q9] + , testParser "parseDecimal" parseDecimal [q0, q1, q2, q3, q4, q5, q6, q7, q8, q9] + , testParser "parseHexadecimalNoZero" parseHexadecimalNoZero [q1, q2, q3, q4, q5, q6, q7, q8, q9, qa, qb, qc, qd, qe, qf] + , testParser "parseHexadecimal" parseHexadecimal [q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, qa, qb, qc, qd, qe, qf] + , testParser "parseHEXADECIMALNoZero" parseHEXADECIMALNoZero [q1, q2, q3, q4, q5, q6, q7, q8, q9, qA, qB, qC, qD, qE, qF] + , testParser "parseHEXADECIMALDecimal" parseHEXADECIMAL [q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, qA, qB, qC, qD, qE, qF] + , testParser "parseHeXaDeCiMaLNoZero" parseHeXaDeCiMaLNoZero [q1, q2, q3, q4, q5, q6, q7, q8, q9, qa, qb, qc, qd, qe, qf, qA, qB, qC, qD, qE, qF] + , testParser "parseHeXaDeCiMaLDecimal" parseHeXaDeCiMaL [q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, qa, qb, qc, qd, qe, qf, qA, qB, qC, qD, qE, qF] + , testParser "parse0" parse0 [q0] + , testParser "parse1" parse1 [q1] + , testParser "parse2" parse2 [q2] + , testParser "parse3" parse3 [q3] + , testParser "parse4" parse4 [q4] + , testParser "parse5" parse5 [q5] + , testParser "parse6" parse6 [q6] + , testParser "parse7" parse7 [q7] + , testParser "parse8" parse8 [q8] + , testParser "parse9" parse9 [q9] + , testParser "parsea" parsea [qa] + , testParser "parseb" parseb [qb] + , testParser "parsec" parsec [qc] + , testParser "parsed" parsed [qd] + , testParser "parsee" parsee [qe] + , testParser "parsef" parsef [qf] + , testParser "parseA" parseA [qA] + , testParser "parseB" parseB [qB] + , testParser "parseC" parseC [qC] + , testParser "parseD" parseD [qD] + , testParser "parseE" parseE [qE] + , testParser "parseF" parseF [qF] + , testParser "parseAa" parseAa [qA, qa] + , testParser "parseBb" parseBb [qB, qb] + , testParser "parseCc" parseCc [qC, qc] + , testParser "parseDd" parseDd [qD, qd] + , testParser "parseEe" parseEe [qE, qe] + , testParser "parseFf" parseFf [qF, qf] + ]