{-# 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 =
    forall d. DA d => Prism' d ()
dA forall t b. AReview t b -> b -> t
# ()

instance DA () where
  dA :: Prism' () ()
dA =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

class DB d where
  dB ::
    Prism'
      d
      ()
  xB ::
    d
  xB =
    forall d. DB d => Prism' d ()
dB forall t b. AReview t b -> b -> t
# ()

instance DB () where
  dB :: Prism' () ()
dB =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

class DC d where
  dC ::
    Prism'
      d
      ()
  xC ::
    d
  xC =
    forall d. DC d => Prism' d ()
dC forall t b. AReview t b -> b -> t
# ()

instance DC () where
  dC :: Prism' () ()
dC =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

class DD d where
  dD ::
    Prism'
      d
      ()
  xD ::
    d
  xD =
    forall d. DD d => Prism' d ()
dD forall t b. AReview t b -> b -> t
# ()

instance DD () where
  dD :: Prism' () ()
dD =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

class DE d where
  dE ::
    Prism'
      d
      ()
  xE ::
    d
  xE =
    forall d. DE d => Prism' d ()
dE forall t b. AReview t b -> b -> t
# ()

instance DE () where
  dE :: Prism' () ()
dE =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

class DF d where
  dF ::
    Prism'
      d
      ()
  xF ::
    d
  xF =
    forall d. DF d => Prism' d ()
dF forall t b. AReview t b -> b -> t
# ()

instance DF () where
  dF :: Prism' () ()
dF =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
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 :: forall d (p :: * -> *). (DA d, CharParsing p) => p d
parseA =
  forall d. DA d => d
xA forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'A' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"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 :: forall d (p :: * -> *). (DB d, CharParsing p) => p d
parseB =
  forall d. DB d => d
xB forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'B' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"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 :: forall d (p :: * -> *). (DC d, CharParsing p) => p d
parseC =
  forall d. DC d => d
xC forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'C' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"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 :: forall d (p :: * -> *). (DD d, CharParsing p) => p d
parseD =
  forall d. DD d => d
xD forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'D' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"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 :: forall d (p :: * -> *). (DE d, CharParsing p) => p d
parseE =
  forall d. DE d => d
xE forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'E' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"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 :: forall d (p :: * -> *). (DF d, CharParsing p) => p d
parseF =
  forall d. DF d => d
xF forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'F' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"F"