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.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
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
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
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
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
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))
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
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) #-}
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)
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
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
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
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
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
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