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

instance DA () where
  dA :: p () (f ()) -> p () (f ())
dA =
    p () (f ()) -> p () (f ())
forall k (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

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

instance DB () where
  dB :: p () (f ()) -> p () (f ())
dB =
    p () (f ()) -> p () (f ())
forall k (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

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

instance DC () where
  dC :: p () (f ()) -> p () (f ())
dC =
    p () (f ()) -> p () (f ())
forall k (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

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

instance DD () where
  dD :: p () (f ()) -> p () (f ())
dD =
    p () (f ()) -> p () (f ())
forall k (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

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

instance DE () where
  dE :: p () (f ()) -> p () (f ())
dE =
    p () (f ()) -> p () (f ())
forall k (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

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

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