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.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
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]
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
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
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
Ord, Int -> HexLetter -> ShowS
[HexLetter] -> ShowS
HexLetter -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [HexLetter] -> ShowS
$cshowList :: [HexLetter] -> ShowS
show :: HexLetter -> [Char]
$cshow :: HexLetter -> [Char]
showsPrec :: Int -> HexLetter -> ShowS
$cshowsPrec :: Int -> HexLetter -> ShowS
Show, Typeable HexLetter
HexLetter -> DataType
HexLetter -> Constr
(forall b. Data b => b -> b) -> HexLetter -> 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(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 (m :: * -> *).
MonadPlus m =>
(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 (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HexLetter -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HexLetter -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HexLetter -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HexLetter -> [u]
gmapQr :: forall r r'.
(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 :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
Data, 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
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
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
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]
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
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
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
Ord, Int -> HexChar -> ShowS
[HexChar] -> ShowS
HexChar -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [HexChar] -> ShowS
$cshowList :: [HexChar] -> ShowS
show :: HexChar -> [Char]
$cshow :: HexChar -> [Char]
showsPrec :: Int -> HexChar -> ShowS
$cshowsPrec :: Int -> HexChar -> ShowS
Show, Typeable HexChar
HexChar -> DataType
HexChar -> Constr
(forall b. Data b => b -> b) -> HexChar -> 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(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 (m :: * -> *).
MonadPlus m =>
(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 (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HexChar -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HexChar -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HexChar -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HexChar -> [u]
gmapQr :: forall r r'.
(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 :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
Data, 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
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
Hashable

data HexCharBreakdown = HexDigit Dec.Digit | HexLetter Case HexLetter
    deriving stock (HexCharBreakdown -> HexCharBreakdown -> Bool
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
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
Ord, Int -> HexCharBreakdown -> ShowS
[HexCharBreakdown] -> ShowS
HexCharBreakdown -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [HexCharBreakdown] -> ShowS
$cshowList :: [HexCharBreakdown] -> ShowS
show :: HexCharBreakdown -> [Char]
$cshow :: HexCharBreakdown -> [Char]
showsPrec :: Int -> HexCharBreakdown -> ShowS
$cshowsPrec :: Int -> HexCharBreakdown -> ShowS
Show, Typeable HexCharBreakdown
HexCharBreakdown -> DataType
HexCharBreakdown -> Constr
(forall b. Data b => b -> b)
-> HexCharBreakdown -> 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(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 (m :: * -> *).
MonadPlus m =>
(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 (m :: * -> *).
Monad m =>
(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 :: forall u.
Int -> (forall d. Data d => d -> u) -> HexCharBreakdown -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> HexCharBreakdown -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HexCharBreakdown -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HexCharBreakdown -> [u]
gmapQr :: forall r r'.
(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 :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
Data, 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
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
Hashable

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

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


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

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

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

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

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

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

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

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

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

        Char
_ -> forall a. Maybe a
Nothing

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

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

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

hexCharLetter :: HexChar -> Maybe HexLetter
hexCharLetter :: HexChar -> Maybe HexLetter
hexCharLetter = \case
    HexChar
x | HexChar
x forall a. Ord a => a -> a -> Bool
<= HexChar
Digit9          ->  forall a. Maybe a
Nothing
    HexChar
x | HexChar
x forall a. Ord a => a -> a -> Bool
<= HexChar
CapitalLetterF  ->  forall a. a -> Maybe a
Just (forall a. Enum a => Int -> a
toEnum (forall a. Enum a => a -> Int
fromEnum HexChar
x forall a. Num a => a -> a -> a
- Int
10))
    HexChar
x                        ->  forall a. a -> Maybe a
Just (forall a. Enum a => Int -> a
toEnum (forall a. Enum a => a -> Int
fromEnum HexChar
x 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 forall a. Ord a => a -> a -> Bool
<= Natural
15 -> forall a. a -> Maybe a
Just (forall a. Enum a => Int -> a
toEnum (forall a b. (Integral a, Num b) => a -> b
fromIntegral Natural
x))
            Natural
_           -> forall a. Maybe a
Nothing
        Case
LowerCase -> \case
            Natural
x | Natural
x forall a. Ord a => a -> a -> Bool
<= Natural
9  -> forall a. a -> Maybe a
Just (forall a. Enum a => Int -> a
toEnum (forall a b. (Integral a, Num b) => a -> b
fromIntegral Natural
x))
            Natural
x | Natural
x forall a. Ord a => a -> a -> Bool
<= Natural
15 -> forall a. a -> Maybe a
Just (forall a. Enum a => Int -> a
toEnum (forall a b. (Integral a, Num b) => a -> b
fromIntegral Natural
x forall a. Num a => a -> a -> a
+ Int
6))
            Natural
_           -> forall a. Maybe a
Nothing

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

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

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

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

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

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

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

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

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

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


---  Classes  ---

class HexCharSuperset char
  where

    fromHexChar :: HexChar -> char

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

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

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

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

class HexStringSuperset string
  where

    fromHexCharList :: [HexChar] -> string

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

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

    toHexCharListMaybe :: string -> Maybe [HexChar]
    toHexCharListMaybe string
x = if forall string. HexStringSuperset string => string -> Bool
isHexString string
x then forall a. a -> Maybe a
Just (forall string. HexStringSuperset string => string -> [HexChar]
toHexCharListUnsafe string
x) else 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 :: forall string.
HexStringSuperset string =>
Case -> Natural -> string
showNatural =
    \Case
c -> \case
        Natural
0 -> forall string. HexStringSuperset string => [HexChar] -> string
fromHexCharList [ HexChar
Digit0 ]
        Natural
n -> forall string. HexStringSuperset string => [HexChar] -> string
fromHexCharList (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 = forall a. DList a -> [a]
DList.toList forall b c a. (b -> c) -> (a -> b) -> a -> c
. Natural -> DList Word4
r
      where
        r :: Natural -> DList Word4
r = \case
            Natural
0 -> forall a. Monoid a => a
mempty
            Natural
n ->
                forall (p :: * -> * -> *) m a b.
(Bifoldable p, Monoid m) =>
(a -> m) -> (b -> m) -> p a b -> m
bifoldMap
                    Natural -> DList Word4
r
                    (forall a. a -> DList a
DList.singleton forall b c a. (b -> c) -> (a -> b) -> a -> c
. Natural -> Word4
naturalD16Unsafe)
                    (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 :: forall string. StringSuperset string => Case -> Integer -> string
showInteger = \Case
c -> forall string. FromString string => [Char] -> string
fromCharList 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 forall a. Ord a => a -> a -> Bool
< Integer
0   ->  Char
ASCII.HyphenMinus forall a. a -> [a] -> [a]
: Case -> Integer -> [Char]
nonNegativeIntegerList Case
c (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 = forall a. DList a -> [a]
DList.toList forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> DList Char
r
      where
        r :: Integer -> DList Char
r = \case
            Integer
0 -> forall a. Monoid a => a
mempty
            Integer
n ->
                forall (p :: * -> * -> *) m a b.
(Bifoldable p, Monoid m) =>
(a -> m) -> (b -> m) -> p a b -> m
bifoldMap
                    Integer -> DList Char
r
                    (forall a. a -> DList a
DList.singleton forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall char. HexCharSuperset char => HexChar -> char
fromHexChar forall b c a. (b -> c) -> (a -> b) -> a -> c
. Case -> Integer -> HexChar
integerHexCharUnsafe Case
c)
                    (forall a. Integral a => a -> a -> (a, a)
quotRem Integer
n Integer
16)

showIntegral :: (StringSuperset string, Integral number) => Case -> number -> string
showIntegral :: forall string number.
(StringSuperset string, Integral number) =>
Case -> number -> string
showIntegral Case
c = forall string. StringSuperset string => Case -> Integer -> string
showInteger Case
c forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 :: forall string. HexStringSuperset string => string -> Maybe Natural
readNatural = (forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty Word4 -> Natural
readNaturalDigits) forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall a. [a] -> Maybe (NonEmpty a)
nonEmpty forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< (forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap HexChar -> Word4
hexCharD16) forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall string.
HexStringSuperset string =>
string -> Maybe [HexChar]
toHexCharListMaybe
  where
    readNaturalDigits :: NonEmpty Word4 -> Natural
    readNaturalDigits :: NonEmpty Word4 -> Natural
readNaturalDigits = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
List.foldl' (\Natural
total Word4
x -> (Natural
16 forall a. Num a => a -> a -> a
* Natural
total) 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 :: forall string. StringSuperset string => string -> Maybe Integer
readInteger = [Char] -> Maybe Integer
readIntegerCharList forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall string. ToString string => string -> Maybe [Char]
toCharListMaybe
  where
    readIntegerCharList :: [ASCII.Char] -> Maybe Integer
    readIntegerCharList :: [Char] -> Maybe Integer
readIntegerCharList =
        \case
            Char
ASCII.HyphenMinus : [Char]
xs  ->  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap 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 = (forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Integral a => a -> Integer
toInteger forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty Word4 -> Integer
readIntegerDigits) forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall a. [a] -> Maybe (NonEmpty a)
nonEmpty forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< (forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap HexChar -> Word4
hexCharD16) forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall string.
HexStringSuperset string =>
string -> Maybe [HexChar]
toHexCharListMaybe

    readIntegerDigits :: NonEmpty Word4 -> Integer
    readIntegerDigits :: NonEmpty Word4 -> Integer
readIntegerDigits = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
List.foldl' (\Integer
total Word4
x -> (Integer
16 forall a. Num a => a -> a -> a
* Integer
total) 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 :: forall string number.
(StringSuperset string, Integral number, Bits number) =>
string -> Maybe number
readIntegral = forall a b.
(Integral a, Integral b, Bits a, Bits b) =>
a -> Maybe b
toIntegralSized forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< 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 = forall a. a -> a
id
    toHexCharUnsafe :: HexChar -> HexChar
toHexCharUnsafe = forall a. a -> a
id
    toHexCharMaybe :: HexChar -> Maybe HexChar
toHexCharMaybe = 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 = forall char. FromChar char => Char -> char
fromChar forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall char. HexCharSuperset char => HexChar -> char
fromHexChar
    toHexCharMaybe :: Char -> Maybe HexChar
toHexCharMaybe = forall char. HexCharSuperset char => char -> Maybe HexChar
toHexCharMaybe forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall char. ToChar char => char -> Maybe Char
toCharMaybe

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

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


---  HexStringSuperset instances  ---

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

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

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

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

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

instance HexStringSuperset TB.Builder
  where
    fromHexCharList :: [HexChar] -> Builder
fromHexCharList = Text -> Builder
TB.fromLazyText forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall string. HexStringSuperset string => [HexChar] -> string
fromHexCharList
    toHexCharListMaybe :: Builder -> Maybe [HexChar]
toHexCharListMaybe = forall string.
HexStringSuperset string =>
string -> Maybe [HexChar]
toHexCharListMaybe 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 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
List.map forall char. HexCharSuperset char => HexChar -> char
fromHexChar
    isHexString :: ByteString -> Bool
isHexString = (Word8 -> Bool) -> ByteString -> Bool
BS.all forall char. HexCharSuperset char => char -> Bool
isHexChar
    toHexCharListUnsafe :: ByteString -> [HexChar]
toHexCharListUnsafe = forall a b. (a -> b) -> [a] -> [b]
List.map forall char. HexCharSuperset char => char -> HexChar
toHexCharUnsafe 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 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
List.map forall char. HexCharSuperset char => HexChar -> char
fromHexChar
    isHexString :: ByteString -> Bool
isHexString = (Word8 -> Bool) -> ByteString -> Bool
LBS.all forall char. HexCharSuperset char => char -> Bool
isHexChar
    toHexCharListUnsafe :: ByteString -> [HexChar]
toHexCharListUnsafe = forall a b. (a -> b) -> [a] -> [b]
List.map forall char. HexCharSuperset char => char -> HexChar
toHexCharUnsafe 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 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall string. HexStringSuperset string => [HexChar] -> string
fromHexCharList
    toHexCharListMaybe :: Builder -> Maybe [HexChar]
toHexCharListMaybe = forall string.
HexStringSuperset string =>
string -> Maybe [HexChar]
toHexCharListMaybe 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 = forall string. HexStringSuperset string => string -> Bool
isHexString forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall superset. ASCII superset -> superset
ASCII.Refinement.lift
    fromHexCharList :: [HexChar] -> ASCII char
fromHexCharList = forall superset. superset -> ASCII superset
asciiUnsafe forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall string. HexStringSuperset string => [HexChar] -> string
fromHexCharList
    toHexCharListUnsafe :: ASCII char -> [HexChar]
toHexCharListUnsafe = forall string. HexStringSuperset string => string -> [HexChar]
toHexCharListUnsafe forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall superset. ASCII superset -> superset
ASCII.Refinement.lift
    toHexCharListMaybe :: ASCII char -> Maybe [HexChar]
toHexCharListMaybe = forall string.
HexStringSuperset string =>
string -> Maybe [HexChar]
toHexCharListMaybe forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall superset. ASCII superset -> superset
ASCII.Refinement.lift