module ASCII.Hexadecimal
(
showNatural, readNatural,
showInteger, readInteger,
showIntegral, readIntegral,
HexChar (..), HexLetter (..), HexCharBreakdown (..),
hexLetterD16, d16HexLetter,
letterHexChar, hexCharLetter,
hexAsciiChar, asciiCharHex,
d16HexChar, hexCharD16,
breakDownHexChar, assembleHexChar,
HexCharSuperset (..),
HexStringSuperset (..),
naturalHexCharMaybe, hexCharNatural, naturalHexCharUnsafe,
naturalD16Maybe, d16Natural, naturalD16Unsafe,
integerHexCharMaybe, hexCharInteger, integerHexCharUnsafe,
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
data HexLetter =
LetterA
| LetterB
| LetterC
| LetterD
| LetterE
| LetterF
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
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
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
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
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))
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
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
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) #-}
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)
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
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
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
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
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
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