module ASCII.Hexadecimal
    (
    {- * Read/show for numeric strings -}
    {- ** Natural  -} showNatural,  readNatural,
    {- ** Integer  -} showInteger,  readInteger,
    {- ** Integral -} showIntegral, readIntegral,

    {- * Various digit types -} HexChar (..), HexLetter (..), HexCharBreakdown (..),

    {- * Monomorphic character conversions -}
    {- ** HexLetter ↔ D16              -} hexLetterD16, d16HexLetter,
    {- ** HexLetter ↔ HexChar          -} letterHexChar, hexCharLetter,
    {- ** HexChar   ↔ ASCII Char       -} hexAsciiChar, asciiCharHex,
    {- ** HexChar   ↔ D16              -} d16HexChar, hexCharD16,
    {- ** HexChar   ↔ HexCharBreakdown -} breakDownHexChar, assembleHexChar,

    {- * Hexadecimal character superset classes -}
    {- * Of hex character       -} HexCharSuperset (..),
    {- * Of hex character lists -} HexStringSuperset (..),

    {- * Character/number conversions -}
    {- ** Natural ↔ HexChar -} naturalHexCharMaybe, hexCharNatural, naturalHexCharUnsafe,
    {- ** Natural ↔ D16     -} naturalD16Maybe,     d16Natural,     naturalD16Unsafe,
    {- ** Integer ↔ HexChar -} integerHexCharMaybe, hexCharInteger, integerHexCharUnsafe,
    {- ** Integer ↔ D16     -} integerD16Maybe,     d16Integer,     integerD16Unsafe

    ) where

import ASCII.Case (Case (..))
import qualified ASCII.Char as ASCII
import qualified ASCII.Decimal as Dec
import ASCII.Lift (Lift (lift))
import ASCII.Refinement (ASCII, asciiUnsafe, lift)
import ASCII.Superset (StringSuperset, fromChar, fromCharList, toCharListMaybe,
                       toCharMaybe)
import ASCII.Word4 (Word4)
import qualified ASCII.Word4 as Word4

import Control.Monad (guard, (<=<), (=<<))
import Data.Bifoldable (bifoldMap)
import Data.Bits (Bits, toIntegralSized)
import Data.Bool (Bool, (&&))
import Data.Data (Data)
import Data.Eq (Eq)
import Data.Function (id, ($), (.))
import Data.Functor (fmap)
import Data.Hashable (Hashable)
import Data.Maybe (Maybe (Just, Nothing), fromJust, isJust)
import Data.Monoid (mempty)
import Data.Ord (Ord (..))
import Data.Word (Word8)
import GHC.Generics (Generic)
import Numeric.Natural (Natural)
import Prelude (Bounded (..), Enum (..), Integer, Integral, abs, fromEnum,
                fromInteger, fromIntegral, negate, quotRem, toEnum, toInteger,
                (*), (+), (-))
import Text.Show (Show)

import qualified Data.Bool as Bool
import qualified Data.Char as Unicode
import qualified Data.List as List

import Data.List.NonEmpty (NonEmpty, nonEmpty)

import qualified DList

import qualified Data.ByteString as BS
import qualified Data.ByteString.Builder as BSB
import qualified Data.ByteString.Lazy as LBS

import qualified Data.Text as T
import qualified Data.Text.Lazy as LT
import qualified Data.Text.Lazy.Builder as TB

---  Types  ---

-- | Letters used as hexadecimal digits above 9, without a notion of case.
data HexLetter =
    LetterA -- ^ 10
  | LetterB -- ^ 11
  | LetterC -- ^ 12
  | LetterD -- ^ 13
  | LetterE -- ^ 14
  | LetterF -- ^ 15
    deriving stock (HexLetter
HexLetter -> HexLetter -> Bounded HexLetter
forall a. a -> a -> Bounded a
maxBound :: HexLetter
$cmaxBound :: HexLetter
minBound :: HexLetter
$cminBound :: HexLetter
Bounded, Int -> HexLetter
HexLetter -> Int
HexLetter -> [HexLetter]
HexLetter -> HexLetter
HexLetter -> HexLetter -> [HexLetter]
HexLetter -> HexLetter -> HexLetter -> [HexLetter]
(HexLetter -> HexLetter)
-> (HexLetter -> HexLetter)
-> (Int -> HexLetter)
-> (HexLetter -> Int)
-> (HexLetter -> [HexLetter])
-> (HexLetter -> HexLetter -> [HexLetter])
-> (HexLetter -> HexLetter -> [HexLetter])
-> (HexLetter -> HexLetter -> HexLetter -> [HexLetter])
-> Enum HexLetter
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: HexLetter -> HexLetter -> HexLetter -> [HexLetter]
$cenumFromThenTo :: HexLetter -> HexLetter -> HexLetter -> [HexLetter]
enumFromTo :: HexLetter -> HexLetter -> [HexLetter]
$cenumFromTo :: HexLetter -> HexLetter -> [HexLetter]
enumFromThen :: HexLetter -> HexLetter -> [HexLetter]
$cenumFromThen :: HexLetter -> HexLetter -> [HexLetter]
enumFrom :: HexLetter -> [HexLetter]
$cenumFrom :: HexLetter -> [HexLetter]
fromEnum :: HexLetter -> Int
$cfromEnum :: HexLetter -> Int
toEnum :: Int -> HexLetter
$ctoEnum :: Int -> HexLetter
pred :: HexLetter -> HexLetter
$cpred :: HexLetter -> HexLetter
succ :: HexLetter -> HexLetter
$csucc :: HexLetter -> HexLetter
Enum, HexLetter -> HexLetter -> Bool
(HexLetter -> HexLetter -> Bool)
-> (HexLetter -> HexLetter -> Bool) -> Eq HexLetter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HexLetter -> HexLetter -> Bool
$c/= :: HexLetter -> HexLetter -> Bool
== :: HexLetter -> HexLetter -> Bool
$c== :: HexLetter -> HexLetter -> Bool
Eq, Eq HexLetter
Eq HexLetter
-> (HexLetter -> HexLetter -> Ordering)
-> (HexLetter -> HexLetter -> Bool)
-> (HexLetter -> HexLetter -> Bool)
-> (HexLetter -> HexLetter -> Bool)
-> (HexLetter -> HexLetter -> Bool)
-> (HexLetter -> HexLetter -> HexLetter)
-> (HexLetter -> HexLetter -> HexLetter)
-> Ord HexLetter
HexLetter -> HexLetter -> Bool
HexLetter -> HexLetter -> Ordering
HexLetter -> HexLetter -> HexLetter
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: HexLetter -> HexLetter -> HexLetter
$cmin :: HexLetter -> HexLetter -> HexLetter
max :: HexLetter -> HexLetter -> HexLetter
$cmax :: HexLetter -> HexLetter -> HexLetter
>= :: HexLetter -> HexLetter -> Bool
$c>= :: HexLetter -> HexLetter -> Bool
> :: HexLetter -> HexLetter -> Bool
$c> :: HexLetter -> HexLetter -> Bool
<= :: HexLetter -> HexLetter -> Bool
$c<= :: HexLetter -> HexLetter -> Bool
< :: HexLetter -> HexLetter -> Bool
$c< :: HexLetter -> HexLetter -> Bool
compare :: HexLetter -> HexLetter -> Ordering
$ccompare :: HexLetter -> HexLetter -> Ordering
$cp1Ord :: Eq HexLetter
Ord, Int -> HexLetter -> ShowS
[HexLetter] -> ShowS
HexLetter -> String
(Int -> HexLetter -> ShowS)
-> (HexLetter -> String)
-> ([HexLetter] -> ShowS)
-> Show HexLetter
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [HexLetter] -> ShowS
$cshowList :: [HexLetter] -> ShowS
show :: HexLetter -> String
$cshow :: HexLetter -> String
showsPrec :: Int -> HexLetter -> ShowS
$cshowsPrec :: Int -> HexLetter -> ShowS
Show, Typeable HexLetter
DataType
Constr
Typeable HexLetter
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HexLetter -> c HexLetter)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HexLetter)
-> (HexLetter -> Constr)
-> (HexLetter -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HexLetter))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HexLetter))
-> ((forall b. Data b => b -> b) -> HexLetter -> HexLetter)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HexLetter -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HexLetter -> r)
-> (forall u. (forall d. Data d => d -> u) -> HexLetter -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> HexLetter -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HexLetter -> m HexLetter)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HexLetter -> m HexLetter)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HexLetter -> m HexLetter)
-> Data HexLetter
HexLetter -> DataType
HexLetter -> Constr
(forall b. Data b => b -> b) -> HexLetter -> HexLetter
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HexLetter -> c HexLetter
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HexLetter
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> HexLetter -> u
forall u. (forall d. Data d => d -> u) -> HexLetter -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HexLetter -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HexLetter -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HexLetter -> m HexLetter
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HexLetter -> m HexLetter
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HexLetter
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HexLetter -> c HexLetter
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HexLetter)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HexLetter)
$cLetterF :: Constr
$cLetterE :: Constr
$cLetterD :: Constr
$cLetterC :: Constr
$cLetterB :: Constr
$cLetterA :: Constr
$tHexLetter :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> HexLetter -> m HexLetter
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HexLetter -> m HexLetter
gmapMp :: (forall d. Data d => d -> m d) -> HexLetter -> m HexLetter
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HexLetter -> m HexLetter
gmapM :: (forall d. Data d => d -> m d) -> HexLetter -> m HexLetter
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HexLetter -> m HexLetter
gmapQi :: Int -> (forall d. Data d => d -> u) -> HexLetter -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HexLetter -> u
gmapQ :: (forall d. Data d => d -> u) -> HexLetter -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HexLetter -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HexLetter -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HexLetter -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HexLetter -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HexLetter -> r
gmapT :: (forall b. Data b => b -> b) -> HexLetter -> HexLetter
$cgmapT :: (forall b. Data b => b -> b) -> HexLetter -> HexLetter
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HexLetter)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HexLetter)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HexLetter)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HexLetter)
dataTypeOf :: HexLetter -> DataType
$cdataTypeOf :: HexLetter -> DataType
toConstr :: HexLetter -> Constr
$ctoConstr :: HexLetter -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HexLetter
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HexLetter
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HexLetter -> c HexLetter
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HexLetter -> c HexLetter
$cp1Data :: Typeable HexLetter
Data, (forall x. HexLetter -> Rep HexLetter x)
-> (forall x. Rep HexLetter x -> HexLetter) -> Generic HexLetter
forall x. Rep HexLetter x -> HexLetter
forall x. HexLetter -> Rep HexLetter x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep HexLetter x -> HexLetter
$cfrom :: forall x. HexLetter -> Rep HexLetter x
Generic)
    deriving anyclass Eq HexLetter
Eq HexLetter
-> (Int -> HexLetter -> Int)
-> (HexLetter -> Int)
-> Hashable HexLetter
Int -> HexLetter -> Int
HexLetter -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: HexLetter -> Int
$chash :: HexLetter -> Int
hashWithSalt :: Int -> HexLetter -> Int
$chashWithSalt :: Int -> HexLetter -> Int
$cp1Hashable :: Eq HexLetter
Hashable

{- | The subset of ASCII used to represent hexadecimal numbers:

* 'ASCII.Char.Digit0' to 'ASCII.Char.Digit9'
* 'ASCII.Char.CapitalLetterA' to 'ASCII.Char.CapitalLetterF'
* 'ASCII.Char.SmallLetterA' to 'ASCII.Char.SmallLetterF'
-}
data HexChar =
      Digit0 | Digit1 | Digit2 | Digit3 | Digit4
    | Digit5 | Digit6 | Digit7 | Digit8 | Digit9
    | CapitalLetterA | CapitalLetterB | CapitalLetterC
    | CapitalLetterD | CapitalLetterE | CapitalLetterF
    | SmallLetterA | SmallLetterB | SmallLetterC
    | SmallLetterD | SmallLetterE | SmallLetterF
    deriving stock (HexChar
HexChar -> HexChar -> Bounded HexChar
forall a. a -> a -> Bounded a
maxBound :: HexChar
$cmaxBound :: HexChar
minBound :: HexChar
$cminBound :: HexChar
Bounded, Int -> HexChar
HexChar -> Int
HexChar -> [HexChar]
HexChar -> HexChar
HexChar -> HexChar -> [HexChar]
HexChar -> HexChar -> HexChar -> [HexChar]
(HexChar -> HexChar)
-> (HexChar -> HexChar)
-> (Int -> HexChar)
-> (HexChar -> Int)
-> (HexChar -> [HexChar])
-> (HexChar -> HexChar -> [HexChar])
-> (HexChar -> HexChar -> [HexChar])
-> (HexChar -> HexChar -> HexChar -> [HexChar])
-> Enum HexChar
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: HexChar -> HexChar -> HexChar -> [HexChar]
$cenumFromThenTo :: HexChar -> HexChar -> HexChar -> [HexChar]
enumFromTo :: HexChar -> HexChar -> [HexChar]
$cenumFromTo :: HexChar -> HexChar -> [HexChar]
enumFromThen :: HexChar -> HexChar -> [HexChar]
$cenumFromThen :: HexChar -> HexChar -> [HexChar]
enumFrom :: HexChar -> [HexChar]
$cenumFrom :: HexChar -> [HexChar]
fromEnum :: HexChar -> Int
$cfromEnum :: HexChar -> Int
toEnum :: Int -> HexChar
$ctoEnum :: Int -> HexChar
pred :: HexChar -> HexChar
$cpred :: HexChar -> HexChar
succ :: HexChar -> HexChar
$csucc :: HexChar -> HexChar
Enum, HexChar -> HexChar -> Bool
(HexChar -> HexChar -> Bool)
-> (HexChar -> HexChar -> Bool) -> Eq HexChar
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HexChar -> HexChar -> Bool
$c/= :: HexChar -> HexChar -> Bool
== :: HexChar -> HexChar -> Bool
$c== :: HexChar -> HexChar -> Bool
Eq, Eq HexChar
Eq HexChar
-> (HexChar -> HexChar -> Ordering)
-> (HexChar -> HexChar -> Bool)
-> (HexChar -> HexChar -> Bool)
-> (HexChar -> HexChar -> Bool)
-> (HexChar -> HexChar -> Bool)
-> (HexChar -> HexChar -> HexChar)
-> (HexChar -> HexChar -> HexChar)
-> Ord HexChar
HexChar -> HexChar -> Bool
HexChar -> HexChar -> Ordering
HexChar -> HexChar -> HexChar
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: HexChar -> HexChar -> HexChar
$cmin :: HexChar -> HexChar -> HexChar
max :: HexChar -> HexChar -> HexChar
$cmax :: HexChar -> HexChar -> HexChar
>= :: HexChar -> HexChar -> Bool
$c>= :: HexChar -> HexChar -> Bool
> :: HexChar -> HexChar -> Bool
$c> :: HexChar -> HexChar -> Bool
<= :: HexChar -> HexChar -> Bool
$c<= :: HexChar -> HexChar -> Bool
< :: HexChar -> HexChar -> Bool
$c< :: HexChar -> HexChar -> Bool
compare :: HexChar -> HexChar -> Ordering
$ccompare :: HexChar -> HexChar -> Ordering
$cp1Ord :: Eq HexChar
Ord, Int -> HexChar -> ShowS
[HexChar] -> ShowS
HexChar -> String
(Int -> HexChar -> ShowS)
-> (HexChar -> String) -> ([HexChar] -> ShowS) -> Show HexChar
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [HexChar] -> ShowS
$cshowList :: [HexChar] -> ShowS
show :: HexChar -> String
$cshow :: HexChar -> String
showsPrec :: Int -> HexChar -> ShowS
$cshowsPrec :: Int -> HexChar -> ShowS
Show, Typeable HexChar
DataType
Constr
Typeable HexChar
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HexChar -> c HexChar)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HexChar)
-> (HexChar -> Constr)
-> (HexChar -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HexChar))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HexChar))
-> ((forall b. Data b => b -> b) -> HexChar -> HexChar)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HexChar -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HexChar -> r)
-> (forall u. (forall d. Data d => d -> u) -> HexChar -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> HexChar -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HexChar -> m HexChar)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HexChar -> m HexChar)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HexChar -> m HexChar)
-> Data HexChar
HexChar -> DataType
HexChar -> Constr
(forall b. Data b => b -> b) -> HexChar -> HexChar
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HexChar -> c HexChar
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HexChar
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> HexChar -> u
forall u. (forall d. Data d => d -> u) -> HexChar -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HexChar -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HexChar -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HexChar -> m HexChar
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HexChar -> m HexChar
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HexChar
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HexChar -> c HexChar
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HexChar)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HexChar)
$cSmallLetterF :: Constr
$cSmallLetterE :: Constr
$cSmallLetterD :: Constr
$cSmallLetterC :: Constr
$cSmallLetterB :: Constr
$cSmallLetterA :: Constr
$cCapitalLetterF :: Constr
$cCapitalLetterE :: Constr
$cCapitalLetterD :: Constr
$cCapitalLetterC :: Constr
$cCapitalLetterB :: Constr
$cCapitalLetterA :: Constr
$cDigit9 :: Constr
$cDigit8 :: Constr
$cDigit7 :: Constr
$cDigit6 :: Constr
$cDigit5 :: Constr
$cDigit4 :: Constr
$cDigit3 :: Constr
$cDigit2 :: Constr
$cDigit1 :: Constr
$cDigit0 :: Constr
$tHexChar :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> HexChar -> m HexChar
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HexChar -> m HexChar
gmapMp :: (forall d. Data d => d -> m d) -> HexChar -> m HexChar
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HexChar -> m HexChar
gmapM :: (forall d. Data d => d -> m d) -> HexChar -> m HexChar
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HexChar -> m HexChar
gmapQi :: Int -> (forall d. Data d => d -> u) -> HexChar -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HexChar -> u
gmapQ :: (forall d. Data d => d -> u) -> HexChar -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HexChar -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HexChar -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HexChar -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HexChar -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HexChar -> r
gmapT :: (forall b. Data b => b -> b) -> HexChar -> HexChar
$cgmapT :: (forall b. Data b => b -> b) -> HexChar -> HexChar
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HexChar)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HexChar)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HexChar)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HexChar)
dataTypeOf :: HexChar -> DataType
$cdataTypeOf :: HexChar -> DataType
toConstr :: HexChar -> Constr
$ctoConstr :: HexChar -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HexChar
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HexChar
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HexChar -> c HexChar
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HexChar -> c HexChar
$cp1Data :: Typeable HexChar
Data, (forall x. HexChar -> Rep HexChar x)
-> (forall x. Rep HexChar x -> HexChar) -> Generic HexChar
forall x. Rep HexChar x -> HexChar
forall x. HexChar -> Rep HexChar x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep HexChar x -> HexChar
$cfrom :: forall x. HexChar -> Rep HexChar x
Generic)
    deriving anyclass Eq HexChar
Eq HexChar
-> (Int -> HexChar -> Int) -> (HexChar -> Int) -> Hashable HexChar
Int -> HexChar -> Int
HexChar -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: HexChar -> Int
$chash :: HexChar -> Int
hashWithSalt :: Int -> HexChar -> Int
$chashWithSalt :: Int -> HexChar -> Int
$cp1Hashable :: Eq HexChar
Hashable

data HexCharBreakdown = HexDigit Dec.Digit | HexLetter Case HexLetter
    deriving stock (HexCharBreakdown -> HexCharBreakdown -> Bool
(HexCharBreakdown -> HexCharBreakdown -> Bool)
-> (HexCharBreakdown -> HexCharBreakdown -> Bool)
-> Eq HexCharBreakdown
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HexCharBreakdown -> HexCharBreakdown -> Bool
$c/= :: HexCharBreakdown -> HexCharBreakdown -> Bool
== :: HexCharBreakdown -> HexCharBreakdown -> Bool
$c== :: HexCharBreakdown -> HexCharBreakdown -> Bool
Eq, Eq HexCharBreakdown
Eq HexCharBreakdown
-> (HexCharBreakdown -> HexCharBreakdown -> Ordering)
-> (HexCharBreakdown -> HexCharBreakdown -> Bool)
-> (HexCharBreakdown -> HexCharBreakdown -> Bool)
-> (HexCharBreakdown -> HexCharBreakdown -> Bool)
-> (HexCharBreakdown -> HexCharBreakdown -> Bool)
-> (HexCharBreakdown -> HexCharBreakdown -> HexCharBreakdown)
-> (HexCharBreakdown -> HexCharBreakdown -> HexCharBreakdown)
-> Ord HexCharBreakdown
HexCharBreakdown -> HexCharBreakdown -> Bool
HexCharBreakdown -> HexCharBreakdown -> Ordering
HexCharBreakdown -> HexCharBreakdown -> HexCharBreakdown
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: HexCharBreakdown -> HexCharBreakdown -> HexCharBreakdown
$cmin :: HexCharBreakdown -> HexCharBreakdown -> HexCharBreakdown
max :: HexCharBreakdown -> HexCharBreakdown -> HexCharBreakdown
$cmax :: HexCharBreakdown -> HexCharBreakdown -> HexCharBreakdown
>= :: HexCharBreakdown -> HexCharBreakdown -> Bool
$c>= :: HexCharBreakdown -> HexCharBreakdown -> Bool
> :: HexCharBreakdown -> HexCharBreakdown -> Bool
$c> :: HexCharBreakdown -> HexCharBreakdown -> Bool
<= :: HexCharBreakdown -> HexCharBreakdown -> Bool
$c<= :: HexCharBreakdown -> HexCharBreakdown -> Bool
< :: HexCharBreakdown -> HexCharBreakdown -> Bool
$c< :: HexCharBreakdown -> HexCharBreakdown -> Bool
compare :: HexCharBreakdown -> HexCharBreakdown -> Ordering
$ccompare :: HexCharBreakdown -> HexCharBreakdown -> Ordering
$cp1Ord :: Eq HexCharBreakdown
Ord, Int -> HexCharBreakdown -> ShowS
[HexCharBreakdown] -> ShowS
HexCharBreakdown -> String
(Int -> HexCharBreakdown -> ShowS)
-> (HexCharBreakdown -> String)
-> ([HexCharBreakdown] -> ShowS)
-> Show HexCharBreakdown
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [HexCharBreakdown] -> ShowS
$cshowList :: [HexCharBreakdown] -> ShowS
show :: HexCharBreakdown -> String
$cshow :: HexCharBreakdown -> String
showsPrec :: Int -> HexCharBreakdown -> ShowS
$cshowsPrec :: Int -> HexCharBreakdown -> ShowS
Show, Typeable HexCharBreakdown
DataType
Constr
Typeable HexCharBreakdown
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HexCharBreakdown -> c HexCharBreakdown)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HexCharBreakdown)
-> (HexCharBreakdown -> Constr)
-> (HexCharBreakdown -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HexCharBreakdown))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HexCharBreakdown))
-> ((forall b. Data b => b -> b)
    -> HexCharBreakdown -> HexCharBreakdown)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HexCharBreakdown -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HexCharBreakdown -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> HexCharBreakdown -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> HexCharBreakdown -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> HexCharBreakdown -> m HexCharBreakdown)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> HexCharBreakdown -> m HexCharBreakdown)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> HexCharBreakdown -> m HexCharBreakdown)
-> Data HexCharBreakdown
HexCharBreakdown -> DataType
HexCharBreakdown -> Constr
(forall b. Data b => b -> b)
-> HexCharBreakdown -> HexCharBreakdown
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HexCharBreakdown -> c HexCharBreakdown
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HexCharBreakdown
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> HexCharBreakdown -> u
forall u. (forall d. Data d => d -> u) -> HexCharBreakdown -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HexCharBreakdown -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HexCharBreakdown -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> HexCharBreakdown -> m HexCharBreakdown
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> HexCharBreakdown -> m HexCharBreakdown
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HexCharBreakdown
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HexCharBreakdown -> c HexCharBreakdown
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HexCharBreakdown)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c HexCharBreakdown)
$cHexLetter :: Constr
$cHexDigit :: Constr
$tHexCharBreakdown :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> HexCharBreakdown -> m HexCharBreakdown
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> HexCharBreakdown -> m HexCharBreakdown
gmapMp :: (forall d. Data d => d -> m d)
-> HexCharBreakdown -> m HexCharBreakdown
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> HexCharBreakdown -> m HexCharBreakdown
gmapM :: (forall d. Data d => d -> m d)
-> HexCharBreakdown -> m HexCharBreakdown
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> HexCharBreakdown -> m HexCharBreakdown
gmapQi :: Int -> (forall d. Data d => d -> u) -> HexCharBreakdown -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> HexCharBreakdown -> u
gmapQ :: (forall d. Data d => d -> u) -> HexCharBreakdown -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HexCharBreakdown -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HexCharBreakdown -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HexCharBreakdown -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HexCharBreakdown -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HexCharBreakdown -> r
gmapT :: (forall b. Data b => b -> b)
-> HexCharBreakdown -> HexCharBreakdown
$cgmapT :: (forall b. Data b => b -> b)
-> HexCharBreakdown -> HexCharBreakdown
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c HexCharBreakdown)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c HexCharBreakdown)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HexCharBreakdown)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HexCharBreakdown)
dataTypeOf :: HexCharBreakdown -> DataType
$cdataTypeOf :: HexCharBreakdown -> DataType
toConstr :: HexCharBreakdown -> Constr
$ctoConstr :: HexCharBreakdown -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HexCharBreakdown
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HexCharBreakdown
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HexCharBreakdown -> c HexCharBreakdown
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HexCharBreakdown -> c HexCharBreakdown
$cp1Data :: Typeable HexCharBreakdown
Data, (forall x. HexCharBreakdown -> Rep HexCharBreakdown x)
-> (forall x. Rep HexCharBreakdown x -> HexCharBreakdown)
-> Generic HexCharBreakdown
forall x. Rep HexCharBreakdown x -> HexCharBreakdown
forall x. HexCharBreakdown -> Rep HexCharBreakdown x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep HexCharBreakdown x -> HexCharBreakdown
$cfrom :: forall x. HexCharBreakdown -> Rep HexCharBreakdown x
Generic)
    deriving anyclass Eq HexCharBreakdown
Eq HexCharBreakdown
-> (Int -> HexCharBreakdown -> Int)
-> (HexCharBreakdown -> Int)
-> Hashable HexCharBreakdown
Int -> HexCharBreakdown -> Int
HexCharBreakdown -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: HexCharBreakdown -> Int
$chash :: HexCharBreakdown -> Int
hashWithSalt :: Int -> HexCharBreakdown -> Int
$chashWithSalt :: Int -> HexCharBreakdown -> Int
$cp1Hashable :: Eq HexCharBreakdown
Hashable

-- | Behaves the same as 'HexChar'
instance Enum HexCharBreakdown
  where
    fromEnum :: HexCharBreakdown -> Int
fromEnum = HexChar -> Int
forall a. Enum a => a -> Int
fromEnum (HexChar -> Int)
-> (HexCharBreakdown -> HexChar) -> HexCharBreakdown -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HexCharBreakdown -> HexChar
assembleHexChar
    toEnum :: Int -> HexCharBreakdown
toEnum = HexChar -> HexCharBreakdown
breakDownHexChar (HexChar -> HexCharBreakdown)
-> (Int -> HexChar) -> Int -> HexCharBreakdown
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> HexChar
forall a. Enum a => Int -> a
toEnum

-- | Behaves the same as 'HexChar'
instance Bounded HexCharBreakdown
  where
    minBound :: HexCharBreakdown
minBound = HexChar -> HexCharBreakdown
breakDownHexChar HexChar
forall a. Bounded a => a
minBound
    maxBound :: HexCharBreakdown
maxBound = HexChar -> HexCharBreakdown
breakDownHexChar HexChar
forall a. Bounded a => a
maxBound


---  Monomorphic conversions between the character types  ---

breakDownHexChar :: HexChar -> HexCharBreakdown
breakDownHexChar :: HexChar -> HexCharBreakdown
breakDownHexChar =
    \case
        HexChar
x | HexChar
x HexChar -> HexChar -> Bool
forall a. Ord a => a -> a -> Bool
<= HexChar
Digit9          ->  Digit -> HexCharBreakdown
HexDigit            (Int -> Digit
forall a. Enum a => Int -> a
toEnum (HexChar -> Int
forall a. Enum a => a -> Int
fromEnum HexChar
x))
        HexChar
x | HexChar
x HexChar -> HexChar -> Bool
forall a. Ord a => a -> a -> Bool
<= HexChar
CapitalLetterF  ->  Case -> HexLetter -> HexCharBreakdown
HexLetter Case
UpperCase (Int -> HexLetter
forall a. Enum a => Int -> a
toEnum (HexChar -> Int
forall a. Enum a => a -> Int
fromEnum HexChar
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
10))
        HexChar
x                        ->  Case -> HexLetter -> HexCharBreakdown
HexLetter Case
LowerCase (Int -> HexLetter
forall a. Enum a => Int -> a
toEnum (HexChar -> Int
forall a. Enum a => a -> Int
fromEnum HexChar
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
16))

assembleHexChar :: HexCharBreakdown -> HexChar
assembleHexChar :: HexCharBreakdown -> HexChar
assembleHexChar =
    \case
        HexDigit Digit
x             ->  Int -> HexChar
forall a. Enum a => Int -> a
toEnum (Digit -> Int
forall a. Enum a => a -> Int
fromEnum Digit
x)
        HexLetter Case
UpperCase HexLetter
x  ->  Int -> HexChar
forall a. Enum a => Int -> a
toEnum (HexLetter -> Int
forall a. Enum a => a -> Int
fromEnum HexLetter
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
10)
        HexLetter Case
LowerCase HexLetter
x  ->  Int -> HexChar
forall a. Enum a => Int -> a
toEnum (HexLetter -> Int
forall a. Enum a => a -> Int
fromEnum HexLetter
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
16)

d16HexChar :: Case -> Word4 -> HexChar
d16HexChar :: Case -> Word4 -> HexChar
d16HexChar Case
c =
    Int -> HexChar
forall a. Enum a => Int -> a
toEnum
    (Int -> HexChar) -> (Word4 -> Int) -> Word4 -> HexChar
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    case Case
c of
        Case
UpperCase -> Word4 -> Int
forall a. Enum a => a -> Int
fromEnum
        Case
LowerCase -> \case
            Word4
x | Word4
x Word4 -> Word4 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word4
Word4.Number9  ->  Word4 -> Int
forall a. Enum a => a -> Int
fromEnum Word4
x
            Word4
x                       ->  Word4 -> Int
forall a. Enum a => a -> Int
fromEnum Word4
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
6

hexCharD16 :: HexChar -> Word4
hexCharD16 :: HexChar -> Word4
hexCharD16 =
    \case
        HexChar
x | HexChar
x HexChar -> HexChar -> Bool
forall a. Ord a => a -> a -> Bool
< HexChar
SmallLetterA  ->  Int -> Word4
forall a. Enum a => Int -> a
toEnum (HexChar -> Int
forall a. Enum a => a -> Int
fromEnum HexChar
x)
        HexChar
x                     ->  Int -> Word4
forall a. Enum a => Int -> a
toEnum (HexChar -> Int
forall a. Enum a => a -> Int
fromEnum HexChar
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
6)

hexAsciiChar :: HexChar -> ASCII.Char
hexAsciiChar :: HexChar -> Char
hexAsciiChar =
    Int -> Char
forall a. Enum a => Int -> a
toEnum
    (Int -> Char) -> (HexChar -> Int) -> HexChar -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    \case
        HexChar
x | HexChar
x HexChar -> HexChar -> Bool
forall a. Ord a => a -> a -> Bool
<= HexChar
Digit9          ->  Char -> Int
forall a. Enum a => a -> Int
fromEnum Char
ASCII.Digit0         Int -> Int -> Int
forall a. Num a => a -> a -> a
+ HexChar -> Int
forall a. Enum a => a -> Int
fromEnum HexChar
x
        HexChar
x | HexChar
x HexChar -> HexChar -> Bool
forall a. Ord a => a -> a -> Bool
<= HexChar
CapitalLetterF  ->  Char -> Int
forall a. Enum a => a -> Int
fromEnum Char
ASCII.CapitalLetterA Int -> Int -> Int
forall a. Num a => a -> a -> a
+ HexChar -> Int
forall a. Enum a => a -> Int
fromEnum HexChar
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
10
        HexChar
x                        ->  Char -> Int
forall a. Enum a => a -> Int
fromEnum Char
ASCII.SmallLetterA   Int -> Int -> Int
forall a. Num a => a -> a -> a
+ HexChar -> Int
forall a. Enum a => a -> Int
fromEnum HexChar
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
16

asciiCharHex :: ASCII.Char -> Maybe HexChar
asciiCharHex :: Char -> Maybe HexChar
asciiCharHex =
    \case
        Char
x | Char
x Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
>= Char
ASCII.Digit0 Bool -> Bool -> Bool
&& Char
x Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
ASCII.Digit9 ->
            HexChar -> Maybe HexChar
forall a. a -> Maybe a
Just (HexChar -> Maybe HexChar) -> HexChar -> Maybe HexChar
forall a b. (a -> b) -> a -> b
$ Int -> HexChar
forall a. Enum a => Int -> a
toEnum (Int -> HexChar) -> Int -> HexChar
forall a b. (a -> b) -> a -> b
$
                Char -> Int
forall a. Enum a => a -> Int
fromEnum Char
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- Char -> Int
forall a. Enum a => a -> Int
fromEnum Char
ASCII.Digit0

        Char
x | Char
x Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
>= Char
ASCII.CapitalLetterA Bool -> Bool -> Bool
&& Char
x Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
ASCII.CapitalLetterF ->
            HexChar -> Maybe HexChar
forall a. a -> Maybe a
Just (HexChar -> Maybe HexChar) -> HexChar -> Maybe HexChar
forall a b. (a -> b) -> a -> b
$ Int -> HexChar
forall a. Enum a => Int -> a
toEnum (Int -> HexChar) -> Int -> HexChar
forall a b. (a -> b) -> a -> b
$
                Char -> Int
forall a. Enum a => a -> Int
fromEnum Char
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
10 Int -> Int -> Int
forall a. Num a => a -> a -> a
- Char -> Int
forall a. Enum a => a -> Int
fromEnum Char
ASCII.CapitalLetterA

        Char
x | Char
x Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
>= Char
ASCII.SmallLetterA Bool -> Bool -> Bool
&& Char
x Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
ASCII.SmallLetterF ->
            HexChar -> Maybe HexChar
forall a. a -> Maybe a
Just (HexChar -> Maybe HexChar) -> HexChar -> Maybe HexChar
forall a b. (a -> b) -> a -> b
$ Int -> HexChar
forall a. Enum a => Int -> a
toEnum (Int -> HexChar) -> Int -> HexChar
forall a b. (a -> b) -> a -> b
$
                Char -> Int
forall a. Enum a => a -> Int
fromEnum Char
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
16 Int -> Int -> Int
forall a. Num a => a -> a -> a
- Char -> Int
forall a. Enum a => a -> Int
fromEnum Char
ASCII.SmallLetterA

        Char
_ -> Maybe HexChar
forall a. Maybe a
Nothing

hexLetterD16 :: HexLetter -> Word4
hexLetterD16 :: HexLetter -> Word4
hexLetterD16 = Int -> Word4
forall a. Enum a => Int -> a
toEnum (Int -> Word4) -> (HexLetter -> Int) -> HexLetter -> Word4
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\Int
x -> Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
10) (Int -> Int) -> (HexLetter -> Int) -> HexLetter -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HexLetter -> Int
forall a. Enum a => a -> Int
fromEnum

d16HexLetter :: Word4 -> Maybe HexLetter
d16HexLetter :: Word4 -> Maybe HexLetter
d16HexLetter Word4
x =
  do
    Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Word4
x Word4 -> Word4 -> Bool
forall a. Ord a => a -> a -> Bool
>= Word4
Word4.Number10)
    HexLetter -> Maybe HexLetter
forall a. a -> Maybe a
Just (Int -> HexLetter
forall a. Enum a => Int -> a
toEnum (Word4 -> Int
forall a. Enum a => a -> Int
fromEnum Word4
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
10))

letterHexChar :: Case -> HexLetter -> HexChar
letterHexChar :: Case -> HexLetter -> HexChar
letterHexChar = \case
    Case
UpperCase -> Int -> HexChar
forall a. Enum a => Int -> a
toEnum (Int -> HexChar) -> (HexLetter -> Int) -> HexLetter -> HexChar
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\Int
x -> Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
10) (Int -> Int) -> (HexLetter -> Int) -> HexLetter -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HexLetter -> Int
forall a. Enum a => a -> Int
fromEnum
    Case
LowerCase -> Int -> HexChar
forall a. Enum a => Int -> a
toEnum (Int -> HexChar) -> (HexLetter -> Int) -> HexLetter -> HexChar
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\Int
x -> Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
16) (Int -> Int) -> (HexLetter -> Int) -> HexLetter -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HexLetter -> Int
forall a. Enum a => a -> Int
fromEnum

hexCharLetter :: HexChar -> Maybe HexLetter
hexCharLetter :: HexChar -> Maybe HexLetter
hexCharLetter = \case
    HexChar
x | HexChar
x HexChar -> HexChar -> Bool
forall a. Ord a => a -> a -> Bool
<= HexChar
Digit9          ->  Maybe HexLetter
forall a. Maybe a
Nothing
    HexChar
x | HexChar
x HexChar -> HexChar -> Bool
forall a. Ord a => a -> a -> Bool
<= HexChar
CapitalLetterF  ->  HexLetter -> Maybe HexLetter
forall a. a -> Maybe a
Just (Int -> HexLetter
forall a. Enum a => Int -> a
toEnum (HexChar -> Int
forall a. Enum a => a -> Int
fromEnum HexChar
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
10))
    HexChar
x                        ->  HexLetter -> Maybe HexLetter
forall a. a -> Maybe a
Just (Int -> HexLetter
forall a. Enum a => Int -> a
toEnum (HexChar -> Int
forall a. Enum a => a -> Int
fromEnum HexChar
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
16))


---  Monomorphic character/number conversions  ---

naturalHexCharMaybe :: Case -> Natural -> Maybe HexChar
naturalHexCharMaybe :: Case -> Natural -> Maybe HexChar
naturalHexCharMaybe =
    \case
        Case
UpperCase -> \case
            Natural
x | Natural
x Natural -> Natural -> Bool
forall a. Ord a => a -> a -> Bool
<= Natural
15 -> HexChar -> Maybe HexChar
forall a. a -> Maybe a
Just (Int -> HexChar
forall a. Enum a => Int -> a
toEnum (Natural -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Natural
x))
            Natural
_           -> Maybe HexChar
forall a. Maybe a
Nothing
        Case
LowerCase -> \case
            Natural
x | Natural
x Natural -> Natural -> Bool
forall a. Ord a => a -> a -> Bool
<= Natural
9  -> HexChar -> Maybe HexChar
forall a. a -> Maybe a
Just (Int -> HexChar
forall a. Enum a => Int -> a
toEnum (Natural -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Natural
x))
            Natural
x | Natural
x Natural -> Natural -> Bool
forall a. Ord a => a -> a -> Bool
<= Natural
15 -> HexChar -> Maybe HexChar
forall a. a -> Maybe a
Just (Int -> HexChar
forall a. Enum a => Int -> a
toEnum (Natural -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Natural
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
6))
            Natural
_           -> Maybe HexChar
forall a. Maybe a
Nothing

naturalHexCharUnsafe :: Case -> Natural -> HexChar
naturalHexCharUnsafe :: Case -> Natural -> HexChar
naturalHexCharUnsafe =
    \case
        Case
UpperCase -> \Natural
x -> Int -> HexChar
forall a. Enum a => Int -> a
toEnum (Natural -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Natural
x)
        Case
LowerCase -> \case
            Natural
x | Natural
x Natural -> Natural -> Bool
forall a. Ord a => a -> a -> Bool
<= Natural
9  -> Int -> HexChar
forall a. Enum a => Int -> a
toEnum (Natural -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Natural
x)
            Natural
x           -> Int -> HexChar
forall a. Enum a => Int -> a
toEnum (Natural -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Natural
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
6)

hexCharNatural :: HexChar -> Natural
hexCharNatural :: HexChar -> Natural
hexCharNatural =
    Int -> Natural
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    (Int -> Natural) -> (HexChar -> Int) -> HexChar -> Natural
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    \case
        Int
x | Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
15  ->  Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
6
        Int
x           ->  Int
x
    (Int -> Int) -> (HexChar -> Int) -> HexChar -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    HexChar -> Int
forall a. Enum a => a -> Int
fromEnum

integerHexCharMaybe :: Case -> Integer -> Maybe HexChar
integerHexCharMaybe :: Case -> Integer -> Maybe HexChar
integerHexCharMaybe =
    \case
        Case
UpperCase -> \case
            Integer
x | Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< Integer
0   -> Maybe HexChar
forall a. Maybe a
Nothing
            Integer
x | Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
<= Integer
15 -> HexChar -> Maybe HexChar
forall a. a -> Maybe a
Just (Int -> HexChar
forall a. Enum a => Int -> a
toEnum (Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
x))
            Integer
_           -> Maybe HexChar
forall a. Maybe a
Nothing
        Case
LowerCase -> \case
            Integer
x | Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< Integer
0   -> Maybe HexChar
forall a. Maybe a
Nothing
            Integer
x | Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
<= Integer
9  -> HexChar -> Maybe HexChar
forall a. a -> Maybe a
Just (Int -> HexChar
forall a. Enum a => Int -> a
toEnum (Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
x))
            Integer
x | Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
<= Integer
15 -> HexChar -> Maybe HexChar
forall a. a -> Maybe a
Just (Int -> HexChar
forall a. Enum a => Int -> a
toEnum (Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
6))
            Integer
_           -> Maybe HexChar
forall a. Maybe a
Nothing

integerHexCharUnsafe :: Case -> Integer -> HexChar
integerHexCharUnsafe :: Case -> Integer -> HexChar
integerHexCharUnsafe =
    \case
        Case
UpperCase -> \Integer
x -> Int -> HexChar
forall a. Enum a => Int -> a
toEnum (Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
x)
        Case
LowerCase -> \case
            Integer
x | Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
<= Integer
9  -> Int -> HexChar
forall a. Enum a => Int -> a
toEnum (Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
x)
            Integer
x           -> Int -> HexChar
forall a. Enum a => Int -> a
toEnum (Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
6)

hexCharInteger :: HexChar -> Integer
hexCharInteger :: HexChar -> Integer
hexCharInteger =
    Int -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    (Int -> Integer) -> (HexChar -> Int) -> HexChar -> Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    \case
        Int
x | Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
15  ->  Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
6
        Int
x           ->  Int
x
    (Int -> Int) -> (HexChar -> Int) -> HexChar -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    HexChar -> Int
forall a. Enum a => a -> Int
fromEnum

naturalD16Maybe :: Natural -> Maybe Word4
naturalD16Maybe :: Natural -> Maybe Word4
naturalD16Maybe =
    \case
        Natural
x | Natural
x Natural -> Natural -> Bool
forall a. Ord a => a -> a -> Bool
<= Natural
15  ->  Word4 -> Maybe Word4
forall a. a -> Maybe a
Just (Int -> Word4
forall a. Enum a => Int -> a
toEnum (Natural -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Natural
x))
        Natural
_            ->  Maybe Word4
forall a. Maybe a
Nothing

d16Natural :: Word4 -> Natural
d16Natural :: Word4 -> Natural
d16Natural = Int -> Natural
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Natural) -> (Word4 -> Int) -> Word4 -> Natural
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word4 -> Int
forall a. Enum a => a -> Int
fromEnum

integerD16Maybe :: Integer -> Maybe Word4
integerD16Maybe :: Integer -> Maybe Word4
integerD16Maybe =
    \case
        Integer
x | Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< Integer
0    ->  Maybe Word4
forall a. Maybe a
Nothing
        Integer
x | Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
<= Integer
15  ->  Word4 -> Maybe Word4
forall a. a -> Maybe a
Just (Int -> Word4
forall a. Enum a => Int -> a
toEnum (Integer -> Int
forall a. Num a => Integer -> a
fromInteger Integer
x))
        Integer
_            ->  Maybe Word4
forall a. Maybe a
Nothing

d16Integer :: Word4 -> Integer
d16Integer :: Word4 -> Integer
d16Integer = Int -> Integer
forall a. Integral a => a -> Integer
toInteger (Int -> Integer) -> (Word4 -> Int) -> Word4 -> Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word4 -> Int
forall a. Enum a => a -> Int
fromEnum

naturalD16Unsafe :: Natural -> Word4
naturalD16Unsafe :: Natural -> Word4
naturalD16Unsafe = Int -> Word4
forall a. Enum a => Int -> a
toEnum (Int -> Word4) -> (Natural -> Int) -> Natural -> Word4
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Natural -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral

integerD16Unsafe :: Integer -> Word4
integerD16Unsafe :: Integer -> Word4
integerD16Unsafe = Int -> Word4
forall a. Enum a => Int -> a
toEnum (Int -> Word4) -> (Integer -> Int) -> Integer -> Word4
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral


---  Lift instances  ---

instance HexCharSuperset char => Lift HexChar char
  where
    lift :: HexChar -> char
lift = HexChar -> char
forall char. HexCharSuperset char => HexChar -> char
fromHexChar

instance HexStringSuperset string => Lift [HexChar] string
  where
    lift :: [HexChar] -> string
lift = [HexChar] -> string
forall string. HexStringSuperset string => [HexChar] -> string
fromHexCharList



---  Classes  ---

class HexCharSuperset char
  where

    fromHexChar :: HexChar -> char

    isHexChar :: char -> Bool
    isHexChar = Maybe HexChar -> Bool
forall a. Maybe a -> Bool
isJust (Maybe HexChar -> Bool) -> (char -> Maybe HexChar) -> char -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. char -> Maybe HexChar
forall char. HexCharSuperset char => char -> Maybe HexChar
toHexCharMaybe

    toHexCharUnsafe :: char -> HexChar
    toHexCharUnsafe = Maybe HexChar -> HexChar
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe HexChar -> HexChar)
-> (char -> Maybe HexChar) -> char -> HexChar
forall b c a. (b -> c) -> (a -> b) -> a -> c
. char -> Maybe HexChar
forall char. HexCharSuperset char => char -> Maybe HexChar
toHexCharMaybe

    toHexCharMaybe :: char -> Maybe HexChar
    toHexCharMaybe char
x = if char -> Bool
forall char. HexCharSuperset char => char -> Bool
isHexChar char
x then HexChar -> Maybe HexChar
forall a. a -> Maybe a
Just (char -> HexChar
forall char. HexCharSuperset char => char -> HexChar
toHexCharUnsafe char
x) else Maybe HexChar
forall a. Maybe a
Nothing

    {-# minimal fromHexChar, ((isHexChar, toHexCharUnsafe) | toHexCharMaybe) #-}

class HexStringSuperset string
  where

    fromHexCharList :: [HexChar] -> string

    isHexString :: string -> Bool
    isHexString = Maybe [HexChar] -> Bool
forall a. Maybe a -> Bool
isJust (Maybe [HexChar] -> Bool)
-> (string -> Maybe [HexChar]) -> string -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. string -> Maybe [HexChar]
forall string.
HexStringSuperset string =>
string -> Maybe [HexChar]
toHexCharListMaybe

    toHexCharListUnsafe :: string -> [HexChar]
    toHexCharListUnsafe = Maybe [HexChar] -> [HexChar]
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe [HexChar] -> [HexChar])
-> (string -> Maybe [HexChar]) -> string -> [HexChar]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. string -> Maybe [HexChar]
forall string.
HexStringSuperset string =>
string -> Maybe [HexChar]
toHexCharListMaybe

    toHexCharListMaybe :: string -> Maybe [HexChar]
    toHexCharListMaybe string
x = if string -> Bool
forall string. HexStringSuperset string => string -> Bool
isHexString string
x then [HexChar] -> Maybe [HexChar]
forall a. a -> Maybe a
Just (string -> [HexChar]
forall string. HexStringSuperset string => string -> [HexChar]
toHexCharListUnsafe string
x) else Maybe [HexChar]
forall a. Maybe a
Nothing

    {-# minimal fromHexCharList, ((isHexString, toHexCharListUnsafe) | toHexCharListMaybe) #-}


---  Show functions  ---

{- |

Examples:

* @showNatural LowerCase 12@ = @"c"@
* @showNatural UpperCase (256 + 12)@ = @"10C"@
* @showNatural UpperCase 0@ = @"0"@

-}
showNatural :: HexStringSuperset string => Case -> Natural -> string
showNatural :: Case -> Natural -> string
showNatural =
    \Case
c -> \case
        Natural
0 -> [HexChar] -> string
forall string. HexStringSuperset string => [HexChar] -> string
fromHexCharList [ HexChar
Digit0 ]
        Natural
n -> [HexChar] -> string
forall string. HexStringSuperset string => [HexChar] -> string
fromHexCharList ((Word4 -> HexChar) -> [Word4] -> [HexChar]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Case -> Word4 -> HexChar
d16HexChar Case
c) (Natural -> [Word4]
naturalList Natural
n))
  where
    naturalList :: Natural -> [Word4]
    naturalList :: Natural -> [Word4]
naturalList = DList Word4 -> [Word4]
forall a. DList a -> [a]
DList.toList (DList Word4 -> [Word4])
-> (Natural -> DList Word4) -> Natural -> [Word4]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Natural -> DList Word4
r
      where
        r :: Natural -> DList Word4
r = \case
            Natural
0 -> DList Word4
forall a. Monoid a => a
mempty
            Natural
n ->
                (Natural -> DList Word4)
-> (Natural -> DList Word4) -> (Natural, Natural) -> DList Word4
forall (p :: * -> * -> *) m a b.
(Bifoldable p, Monoid m) =>
(a -> m) -> (b -> m) -> p a b -> m
bifoldMap
                    Natural -> DList Word4
r
                    (Word4 -> DList Word4
forall a. a -> DList a
DList.singleton (Word4 -> DList Word4)
-> (Natural -> Word4) -> Natural -> DList Word4
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Natural -> Word4
naturalD16Unsafe)
                    (Natural -> Natural -> (Natural, Natural)
forall a. Integral a => a -> a -> (a, a)
quotRem Natural
n Natural
16)

{- |

Examples:

* @showInteger LowerCase 12@ = @"c"@
* @showInteger LowerCase (negate 12)@ = @"-c"@
* @showInteger UpperCase (256 + 12)@ = @"10C"@
* @showInteger UpperCase (negate (256 + 12))@ = @"-10C"@
* @showInteger UpperCase 0@ = @"0"@

-}
showInteger :: StringSuperset string => Case -> Integer -> string
showInteger :: Case -> Integer -> string
showInteger = \Case
c -> [Char] -> string
forall string. StringSuperset string => [Char] -> string
fromCharList ([Char] -> string) -> (Integer -> [Char]) -> Integer -> string
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Case -> Integer -> [Char]
integerList Case
c
  where
    integerList :: Case -> Integer -> [ASCII.Char]
    integerList :: Case -> Integer -> [Char]
integerList Case
c =
        \case
            Integer
0           ->  [ Char
ASCII.Digit0 ]
            Integer
n | Integer
n Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< Integer
0   ->  Char
ASCII.HyphenMinus Char -> [Char] -> [Char]
forall a. a -> [a] -> [a]
: Case -> Integer -> [Char]
nonNegativeIntegerList Case
c (Integer -> Integer
forall a. Num a => a -> a
abs Integer
n)
            Integer
n           ->  Case -> Integer -> [Char]
nonNegativeIntegerList Case
c Integer
n

    nonNegativeIntegerList :: Case -> Integer -> [ASCII.Char]
    nonNegativeIntegerList :: Case -> Integer -> [Char]
nonNegativeIntegerList Case
c = DList Char -> [Char]
forall a. DList a -> [a]
DList.toList (DList Char -> [Char])
-> (Integer -> DList Char) -> Integer -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> DList Char
r
      where
        r :: Integer -> DList Char
r = \case
            Integer
0 -> DList Char
forall a. Monoid a => a
mempty
            Integer
n ->
                (Integer -> DList Char)
-> (Integer -> DList Char) -> (Integer, Integer) -> DList Char
forall (p :: * -> * -> *) m a b.
(Bifoldable p, Monoid m) =>
(a -> m) -> (b -> m) -> p a b -> m
bifoldMap
                    Integer -> DList Char
r
                    (Char -> DList Char
forall a. a -> DList a
DList.singleton (Char -> DList Char) -> (Integer -> Char) -> Integer -> DList Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HexChar -> Char
forall char. HexCharSuperset char => HexChar -> char
fromHexChar (HexChar -> Char) -> (Integer -> HexChar) -> Integer -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Case -> Integer -> HexChar
integerHexCharUnsafe Case
c)
                    (Integer -> Integer -> (Integer, Integer)
forall a. Integral a => a -> a -> (a, a)
quotRem Integer
n Integer
16)

showIntegral :: (StringSuperset string, Integral number) => Case -> number -> string
showIntegral :: Case -> number -> string
showIntegral Case
c = Case -> Integer -> string
forall string. StringSuperset string => Case -> Integer -> string
showInteger Case
c (Integer -> string) -> (number -> Integer) -> number -> string
forall b c a. (b -> c) -> (a -> b) -> a -> c
. number -> Integer
forall a. Integral a => a -> Integer
toInteger


---  Read functions  ---

{- |

Examples:

* @readNatural "5"@ = @Just 5@
* @readNatural "-5"@ = @Nothing@
* @readNatural "1f"@ = @Just 31@
* @readNatural "1F"@ = @Just 31@
* @readNatural "xa"@ = @Nothing@
* @readNatural ""@ = @Nothing@

-}
readNatural :: HexStringSuperset string => string -> Maybe Natural
readNatural :: string -> Maybe Natural
readNatural = (Natural -> Maybe Natural
forall a. a -> Maybe a
Just (Natural -> Maybe Natural)
-> (NonEmpty Word4 -> Natural) -> NonEmpty Word4 -> Maybe Natural
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty Word4 -> Natural
readNaturalDigits) (NonEmpty Word4 -> Maybe Natural)
-> (string -> Maybe (NonEmpty Word4)) -> string -> Maybe Natural
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< [Word4] -> Maybe (NonEmpty Word4)
forall a. [a] -> Maybe (NonEmpty a)
nonEmpty ([Word4] -> Maybe (NonEmpty Word4))
-> (string -> Maybe [Word4]) -> string -> Maybe (NonEmpty Word4)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< ([Word4] -> Maybe [Word4]
forall a. a -> Maybe a
Just ([Word4] -> Maybe [Word4])
-> ([HexChar] -> [Word4]) -> [HexChar] -> Maybe [Word4]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (HexChar -> Word4) -> [HexChar] -> [Word4]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap HexChar -> Word4
hexCharD16) ([HexChar] -> Maybe [Word4])
-> (string -> Maybe [HexChar]) -> string -> Maybe [Word4]
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< string -> Maybe [HexChar]
forall string.
HexStringSuperset string =>
string -> Maybe [HexChar]
toHexCharListMaybe
  where
    readNaturalDigits :: NonEmpty Word4 -> Natural
    readNaturalDigits :: NonEmpty Word4 -> Natural
readNaturalDigits = (Natural -> Word4 -> Natural)
-> Natural -> NonEmpty Word4 -> Natural
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
List.foldl' (\Natural
total Word4
x -> (Natural
16 Natural -> Natural -> Natural
forall a. Num a => a -> a -> a
* Natural
total) Natural -> Natural -> Natural
forall a. Num a => a -> a -> a
+ Word4 -> Natural
d16Natural Word4
x) Natural
0

{- |

Examples:

* @readInteger "5"@ = @Just 5@
* @readInteger "-5"@ = @Just (-5)@
* @readInteger "1f"@ = @Just 31@
* @readInteger "1F"@ = @Just 31@
* @readInteger "xa"@ = @Nothing@
* @readInteger ""@ = @Nothing@
* @readInteger "-"@ = @Nothing@

-}
readInteger :: StringSuperset string => string -> Maybe Integer
readInteger :: string -> Maybe Integer
readInteger = [Char] -> Maybe Integer
readIntegerCharList ([Char] -> Maybe Integer)
-> (string -> Maybe [Char]) -> string -> Maybe Integer
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< string -> Maybe [Char]
forall string. StringSuperset string => string -> Maybe [Char]
toCharListMaybe
  where
    readIntegerCharList :: [ASCII.Char] -> Maybe Integer
    readIntegerCharList :: [Char] -> Maybe Integer
readIntegerCharList =
        \case
            Char
ASCII.HyphenMinus : [Char]
xs  ->  (Integer -> Integer) -> Maybe Integer -> Maybe Integer
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Integer -> Integer
forall a. Num a => a -> a
negate ([Char] -> Maybe Integer
readNonNegative [Char]
xs)
            [Char]
xs                      ->  [Char] -> Maybe Integer
readNonNegative [Char]
xs

    readNonNegative :: [ASCII.Char] -> Maybe Integer
    readNonNegative :: [Char] -> Maybe Integer
readNonNegative = (Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Integer -> Maybe Integer)
-> (NonEmpty Word4 -> Integer) -> NonEmpty Word4 -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Integer
forall a. Integral a => a -> Integer
toInteger (Integer -> Integer)
-> (NonEmpty Word4 -> Integer) -> NonEmpty Word4 -> Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty Word4 -> Integer
readIntegerDigits) (NonEmpty Word4 -> Maybe Integer)
-> ([Char] -> Maybe (NonEmpty Word4)) -> [Char] -> Maybe Integer
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< [Word4] -> Maybe (NonEmpty Word4)
forall a. [a] -> Maybe (NonEmpty a)
nonEmpty ([Word4] -> Maybe (NonEmpty Word4))
-> ([Char] -> Maybe [Word4]) -> [Char] -> Maybe (NonEmpty Word4)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< ([Word4] -> Maybe [Word4]
forall a. a -> Maybe a
Just ([Word4] -> Maybe [Word4])
-> ([HexChar] -> [Word4]) -> [HexChar] -> Maybe [Word4]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (HexChar -> Word4) -> [HexChar] -> [Word4]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap HexChar -> Word4
hexCharD16) ([HexChar] -> Maybe [Word4])
-> ([Char] -> Maybe [HexChar]) -> [Char] -> Maybe [Word4]
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< [Char] -> Maybe [HexChar]
forall string.
HexStringSuperset string =>
string -> Maybe [HexChar]
toHexCharListMaybe

    readIntegerDigits :: NonEmpty Word4 -> Integer
    readIntegerDigits :: NonEmpty Word4 -> Integer
readIntegerDigits = (Integer -> Word4 -> Integer)
-> Integer -> NonEmpty Word4 -> Integer
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
List.foldl' (\Integer
total Word4
x -> (Integer
16 Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Integer
total) Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Word4 -> Integer
d16Integer Word4
x) Integer
0

{- |

Examples:

* @readIntegral "0014"@ = @Just (20 :: Word8)@
* @readIntegral ""@ = @(Nothing :: Maybe Word8)@
* @readIntegral "-4"@ = @(Nothing :: Maybe Word8)@
* @readIntegral "1234"@ = @(Nothing :: Maybe Word8)@

-}
readIntegral :: (StringSuperset string, Integral number, Bits number) => string -> Maybe number
readIntegral :: string -> Maybe number
readIntegral = Integer -> Maybe number
forall a b.
(Integral a, Integral b, Bits a, Bits b) =>
a -> Maybe b
toIntegralSized (Integer -> Maybe number)
-> (string -> Maybe Integer) -> string -> Maybe number
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< string -> Maybe Integer
forall string. StringSuperset string => string -> Maybe Integer
readInteger


---  HexCharSuperset instances  ---

instance HexCharSuperset HexChar
  where
    isHexChar :: HexChar -> Bool
isHexChar HexChar
_ = Bool
Bool.True
    fromHexChar :: HexChar -> HexChar
fromHexChar = HexChar -> HexChar
forall a. a -> a
id
    toHexCharUnsafe :: HexChar -> HexChar
toHexCharUnsafe = HexChar -> HexChar
forall a. a -> a
id
    toHexCharMaybe :: HexChar -> Maybe HexChar
toHexCharMaybe = HexChar -> Maybe HexChar
forall a. a -> Maybe a
Just

instance HexCharSuperset ASCII.Char
  where
    fromHexChar :: HexChar -> Char
fromHexChar = HexChar -> Char
hexAsciiChar
    toHexCharMaybe :: Char -> Maybe HexChar
toHexCharMaybe = Char -> Maybe HexChar
asciiCharHex

instance HexCharSuperset Unicode.Char
  where
    fromHexChar :: HexChar -> Char
fromHexChar = Char -> Char
forall char. CharSuperset char => Char -> char
fromChar (Char -> Char) -> (HexChar -> Char) -> HexChar -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HexChar -> Char
forall char. HexCharSuperset char => HexChar -> char
fromHexChar
    toHexCharMaybe :: Char -> Maybe HexChar
toHexCharMaybe = Char -> Maybe HexChar
forall char. HexCharSuperset char => char -> Maybe HexChar
toHexCharMaybe (Char -> Maybe HexChar)
-> (Char -> Maybe Char) -> Char -> Maybe HexChar
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Char -> Maybe Char
forall char. CharSuperset char => char -> Maybe Char
toCharMaybe

instance HexCharSuperset Word8
  where
    fromHexChar :: HexChar -> Word8
fromHexChar HexChar
x = Char -> Word8
forall char. CharSuperset char => Char -> char
fromChar (HexChar -> Char
forall char. HexCharSuperset char => HexChar -> char
fromHexChar HexChar
x :: ASCII.Char)
    toHexCharMaybe :: Word8 -> Maybe HexChar
toHexCharMaybe Word8
w = Char -> Maybe HexChar
forall char. HexCharSuperset char => char -> Maybe HexChar
toHexCharMaybe (Char -> Maybe HexChar) -> Maybe Char -> Maybe HexChar
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< (Word8 -> Maybe Char
forall char. CharSuperset char => char -> Maybe Char
toCharMaybe Word8
w :: Maybe ASCII.Char)

instance HexCharSuperset char => HexCharSuperset (ASCII char)
  where
    isHexChar :: ASCII char -> Bool
isHexChar = char -> Bool
forall char. HexCharSuperset char => char -> Bool
isHexChar (char -> Bool) -> (ASCII char -> char) -> ASCII char -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ASCII char -> char
forall superset. ASCII superset -> superset
ASCII.Refinement.lift
    fromHexChar :: HexChar -> ASCII char
fromHexChar = char -> ASCII char
forall superset. superset -> ASCII superset
asciiUnsafe (char -> ASCII char) -> (HexChar -> char) -> HexChar -> ASCII char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HexChar -> char
forall char. HexCharSuperset char => HexChar -> char
fromHexChar
    toHexCharUnsafe :: ASCII char -> HexChar
toHexCharUnsafe = char -> HexChar
forall char. HexCharSuperset char => char -> HexChar
toHexCharUnsafe (char -> HexChar) -> (ASCII char -> char) -> ASCII char -> HexChar
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ASCII char -> char
forall superset. ASCII superset -> superset
ASCII.Refinement.lift
    toHexCharMaybe :: ASCII char -> Maybe HexChar
toHexCharMaybe = char -> Maybe HexChar
forall char. HexCharSuperset char => char -> Maybe HexChar
toHexCharMaybe (char -> Maybe HexChar)
-> (ASCII char -> char) -> ASCII char -> Maybe HexChar
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ASCII char -> char
forall superset. ASCII superset -> superset
ASCII.Refinement.lift


---  HexStringSuperset instances  ---

instance HexStringSuperset [HexChar]
  where
    fromHexCharList :: [HexChar] -> [HexChar]
fromHexCharList = [HexChar] -> [HexChar]
forall a. a -> a
id
    isHexString :: [HexChar] -> Bool
isHexString [HexChar]
_ = Bool
Bool.True
    toHexCharListUnsafe :: [HexChar] -> [HexChar]
toHexCharListUnsafe = [HexChar] -> [HexChar]
forall a. a -> a
id
    toHexCharListMaybe :: [HexChar] -> Maybe [HexChar]
toHexCharListMaybe = [HexChar] -> Maybe [HexChar]
forall a. a -> Maybe a
Just

instance HexStringSuperset [ASCII.Char]
  where
    fromHexCharList :: [HexChar] -> [Char]
fromHexCharList = (HexChar -> Char) -> [HexChar] -> [Char]
forall a b. (a -> b) -> [a] -> [b]
List.map HexChar -> Char
forall char. HexCharSuperset char => HexChar -> char
fromHexChar
    isHexString :: [Char] -> Bool
isHexString = (Char -> Bool) -> [Char] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
List.all Char -> Bool
forall char. HexCharSuperset char => char -> Bool
isHexChar
    toHexCharListUnsafe :: [Char] -> [HexChar]
toHexCharListUnsafe = (Char -> HexChar) -> [Char] -> [HexChar]
forall a b. (a -> b) -> [a] -> [b]
List.map Char -> HexChar
forall char. HexCharSuperset char => char -> HexChar
toHexCharUnsafe

instance HexStringSuperset [Unicode.Char]
  where
    fromHexCharList :: [HexChar] -> String
fromHexCharList = (HexChar -> Char) -> [HexChar] -> String
forall a b. (a -> b) -> [a] -> [b]
List.map HexChar -> Char
forall char. HexCharSuperset char => HexChar -> char
fromHexChar
    isHexString :: String -> Bool
isHexString = (Char -> Bool) -> String -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
List.all Char -> Bool
forall char. HexCharSuperset char => char -> Bool
isHexChar
    toHexCharListUnsafe :: String -> [HexChar]
toHexCharListUnsafe = (Char -> HexChar) -> String -> [HexChar]
forall a b. (a -> b) -> [a] -> [b]
List.map Char -> HexChar
forall char. HexCharSuperset char => char -> HexChar
toHexCharUnsafe

instance HexStringSuperset T.Text
  where
    fromHexCharList :: [HexChar] -> Text
fromHexCharList = String -> Text
T.pack (String -> Text) -> ([HexChar] -> String) -> [HexChar] -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (HexChar -> Char) -> [HexChar] -> String
forall a b. (a -> b) -> [a] -> [b]
List.map HexChar -> Char
forall char. HexCharSuperset char => HexChar -> char
fromHexChar
    isHexString :: Text -> Bool
isHexString = (Char -> Bool) -> Text -> Bool
T.all Char -> Bool
forall char. HexCharSuperset char => char -> Bool
isHexChar
    toHexCharListUnsafe :: Text -> [HexChar]
toHexCharListUnsafe = (Char -> HexChar) -> String -> [HexChar]
forall a b. (a -> b) -> [a] -> [b]
List.map Char -> HexChar
forall char. HexCharSuperset char => char -> HexChar
toHexCharUnsafe (String -> [HexChar]) -> (Text -> String) -> Text -> [HexChar]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
T.unpack

instance HexStringSuperset LT.Text
  where
    fromHexCharList :: [HexChar] -> Text
fromHexCharList = String -> Text
LT.pack (String -> Text) -> ([HexChar] -> String) -> [HexChar] -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (HexChar -> Char) -> [HexChar] -> String
forall a b. (a -> b) -> [a] -> [b]
List.map HexChar -> Char
forall char. HexCharSuperset char => HexChar -> char
fromHexChar
    isHexString :: Text -> Bool
isHexString = (Char -> Bool) -> Text -> Bool
LT.all Char -> Bool
forall char. HexCharSuperset char => char -> Bool
isHexChar
    toHexCharListUnsafe :: Text -> [HexChar]
toHexCharListUnsafe = (Char -> HexChar) -> String -> [HexChar]
forall a b. (a -> b) -> [a] -> [b]
List.map Char -> HexChar
forall char. HexCharSuperset char => char -> HexChar
toHexCharUnsafe (String -> [HexChar]) -> (Text -> String) -> Text -> [HexChar]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
LT.unpack

instance HexStringSuperset TB.Builder
  where
    fromHexCharList :: [HexChar] -> Builder
fromHexCharList = Text -> Builder
TB.fromLazyText (Text -> Builder) -> ([HexChar] -> Text) -> [HexChar] -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [HexChar] -> Text
forall string. HexStringSuperset string => [HexChar] -> string
fromHexCharList
    toHexCharListMaybe :: Builder -> Maybe [HexChar]
toHexCharListMaybe = Text -> Maybe [HexChar]
forall string.
HexStringSuperset string =>
string -> Maybe [HexChar]
toHexCharListMaybe (Text -> Maybe [HexChar])
-> (Builder -> Text) -> Builder -> Maybe [HexChar]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Builder -> Text
TB.toLazyText

instance HexStringSuperset BS.ByteString
  where
    fromHexCharList :: [HexChar] -> ByteString
fromHexCharList = [Word8] -> ByteString
BS.pack ([Word8] -> ByteString)
-> ([HexChar] -> [Word8]) -> [HexChar] -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (HexChar -> Word8) -> [HexChar] -> [Word8]
forall a b. (a -> b) -> [a] -> [b]
List.map HexChar -> Word8
forall char. HexCharSuperset char => HexChar -> char
fromHexChar
    isHexString :: ByteString -> Bool
isHexString = (Word8 -> Bool) -> ByteString -> Bool
BS.all Word8 -> Bool
forall char. HexCharSuperset char => char -> Bool
isHexChar
    toHexCharListUnsafe :: ByteString -> [HexChar]
toHexCharListUnsafe = (Word8 -> HexChar) -> [Word8] -> [HexChar]
forall a b. (a -> b) -> [a] -> [b]
List.map Word8 -> HexChar
forall char. HexCharSuperset char => char -> HexChar
toHexCharUnsafe ([Word8] -> [HexChar])
-> (ByteString -> [Word8]) -> ByteString -> [HexChar]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> [Word8]
BS.unpack

instance HexStringSuperset LBS.ByteString
  where
    fromHexCharList :: [HexChar] -> ByteString
fromHexCharList = [Word8] -> ByteString
LBS.pack ([Word8] -> ByteString)
-> ([HexChar] -> [Word8]) -> [HexChar] -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (HexChar -> Word8) -> [HexChar] -> [Word8]
forall a b. (a -> b) -> [a] -> [b]
List.map HexChar -> Word8
forall char. HexCharSuperset char => HexChar -> char
fromHexChar
    isHexString :: ByteString -> Bool
isHexString = (Word8 -> Bool) -> ByteString -> Bool
LBS.all Word8 -> Bool
forall char. HexCharSuperset char => char -> Bool
isHexChar
    toHexCharListUnsafe :: ByteString -> [HexChar]
toHexCharListUnsafe = (Word8 -> HexChar) -> [Word8] -> [HexChar]
forall a b. (a -> b) -> [a] -> [b]
List.map Word8 -> HexChar
forall char. HexCharSuperset char => char -> HexChar
toHexCharUnsafe ([Word8] -> [HexChar])
-> (ByteString -> [Word8]) -> ByteString -> [HexChar]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> [Word8]
LBS.unpack

instance HexStringSuperset BSB.Builder
  where
    fromHexCharList :: [HexChar] -> Builder
fromHexCharList = ByteString -> Builder
BSB.lazyByteString (ByteString -> Builder)
-> ([HexChar] -> ByteString) -> [HexChar] -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [HexChar] -> ByteString
forall string. HexStringSuperset string => [HexChar] -> string
fromHexCharList
    toHexCharListMaybe :: Builder -> Maybe [HexChar]
toHexCharListMaybe = ByteString -> Maybe [HexChar]
forall string.
HexStringSuperset string =>
string -> Maybe [HexChar]
toHexCharListMaybe (ByteString -> Maybe [HexChar])
-> (Builder -> ByteString) -> Builder -> Maybe [HexChar]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Builder -> ByteString
BSB.toLazyByteString

instance HexStringSuperset char => HexStringSuperset (ASCII char)
  where
    isHexString :: ASCII char -> Bool
isHexString = char -> Bool
forall string. HexStringSuperset string => string -> Bool
isHexString (char -> Bool) -> (ASCII char -> char) -> ASCII char -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ASCII char -> char
forall superset. ASCII superset -> superset
ASCII.Refinement.lift
    fromHexCharList :: [HexChar] -> ASCII char
fromHexCharList = char -> ASCII char
forall superset. superset -> ASCII superset
asciiUnsafe (char -> ASCII char)
-> ([HexChar] -> char) -> [HexChar] -> ASCII char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [HexChar] -> char
forall string. HexStringSuperset string => [HexChar] -> string
fromHexCharList
    toHexCharListUnsafe :: ASCII char -> [HexChar]
toHexCharListUnsafe = char -> [HexChar]
forall string. HexStringSuperset string => string -> [HexChar]
toHexCharListUnsafe (char -> [HexChar])
-> (ASCII char -> char) -> ASCII char -> [HexChar]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ASCII char -> char
forall superset. ASCII superset -> superset
ASCII.Refinement.lift
    toHexCharListMaybe :: ASCII char -> Maybe [HexChar]
toHexCharListMaybe = char -> Maybe [HexChar]
forall string.
HexStringSuperset string =>
string -> Maybe [HexChar]
toHexCharListMaybe (char -> Maybe [HexChar])
-> (ASCII char -> char) -> ASCII char -> Maybe [HexChar]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ASCII char -> char
forall superset. ASCII superset -> superset
ASCII.Refinement.lift