diff --git a/digit.cabal b/digit.cabal --- a/digit.cabal +++ b/digit.cabal @@ -1,5 +1,5 @@ name: digit -version: 0.6 +version: 0.7 license: BSD3 license-file: LICENCE author: Queensland Functional Programming Lab @@ -33,7 +33,6 @@ , parsers >= 0.12.3 && < 0.13 , semigroups >= 0.12 && < 1.0 , template-haskell >= 2.8 && < 3 - , papa >= 0.3.1 && < 0.4 , semigroupoids >= 5 && < 6 , scientific >= 0.3 && < 0.4 @@ -52,37 +51,26 @@ Data.Digit.Natural Data.Digit.Decimal Data.Digit.Octal - Data.Digit.Hexadecimal - Data.Digit.HeXaDeCiMaL - Data.Digit.HEXADECIMAL - Data.Digit.D0 - Data.Digit.D1 - Data.Digit.D2 - Data.Digit.D3 - Data.Digit.D4 - Data.Digit.D5 - Data.Digit.D6 - Data.Digit.D7 - Data.Digit.D8 - Data.Digit.D9 - Data.Digit.Da - Data.Digit.DA - Data.Digit.Db - Data.Digit.DB - Data.Digit.Dc - Data.Digit.DC - Data.Digit.Dd - Data.Digit.DD - Data.Digit.De - Data.Digit.DE - Data.Digit.Df - Data.Digit.DF - Data.Digit.DAa - Data.Digit.DBb - Data.Digit.DCc - Data.Digit.DDd - Data.Digit.DEe - Data.Digit.DFf + + Data.Digit.Hexadecimal.LowerCase + Data.Digit.Hexadecimal.UpperCase + Data.Digit.Hexadecimal.MixedCase + + Data.Digit.Class.D0 + Data.Digit.Class.D1 + Data.Digit.Class.D2 + Data.Digit.Class.D3 + Data.Digit.Class.D4 + Data.Digit.Class.D5 + Data.Digit.Class.D6 + Data.Digit.Class.D7 + Data.Digit.Class.D8 + Data.Digit.Class.D9 + + Data.Digit.Class.LowerCase + Data.Digit.Class.MixedCase + Data.Digit.Class.UpperCase + Data.Digit.Char Data.Digit.Enum Data.Digit.Integral @@ -105,13 +93,13 @@ , hedgehog >=0.5 && <0.7 , tasty >=0.11 && <1.2 , tasty-hspec >=1.1 && <1.2 - , papa >= 0.3.1 && < 0.4 , parsec >=3.1 && <3.2 , parsers >=0.12.3 && <0.13 , pretty >=1.1 && <1.2 , text >=1.2 && <1.3 , tasty-hedgehog >=0.1 && <0.3 , tasty-hunit >=0.9 && <0.11 + , semigroups >= 0.12 && < 1.0 , digit ghc-options: diff --git a/src/Data/Digit.hs b/src/Data/Digit.hs --- a/src/Data/Digit.hs +++ b/src/Data/Digit.hs @@ -4,9 +4,9 @@ module Data.Digit.Binary , module Data.Digit.Decimal , module Data.Digit.Octal -, module Data.Digit.Hexadecimal -, module Data.Digit.HeXaDeCiMaL -, module Data.Digit.HEXADECIMAL +, module Data.Digit.Hexadecimal.LowerCase +, module Data.Digit.Hexadecimal.UpperCase +, module Data.Digit.Hexadecimal.MixedCase -- * Utilities , module Data.Digit.Char , module Data.Digit.Enum @@ -17,9 +17,9 @@ import Data.Digit.Binary import Data.Digit.Decimal import Data.Digit.Octal -import Data.Digit.Hexadecimal -import Data.Digit.HeXaDeCiMaL -import Data.Digit.HEXADECIMAL +import Data.Digit.Hexadecimal.LowerCase +import Data.Digit.Hexadecimal.UpperCase +import Data.Digit.Hexadecimal.MixedCase import Data.Digit.Char import Data.Digit.Enum import Data.Digit.Integral diff --git a/src/Data/Digit/Binary.hs b/src/Data/Digit/Binary.hs --- a/src/Data/Digit/Binary.hs +++ b/src/Data/Digit/Binary.hs @@ -12,16 +12,17 @@ , _BinDigit0 , _BinDigit1 -- * Re-exports -, module Data.Digit.D0 -, module Data.Digit.D1 +, module Data.Digit.Class.D0 +, module Data.Digit.Class.D1 ) where import Prelude (Eq, Show, Ord) import Control.Lens.TH (makePrisms) import Text.Parser.Char(CharParsing) import Text.Parser.Combinators((), choice) -import Data.Digit.D0 -import Data.Digit.D1 + +import Data.Digit.Class.D0 +import Data.Digit.Class.D1 data BinDigit = BinDigit0 diff --git a/src/Data/Digit/Char.hs b/src/Data/Digit/Char.hs --- a/src/Data/Digit/Char.hs +++ b/src/Data/Digit/Char.hs @@ -21,16 +21,24 @@ , charHeXaDeCiMaL ) where -import Control.Lens.Extras(is) -import Data.Digit.Binary as D -import Data.Digit.Decimal as D -import Data.Digit.Octal as D -import Data.Digit.Hexadecimal as D -import Data.Digit.HeXaDeCiMaL as D -import Data.Digit.HEXADECIMAL as D -import Papa +import Prelude (Char, Eq, fst, lookup) +import Control.Applicative (Applicative) +import Control.Lens (APrism, Choice, Prism', clonePrism, + prism', ( # )) +import Control.Lens.Extras (is) +import Data.Foldable (find) +import Data.Functor ((<$>)) +import Data.Maybe (fromMaybe) + +import Data.Digit.Binary as D +import Data.Digit.Decimal as D +import Data.Digit.Hexadecimal.LowerCase as D +import Data.Digit.Hexadecimal.UpperCase as D +import Data.Digit.Hexadecimal.MixedCase as D +import Data.Digit.Octal as D + -- $setup -- >>> import Data.Digit @@ -48,7 +56,7 @@ d charBinaryNoZero = associatePrism ('1', d1) [] - + -- | -- -- >>> '0' ^? charBinary :: Maybe BinDigit @@ -63,7 +71,7 @@ d charBinary = associatePrism ('0', d0) [('1', d1)] - + -- | -- -- >>> '6' ^? charOctalNoZero :: Maybe OctDigit @@ -78,7 +86,7 @@ d charOctalNoZero = associatePrism ('1', d1) [('2', d2), ('3', d3), ('4', d4), ('5', d5), ('6', d6), ('7', d7)] - + -- | -- >>> '7' ^? charOctal :: Maybe OctDigit -- Just OctDigit7 @@ -92,7 +100,7 @@ d charOctal = associatePrism ('0', d0) [('1', d1), ('2', d2), ('3', d3), ('4', d4), ('5', d5), ('6', d6), ('7', d7)] - + -- | -- >>> '9' ^? charDecimalNoZero :: Maybe DecDigit -- Just DecDigit9 @@ -106,7 +114,7 @@ d charDecimalNoZero = associatePrism ('1', d1) [('2', d2), ('3', d3), ('4', d4), ('5', d5), ('6', d6), ('7', d7), ('8', d8), ('9', d9)] - + -- | -- >>> '9' ^? charDecimal :: Maybe DecDigit -- Just DecDigit9 @@ -120,7 +128,7 @@ d charDecimal = associatePrism ('0', d0) [('1', d1), ('2', d2), ('3', d3), ('4', d4), ('5', d5), ('6', d6), ('7', d7), ('8', d8), ('9', d9)] - + -- | -- >>> 'f' ^? charHexadecimalNoZero :: Maybe HexDigit -- Just HexDigitf @@ -134,7 +142,7 @@ d charHexadecimalNoZero = associatePrism ('1', d1) [('2', d2), ('3', d3), ('4', d4), ('5', d5), ('6', d6), ('7', d7), ('8', d8), ('9', d9), ('a', da), ('b', db), ('c', dc), ('d', dd), ('e', de), ('f', df)] - + -- | -- >>> 'f' ^? charHexadecimal :: Maybe HexDigit -- Just HexDigitf @@ -148,7 +156,7 @@ d charHexadecimal = associatePrism ('0', d0) [('1', d1), ('2', d2), ('3', d3), ('4', d4), ('5', d5), ('6', d6), ('7', d7), ('8', d8), ('9', d9), ('a', da), ('b', db), ('c', dc), ('d', dd), ('e', de), ('f', df)] - + -- | -- >>> 'F' ^? charHEXADECIMALNoZero :: Maybe HEXDigit -- Just HEXDigitF @@ -162,7 +170,7 @@ d charHEXADECIMALNoZero = associatePrism ('1', d1) [('2', d2), ('3', d3), ('4', d4), ('5', d5), ('6', d6), ('7', d7), ('8', d8), ('9', d9), ('A', dA), ('B', dB), ('C', dC), ('D', dD), ('E', dE), ('F', dF)] - + -- | -- >>> 'F' ^? charHEXADECIMAL :: Maybe HEXDigit -- Just HEXDigitF @@ -176,7 +184,7 @@ d charHEXADECIMAL = associatePrism ('0', d0) [('1', d1), ('2', d2), ('3', d3), ('4', d4), ('5', d5), ('6', d6), ('7', d7), ('8', d8), ('9', d9), ('A', dA), ('B', dB), ('C', dC), ('D', dD), ('E', dE), ('F', dF)] - + -- | -- >>> 'f' ^? charHeXaDeCiMaLNoZero :: Maybe HeXDigit -- Just HeXDigitf @@ -196,7 +204,7 @@ d charHeXaDeCiMaLNoZero = associatePrism ('1', d1) [('2', d2), ('3', d3), ('4', d4), ('5', d5), ('6', d6), ('7', d7), ('8', d8), ('9', d9), ('a', da), ('b', db), ('c', dc), ('d', dd), ('e', de), ('f', df), ('A', dA), ('B', dB), ('C', dC), ('D', dD), ('E', dE), ('F', dF)] - + -- | -- >>> 'f' ^? charHeXaDeCiMaL :: Maybe HeXDigit diff --git a/src/Data/Digit/Class/D0.hs b/src/Data/Digit/Class/D0.hs new file mode 100644 --- /dev/null +++ b/src/Data/Digit/Class/D0.hs @@ -0,0 +1,50 @@ +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE FlexibleInstances #-} + +module Data.Digit.Class.D0( + D0(..) +, parse0 +) where + +import Control.Category (id) +import Control.Lens (Prism', (#)) + +import Data.Functor ((<$)) + +import Text.Parser.Char(CharParsing, char) +import Text.Parser.Combinators(()) + +-- $setup +-- >>> import Data.Digit.Class +-- >>> import Text.Parsec(parse, ParseError, eof) +-- >>> import Data.Void(Void) + +class D0 d where + d0 :: + Prism' + d + () + x0 :: + d + x0 = + d0 # () + +instance D0 () where + d0 = + id + +-- | +-- +-- >>> parse (parse0 <* eof) "test" "0" :: Either ParseError BinDigit +-- Right BinDigit0 +-- +-- >>> parse parse0 "test" "0xyz" :: Either ParseError BinDigit +-- Right BinDigit0 +-- +-- >>> isn't _Right (parse parse0 "test" "xyz" :: Either ParseError BinDigit) +-- True +parse0 :: + (D0 d, CharParsing p) => + p d +parse0 = + x0 <$ char '0' "0" diff --git a/src/Data/Digit/Class/D1.hs b/src/Data/Digit/Class/D1.hs new file mode 100644 --- /dev/null +++ b/src/Data/Digit/Class/D1.hs @@ -0,0 +1,49 @@ +{-# LANGUAGE NoImplicitPrelude #-} + +module Data.Digit.Class.D1( + D1(..) +, parse1 +) where + +import Control.Category (id) +import Control.Lens (Prism', (#)) + +import Data.Functor ((<$)) + +import Text.Parser.Char(CharParsing, char) +import Text.Parser.Combinators(()) + +-- $setup +-- >>> import Data.Digit.Class +-- >>> import Text.Parsec(parse, ParseError, eof) +-- >>> import Data.Void(Void) + +class D1 d where + d1 :: + Prism' + d + () + x1 :: + d + x1 = + d1 # () + +instance D1 () where + d1 = + id + +-- | +-- +-- >>> parse (parse1 <* eof) "test" "1" :: Either ParseError BinDigit +-- Right BinDigit1 +-- +-- >>> parse parse1 "test" "1xyz" :: Either ParseError BinDigit +-- Right BinDigit1 +-- +-- >>> isn't _Right (parse parse1 "test" "xyz" :: Either ParseError BinDigit) +-- True +parse1 :: + (D1 d, CharParsing p) => + p d +parse1 = + x1 <$ char '1' "1" diff --git a/src/Data/Digit/Class/D2.hs b/src/Data/Digit/Class/D2.hs new file mode 100644 --- /dev/null +++ b/src/Data/Digit/Class/D2.hs @@ -0,0 +1,49 @@ +{-# LANGUAGE NoImplicitPrelude #-} + +module Data.Digit.Class.D2( + D2(..) +, parse2 +) where + +import Control.Category (id) +import Control.Lens (Prism', (#)) + +import Data.Functor ((<$)) + +import Text.Parser.Char(CharParsing, char) +import Text.Parser.Combinators(()) + +-- $setup +-- >>> import Data.Digit.Class +-- >>> import Text.Parsec(parse, ParseError, eof) +-- >>> import Data.Void(Void) + +class D2 d where + d2 :: + Prism' + d + () + x2 :: + d + x2 = + d2 # () + +instance D2 () where + d2 = + id + +-- | +-- +-- >>> parse (parse2 <* eof) "test" "2" :: Either ParseError DecDigit +-- Right DecDigit2 +-- +-- >>> parse parse2 "test" "2xyz" :: Either ParseError DecDigit +-- Right DecDigit2 +-- +-- >>> isn't _Right (parse parse2 "test" "xyz" :: Either ParseError DecDigit) +-- True +parse2 :: + (D2 d, CharParsing p) => + p d +parse2 = + x2 <$ char '2' "2" diff --git a/src/Data/Digit/Class/D3.hs b/src/Data/Digit/Class/D3.hs new file mode 100644 --- /dev/null +++ b/src/Data/Digit/Class/D3.hs @@ -0,0 +1,49 @@ +{-# LANGUAGE NoImplicitPrelude #-} + +module Data.Digit.Class.D3( + D3(..) +, parse3 +) where + +import Control.Category (id) +import Control.Lens (Prism', (#)) + +import Data.Functor ((<$)) + +import Text.Parser.Char(CharParsing, char) +import Text.Parser.Combinators(()) + +-- $setup +-- >>> import Data.Digit.Class +-- >>> import Text.Parsec(parse, ParseError, eof) +-- >>> import Data.Void(Void) + +class D3 d where + d3 :: + Prism' + d + () + x3 :: + d + x3 = + d3 # () + +instance D3 () where + d3 = + id + +-- | +-- +-- >>> parse (parse3 <* eof) "test" "3" :: Either ParseError DecDigit +-- Right DecDigit3 +-- +-- >>> parse parse3 "test" "3xyz" :: Either ParseError DecDigit +-- Right DecDigit3 +-- +-- >>> isn't _Right (parse parse3 "test" "xyz" :: Either ParseError DecDigit) +-- True +parse3 :: + (D3 d, CharParsing p) => + p d +parse3 = + x3 <$ char '3' "3" diff --git a/src/Data/Digit/Class/D4.hs b/src/Data/Digit/Class/D4.hs new file mode 100644 --- /dev/null +++ b/src/Data/Digit/Class/D4.hs @@ -0,0 +1,49 @@ +{-# LANGUAGE NoImplicitPrelude #-} + +module Data.Digit.Class.D4( + D4(..) +, parse4 +) where + +import Control.Category (id) +import Control.Lens (Prism', (#)) + +import Data.Functor ((<$)) + +import Text.Parser.Char(CharParsing, char) +import Text.Parser.Combinators(()) + +-- $setup +-- >>> import Data.Digit.Class +-- >>> import Text.Parsec(parse, ParseError, eof) +-- >>> import Data.Void(Void) + +class D4 d where + d4 :: + Prism' + d + () + x4 :: + d + x4 = + d4 # () + +instance D4 () where + d4 = + id + +-- | +-- +-- >>> parse (parse4 <* eof) "test" "4" :: Either ParseError DecDigit +-- Right DecDigit4 +-- +-- >>> parse parse4 "test" "4xyz" :: Either ParseError DecDigit +-- Right DecDigit4 +-- +-- >>> isn't _Right (parse parse4 "test" "xyz" :: Either ParseError DecDigit) +-- True +parse4 :: + (D4 d, CharParsing p) => + p d +parse4 = + x4 <$ char '4' "4" diff --git a/src/Data/Digit/Class/D5.hs b/src/Data/Digit/Class/D5.hs new file mode 100644 --- /dev/null +++ b/src/Data/Digit/Class/D5.hs @@ -0,0 +1,49 @@ +{-# LANGUAGE NoImplicitPrelude #-} + +module Data.Digit.Class.D5( + D5(..) +, parse5 +) where + +import Control.Category (id) +import Control.Lens (Prism', (#)) + +import Data.Functor ((<$)) + +import Text.Parser.Char(CharParsing, char) +import Text.Parser.Combinators(()) + +-- $setup +-- >>> import Data.Digit.Class +-- >>> import Text.Parsec(parse, ParseError, eof) +-- >>> import Data.Void(Void) + +class D5 d where + d5 :: + Prism' + d + () + x5 :: + d + x5 = + d5 # () + +instance D5 () where + d5 = + id + +-- | +-- +-- >>> parse (parse5 <* eof) "test" "5" :: Either ParseError DecDigit +-- Right DecDigit5 +-- +-- >>> parse parse5 "test" "5xyz" :: Either ParseError DecDigit +-- Right DecDigit5 +-- +-- >>> isn't _Right (parse parse5 "test" "xyz" :: Either ParseError DecDigit) +-- True +parse5 :: + (D5 d, CharParsing p) => + p d +parse5 = + x5 <$ char '5' "5" diff --git a/src/Data/Digit/Class/D6.hs b/src/Data/Digit/Class/D6.hs new file mode 100644 --- /dev/null +++ b/src/Data/Digit/Class/D6.hs @@ -0,0 +1,50 @@ +{-# LANGUAGE NoImplicitPrelude #-} + +module Data.Digit.Class.D6( + D6(..) +, parse6 +) where + + +import Control.Category (id) +import Control.Lens (Prism', (#)) + +import Data.Functor ((<$)) + +import Text.Parser.Char(CharParsing, char) +import Text.Parser.Combinators(()) + +-- $setup +-- >>> import Data.Digit.Class +-- >>> import Text.Parsec(parse, ParseError, eof) +-- >>> import Data.Void(Void) + +class D6 d where + d6 :: + Prism' + d + () + x6 :: + d + x6 = + d6 # () + +instance D6 () where + d6 = + id + +-- | +-- +-- >>> parse (parse6 <* eof) "test" "6" :: Either ParseError DecDigit +-- Right DecDigit6 +-- +-- >>> parse parse6 "test" "6xyz" :: Either ParseError DecDigit +-- Right DecDigit6 +-- +-- >>> isn't _Right (parse parse6 "test" "xyz" :: Either ParseError DecDigit) +-- True +parse6 :: + (D6 d, CharParsing p) => + p d +parse6 = + x6 <$ char '6' "6" diff --git a/src/Data/Digit/Class/D7.hs b/src/Data/Digit/Class/D7.hs new file mode 100644 --- /dev/null +++ b/src/Data/Digit/Class/D7.hs @@ -0,0 +1,49 @@ +{-# LANGUAGE NoImplicitPrelude #-} + +module Data.Digit.Class.D7( + D7(..) +, parse7 +) where + +import Control.Category (id) +import Control.Lens (Prism', (#)) + +import Data.Functor ((<$)) + +import Text.Parser.Char(CharParsing, char) +import Text.Parser.Combinators(()) + +-- $setup +-- >>> import Data.Digit.Class +-- >>> import Text.Parsec(parse, ParseError, eof) +-- >>> import Data.Void(Void) + +class D7 d where + d7 :: + Prism' + d + () + x7 :: + d + x7 = + d7 # () + +instance D7 () where + d7 = + id + +-- | +-- +-- >>> parse (parse7 <* eof) "test" "7" :: Either ParseError DecDigit +-- Right DecDigit7 +-- +-- >>> parse parse7 "test" "7xyz" :: Either ParseError DecDigit +-- Right DecDigit7 +-- +-- >>> isn't _Right (parse parse7 "test" "xyz" :: Either ParseError DecDigit) +-- True +parse7 :: + (D7 d, CharParsing p) => + p d +parse7 = + x7 <$ char '7' "7" diff --git a/src/Data/Digit/Class/D8.hs b/src/Data/Digit/Class/D8.hs new file mode 100644 --- /dev/null +++ b/src/Data/Digit/Class/D8.hs @@ -0,0 +1,49 @@ +{-# LANGUAGE NoImplicitPrelude #-} + +module Data.Digit.Class.D8( + D8(..) +, parse8 +) where + +import Control.Category (id) +import Control.Lens (Prism', (#)) + +import Data.Functor ((<$)) + +import Text.Parser.Char(CharParsing, char) +import Text.Parser.Combinators(()) + +-- $setup +-- >>> import Data.Digit.Class +-- >>> import Text.Parsec(parse, ParseError, eof) +-- >>> import Data.Void(Void) + +class D8 d where + d8 :: + Prism' + d + () + x8 :: + d + x8 = + d8 # () + +instance D8 () where + d8 = + id + +-- | +-- +-- >>> parse (parse8 <* eof) "test" "8" :: Either ParseError DecDigit +-- Right DecDigit8 +-- +-- >>> parse parse8 "test" "8xyz" :: Either ParseError DecDigit +-- Right DecDigit8 +-- +-- >>> isn't _Right (parse parse8 "test" "xyz" :: Either ParseError DecDigit) +-- True +parse8 :: + (D8 d, CharParsing p) => + p d +parse8 = + x8 <$ char '8' "8" diff --git a/src/Data/Digit/Class/D9.hs b/src/Data/Digit/Class/D9.hs new file mode 100644 --- /dev/null +++ b/src/Data/Digit/Class/D9.hs @@ -0,0 +1,49 @@ +{-# LANGUAGE NoImplicitPrelude #-} + +module Data.Digit.Class.D9( + D9(..) +, parse9 +) where + +import Control.Category (id) +import Control.Lens (Prism', (#)) + +import Data.Functor ((<$)) + +import Text.Parser.Char(CharParsing, char) +import Text.Parser.Combinators(()) + +-- $setup +-- >>> import Data.Digit.Class +-- >>> import Text.Parsec(parse, ParseError, eof) +-- >>> import Data.Void(Void) + +class D9 d where + d9 :: + Prism' + d + () + x9 :: + d + x9 = + d9 # () + +instance D9 () where + d9 = + id + +-- | +-- +-- >>> parse (parse9 <* eof) "test" "9" :: Either ParseError DecDigit +-- Right DecDigit9 +-- +-- >>> parse parse9 "test" "9xyz" :: Either ParseError DecDigit +-- Right DecDigit9 +-- +-- >>> isn't _Right (parse parse9 "test" "xyz" :: Either ParseError DecDigit) +-- True +parse9 :: + (D9 d, CharParsing p) => + p d +parse9 = + x9 <$ char '9' "9" diff --git a/src/Data/Digit/Class/LowerCase.hs b/src/Data/Digit/Class/LowerCase.hs new file mode 100644 --- /dev/null +++ b/src/Data/Digit/Class/LowerCase.hs @@ -0,0 +1,214 @@ +{-# LANGUAGE NoImplicitPrelude #-} + +module Data.Digit.Class.LowerCase ( + + -- * Classes + Da(..) + , Db(..) + , Dc(..) + , Dd(..) + , De(..) + , Df(..) + + -- * Parsers + , parsea + , parseb + , parsec + , parsed + , parsee + , parsef + +) where + +import Control.Category (id) +import Control.Lens (Prism', ( # )) + +import Data.Functor ((<$)) + +import Text.Parser.Char (CharParsing, char) +import Text.Parser.Combinators (()) + +-- $setup +-- >>> import Data.Digit +-- >>> import Text.Parsec(parse, ParseError, eof) +-- >>> import Data.Void(Void) + +class Da d where + da :: + Prism' + d + () + xa :: + d + xa = + da # () + +instance Da () where + da = + id + +class Db d where + db :: + Prism' + d + () + xb :: + d + xb = + db # () + +instance Db () where + db = + id + +class Dc d where + dc :: + Prism' + d + () + xc :: + d + xc = + dc # () + +instance Dc () where + dc = + id + +class Dd d where + dd :: + Prism' + d + () + xd :: + d + xd = + dd # () + +instance Dd () where + dd = + id + +class De d where + de :: + Prism' + d + () + xe :: + d + xe = + de # () + +instance De () where + de = + id + +class Df d where + df :: + Prism' + d + () + xf :: + d + xf = + df # () + +instance Df () where + df = + id + +-- | +-- +-- >>> parse (parsea <* eof) "test" "a" :: Either ParseError HexDigit +-- Right HexDigita +-- +-- >>> parse parsea "test" "axyz" :: Either ParseError HexDigit +-- Right HexDigita +-- +-- >>> isn't _Right (parse parsea "test" "xyz" :: Either ParseError HexDigit) +-- True +parsea :: + (Da d, CharParsing p) => + p d +parsea = + xa <$ char 'a' "a" + +-- | +-- +-- >>> parse (parseb <* eof) "test" "b" :: Either ParseError HexDigit +-- Right HexDigitb +-- +-- >>> parse parseb "test" "bxyz" :: Either ParseError HexDigit +-- Right HexDigitb +-- +-- >>> isn't _Right (parse parseb "test" "xyz" :: Either ParseError HexDigit) +-- True +parseb :: + (Db d, CharParsing p) => + p d +parseb = + xb <$ char 'b' "b" + +-- | +-- +-- >>> parse (parsec <* eof) "test" "c" :: Either ParseError HexDigit +-- Right HexDigitc +-- +-- >>> parse parsec "test" "cxyz" :: Either ParseError HexDigit +-- Right HexDigitc +-- +-- >>> isn't _Right (parse parsec "test" "xyz" :: Either ParseError HexDigit) +-- True +parsec :: + (Dc d, CharParsing p) => + p d +parsec = + xc <$ char 'c' "c" + +-- | +-- +-- >>> parse (parsed <* eof) "test" "d" :: Either ParseError HexDigit +-- Right HexDigitd +-- +-- >>> parse parsed "test" "dxyz" :: Either ParseError HexDigit +-- Right HexDigitd +-- +-- >>> isn't _Right (parse parsed "test" "xyz" :: Either ParseError HexDigit) +-- True +parsed :: + (Dd d, CharParsing p) => + p d +parsed = + xd <$ char 'd' "d" + +-- | +-- +-- >>> parse (parsee <* eof) "test" "e" :: Either ParseError HexDigit +-- Right HexDigite +-- +-- >>> parse parsee "test" "exyz" :: Either ParseError HexDigit +-- Right HexDigite +-- +-- >>> isn't _Right (parse parsee "test" "xyz" :: Either ParseError HexDigit) +-- True +parsee :: + (De d, CharParsing p) => + p d +parsee = + xe <$ char 'e' "e" + +-- | +-- +-- >>> parse (parsef <* eof) "test" "f" :: Either ParseError HexDigit +-- Right HexDigitf +-- +-- >>> parse parsef "test" "fxyz" :: Either ParseError HexDigit +-- Right HexDigitf +-- +-- >>> isn't _Right (parse parsef "test" "xyz" :: Either ParseError HexDigit) +-- True +parsef :: + (Df d, CharParsing p) => + p d +parsef = + xf <$ char 'f' "f" diff --git a/src/Data/Digit/Class/MixedCase.hs b/src/Data/Digit/Class/MixedCase.hs new file mode 100644 --- /dev/null +++ b/src/Data/Digit/Class/MixedCase.hs @@ -0,0 +1,192 @@ +{-# LANGUAGE ConstraintKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE TypeFamilies #-} + +module Data.Digit.Class.MixedCase + ( + -- * Types + DAa + , DBb + , DCc + , DDd + , DEe + , DFf + + -- * Parsers + , parseAa + , parseBb + , parseCc + , parseDd + , parseEe + , parseFf + + -- * Re-exports + , module Data.Digit.Class.UpperCase + , module Data.Digit.Class.LowerCase + + ) where + +import Text.Parser.Char (CharParsing) +import Text.Parser.Combinators (choice, ()) + +import Data.Digit.Class.LowerCase +import Data.Digit.Class.UpperCase + +-- $setup +-- >>> import Text.Parsec(parse, ParseError, eof) +-- >>> import Data.Void(Void) +-- >>> import Data.Digit +-- >>> import Papa + +type DAa a = + (DA a, Da a) + +type DBb a = + (DB a, Db a) + +type DCc a = + (DC a, Dc a) + +type DDd a = + (DD a, Dd a) + +type DEe a = + (DE a, De a) + +type DFf a = + (DF a, Df a) + +-- | +-- +-- >>> parse (parseAa <* eof) "test" "A" :: Either ParseError HeXDigit +-- Right HeXDigitA +-- +-- >>> parse parseAa "test" "Axyz" :: Either ParseError HeXDigit +-- Right HeXDigitA +-- +-- >>> parse (parseAa <* eof) "test" "a" :: Either ParseError HeXDigit +-- Right HeXDigita +-- +-- >>> parse parseAa "test" "axyz" :: Either ParseError HeXDigit +-- Right HeXDigita +-- +-- >>> isn't _Right (parse parseAa "test" "xyz" :: Either ParseError HeXDigit) +-- True +parseAa :: + (DAa d, CharParsing p) => + p d +parseAa = + choice [parseA, parsea] "Aa" + +-- | +-- +-- >>> parse (parseBb <* eof) "test" "B" :: Either ParseError HeXDigit +-- Right HeXDigitB +-- +-- >>> parse parseBb "test" "Bxyz" :: Either ParseError HeXDigit +-- Right HeXDigitB +-- +-- >>> parse (parseBb <* eof) "test" "b" :: Either ParseError HeXDigit +-- Right HeXDigitb +-- +-- >>> parse parseBb "test" "bxyz" :: Either ParseError HeXDigit +-- Right HeXDigitb +-- +-- >>> isn't _Right (parse parseBb "test" "xyz" :: Either ParseError HeXDigit) +-- True +parseBb :: + (DBb d, CharParsing p) => + p d +parseBb = + choice [parseB, parseb] "Bb" + +-- | +-- +-- >>> parse (parseCc <* eof) "test" "C" :: Either ParseError HeXDigit +-- Right HeXDigitC +-- +-- >>> parse parseCc "test" "Cxyz" :: Either ParseError HeXDigit +-- Right HeXDigitC +-- +-- >>> parse (parseCc <* eof) "test" "c" :: Either ParseError HeXDigit +-- Right HeXDigitc +-- +-- >>> parse parseCc "test" "cxyz" :: Either ParseError HeXDigit +-- Right HeXDigitc +-- +-- >>> isn't _Right (parse parseCc "test" "xyz" :: Either ParseError HeXDigit) +-- True +parseCc :: + (DCc d, CharParsing p) => + p d +parseCc = + choice [parseC, parsec] "Cc" + + +-- | +-- +-- >>> parse (parseDd <* eof) "test" "D" :: Either ParseError HeXDigit +-- Right HeXDigitD +-- +-- >>> parse parseDd "test" "Dxyz" :: Either ParseError HeXDigit +-- Right HeXDigitD +-- +-- >>> parse (parseDd <* eof) "test" "d" :: Either ParseError HeXDigit +-- Right HeXDigitd +-- +-- >>> parse parseDd "test" "dxyz" :: Either ParseError HeXDigit +-- Right HeXDigitd +-- +-- >>> isn't _Right (parse parseDd "test" "xyz" :: Either ParseError HeXDigit) +-- True +parseDd :: + (DDd d, CharParsing p) => + p d +parseDd = + choice [parseD, parsed] "Dd" + +-- | +-- +-- >>> parse (parseEe <* eof) "test" "E" :: Either ParseError HeXDigit +-- Right HeXDigitE +-- +-- >>> parse parseEe "test" "Exyz" :: Either ParseError HeXDigit +-- Right HeXDigitE +-- +-- >>> parse (parseEe <* eof) "test" "e" :: Either ParseError HeXDigit +-- Right HeXDigite +-- +-- >>> parse parseEe "test" "exyz" :: Either ParseError HeXDigit +-- Right HeXDigite +-- +-- >>> isn't _Right (parse parseEe "test" "xyz" :: Either ParseError HeXDigit) +-- True +parseEe :: + (DEe d, CharParsing p) => + p d +parseEe = + choice [parseE, parsee] "Ee" + +-- | +-- +-- >>> parse (parseFf <* eof) "test" "F" :: Either ParseError HeXDigit +-- Right HeXDigitF +-- +-- >>> parse parseFf "test" "Fxyz" :: Either ParseError HeXDigit +-- Right HeXDigitF +-- +-- >>> parse (parseFf <* eof) "test" "f" :: Either ParseError HeXDigit +-- Right HeXDigitf +-- +-- >>> parse parseFf "test" "fxyz" :: Either ParseError HeXDigit +-- Right HeXDigitf +-- +-- >>> isn't _Right (parse parseFf "test" "xyz" :: Either ParseError HeXDigit) +-- True +parseFf :: + (DFf d, CharParsing p) => + p d +parseFf = + choice [parseF, parsef] "Ff" diff --git a/src/Data/Digit/Class/UpperCase.hs b/src/Data/Digit/Class/UpperCase.hs new file mode 100644 --- /dev/null +++ b/src/Data/Digit/Class/UpperCase.hs @@ -0,0 +1,213 @@ +{-# LANGUAGE NoImplicitPrelude #-} + +module Data.Digit.Class.UpperCase + ( + -- * Classes + DA(..) + , DB(..) + , DC(..) + , DD(..) + , DE(..) + , DF(..) + + -- * Parsers + , parseA + , parseB + , parseC + , parseD + , parseE + , parseF + ) where + +import Control.Category (id) +import Control.Lens (Prism', ( # )) + +import Data.Functor ((<$)) + +import Text.Parser.Char (CharParsing, char) +import Text.Parser.Combinators (()) + +-- $setup +-- >>> import Data.Digit +-- >>> import Text.Parsec(parse, ParseError, eof) +-- >>> import Data.Void(Void) + +class DA d where + dA :: + Prism' + d + () + xA :: + d + xA = + dA # () + +instance DA () where + dA = + id + +class DB d where + dB :: + Prism' + d + () + xB :: + d + xB = + dB # () + +instance DB () where + dB = + id + +class DC d where + dC :: + Prism' + d + () + xC :: + d + xC = + dC # () + +instance DC () where + dC = + id + +class DD d where + dD :: + Prism' + d + () + xD :: + d + xD = + dD # () + +instance DD () where + dD = + id + +class DE d where + dE :: + Prism' + d + () + xE :: + d + xE = + dE # () + +instance DE () where + dE = + id + +class DF d where + dF :: + Prism' + d + () + xF :: + d + xF = + dF # () + +instance DF () where + dF = + id + +-- | +-- +-- >>> parse (parseA <* eof) "test" "A" :: Either ParseError HEXDigit +-- Right HEXDigitA +-- +-- >>> parse parseA "test" "Axyz" :: Either ParseError HEXDigit +-- Right HEXDigitA +-- +-- >>> isn't _Right (parse parseA "test" "xyz" :: Either ParseError HEXDigit) +-- True +parseA :: + (DA d, CharParsing p) => + p d +parseA = + xA <$ char 'A' "A" + +-- | +-- +-- >>> parse (parseB <* eof) "test" "B" :: Either ParseError HEXDigit +-- Right HEXDigitB +-- +-- >>> parse parseB "test" "Bxyz" :: Either ParseError HEXDigit +-- Right HEXDigitB +-- +-- >>> isn't _Right (parse parseB "test" "xyz" :: Either ParseError HEXDigit) +-- True +parseB :: + (DB d, CharParsing p) => + p d +parseB = + xB <$ char 'B' "B" + +-- | +-- +-- >>> parse (parseC <* eof) "test" "C" :: Either ParseError HEXDigit +-- Right HEXDigitC +-- +-- >>> parse parseC "test" "Cxyz" :: Either ParseError HEXDigit +-- Right HEXDigitC +-- +-- >>> isn't _Right (parse parseC "test" "xyz" :: Either ParseError HEXDigit) +-- True +parseC :: + (DC d, CharParsing p) => + p d +parseC = + xC <$ char 'C' "C" + +-- | +-- +-- >>> parse (parseD <* eof) "test" "D" :: Either ParseError HEXDigit +-- Right HEXDigitD +-- +-- >>> parse parseD "test" "Dxyz" :: Either ParseError HEXDigit +-- Right HEXDigitD +-- +-- >>> isn't _Right (parse parseD "test" "xyz" :: Either ParseError HEXDigit) +-- True +parseD :: + (DD d, CharParsing p) => + p d +parseD = + xD <$ char 'D' "D" + +-- | +-- +-- >>> parse (parseE <* eof) "test" "E" :: Either ParseError HEXDigit +-- Right HEXDigitE +-- +-- >>> parse parseE "test" "Exyz" :: Either ParseError HEXDigit +-- Right HEXDigitE +-- +-- >>> isn't _Right (parse parseE "test" "xyz" :: Either ParseError HEXDigit) +-- True +parseE :: + (DE d, CharParsing p) => + p d +parseE = + xE <$ char 'E' "E" + +-- | +-- +-- >>> parse (parseF <* eof) "test" "F" :: Either ParseError HEXDigit +-- Right HEXDigitF +-- +-- >>> parse parseF "test" "Fxyz" :: Either ParseError HEXDigit +-- Right HEXDigitF +-- +-- >>> isn't _Right (parse parseF "test" "xyz" :: Either ParseError HEXDigit) +-- True +parseF :: + (DF d, CharParsing p) => + p d +parseF = + xF <$ char 'F' "F" diff --git a/src/Data/Digit/D0.hs b/src/Data/Digit/D0.hs deleted file mode 100644 --- a/src/Data/Digit/D0.hs +++ /dev/null @@ -1,46 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} -{-# LANGUAGE FlexibleInstances #-} - -module Data.Digit.D0( - D0(..) -, parse0 -) where - -import Papa -import Text.Parser.Char(CharParsing, char) -import Text.Parser.Combinators(()) - --- $setup --- >>> import Data.Digit --- >>> import Text.Parsec(parse, ParseError, eof) --- >>> import Data.Void(Void) - -class D0 d where - d0 :: - Prism' - d - () - x0 :: - d - x0 = - d0 # () - -instance D0 () where - d0 = - id - --- | --- --- >>> parse (parse0 <* eof) "test" "0" :: Either ParseError BinDigit --- Right BinDigit0 --- --- >>> parse parse0 "test" "0xyz" :: Either ParseError BinDigit --- Right BinDigit0 --- --- >>> isn't _Right (parse parse0 "test" "xyz" :: Either ParseError BinDigit) --- True -parse0 :: - (D0 d, CharParsing p) => - p d -parse0 = - x0 <$ char '0' "0" diff --git a/src/Data/Digit/D1.hs b/src/Data/Digit/D1.hs deleted file mode 100644 --- a/src/Data/Digit/D1.hs +++ /dev/null @@ -1,45 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} - -module Data.Digit.D1( - D1(..) -, parse1 -) where - -import Papa -import Text.Parser.Char(CharParsing, char) -import Text.Parser.Combinators(()) - --- $setup --- >>> import Data.Digit --- >>> import Text.Parsec(parse, ParseError, eof) --- >>> import Data.Void(Void) - -class D1 d where - d1 :: - Prism' - d - () - x1 :: - d - x1 = - d1 # () - -instance D1 () where - d1 = - id - --- | --- --- >>> parse (parse1 <* eof) "test" "1" :: Either ParseError BinDigit --- Right BinDigit1 --- --- >>> parse parse1 "test" "1xyz" :: Either ParseError BinDigit --- Right BinDigit1 --- --- >>> isn't _Right (parse parse1 "test" "xyz" :: Either ParseError BinDigit) --- True -parse1 :: - (D1 d, CharParsing p) => - p d -parse1 = - x1 <$ char '1' "1" diff --git a/src/Data/Digit/D2.hs b/src/Data/Digit/D2.hs deleted file mode 100644 --- a/src/Data/Digit/D2.hs +++ /dev/null @@ -1,45 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} - -module Data.Digit.D2( - D2(..) -, parse2 -) where - -import Papa -import Text.Parser.Char(CharParsing, char) -import Text.Parser.Combinators(()) - --- $setup --- >>> import Data.Digit --- >>> import Text.Parsec(parse, ParseError, eof) --- >>> import Data.Void(Void) - -class D2 d where - d2 :: - Prism' - d - () - x2 :: - d - x2 = - d2 # () - -instance D2 () where - d2 = - id - --- | --- --- >>> parse (parse2 <* eof) "test" "2" :: Either ParseError DecDigit --- Right DecDigit2 --- --- >>> parse parse2 "test" "2xyz" :: Either ParseError DecDigit --- Right DecDigit2 --- --- >>> isn't _Right (parse parse2 "test" "xyz" :: Either ParseError DecDigit) --- True -parse2 :: - (D2 d, CharParsing p) => - p d -parse2 = - x2 <$ char '2' "2" diff --git a/src/Data/Digit/D3.hs b/src/Data/Digit/D3.hs deleted file mode 100644 --- a/src/Data/Digit/D3.hs +++ /dev/null @@ -1,45 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} - -module Data.Digit.D3( - D3(..) -, parse3 -) where - -import Papa -import Text.Parser.Char(CharParsing, char) -import Text.Parser.Combinators(()) - --- $setup --- >>> import Data.Digit --- >>> import Text.Parsec(parse, ParseError, eof) --- >>> import Data.Void(Void) - -class D3 d where - d3 :: - Prism' - d - () - x3 :: - d - x3 = - d3 # () - -instance D3 () where - d3 = - id - --- | --- --- >>> parse (parse3 <* eof) "test" "3" :: Either ParseError DecDigit --- Right DecDigit3 --- --- >>> parse parse3 "test" "3xyz" :: Either ParseError DecDigit --- Right DecDigit3 --- --- >>> isn't _Right (parse parse3 "test" "xyz" :: Either ParseError DecDigit) --- True -parse3 :: - (D3 d, CharParsing p) => - p d -parse3 = - x3 <$ char '3' "3" diff --git a/src/Data/Digit/D4.hs b/src/Data/Digit/D4.hs deleted file mode 100644 --- a/src/Data/Digit/D4.hs +++ /dev/null @@ -1,45 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} - -module Data.Digit.D4( - D4(..) -, parse4 -) where - -import Papa -import Text.Parser.Char(CharParsing, char) -import Text.Parser.Combinators(()) - --- $setup --- >>> import Data.Digit --- >>> import Text.Parsec(parse, ParseError, eof) --- >>> import Data.Void(Void) - -class D4 d where - d4 :: - Prism' - d - () - x4 :: - d - x4 = - d4 # () - -instance D4 () where - d4 = - id - --- | --- --- >>> parse (parse4 <* eof) "test" "4" :: Either ParseError DecDigit --- Right DecDigit4 --- --- >>> parse parse4 "test" "4xyz" :: Either ParseError DecDigit --- Right DecDigit4 --- --- >>> isn't _Right (parse parse4 "test" "xyz" :: Either ParseError DecDigit) --- True -parse4 :: - (D4 d, CharParsing p) => - p d -parse4 = - x4 <$ char '4' "4" diff --git a/src/Data/Digit/D5.hs b/src/Data/Digit/D5.hs deleted file mode 100644 --- a/src/Data/Digit/D5.hs +++ /dev/null @@ -1,45 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} - -module Data.Digit.D5( - D5(..) -, parse5 -) where - -import Papa -import Text.Parser.Char(CharParsing, char) -import Text.Parser.Combinators(()) - --- $setup --- >>> import Data.Digit --- >>> import Text.Parsec(parse, ParseError, eof) --- >>> import Data.Void(Void) - -class D5 d where - d5 :: - Prism' - d - () - x5 :: - d - x5 = - d5 # () - -instance D5 () where - d5 = - id - --- | --- --- >>> parse (parse5 <* eof) "test" "5" :: Either ParseError DecDigit --- Right DecDigit5 --- --- >>> parse parse5 "test" "5xyz" :: Either ParseError DecDigit --- Right DecDigit5 --- --- >>> isn't _Right (parse parse5 "test" "xyz" :: Either ParseError DecDigit) --- True -parse5 :: - (D5 d, CharParsing p) => - p d -parse5 = - x5 <$ char '5' "5" diff --git a/src/Data/Digit/D6.hs b/src/Data/Digit/D6.hs deleted file mode 100644 --- a/src/Data/Digit/D6.hs +++ /dev/null @@ -1,45 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} - -module Data.Digit.D6( - D6(..) -, parse6 -) where - -import Papa -import Text.Parser.Char(CharParsing, char) -import Text.Parser.Combinators(()) - --- $setup --- >>> import Data.Digit --- >>> import Text.Parsec(parse, ParseError, eof) --- >>> import Data.Void(Void) - -class D6 d where - d6 :: - Prism' - d - () - x6 :: - d - x6 = - d6 # () - -instance D6 () where - d6 = - id - --- | --- --- >>> parse (parse6 <* eof) "test" "6" :: Either ParseError DecDigit --- Right DecDigit6 --- --- >>> parse parse6 "test" "6xyz" :: Either ParseError DecDigit --- Right DecDigit6 --- --- >>> isn't _Right (parse parse6 "test" "xyz" :: Either ParseError DecDigit) --- True -parse6 :: - (D6 d, CharParsing p) => - p d -parse6 = - x6 <$ char '6' "6" diff --git a/src/Data/Digit/D7.hs b/src/Data/Digit/D7.hs deleted file mode 100644 --- a/src/Data/Digit/D7.hs +++ /dev/null @@ -1,45 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} - -module Data.Digit.D7( - D7(..) -, parse7 -) where - -import Papa -import Text.Parser.Char(CharParsing, char) -import Text.Parser.Combinators(()) - --- $setup --- >>> import Data.Digit --- >>> import Text.Parsec(parse, ParseError, eof) --- >>> import Data.Void(Void) - -class D7 d where - d7 :: - Prism' - d - () - x7 :: - d - x7 = - d7 # () - -instance D7 () where - d7 = - id - --- | --- --- >>> parse (parse7 <* eof) "test" "7" :: Either ParseError DecDigit --- Right DecDigit7 --- --- >>> parse parse7 "test" "7xyz" :: Either ParseError DecDigit --- Right DecDigit7 --- --- >>> isn't _Right (parse parse7 "test" "xyz" :: Either ParseError DecDigit) --- True -parse7 :: - (D7 d, CharParsing p) => - p d -parse7 = - x7 <$ char '7' "7" diff --git a/src/Data/Digit/D8.hs b/src/Data/Digit/D8.hs deleted file mode 100644 --- a/src/Data/Digit/D8.hs +++ /dev/null @@ -1,45 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} - -module Data.Digit.D8( - D8(..) -, parse8 -) where - -import Papa -import Text.Parser.Char(CharParsing, char) -import Text.Parser.Combinators(()) - --- $setup --- >>> import Data.Digit --- >>> import Text.Parsec(parse, ParseError, eof) --- >>> import Data.Void(Void) - -class D8 d where - d8 :: - Prism' - d - () - x8 :: - d - x8 = - d8 # () - -instance D8 () where - d8 = - id - --- | --- --- >>> parse (parse8 <* eof) "test" "8" :: Either ParseError DecDigit --- Right DecDigit8 --- --- >>> parse parse8 "test" "8xyz" :: Either ParseError DecDigit --- Right DecDigit8 --- --- >>> isn't _Right (parse parse8 "test" "xyz" :: Either ParseError DecDigit) --- True -parse8 :: - (D8 d, CharParsing p) => - p d -parse8 = - x8 <$ char '8' "8" diff --git a/src/Data/Digit/D9.hs b/src/Data/Digit/D9.hs deleted file mode 100644 --- a/src/Data/Digit/D9.hs +++ /dev/null @@ -1,45 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} - -module Data.Digit.D9( - D9(..) -, parse9 -) where - -import Papa -import Text.Parser.Char(CharParsing, char) -import Text.Parser.Combinators(()) - --- $setup --- >>> import Data.Digit --- >>> import Text.Parsec(parse, ParseError, eof) --- >>> import Data.Void(Void) - -class D9 d where - d9 :: - Prism' - d - () - x9 :: - d - x9 = - d9 # () - -instance D9 () where - d9 = - id - --- | --- --- >>> parse (parse9 <* eof) "test" "9" :: Either ParseError DecDigit --- Right DecDigit9 --- --- >>> parse parse9 "test" "9xyz" :: Either ParseError DecDigit --- Right DecDigit9 --- --- >>> isn't _Right (parse parse9 "test" "xyz" :: Either ParseError DecDigit) --- True -parse9 :: - (D9 d, CharParsing p) => - p d -parse9 = - x9 <$ char '9' "9" diff --git a/src/Data/Digit/DA.hs b/src/Data/Digit/DA.hs deleted file mode 100644 --- a/src/Data/Digit/DA.hs +++ /dev/null @@ -1,45 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} - -module Data.Digit.DA( - DA(..) -, parseA -) where - -import Papa -import Text.Parser.Char(CharParsing, char) -import Text.Parser.Combinators(()) - --- $setup --- >>> import Data.Digit --- >>> import Text.Parsec(parse, ParseError, eof) --- >>> import Data.Void(Void) - -class DA d where - dA :: - Prism' - d - () - xA :: - d - xA = - dA # () - -instance DA () where - dA = - id - --- | --- --- >>> parse (parseA <* eof) "test" "A" :: Either ParseError HEXDigit --- Right HEXDigitA --- --- >>> parse parseA "test" "Axyz" :: Either ParseError HEXDigit --- Right HEXDigitA --- --- >>> isn't _Right (parse parseA "test" "xyz" :: Either ParseError HEXDigit) --- True -parseA :: - (DA d, CharParsing p) => - p d -parseA = - xA <$ char 'A' "A" diff --git a/src/Data/Digit/DAa.hs b/src/Data/Digit/DAa.hs deleted file mode 100644 --- a/src/Data/Digit/DAa.hs +++ /dev/null @@ -1,48 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} -{-# LANGUAGE ConstraintKinds #-} -{-# LANGUAGE TypeFamilies #-} -{-# LANGUAGE FlexibleInstances #-} -{-# LANGUAGE MultiParamTypeClasses #-} - -module Data.Digit.DAa( - module Data.Digit.DA -, module Data.Digit.Da -, DAa -, parseAa -) where - -import Text.Parser.Char(CharParsing) -import Text.Parser.Combinators((), choice) -import Data.Digit.DA -import Data.Digit.Da - --- $setup --- >>> import Text.Parsec(parse, ParseError, eof) --- >>> import Data.Void(Void) --- >>> import Data.Digit --- >>> import Papa - -type DAa a = - (DA a, Da a) - --- | --- --- >>> parse (parseAa <* eof) "test" "A" :: Either ParseError HeXDigit --- Right HeXDigitA --- --- >>> parse parseAa "test" "Axyz" :: Either ParseError HeXDigit --- Right HeXDigitA --- --- >>> parse (parseAa <* eof) "test" "a" :: Either ParseError HeXDigit --- Right HeXDigita --- --- >>> parse parseAa "test" "axyz" :: Either ParseError HeXDigit --- Right HeXDigita --- --- >>> isn't _Right (parse parseAa "test" "xyz" :: Either ParseError HeXDigit) --- True -parseAa :: - (DAa d, CharParsing p) => - p d -parseAa = - choice [parseA, parsea] "Aa" diff --git a/src/Data/Digit/DB.hs b/src/Data/Digit/DB.hs deleted file mode 100644 --- a/src/Data/Digit/DB.hs +++ /dev/null @@ -1,45 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} - -module Data.Digit.DB( - DB(..) -, parseB -) where - -import Papa -import Text.Parser.Char(CharParsing, char) -import Text.Parser.Combinators(()) - --- $setup --- >>> import Data.Digit --- >>> import Text.Parsec(parse, ParseError, eof) --- >>> import Data.Void(Void) - -class DB d where - dB :: - Prism' - d - () - xB :: - d - xB = - dB # () - -instance DB () where - dB = - id - --- | --- --- >>> parse (parseB <* eof) "test" "B" :: Either ParseError HEXDigit --- Right HEXDigitB --- --- >>> parse parseB "test" "Bxyz" :: Either ParseError HEXDigit --- Right HEXDigitB --- --- >>> isn't _Right (parse parseB "test" "xyz" :: Either ParseError HEXDigit) --- True -parseB :: - (DB d, CharParsing p) => - p d -parseB = - xB <$ char 'B' "B" diff --git a/src/Data/Digit/DBb.hs b/src/Data/Digit/DBb.hs deleted file mode 100644 --- a/src/Data/Digit/DBb.hs +++ /dev/null @@ -1,45 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} -{-# LANGUAGE ConstraintKinds #-} - -module Data.Digit.DBb( - module Data.Digit.DB -, module Data.Digit.Db -, DBb -, parseBb -) where - -import Text.Parser.Char(CharParsing) -import Text.Parser.Combinators((), choice) -import Data.Digit.DB -import Data.Digit.Db - --- $setup --- >>> import Text.Parsec(parse, ParseError, eof) --- >>> import Data.Void(Void) --- >>> import Data.Digit --- >>> import Papa - -type DBb a = - (DB a, Db a) - --- | --- --- >>> parse (parseBb <* eof) "test" "B" :: Either ParseError HeXDigit --- Right HeXDigitB --- --- >>> parse parseBb "test" "Bxyz" :: Either ParseError HeXDigit --- Right HeXDigitB --- --- >>> parse (parseBb <* eof) "test" "b" :: Either ParseError HeXDigit --- Right HeXDigitb --- --- >>> parse parseBb "test" "bxyz" :: Either ParseError HeXDigit --- Right HeXDigitb --- --- >>> isn't _Right (parse parseBb "test" "xyz" :: Either ParseError HeXDigit) --- True -parseBb :: - (DBb d, CharParsing p) => - p d -parseBb = - choice [parseB, parseb] "Bb" diff --git a/src/Data/Digit/DC.hs b/src/Data/Digit/DC.hs deleted file mode 100644 --- a/src/Data/Digit/DC.hs +++ /dev/null @@ -1,45 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} - -module Data.Digit.DC( - DC(..) -, parseC -) where - -import Papa -import Text.Parser.Char(CharParsing, char) -import Text.Parser.Combinators(()) - --- $setup --- >>> import Data.Digit --- >>> import Text.Parsec(parse, ParseError, eof) --- >>> import Data.Void(Void) - -class DC d where - dC :: - Prism' - d - () - xC :: - d - xC = - dC # () - -instance DC () where - dC = - id - --- | --- --- >>> parse (parseC <* eof) "test" "C" :: Either ParseError HEXDigit --- Right HEXDigitC --- --- >>> parse parseC "test" "Cxyz" :: Either ParseError HEXDigit --- Right HEXDigitC --- --- >>> isn't _Right (parse parseC "test" "xyz" :: Either ParseError HEXDigit) --- True -parseC :: - (DC d, CharParsing p) => - p d -parseC = - xC <$ char 'C' "C" diff --git a/src/Data/Digit/DCc.hs b/src/Data/Digit/DCc.hs deleted file mode 100644 --- a/src/Data/Digit/DCc.hs +++ /dev/null @@ -1,45 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} -{-# LANGUAGE ConstraintKinds #-} - -module Data.Digit.DCc( - module Data.Digit.DC -, module Data.Digit.Dc -, DCc -, parseCc -) where - -import Text.Parser.Char(CharParsing) -import Text.Parser.Combinators((), choice) -import Data.Digit.DC -import Data.Digit.Dc - --- $setup --- >>> import Text.Parsec(parse, ParseError, eof) --- >>> import Data.Void(Void) --- >>> import Data.Digit --- >>> import Papa - -type DCc a = - (DC a, Dc a) - --- | --- --- >>> parse (parseCc <* eof) "test" "C" :: Either ParseError HeXDigit --- Right HeXDigitC --- --- >>> parse parseCc "test" "Cxyz" :: Either ParseError HeXDigit --- Right HeXDigitC --- --- >>> parse (parseCc <* eof) "test" "c" :: Either ParseError HeXDigit --- Right HeXDigitc --- --- >>> parse parseCc "test" "cxyz" :: Either ParseError HeXDigit --- Right HeXDigitc --- --- >>> isn't _Right (parse parseCc "test" "xyz" :: Either ParseError HeXDigit) --- True -parseCc :: - (DCc d, CharParsing p) => - p d -parseCc = - choice [parseC, parsec] "Cc" diff --git a/src/Data/Digit/DD.hs b/src/Data/Digit/DD.hs deleted file mode 100644 --- a/src/Data/Digit/DD.hs +++ /dev/null @@ -1,45 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} - -module Data.Digit.DD( - DD(..) -, parseD -) where - -import Papa -import Text.Parser.Char(CharParsing, char) -import Text.Parser.Combinators(()) - --- $setup --- >>> import Data.Digit --- >>> import Text.Parsec(parse, ParseError, eof) --- >>> import Data.Void(Void) - -class DD d where - dD :: - Prism' - d - () - xD :: - d - xD = - dD # () - -instance DD () where - dD = - id - --- | --- --- >>> parse (parseD <* eof) "test" "D" :: Either ParseError HEXDigit --- Right HEXDigitD --- --- >>> parse parseD "test" "Dxyz" :: Either ParseError HEXDigit --- Right HEXDigitD --- --- >>> isn't _Right (parse parseD "test" "xyz" :: Either ParseError HEXDigit) --- True -parseD :: - (DD d, CharParsing p) => - p d -parseD = - xD <$ char 'D' "D" diff --git a/src/Data/Digit/DDd.hs b/src/Data/Digit/DDd.hs deleted file mode 100644 --- a/src/Data/Digit/DDd.hs +++ /dev/null @@ -1,45 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} -{-# LANGUAGE ConstraintKinds #-} - -module Data.Digit.DDd( - module Data.Digit.DD -, module Data.Digit.Dd -, DDd -, parseDd -) where - -import Text.Parser.Char(CharParsing) -import Text.Parser.Combinators((), choice) -import Data.Digit.DD -import Data.Digit.Dd - --- $setup --- >>> import Text.Parsec(parse, ParseError, eof) --- >>> import Data.Void(Void) --- >>> import Data.Digit --- >>> import Papa - -type DDd a = - (DD a, Dd a) - --- | --- --- >>> parse (parseDd <* eof) "test" "D" :: Either ParseError HeXDigit --- Right HeXDigitD --- --- >>> parse parseDd "test" "Dxyz" :: Either ParseError HeXDigit --- Right HeXDigitD --- --- >>> parse (parseDd <* eof) "test" "d" :: Either ParseError HeXDigit --- Right HeXDigitd --- --- >>> parse parseDd "test" "dxyz" :: Either ParseError HeXDigit --- Right HeXDigitd --- --- >>> isn't _Right (parse parseDd "test" "xyz" :: Either ParseError HeXDigit) --- True -parseDd :: - (DDd d, CharParsing p) => - p d -parseDd = - choice [parseD, parsed] "Dd" diff --git a/src/Data/Digit/DE.hs b/src/Data/Digit/DE.hs deleted file mode 100644 --- a/src/Data/Digit/DE.hs +++ /dev/null @@ -1,45 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} - -module Data.Digit.DE( - DE(..) -, parseE -) where - -import Papa -import Text.Parser.Char(CharParsing, char) -import Text.Parser.Combinators(()) - --- $setup --- >>> import Data.Digit --- >>> import Text.Parsec(parse, ParseError, eof) --- >>> import Data.Void(Void) - -class DE d where - dE :: - Prism' - d - () - xE :: - d - xE = - dE # () - -instance DE () where - dE = - id - --- | --- --- >>> parse (parseE <* eof) "test" "E" :: Either ParseError HEXDigit --- Right HEXDigitE --- --- >>> parse parseE "test" "Exyz" :: Either ParseError HEXDigit --- Right HEXDigitE --- --- >>> isn't _Right (parse parseE "test" "xyz" :: Either ParseError HEXDigit) --- True -parseE :: - (DE d, CharParsing p) => - p d -parseE = - xE <$ char 'E' "E" diff --git a/src/Data/Digit/DEe.hs b/src/Data/Digit/DEe.hs deleted file mode 100644 --- a/src/Data/Digit/DEe.hs +++ /dev/null @@ -1,45 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} -{-# LANGUAGE ConstraintKinds #-} - -module Data.Digit.DEe( - module Data.Digit.DE -, module Data.Digit.De -, DEe -, parseEe -) where - -import Text.Parser.Char(CharParsing) -import Text.Parser.Combinators((), choice) -import Data.Digit.DE -import Data.Digit.De - --- $setup --- >>> import Text.Parsec(parse, ParseError, eof) --- >>> import Data.Void(Void) --- >>> import Data.Digit.Digit --- >>> import Papa - -type DEe a = - (DE a, De a) - --- | --- --- >>> parse (parseEe <* eof) "test" "E" :: Either ParseError HeXDigit --- Right HeXDigitE --- --- >>> parse parseEe "test" "Exyz" :: Either ParseError HeXDigit --- Right HeXDigitE --- --- >>> parse (parseEe <* eof) "test" "e" :: Either ParseError HeXDigit --- Right HeXDigite --- --- >>> parse parseEe "test" "exyz" :: Either ParseError HeXDigit --- Right HeXDigite --- --- >>> isn't _Right (parse parseEe "test" "xyz" :: Either ParseError HeXDigit) --- True -parseEe :: - (DEe d, CharParsing p) => - p d -parseEe = - choice [parseE, parsee] "Ee" diff --git a/src/Data/Digit/DF.hs b/src/Data/Digit/DF.hs deleted file mode 100644 --- a/src/Data/Digit/DF.hs +++ /dev/null @@ -1,45 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} - -module Data.Digit.DF( - DF(..) -, parseF -) where - -import Papa -import Text.Parser.Char(CharParsing, char) -import Text.Parser.Combinators(()) - --- $setup --- >>> import Data.Digit --- >>> import Text.Parsec(parse, ParseError, eof) --- >>> import Data.Void(Void) - -class DF d where - dF :: - Prism' - d - () - xF :: - d - xF = - dF # () - -instance DF () where - dF = - id - --- | --- --- >>> parse (parseF <* eof) "test" "F" :: Either ParseError HEXDigit --- Right HEXDigitF --- --- >>> parse parseF "test" "Fxyz" :: Either ParseError HEXDigit --- Right HEXDigitF --- --- >>> isn't _Right (parse parseF "test" "xyz" :: Either ParseError HEXDigit) --- True -parseF :: - (DF d, CharParsing p) => - p d -parseF = - xF <$ char 'F' "F" diff --git a/src/Data/Digit/DFf.hs b/src/Data/Digit/DFf.hs deleted file mode 100644 --- a/src/Data/Digit/DFf.hs +++ /dev/null @@ -1,45 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} -{-# LANGUAGE ConstraintKinds #-} - -module Data.Digit.DFf( - module Data.Digit.DF -, module Data.Digit.Df -, DFf -, parseFf -) where - -import Text.Parser.Char(CharParsing) -import Text.Parser.Combinators((), choice) -import Data.Digit.DF -import Data.Digit.Df - --- $setup --- >>> import Text.Parsec(parse, ParseError, eof) --- >>> import Data.Void(Void) --- >>> import Data.Digit --- >>> import Papa - -type DFf a = - (DF a, Df a) - --- | --- --- >>> parse (parseFf <* eof) "test" "F" :: Either ParseError HeXDigit --- Right HeXDigitF --- --- >>> parse parseFf "test" "Fxyz" :: Either ParseError HeXDigit --- Right HeXDigitF --- --- >>> parse (parseFf <* eof) "test" "f" :: Either ParseError HeXDigit --- Right HeXDigitf --- --- >>> parse parseFf "test" "fxyz" :: Either ParseError HeXDigit --- Right HeXDigitf --- --- >>> isn't _Right (parse parseFf "test" "xyz" :: Either ParseError HeXDigit) --- True -parseFf :: - (DFf d, CharParsing p) => - p d -parseFf = - choice [parseF, parsef] "Ff" diff --git a/src/Data/Digit/Da.hs b/src/Data/Digit/Da.hs deleted file mode 100644 --- a/src/Data/Digit/Da.hs +++ /dev/null @@ -1,45 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} - -module Data.Digit.Da( - Da(..) -, parsea -) where - -import Papa -import Text.Parser.Char(CharParsing, char) -import Text.Parser.Combinators(()) - --- $setup --- >>> import Data.Digit --- >>> import Text.Parsec(parse, ParseError, eof) --- >>> import Data.Void(Void) - -class Da d where - da :: - Prism' - d - () - xa :: - d - xa = - da # () - -instance Da () where - da = - id - --- | --- --- >>> parse (parsea <* eof) "test" "a" :: Either ParseError HexDigit --- Right HexDigita --- --- >>> parse parsea "test" "axyz" :: Either ParseError HexDigit --- Right HexDigita --- --- >>> isn't _Right (parse parsea "test" "xyz" :: Either ParseError HexDigit) --- True -parsea :: - (Da d, CharParsing p) => - p d -parsea = - xa <$ char 'a' "a" diff --git a/src/Data/Digit/Db.hs b/src/Data/Digit/Db.hs deleted file mode 100644 --- a/src/Data/Digit/Db.hs +++ /dev/null @@ -1,45 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} - -module Data.Digit.Db( - Db(..) -, parseb -) where - -import Papa -import Text.Parser.Char(CharParsing, char) -import Text.Parser.Combinators(()) - --- $setup --- >>> import Data.Digit --- >>> import Text.Parsec(parse, ParseError, eof) --- >>> import Data.Void(Void) - -class Db d where - db :: - Prism' - d - () - xb :: - d - xb = - db # () - -instance Db () where - db = - id - --- | --- --- >>> parse (parseb <* eof) "test" "b" :: Either ParseError HexDigit --- Right HexDigitb --- --- >>> parse parseb "test" "bxyz" :: Either ParseError HexDigit --- Right HexDigitb --- --- >>> isn't _Right (parse parseb "test" "xyz" :: Either ParseError HexDigit) --- True -parseb :: - (Db d, CharParsing p) => - p d -parseb = - xb <$ char 'b' "b" diff --git a/src/Data/Digit/Dc.hs b/src/Data/Digit/Dc.hs deleted file mode 100644 --- a/src/Data/Digit/Dc.hs +++ /dev/null @@ -1,45 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} - -module Data.Digit.Dc( - Dc(..) -, parsec -) where - -import Papa -import Text.Parser.Char(CharParsing, char) -import Text.Parser.Combinators(()) - --- $setup --- >>> import Data.Digit --- >>> import Text.Parsec(parse, ParseError, eof) --- >>> import Data.Void(Void) - -class Dc d where - dc :: - Prism' - d - () - xc :: - d - xc = - dc # () - -instance Dc () where - dc = - id - --- | --- --- >>> parse (parsec <* eof) "test" "c" :: Either ParseError HexDigit --- Right HexDigitc --- --- >>> parse parsec "test" "cxyz" :: Either ParseError HexDigit --- Right HexDigitc --- --- >>> isn't _Right (parse parsec "test" "xyz" :: Either ParseError HexDigit) --- True -parsec :: - (Dc d, CharParsing p) => - p d -parsec = - xc <$ char 'c' "c" diff --git a/src/Data/Digit/Dd.hs b/src/Data/Digit/Dd.hs deleted file mode 100644 --- a/src/Data/Digit/Dd.hs +++ /dev/null @@ -1,45 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} - -module Data.Digit.Dd( - Dd(..) -, parsed -) where - -import Papa -import Text.Parser.Char(CharParsing, char) -import Text.Parser.Combinators(()) - --- $setup --- >>> import Data.Digit --- >>> import Text.Parsec(parse, ParseError, eof) --- >>> import Data.Void(Void) - -class Dd d where - dd :: - Prism' - d - () - xd :: - d - xd = - dd # () - -instance Dd () where - dd = - id - --- | --- --- >>> parse (parsed <* eof) "test" "d" :: Either ParseError HexDigit --- Right HexDigitd --- --- >>> parse parsed "test" "dxyz" :: Either ParseError HexDigit --- Right HexDigitd --- --- >>> isn't _Right (parse parsed "test" "xyz" :: Either ParseError HexDigit) --- True -parsed :: - (Dd d, CharParsing p) => - p d -parsed = - xd <$ char 'd' "d" diff --git a/src/Data/Digit/De.hs b/src/Data/Digit/De.hs deleted file mode 100644 --- a/src/Data/Digit/De.hs +++ /dev/null @@ -1,45 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} - -module Data.Digit.De( - De(..) -, parsee -) where - -import Papa -import Text.Parser.Char(CharParsing, char) -import Text.Parser.Combinators(()) - --- $setup --- >>> import Data.Digit --- >>> import Text.Parsec(parse, ParseError, eof) --- >>> import Data.Void(Void) - -class De d where - de :: - Prism' - d - () - xe :: - d - xe = - de # () - -instance De () where - de = - id - --- | --- --- >>> parse (parsee <* eof) "test" "e" :: Either ParseError HexDigit --- Right HexDigite --- --- >>> parse parsee "test" "exyz" :: Either ParseError HexDigit --- Right HexDigite --- --- >>> isn't _Right (parse parsee "test" "xyz" :: Either ParseError HexDigit) --- True -parsee :: - (De d, CharParsing p) => - p d -parsee = - xe <$ char 'e' "e" diff --git a/src/Data/Digit/Decimal.hs b/src/Data/Digit/Decimal.hs --- a/src/Data/Digit/Decimal.hs +++ b/src/Data/Digit/Decimal.hs @@ -20,32 +20,33 @@ , _DecDigit8 , _DecDigit9 -- * Re-exports -, module Data.Digit.D0 -, module Data.Digit.D1 -, module Data.Digit.D2 -, module Data.Digit.D3 -, module Data.Digit.D4 -, module Data.Digit.D5 -, module Data.Digit.D6 -, module Data.Digit.D7 -, module Data.Digit.D8 -, module Data.Digit.D9 +, module Data.Digit.Class.D0 +, module Data.Digit.Class.D1 +, module Data.Digit.Class.D2 +, module Data.Digit.Class.D3 +, module Data.Digit.Class.D4 +, module Data.Digit.Class.D5 +, module Data.Digit.Class.D6 +, module Data.Digit.Class.D7 +, module Data.Digit.Class.D8 +, module Data.Digit.Class.D9 ) where import Prelude (Eq, Show, Ord, Enum, Bounded) import Control.Lens.TH (makePrisms) import Text.Parser.Char(CharParsing) import Text.Parser.Combinators((), choice) -import Data.Digit.D0 -import Data.Digit.D1 -import Data.Digit.D2 -import Data.Digit.D3 -import Data.Digit.D4 -import Data.Digit.D5 -import Data.Digit.D6 -import Data.Digit.D7 -import Data.Digit.D8 -import Data.Digit.D9 + +import Data.Digit.Class.D0 +import Data.Digit.Class.D1 +import Data.Digit.Class.D2 +import Data.Digit.Class.D3 +import Data.Digit.Class.D4 +import Data.Digit.Class.D5 +import Data.Digit.Class.D6 +import Data.Digit.Class.D7 +import Data.Digit.Class.D8 +import Data.Digit.Class.D9 data DecDigit = DecDigit0 diff --git a/src/Data/Digit/Df.hs b/src/Data/Digit/Df.hs deleted file mode 100644 --- a/src/Data/Digit/Df.hs +++ /dev/null @@ -1,45 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} - -module Data.Digit.Df( - Df(..) -, parsef -) where - -import Papa -import Text.Parser.Char(CharParsing, char) -import Text.Parser.Combinators(()) - --- $setup --- >>> import Data.Digit --- >>> import Text.Parsec(parse, ParseError, eof) --- >>> import Data.Void(Void) - -class Df d where - df :: - Prism' - d - () - xf :: - d - xf = - df # () - -instance Df () where - df = - id - --- | --- --- >>> parse (parsef <* eof) "test" "f" :: Either ParseError HexDigit --- Right HexDigitf --- --- >>> parse parsef "test" "fxyz" :: Either ParseError HexDigit --- Right HexDigitf --- --- >>> isn't _Right (parse parsef "test" "xyz" :: Either ParseError HexDigit) --- True -parsef :: - (Df d, CharParsing p) => - p d -parsef = - xf <$ char 'f' "f" diff --git a/src/Data/Digit/Enum.hs b/src/Data/Digit/Enum.hs --- a/src/Data/Digit/Enum.hs +++ b/src/Data/Digit/Enum.hs @@ -20,8 +20,8 @@ import Control.Lens.Review ((#)) import Data.Digit.Binary import Data.Digit.Decimal -import Data.Digit.Hexadecimal -import Data.Digit.HEXADECIMAL +import Data.Digit.Hexadecimal.LowerCase +import Data.Digit.Hexadecimal.UpperCase import Data.Digit.Octal -- | @[1]@ diff --git a/src/Data/Digit/HEXADECIMAL.hs b/src/Data/Digit/HEXADECIMAL.hs deleted file mode 100644 --- a/src/Data/Digit/HEXADECIMAL.hs +++ /dev/null @@ -1,136 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} -{-# LANGUAGE ConstraintKinds #-} -{-# LANGUAGE TemplateHaskell #-} - -module Data.Digit.HEXADECIMAL( - HEXDigit(..) -, HEXADECIMALNoZero -, HEXADECIMAL -, parseHEXADECIMALNoZero -, parseHEXADECIMAL --- * Prisms -, _HEXDigit0 -, _HEXDigit1 -, _HEXDigit2 -, _HEXDigit3 -, _HEXDigit4 -, _HEXDigit5 -, _HEXDigit6 -, _HEXDigit7 -, _HEXDigit8 -, _HEXDigit9 -, _HEXDigitA -, _HEXDigitB -, _HEXDigitC -, _HEXDigitD -, _HEXDigitE -, _HEXDigitF --- * Re-exports -, module Data.Digit.D0 -, module Data.Digit.D1 -, module Data.Digit.D2 -, module Data.Digit.D3 -, module Data.Digit.D4 -, module Data.Digit.D5 -, module Data.Digit.D6 -, module Data.Digit.D7 -, module Data.Digit.D8 -, module Data.Digit.D9 -, module Data.Digit.DA -, module Data.Digit.DB -, module Data.Digit.DC -, module Data.Digit.DD -, module Data.Digit.DE -, module Data.Digit.DF -) where - -import Prelude (Eq, Show, Ord) -import Control.Lens.TH (makePrisms) -import Text.Parser.Char(CharParsing) -import Text.Parser.Combinators((), choice) -import Data.Digit.D0 -import Data.Digit.D1 -import Data.Digit.D2 -import Data.Digit.D3 -import Data.Digit.D4 -import Data.Digit.D5 -import Data.Digit.D6 -import Data.Digit.D7 -import Data.Digit.D8 -import Data.Digit.D9 -import Data.Digit.DA -import Data.Digit.DB -import Data.Digit.DC -import Data.Digit.DD -import Data.Digit.DE -import Data.Digit.DF -import Data.Digit.Decimal(parseDecimalNoZero) - -data HEXDigit - = HEXDigit0 - | HEXDigit1 - | HEXDigit2 - | HEXDigit3 - | HEXDigit4 - | HEXDigit5 - | HEXDigit6 - | HEXDigit7 - | HEXDigit8 - | HEXDigit9 - | HEXDigitA - | HEXDigitB - | HEXDigitC - | HEXDigitD - | HEXDigitE - | HEXDigitF - deriving (Show, Eq, Ord) - -makePrisms ''HEXDigit - -instance D0 HEXDigit where; d0 = _HEXDigit0 -instance D1 HEXDigit where; d1 = _HEXDigit1 -instance D2 HEXDigit where; d2 = _HEXDigit2 -instance D3 HEXDigit where; d3 = _HEXDigit3 -instance D4 HEXDigit where; d4 = _HEXDigit4 -instance D5 HEXDigit where; d5 = _HEXDigit5 -instance D6 HEXDigit where; d6 = _HEXDigit6 -instance D7 HEXDigit where; d7 = _HEXDigit7 -instance D8 HEXDigit where; d8 = _HEXDigit8 -instance D9 HEXDigit where; d9 = _HEXDigit9 -instance DA HEXDigit where; dA = _HEXDigitA -instance DB HEXDigit where; dB = _HEXDigitB -instance DC HEXDigit where; dC = _HEXDigitC -instance DD HEXDigit where; dD = _HEXDigitD -instance DE HEXDigit where; dE = _HEXDigitE -instance DF HEXDigit where; dF = _HEXDigitF - -type HEXADECIMALNoZero d = - (D1 d, D2 d, D3 d, D4 d, D5 d, D6 d, D7 d, D8 d, D9 d, DA d, DB d, DC d, DD d, DE d, DF d) - -parseHEXADECIMALNoZero :: - (HEXADECIMALNoZero d, CharParsing p) => - p d -parseHEXADECIMALNoZero = - choice - [ - parseDecimalNoZero - , parseA - , parseB - , parseC - , parseD - , parseE - , parseF - ] "HEXADECIMALNoZero" - -type HEXADECIMAL d = - (D0 d, HEXADECIMALNoZero d) - -parseHEXADECIMAL :: - (HEXADECIMAL d, CharParsing p) => - p d -parseHEXADECIMAL = - choice - [ - parse0 - , parseHEXADECIMALNoZero - ] "HEXADECIMAL" diff --git a/src/Data/Digit/HeXaDeCiMaL.hs b/src/Data/Digit/HeXaDeCiMaL.hs deleted file mode 100644 --- a/src/Data/Digit/HeXaDeCiMaL.hs +++ /dev/null @@ -1,154 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} -{-# LANGUAGE ConstraintKinds #-} -{-# LANGUAGE TemplateHaskell #-} - -module Data.Digit.HeXaDeCiMaL( - HeXDigit(..) -, HeXaDeCiMaLNoZero -, HeXaDeCiMaL -, parseHeXaDeCiMaLNoZero -, parseHeXaDeCiMaL --- * Prisms -, _HeXDigit0 -, _HeXDigit1 -, _HeXDigit2 -, _HeXDigit3 -, _HeXDigit4 -, _HeXDigit5 -, _HeXDigit6 -, _HeXDigit7 -, _HeXDigit8 -, _HeXDigit9 -, _HeXDigita -, _HeXDigitb -, _HeXDigitc -, _HeXDigitd -, _HeXDigite -, _HeXDigitf -, _HeXDigitA -, _HeXDigitB -, _HeXDigitC -, _HeXDigitD -, _HeXDigitE -, _HeXDigitF --- * Re-exports -, module Data.Digit.D0 -, module Data.Digit.D1 -, module Data.Digit.D2 -, module Data.Digit.D3 -, module Data.Digit.D4 -, module Data.Digit.D5 -, module Data.Digit.D6 -, module Data.Digit.D7 -, module Data.Digit.D8 -, module Data.Digit.D9 -, module Data.Digit.DAa -, module Data.Digit.DBb -, module Data.Digit.DCc -, module Data.Digit.DDd -, module Data.Digit.DEe -, module Data.Digit.DFf -) where - -import Prelude (Eq, Show, Ord) -import Control.Lens.TH (makePrisms) -import Text.Parser.Char(CharParsing) -import Text.Parser.Combinators((), choice) -import Data.Digit.D0 -import Data.Digit.D1 -import Data.Digit.D2 -import Data.Digit.D3 -import Data.Digit.D4 -import Data.Digit.D5 -import Data.Digit.D6 -import Data.Digit.D7 -import Data.Digit.D8 -import Data.Digit.D9 -import Data.Digit.Decimal(parseDecimalNoZero) -import Data.Digit.DAa -import Data.Digit.DBb -import Data.Digit.DCc -import Data.Digit.DDd -import Data.Digit.DEe -import Data.Digit.DFf - -data HeXDigit - = HeXDigit0 - | HeXDigit1 - | HeXDigit2 - | HeXDigit3 - | HeXDigit4 - | HeXDigit5 - | HeXDigit6 - | HeXDigit7 - | HeXDigit8 - | HeXDigit9 - | HeXDigita - | HeXDigitb - | HeXDigitc - | HeXDigitd - | HeXDigite - | HeXDigitf - | HeXDigitA - | HeXDigitB - | HeXDigitC - | HeXDigitD - | HeXDigitE - | HeXDigitF - deriving (Show, Eq, Ord) - -makePrisms ''HeXDigit - -instance D0 HeXDigit where; d0 = _HeXDigit0 -instance D1 HeXDigit where; d1 = _HeXDigit1 -instance D2 HeXDigit where; d2 = _HeXDigit2 -instance D3 HeXDigit where; d3 = _HeXDigit3 -instance D4 HeXDigit where; d4 = _HeXDigit4 -instance D5 HeXDigit where; d5 = _HeXDigit5 -instance D6 HeXDigit where; d6 = _HeXDigit6 -instance D7 HeXDigit where; d7 = _HeXDigit7 -instance D8 HeXDigit where; d8 = _HeXDigit8 -instance D9 HeXDigit where; d9 = _HeXDigit9 -instance DA HeXDigit where; dA = _HeXDigitA -instance Da HeXDigit where; da = _HeXDigita -instance DB HeXDigit where; dB = _HeXDigitB -instance Db HeXDigit where; db = _HeXDigitb -instance DC HeXDigit where; dC = _HeXDigitC -instance Dc HeXDigit where; dc = _HeXDigitc -instance DD HeXDigit where; dD = _HeXDigitD -instance Dd HeXDigit where; dd = _HeXDigitd -instance DE HeXDigit where; dE = _HeXDigitE -instance De HeXDigit where; de = _HeXDigite -instance DF HeXDigit where; dF = _HeXDigitF -instance Df HeXDigit where; df = _HeXDigitf - -type HeXaDeCiMaLNoZero d = - (D1 d, D2 d, D3 d, D4 d, D5 d, D6 d, D7 d, D8 d, D9 d, DA d, DB d, DC d, DD d, DE d, DF d, Da d, Db d, Dc d, Dd d, De d, De d, Df d) - -parseHeXaDeCiMaLNoZero :: - (HeXaDeCiMaLNoZero d, CharParsing p) => - p d -parseHeXaDeCiMaLNoZero = - choice - [ - parseDecimalNoZero - , parseAa - , parseBb - , parseCc - , parseDd - , parseEe - , parseFf - ] "HeXaDeCiMaLNoZero" - -type HeXaDeCiMaL d = - (D0 d, HeXaDeCiMaLNoZero d) - -parseHeXaDeCiMaL :: - (HeXaDeCiMaL d, CharParsing p) => - p d -parseHeXaDeCiMaL = - choice - [ - parse0 - , parseHeXaDeCiMaLNoZero - ] "HeXaDeCiMaL" diff --git a/src/Data/Digit/Hexadecimal.hs b/src/Data/Digit/Hexadecimal.hs deleted file mode 100644 --- a/src/Data/Digit/Hexadecimal.hs +++ /dev/null @@ -1,136 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} -{-# LANGUAGE ConstraintKinds #-} -{-# LANGUAGE TemplateHaskell #-} - -module Data.Digit.Hexadecimal( - HexDigit(..) -, HexadecimalNoZero -, Hexadecimal -, parseHexadecimalNoZero -, parseHexadecimal --- * Prisms -, _HexDigit0 -, _HexDigit1 -, _HexDigit2 -, _HexDigit3 -, _HexDigit4 -, _HexDigit5 -, _HexDigit6 -, _HexDigit7 -, _HexDigit8 -, _HexDigit9 -, _HexDigita -, _HexDigitb -, _HexDigitc -, _HexDigitd -, _HexDigite -, _HexDigitf --- * Re-exports -, module Data.Digit.D0 -, module Data.Digit.D1 -, module Data.Digit.D2 -, module Data.Digit.D3 -, module Data.Digit.D4 -, module Data.Digit.D5 -, module Data.Digit.D6 -, module Data.Digit.D7 -, module Data.Digit.D8 -, module Data.Digit.D9 -, module Data.Digit.Da -, module Data.Digit.Db -, module Data.Digit.Dc -, module Data.Digit.Dd -, module Data.Digit.De -, module Data.Digit.Df -) where - -import Prelude (Eq, Show, Ord) -import Control.Lens.TH (makePrisms) -import Text.Parser.Char(CharParsing) -import Text.Parser.Combinators((), choice) -import Data.Digit.D0 -import Data.Digit.D1 -import Data.Digit.D2 -import Data.Digit.D3 -import Data.Digit.D4 -import Data.Digit.D5 -import Data.Digit.D6 -import Data.Digit.D7 -import Data.Digit.D8 -import Data.Digit.D9 -import Data.Digit.Da -import Data.Digit.Db -import Data.Digit.Dc -import Data.Digit.Dd -import Data.Digit.De -import Data.Digit.Df -import Data.Digit.Decimal(parseDecimalNoZero) - -data HexDigit - = HexDigit0 - | HexDigit1 - | HexDigit2 - | HexDigit3 - | HexDigit4 - | HexDigit5 - | HexDigit6 - | HexDigit7 - | HexDigit8 - | HexDigit9 - | HexDigita - | HexDigitb - | HexDigitc - | HexDigitd - | HexDigite - | HexDigitf - deriving (Show, Eq, Ord) - -makePrisms ''HexDigit - -instance D0 HexDigit where; d0 = _HexDigit0 -instance D1 HexDigit where; d1 = _HexDigit1 -instance D2 HexDigit where; d2 = _HexDigit2 -instance D3 HexDigit where; d3 = _HexDigit3 -instance D4 HexDigit where; d4 = _HexDigit4 -instance D5 HexDigit where; d5 = _HexDigit5 -instance D6 HexDigit where; d6 = _HexDigit6 -instance D7 HexDigit where; d7 = _HexDigit7 -instance D8 HexDigit where; d8 = _HexDigit8 -instance D9 HexDigit where; d9 = _HexDigit9 -instance Da HexDigit where; da = _HexDigita -instance Db HexDigit where; db = _HexDigitb -instance Dc HexDigit where; dc = _HexDigitc -instance Dd HexDigit where; dd = _HexDigitd -instance De HexDigit where; de = _HexDigite -instance Df HexDigit where; df = _HexDigitf - -type HexadecimalNoZero d = - (D1 d, D2 d, D3 d, D4 d, D5 d, D6 d, D7 d, D8 d, D9 d, Da d, Db d, Dc d, Dd d, De d, De d, Df d) - -parseHexadecimalNoZero :: - (HexadecimalNoZero d, CharParsing p) => - p d -parseHexadecimalNoZero = - choice - [ - parseDecimalNoZero - , parsea - , parseb - , parsec - , parsed - , parsee - , parsef - ] "HexadecimalNoZero" - -type Hexadecimal d = - (D0 d, HexadecimalNoZero d) - -parseHexadecimal :: - (Hexadecimal d, CharParsing p) => - p d -parseHexadecimal = - choice - [ - parse0 - , parseHexadecimalNoZero - ] "Hexadecimal" diff --git a/src/Data/Digit/Hexadecimal/LowerCase.hs b/src/Data/Digit/Hexadecimal/LowerCase.hs new file mode 100644 --- /dev/null +++ b/src/Data/Digit/Hexadecimal/LowerCase.hs @@ -0,0 +1,129 @@ +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE ConstraintKinds #-} +{-# LANGUAGE TemplateHaskell #-} + +module Data.Digit.Hexadecimal.LowerCase( + HexDigit(..) +, HexadecimalNoZero +, Hexadecimal +, parseHexadecimalNoZero +, parseHexadecimal +-- * Prisms +, _HexDigit0 +, _HexDigit1 +, _HexDigit2 +, _HexDigit3 +, _HexDigit4 +, _HexDigit5 +, _HexDigit6 +, _HexDigit7 +, _HexDigit8 +, _HexDigit9 +, _HexDigita +, _HexDigitb +, _HexDigitc +, _HexDigitd +, _HexDigite +, _HexDigitf +-- * Re-exports +, module Data.Digit.Class.D0 +, module Data.Digit.Class.D1 +, module Data.Digit.Class.D2 +, module Data.Digit.Class.D3 +, module Data.Digit.Class.D4 +, module Data.Digit.Class.D5 +, module Data.Digit.Class.D6 +, module Data.Digit.Class.D7 +, module Data.Digit.Class.D8 +, module Data.Digit.Class.D9 + +, module Data.Digit.Class.LowerCase +) where + +import Prelude (Eq, Show, Ord) +import Control.Lens.TH (makePrisms) +import Text.Parser.Char(CharParsing) +import Text.Parser.Combinators((), choice) + +import Data.Digit.Class.D0 +import Data.Digit.Class.D1 +import Data.Digit.Class.D2 +import Data.Digit.Class.D3 +import Data.Digit.Class.D4 +import Data.Digit.Class.D5 +import Data.Digit.Class.D6 +import Data.Digit.Class.D7 +import Data.Digit.Class.D8 +import Data.Digit.Class.D9 +import Data.Digit.Class.LowerCase + +import Data.Digit.Decimal(parseDecimalNoZero) + +data HexDigit + = HexDigit0 + | HexDigit1 + | HexDigit2 + | HexDigit3 + | HexDigit4 + | HexDigit5 + | HexDigit6 + | HexDigit7 + | HexDigit8 + | HexDigit9 + | HexDigita + | HexDigitb + | HexDigitc + | HexDigitd + | HexDigite + | HexDigitf + deriving (Show, Eq, Ord) + +makePrisms ''HexDigit + +instance D0 HexDigit where; d0 = _HexDigit0 +instance D1 HexDigit where; d1 = _HexDigit1 +instance D2 HexDigit where; d2 = _HexDigit2 +instance D3 HexDigit where; d3 = _HexDigit3 +instance D4 HexDigit where; d4 = _HexDigit4 +instance D5 HexDigit where; d5 = _HexDigit5 +instance D6 HexDigit where; d6 = _HexDigit6 +instance D7 HexDigit where; d7 = _HexDigit7 +instance D8 HexDigit where; d8 = _HexDigit8 +instance D9 HexDigit where; d9 = _HexDigit9 +instance Da HexDigit where; da = _HexDigita +instance Db HexDigit where; db = _HexDigitb +instance Dc HexDigit where; dc = _HexDigitc +instance Dd HexDigit where; dd = _HexDigitd +instance De HexDigit where; de = _HexDigite +instance Df HexDigit where; df = _HexDigitf + +type HexadecimalNoZero d = + (D1 d, D2 d, D3 d, D4 d, D5 d, D6 d, D7 d, D8 d, D9 d, Da d, Db d, Dc d, Dd d, De d, De d, Df d) + +parseHexadecimalNoZero :: + (HexadecimalNoZero d, CharParsing p) => + p d +parseHexadecimalNoZero = + choice + [ + parseDecimalNoZero + , parsea + , parseb + , parsec + , parsed + , parsee + , parsef + ] "HexadecimalNoZero" + +type Hexadecimal d = + (D0 d, HexadecimalNoZero d) + +parseHexadecimal :: + (Hexadecimal d, CharParsing p) => + p d +parseHexadecimal = + choice + [ + parse0 + , parseHexadecimalNoZero + ] "Hexadecimal" diff --git a/src/Data/Digit/Hexadecimal/MixedCase.hs b/src/Data/Digit/Hexadecimal/MixedCase.hs new file mode 100644 --- /dev/null +++ b/src/Data/Digit/Hexadecimal/MixedCase.hs @@ -0,0 +1,144 @@ +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE ConstraintKinds #-} +{-# LANGUAGE TemplateHaskell #-} + +module Data.Digit.Hexadecimal.MixedCase( + HeXDigit(..) +, HeXaDeCiMaLNoZero +, HeXaDeCiMaL +, parseHeXaDeCiMaLNoZero +, parseHeXaDeCiMaL +-- * Prisms +, _HeXDigit0 +, _HeXDigit1 +, _HeXDigit2 +, _HeXDigit3 +, _HeXDigit4 +, _HeXDigit5 +, _HeXDigit6 +, _HeXDigit7 +, _HeXDigit8 +, _HeXDigit9 +, _HeXDigita +, _HeXDigitb +, _HeXDigitc +, _HeXDigitd +, _HeXDigite +, _HeXDigitf +, _HeXDigitA +, _HeXDigitB +, _HeXDigitC +, _HeXDigitD +, _HeXDigitE +, _HeXDigitF +-- * Re-exports +, module Data.Digit.Class.D0 +, module Data.Digit.Class.D1 +, module Data.Digit.Class.D2 +, module Data.Digit.Class.D3 +, module Data.Digit.Class.D4 +, module Data.Digit.Class.D5 +, module Data.Digit.Class.D6 +, module Data.Digit.Class.D7 +, module Data.Digit.Class.D8 +, module Data.Digit.Class.D9 +, module Data.Digit.Class.MixedCase +) where + +import Prelude (Eq, Show, Ord) +import Control.Lens.TH (makePrisms) +import Text.Parser.Char(CharParsing) +import Text.Parser.Combinators((), choice) +import Data.Digit.Class.D0 +import Data.Digit.Class.D1 +import Data.Digit.Class.D2 +import Data.Digit.Class.D3 +import Data.Digit.Class.D4 +import Data.Digit.Class.D5 +import Data.Digit.Class.D6 +import Data.Digit.Class.D7 +import Data.Digit.Class.D8 +import Data.Digit.Class.D9 +import Data.Digit.Class.MixedCase +import Data.Digit.Decimal(parseDecimalNoZero) + +data HeXDigit + = HeXDigit0 + | HeXDigit1 + | HeXDigit2 + | HeXDigit3 + | HeXDigit4 + | HeXDigit5 + | HeXDigit6 + | HeXDigit7 + | HeXDigit8 + | HeXDigit9 + | HeXDigita + | HeXDigitb + | HeXDigitc + | HeXDigitd + | HeXDigite + | HeXDigitf + | HeXDigitA + | HeXDigitB + | HeXDigitC + | HeXDigitD + | HeXDigitE + | HeXDigitF + deriving (Show, Eq, Ord) + +makePrisms ''HeXDigit + +instance D0 HeXDigit where; d0 = _HeXDigit0 +instance D1 HeXDigit where; d1 = _HeXDigit1 +instance D2 HeXDigit where; d2 = _HeXDigit2 +instance D3 HeXDigit where; d3 = _HeXDigit3 +instance D4 HeXDigit where; d4 = _HeXDigit4 +instance D5 HeXDigit where; d5 = _HeXDigit5 +instance D6 HeXDigit where; d6 = _HeXDigit6 +instance D7 HeXDigit where; d7 = _HeXDigit7 +instance D8 HeXDigit where; d8 = _HeXDigit8 +instance D9 HeXDigit where; d9 = _HeXDigit9 +instance DA HeXDigit where; dA = _HeXDigitA +instance Da HeXDigit where; da = _HeXDigita +instance DB HeXDigit where; dB = _HeXDigitB +instance Db HeXDigit where; db = _HeXDigitb +instance DC HeXDigit where; dC = _HeXDigitC +instance Dc HeXDigit where; dc = _HeXDigitc +instance DD HeXDigit where; dD = _HeXDigitD +instance Dd HeXDigit where; dd = _HeXDigitd +instance DE HeXDigit where; dE = _HeXDigitE +instance De HeXDigit where; de = _HeXDigite +instance DF HeXDigit where; dF = _HeXDigitF +instance Df HeXDigit where; df = _HeXDigitf + +type HeXaDeCiMaLNoZero d = + (D1 d, D2 d, D3 d, D4 d, D5 d, D6 d, D7 d, D8 d, D9 d, DA d, DB d, DC d, DD d, DE d, DF d, Da d, Db d, Dc d, Dd d, De d, De d, Df d) + +parseHeXaDeCiMaLNoZero :: + (HeXaDeCiMaLNoZero d, CharParsing p) => + p d +parseHeXaDeCiMaLNoZero = + choice + [ + parseDecimalNoZero + , parseAa + , parseBb + , parseCc + , parseDd + , parseEe + , parseFf + ] "HeXaDeCiMaLNoZero" + +type HeXaDeCiMaL d = + (D0 d, HeXaDeCiMaLNoZero d) + +parseHeXaDeCiMaL :: + (HeXaDeCiMaL d, CharParsing p) => + p d +parseHeXaDeCiMaL = + choice + [ + parse0 + , parseHeXaDeCiMaLNoZero + ] "HeXaDeCiMaL" diff --git a/src/Data/Digit/Hexadecimal/UpperCase.hs b/src/Data/Digit/Hexadecimal/UpperCase.hs new file mode 100644 --- /dev/null +++ b/src/Data/Digit/Hexadecimal/UpperCase.hs @@ -0,0 +1,126 @@ +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE ConstraintKinds #-} +{-# LANGUAGE TemplateHaskell #-} + +module Data.Digit.Hexadecimal.UpperCase( + HEXDigit(..) +, HEXADECIMALNoZero +, HEXADECIMAL +, parseHEXADECIMALNoZero +, parseHEXADECIMAL +-- * Prisms +, _HEXDigit0 +, _HEXDigit1 +, _HEXDigit2 +, _HEXDigit3 +, _HEXDigit4 +, _HEXDigit5 +, _HEXDigit6 +, _HEXDigit7 +, _HEXDigit8 +, _HEXDigit9 +, _HEXDigitA +, _HEXDigitB +, _HEXDigitC +, _HEXDigitD +, _HEXDigitE +, _HEXDigitF +-- * Re-exports +, module Data.Digit.Class.D0 +, module Data.Digit.Class.D1 +, module Data.Digit.Class.D2 +, module Data.Digit.Class.D3 +, module Data.Digit.Class.D4 +, module Data.Digit.Class.D5 +, module Data.Digit.Class.D6 +, module Data.Digit.Class.D7 +, module Data.Digit.Class.D8 +, module Data.Digit.Class.D9 +, module Data.Digit.Class.UpperCase +) where + +import Prelude (Eq, Show, Ord) +import Control.Lens.TH (makePrisms) +import Text.Parser.Char(CharParsing) +import Text.Parser.Combinators((), choice) +import Data.Digit.Class.D0 +import Data.Digit.Class.D1 +import Data.Digit.Class.D2 +import Data.Digit.Class.D3 +import Data.Digit.Class.D4 +import Data.Digit.Class.D5 +import Data.Digit.Class.D6 +import Data.Digit.Class.D7 +import Data.Digit.Class.D8 +import Data.Digit.Class.D9 +import Data.Digit.Class.UpperCase +import Data.Digit.Decimal(parseDecimalNoZero) + +data HEXDigit + = HEXDigit0 + | HEXDigit1 + | HEXDigit2 + | HEXDigit3 + | HEXDigit4 + | HEXDigit5 + | HEXDigit6 + | HEXDigit7 + | HEXDigit8 + | HEXDigit9 + | HEXDigitA + | HEXDigitB + | HEXDigitC + | HEXDigitD + | HEXDigitE + | HEXDigitF + deriving (Show, Eq, Ord) + +makePrisms ''HEXDigit + +instance D0 HEXDigit where; d0 = _HEXDigit0 +instance D1 HEXDigit where; d1 = _HEXDigit1 +instance D2 HEXDigit where; d2 = _HEXDigit2 +instance D3 HEXDigit where; d3 = _HEXDigit3 +instance D4 HEXDigit where; d4 = _HEXDigit4 +instance D5 HEXDigit where; d5 = _HEXDigit5 +instance D6 HEXDigit where; d6 = _HEXDigit6 +instance D7 HEXDigit where; d7 = _HEXDigit7 +instance D8 HEXDigit where; d8 = _HEXDigit8 +instance D9 HEXDigit where; d9 = _HEXDigit9 +instance DA HEXDigit where; dA = _HEXDigitA +instance DB HEXDigit where; dB = _HEXDigitB +instance DC HEXDigit where; dC = _HEXDigitC +instance DD HEXDigit where; dD = _HEXDigitD +instance DE HEXDigit where; dE = _HEXDigitE +instance DF HEXDigit where; dF = _HEXDigitF + +type HEXADECIMALNoZero d = + (D1 d, D2 d, D3 d, D4 d, D5 d, D6 d, D7 d, D8 d, D9 d, DA d, DB d, DC d, DD d, DE d, DF d) + +parseHEXADECIMALNoZero :: + (HEXADECIMALNoZero d, CharParsing p) => + p d +parseHEXADECIMALNoZero = + choice + [ + parseDecimalNoZero + , parseA + , parseB + , parseC + , parseD + , parseE + , parseF + ] "HEXADECIMALNoZero" + +type HEXADECIMAL d = + (D0 d, HEXADECIMALNoZero d) + +parseHEXADECIMAL :: + (HEXADECIMAL d, CharParsing p) => + p d +parseHEXADECIMAL = + choice + [ + parse0 + , parseHEXADECIMALNoZero + ] "HEXADECIMAL" diff --git a/src/Data/Digit/Integral.hs b/src/Data/Digit/Integral.hs --- a/src/Data/Digit/Integral.hs +++ b/src/Data/Digit/Integral.hs @@ -32,17 +32,31 @@ , _HeXDigitsIntegral ) where -import Prelude (error) -import Control.Lens.Extras(is) -import Data.Digit.Binary -import Data.Digit.Decimal -import Data.Digit.Octal -import Data.Digit.Hexadecimal -import Data.Digit.HEXADECIMAL -import Data.Digit.HeXaDeCiMaL -import qualified Data.List.NonEmpty as NonEmpty -import Papa +import Prelude (Eq, Integral, error, fst, lookup, + quotRem, (*), (+), (-), (==), (>=)) +import Control.Applicative (Applicative) +import Control.Category (id, (.)) +import Control.Lens (APrism, Choice, Prism', Review, + clonePrism, outside, prism', unto, + ( # ), (.~), (^?!)) +import Control.Lens.Extras (is) + +import Data.Either (Either (..), either) +import Data.Foldable (find, foldl') +import Data.Function (($),const) +import Data.Functor ((<$>)) +import Data.List.NonEmpty (NonEmpty) +import Data.Maybe (fromMaybe) + +import Data.Digit.Binary +import Data.Digit.Decimal +import Data.Digit.Hexadecimal.LowerCase +import Data.Digit.Hexadecimal.UpperCase +import Data.Digit.Hexadecimal.MixedCase +import Data.Digit.Octal +import qualified Data.List.NonEmpty as NonEmpty + -- $setup -- >>> import Data.Digit @@ -60,7 +74,7 @@ d integralBinaryNoZero = associatePrism (1, d1) [] - + -- | -- -- >>> 0 ^? integralBinary :: Maybe BinDigit @@ -201,7 +215,7 @@ d integralDecimalNoZero = associatePrism (1, d1) [(2, d2), (3, d3), (4, d4), (5, d5), (6, d6), (7, d7), (8, d8), (9, d9)] - + -- | -- >>> 9 ^? integralDecimal :: Maybe DecDigit -- Just DecDigit9 @@ -271,7 +285,7 @@ d integralHexadecimalNoZero = associatePrism (1, d1) [(2, d2), (3, d3), (4, d4), (5, d5), (6, d6), (7, d7), (8, d8), (9, d9), (10, da), (11, db), (12, dc), (13, dd), (14, de), (15, df)] - + -- | -- -- >>> 15 ^? integralHexadecimal :: Maybe HexDigit @@ -342,8 +356,8 @@ d integralHEXADECIMALNoZero = associatePrism (1, d1) [(2, d2), (3, d3), (4, d4), (5, d5), (6, d6), (7, d7), (8, d8), (9, d9), (10, dA), (11, dB), (12, dC), (13, dD), (14, dE), (15, dF)] - + -- | -- -- >>> 15 ^? integralHEXADECIMAL :: Maybe HEXDigit @@ -414,27 +428,27 @@ d integralHeXaDeCiMaLNoZero = unto - (outside d1 .~ (\_ -> 1) $ - outside d2 .~ (\_ -> 2) $ - outside d3 .~ (\_ -> 3) $ - outside d4 .~ (\_ -> 4) $ - outside d5 .~ (\_ -> 5) $ - outside d6 .~ (\_ -> 6) $ - outside d7 .~ (\_ -> 7) $ - outside d8 .~ (\_ -> 8) $ - outside d9 .~ (\_ -> 9) $ - outside da .~ (\_ -> 10) $ - outside dA .~ (\_ -> 10) $ - outside db .~ (\_ -> 11) $ - outside dB .~ (\_ -> 11) $ - outside dc .~ (\_ -> 12) $ - outside dC .~ (\_ -> 12) $ - outside dd .~ (\_ -> 13) $ - outside dD .~ (\_ -> 13) $ - outside de .~ (\_ -> 14) $ - outside dE .~ (\_ -> 14) $ - outside df .~ (\_ -> 15) $ - outside dF .~ (\_ -> 15) $ + (outside d1 .~ const 1 $ + outside d2 .~ const 2 $ + outside d3 .~ const 3 $ + outside d4 .~ const 4 $ + outside d5 .~ const 5 $ + outside d6 .~ const 6 $ + outside d7 .~ const 7 $ + outside d8 .~ const 8 $ + outside d9 .~ const 9 $ + outside da .~ const 10 $ + outside dA .~ const 10 $ + outside db .~ const 11 $ + outside dB .~ const 11 $ + outside dc .~ const 12 $ + outside dC .~ const 12 $ + outside dd .~ const 13 $ + outside dD .~ const 13 $ + outside de .~ const 14 $ + outside dE .~ const 14 $ + outside df .~ const 15 $ + outside dF .~ const 15 $ error "incomplete pattern") -- | @@ -451,28 +465,28 @@ d integralHeXaDeCiMaL = unto - (outside d0 .~ (\_ -> 0) $ - outside d1 .~ (\_ -> 1) $ - outside d2 .~ (\_ -> 2) $ - outside d3 .~ (\_ -> 3) $ - outside d4 .~ (\_ -> 4) $ - outside d5 .~ (\_ -> 5) $ - outside d6 .~ (\_ -> 6) $ - outside d7 .~ (\_ -> 7) $ - outside d8 .~ (\_ -> 8) $ - outside d9 .~ (\_ -> 9) $ - outside da .~ (\_ -> 10) $ - outside dA .~ (\_ -> 10) $ - outside db .~ (\_ -> 11) $ - outside dB .~ (\_ -> 11) $ - outside dc .~ (\_ -> 12) $ - outside dC .~ (\_ -> 12) $ - outside dd .~ (\_ -> 13) $ - outside dD .~ (\_ -> 13) $ - outside de .~ (\_ -> 14) $ - outside dE .~ (\_ -> 14) $ - outside df .~ (\_ -> 15) $ - outside dF .~ (\_ -> 15) $ + (outside d0 .~ const 0 $ + outside d1 .~ const 1 $ + outside d2 .~ const 2 $ + outside d3 .~ const 3 $ + outside d4 .~ const 4 $ + outside d5 .~ const 5 $ + outside d6 .~ const 6 $ + outside d7 .~ const 7 $ + outside d8 .~ const 8 $ + outside d9 .~ const 9 $ + outside da .~ const 10 $ + outside dA .~ const 10 $ + outside db .~ const 11 $ + outside dB .~ const 11 $ + outside dc .~ const 12 $ + outside dC .~ const 12 $ + outside dd .~ const 13 $ + outside dD .~ const 13 $ + outside de .~ const 14 $ + outside dE .~ const 14 $ + outside df .~ const 15 $ + outside dF .~ const 15 $ error "incomplete pattern") -- | diff --git a/src/Data/Digit/Octal.hs b/src/Data/Digit/Octal.hs --- a/src/Data/Digit/Octal.hs +++ b/src/Data/Digit/Octal.hs @@ -18,28 +18,28 @@ , _OctDigit6 , _OctDigit7 -- * Re-exports -, module Data.Digit.D0 -, module Data.Digit.D1 -, module Data.Digit.D2 -, module Data.Digit.D3 -, module Data.Digit.D4 -, module Data.Digit.D5 -, module Data.Digit.D6 -, module Data.Digit.D7 +, module Data.Digit.Class.D0 +, module Data.Digit.Class.D1 +, module Data.Digit.Class.D2 +, module Data.Digit.Class.D3 +, module Data.Digit.Class.D4 +, module Data.Digit.Class.D5 +, module Data.Digit.Class.D6 +, module Data.Digit.Class.D7 ) where import Prelude (Eq, Show, Ord, Enum, Bounded) import Control.Lens.TH (makePrisms) import Text.Parser.Char(CharParsing) import Text.Parser.Combinators((), choice) -import Data.Digit.D0 -import Data.Digit.D1 -import Data.Digit.D2 -import Data.Digit.D3 -import Data.Digit.D4 -import Data.Digit.D5 -import Data.Digit.D6 -import Data.Digit.D7 +import Data.Digit.Class.D0 +import Data.Digit.Class.D1 +import Data.Digit.Class.D2 +import Data.Digit.Class.D3 +import Data.Digit.Class.D4 +import Data.Digit.Class.D5 +import Data.Digit.Class.D6 +import Data.Digit.Class.D7 data OctDigit = OctDigit0 diff --git a/test/Main.hs b/test/Main.hs --- a/test/Main.hs +++ b/test/Main.hs @@ -1,14 +1,28 @@ {-# LANGUAGE RankNTypes #-} - +{-# LANGUAGE NoImplicitPrelude #-} module Main( main ) where import Data.Digit import Numeric.Natural (Natural) -import Prelude (minBound, maxBound) -import Papa hiding (re) +import Prelude (Char, Integral, Int, String, Eq, Show, IO, Integer, minBound, maxBound, fromIntegral,fst,notElem) + +import Control.Category ((.)) +import Control.Monad ((>>=)) +import Control.Applicative ((<*)) +import Control.Lens (Prism', (^?), (#)) + +import Data.Semigroup ((<>)) +import Data.Monoid (mconcat) +import Data.Functor ((<$>),fmap) +import Data.Function (($)) +import Data.Maybe (Maybe (..)) +import Data.Either (Either (..),isLeft) +import Data.List.NonEmpty (NonEmpty) + import Hedgehog(Property, Gen, forAll, property, assert, (===)) + import Test.Tasty(TestTree, defaultMain, testGroup) import Test.Tasty.Hedgehog(testProperty) import Test.Tasty.HUnit(testCase, (@?=)) @@ -25,20 +39,20 @@ -> [TestTree] testPrism g n p x = testProperty - (n ++ " prism invalid values") + (n <> " prism invalid values") ( property $ - do c <- forAll . Gen.filter (`notElem` (map fst x)) $ g + do c <- forAll . Gen.filter (`notElem` (fmap fst x)) $ g (c ^? p :: Maybe HeXDigit) === Nothing ) : ( x >>= \(c, d) -> [ testCase - (n ++ " prism ->") + (n <> " prism ->") ((c ^? p :: Maybe HeXDigit) @?= Just d) , testCase - (n ++ " prism <-") + (n <> " prism <-") (p # d @?= c) ] ) @@ -50,26 +64,26 @@ -> [TestTree] testParser n p x = ( - let n' = n ++ " parser invalid values" + let n' = n <> " parser invalid values" in testProperty n' ( property $ - do c <- forAll . Gen.filter (`notElem` (map fst x)) . Gen.choice $ [Gen.hexit, Gen.unicode] - assert (isLeft (parse p (n' ++ " test") [c] :: Either ParseError HeXDigit)) + do c <- forAll . Gen.filter (`notElem` (fmap fst x)) . Gen.choice $ [Gen.hexit, Gen.unicode] + assert (isLeft (parse p (n' <> " test") [c] :: Either ParseError HeXDigit)) ) ) : ( x >>= \(c, d) -> [ - let n' = n ++ " parses exactly one character" + let n' = n <> " parses exactly one character" in testCase n' - ((parse (p <* eof) (n' ++ " test") [c] :: Either ParseError HeXDigit) @?= Right d) - , let n' = n ++ " parses the correct digit" + ((parse (p <* eof) (n' <> " test") [c] :: Either ParseError HeXDigit) @?= Right d) + , let n' = n <> " parses the correct digit" in testCase n' - ((parse p (n' ++ "test") (c:"xyz") :: Either ParseError HeXDigit) @?= Right d) + ((parse p (n' <> "test") (c:"xyz") :: Either ParseError HeXDigit) @?= Right d) ] ) @@ -228,7 +242,7 @@ rE = (14 , HeXDigitE) rF :: (Integer, HeXDigit) rF = (15 , HeXDigitF) - in concat [ + in mconcat [ charPrism "charBinaryNoZero" charBinaryNoZero [q1] , charPrism "charBinary" charBinary [q0, q1] , charPrism "charOctalNoZero" charOctalNoZero [q1, q2, q3, q4, q5, q6, q7]