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

    {- * The digit type -} Digit (..),

    {- * Decimal digit superset classes -}
    {- ** Of digit -} DigitSuperset (..),
    {- ** Of digit lists -} DigitStringSuperset (..),

    {- * Character/number conversions -}
    {- ** Natural -} naturalDigitMaybe, digitNatural,
    {- ** Integer -} integerDigitMaybe, digitInteger

    ) where

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

import Control.Monad ((<=<), (=<<))
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.List.NonEmpty (NonEmpty, nonEmpty)
import Data.Maybe (Maybe (..), 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 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

import DList (DList)
import qualified DList

{- |

The subset of ASCII used to represent unsigned decimal numbers:

* 'ASCII.Char.Digit0' to 'ASCII.Char.Digit9'

-}
data Digit
    = Digit0  -- ^ Zero
    | Digit1  -- ^ One
    | Digit2  -- ^ Two
    | Digit3  -- ^ Three
    | Digit4  -- ^ Four
    | Digit5  -- ^ Five
    | Digit6  -- ^ Six
    | Digit7  -- ^ Seven
    | Digit8  -- ^ Eight
    | Digit9  -- ^ Nine
    deriving stock (Digit
Digit -> Digit -> Bounded Digit
forall a. a -> a -> Bounded a
maxBound :: Digit
$cmaxBound :: Digit
minBound :: Digit
$cminBound :: Digit
Bounded, Int -> Digit
Digit -> Int
Digit -> [Digit]
Digit -> Digit
Digit -> Digit -> [Digit]
Digit -> Digit -> Digit -> [Digit]
(Digit -> Digit)
-> (Digit -> Digit)
-> (Int -> Digit)
-> (Digit -> Int)
-> (Digit -> [Digit])
-> (Digit -> Digit -> [Digit])
-> (Digit -> Digit -> [Digit])
-> (Digit -> Digit -> Digit -> [Digit])
-> Enum Digit
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 :: Digit -> Digit -> Digit -> [Digit]
$cenumFromThenTo :: Digit -> Digit -> Digit -> [Digit]
enumFromTo :: Digit -> Digit -> [Digit]
$cenumFromTo :: Digit -> Digit -> [Digit]
enumFromThen :: Digit -> Digit -> [Digit]
$cenumFromThen :: Digit -> Digit -> [Digit]
enumFrom :: Digit -> [Digit]
$cenumFrom :: Digit -> [Digit]
fromEnum :: Digit -> Int
$cfromEnum :: Digit -> Int
toEnum :: Int -> Digit
$ctoEnum :: Int -> Digit
pred :: Digit -> Digit
$cpred :: Digit -> Digit
succ :: Digit -> Digit
$csucc :: Digit -> Digit
Enum, Digit -> Digit -> Bool
(Digit -> Digit -> Bool) -> (Digit -> Digit -> Bool) -> Eq Digit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Digit -> Digit -> Bool
$c/= :: Digit -> Digit -> Bool
== :: Digit -> Digit -> Bool
$c== :: Digit -> Digit -> Bool
Eq, Eq Digit
Eq Digit
-> (Digit -> Digit -> Ordering)
-> (Digit -> Digit -> Bool)
-> (Digit -> Digit -> Bool)
-> (Digit -> Digit -> Bool)
-> (Digit -> Digit -> Bool)
-> (Digit -> Digit -> Digit)
-> (Digit -> Digit -> Digit)
-> Ord Digit
Digit -> Digit -> Bool
Digit -> Digit -> Ordering
Digit -> Digit -> Digit
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 :: Digit -> Digit -> Digit
$cmin :: Digit -> Digit -> Digit
max :: Digit -> Digit -> Digit
$cmax :: Digit -> Digit -> Digit
>= :: Digit -> Digit -> Bool
$c>= :: Digit -> Digit -> Bool
> :: Digit -> Digit -> Bool
$c> :: Digit -> Digit -> Bool
<= :: Digit -> Digit -> Bool
$c<= :: Digit -> Digit -> Bool
< :: Digit -> Digit -> Bool
$c< :: Digit -> Digit -> Bool
compare :: Digit -> Digit -> Ordering
$ccompare :: Digit -> Digit -> Ordering
$cp1Ord :: Eq Digit
Ord, Int -> Digit -> ShowS
[Digit] -> ShowS
Digit -> String
(Int -> Digit -> ShowS)
-> (Digit -> String) -> ([Digit] -> ShowS) -> Show Digit
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Digit] -> ShowS
$cshowList :: [Digit] -> ShowS
show :: Digit -> String
$cshow :: Digit -> String
showsPrec :: Int -> Digit -> ShowS
$cshowsPrec :: Int -> Digit -> ShowS
Show, Typeable Digit
DataType
Constr
Typeable Digit
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Digit -> c Digit)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Digit)
-> (Digit -> Constr)
-> (Digit -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Digit))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Digit))
-> ((forall b. Data b => b -> b) -> Digit -> Digit)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Digit -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Digit -> r)
-> (forall u. (forall d. Data d => d -> u) -> Digit -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Digit -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Digit -> m Digit)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Digit -> m Digit)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Digit -> m Digit)
-> Data Digit
Digit -> DataType
Digit -> Constr
(forall b. Data b => b -> b) -> Digit -> Digit
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Digit -> c Digit
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Digit
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) -> Digit -> u
forall u. (forall d. Data d => d -> u) -> Digit -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Digit -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Digit -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Digit -> m Digit
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Digit -> m Digit
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Digit
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Digit -> c Digit
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Digit)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Digit)
$cDigit9 :: Constr
$cDigit8 :: Constr
$cDigit7 :: Constr
$cDigit6 :: Constr
$cDigit5 :: Constr
$cDigit4 :: Constr
$cDigit3 :: Constr
$cDigit2 :: Constr
$cDigit1 :: Constr
$cDigit0 :: Constr
$tDigit :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Digit -> m Digit
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Digit -> m Digit
gmapMp :: (forall d. Data d => d -> m d) -> Digit -> m Digit
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Digit -> m Digit
gmapM :: (forall d. Data d => d -> m d) -> Digit -> m Digit
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Digit -> m Digit
gmapQi :: Int -> (forall d. Data d => d -> u) -> Digit -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Digit -> u
gmapQ :: (forall d. Data d => d -> u) -> Digit -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Digit -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Digit -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Digit -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Digit -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Digit -> r
gmapT :: (forall b. Data b => b -> b) -> Digit -> Digit
$cgmapT :: (forall b. Data b => b -> b) -> Digit -> Digit
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Digit)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Digit)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Digit)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Digit)
dataTypeOf :: Digit -> DataType
$cdataTypeOf :: Digit -> DataType
toConstr :: Digit -> Constr
$ctoConstr :: Digit -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Digit
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Digit
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Digit -> c Digit
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Digit -> c Digit
$cp1Data :: Typeable Digit
Data, (forall x. Digit -> Rep Digit x)
-> (forall x. Rep Digit x -> Digit) -> Generic Digit
forall x. Rep Digit x -> Digit
forall x. Digit -> Rep Digit x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Digit x -> Digit
$cfrom :: forall x. Digit -> Rep Digit x
Generic)
    deriving anyclass Eq Digit
Eq Digit
-> (Int -> Digit -> Int) -> (Digit -> Int) -> Hashable Digit
Int -> Digit -> Int
Digit -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: Digit -> Int
$chash :: Digit -> Int
hashWithSalt :: Int -> Digit -> Int
$chashWithSalt :: Int -> Digit -> Int
$cp1Hashable :: Eq Digit
Hashable


---  Show functions  ---

{- |

Examples:

* @showNatural 0@ = @"0"@
* @showNatural 268@ = @"268"@

-}
showNatural :: DigitStringSuperset string => Natural -> string
showNatural :: Natural -> string
showNatural =
    \case
        Natural
0 -> [Digit] -> string
forall string. DigitStringSuperset string => [Digit] -> string
fromDigitList [ Digit
Digit0 ]
        Natural
n -> [Digit] -> string
forall string. DigitStringSuperset string => [Digit] -> string
fromDigitList (Natural -> [Digit]
naturalList Natural
n)
  where
    naturalList :: Natural -> [Digit]
    naturalList :: Natural -> [Digit]
naturalList = DList Digit -> [Digit]
forall a. DList a -> [a]
DList.toList (DList Digit -> [Digit])
-> (Natural -> DList Digit) -> Natural -> [Digit]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Natural -> DList Digit
r
      where
        r :: Natural -> DList Digit
        r :: Natural -> DList Digit
r = \case
            Natural
0 -> DList Digit
forall a. Monoid a => a
mempty
            Natural
n ->
                (Natural -> DList Digit)
-> (Natural -> DList Digit) -> (Natural, Natural) -> DList Digit
forall (p :: * -> * -> *) m a b.
(Bifoldable p, Monoid m) =>
(a -> m) -> (b -> m) -> p a b -> m
bifoldMap
                    Natural -> DList Digit
r
                    (Digit -> DList Digit
forall a. a -> DList a
DList.singleton (Digit -> DList Digit)
-> (Natural -> Digit) -> Natural -> DList Digit
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Digit
forall a. Enum a => Int -> a
toEnum (Int -> Digit) -> (Natural -> Int) -> Natural -> Digit
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Natural -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral)
                    (Natural -> Natural -> (Natural, Natural)
forall a. Integral a => a -> a -> (a, a)
quotRem Natural
n Natural
10)

{- |

Examples:

* @showInteger 0@ = @"0"@
* @showInteger 12@ = @"12"@
* @showInteger (negate 12)@ = @"-12"@

-}
showInteger :: StringSuperset string => Integer -> string
showInteger :: Integer -> string
showInteger = [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
. Integer -> [Char]
integerList
  where
    integerList :: Integer -> [ASCII.Char]
    integerList :: Integer -> [Char]
integerList =
        \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]
: Integer -> [Char]
nonNegativeIntegerList (Integer -> Integer
forall a. Num a => a -> a
abs Integer
n)
            Integer
n           ->  Integer -> [Char]
nonNegativeIntegerList Integer
n

    nonNegativeIntegerList :: Integer -> [ASCII.Char]
    nonNegativeIntegerList :: Integer -> [Char]
nonNegativeIntegerList = 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 ASCII.Char
        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
. Digit -> Char
forall char. DigitSuperset char => Digit -> char
fromDigit (Digit -> Char) -> (Integer -> Digit) -> Integer -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Digit
forall a. Enum a => Int -> a
toEnum (Int -> Digit) -> (Integer -> Int) -> Integer -> Digit
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Int
forall a. Num a => Integer -> a
fromInteger)
                    (Integer -> Integer -> (Integer, Integer)
forall a. Integral a => a -> a -> (a, a)
quotRem Integer
n Integer
10)

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


---  Read functions  ---

{- |

Examples:

* @readNatural "0"@ = @Just 0@
* @readNatural "268"@ = @Just 268@
* @readNatural "0004"@ = @Just 4@
* @readNatural ""@ = @Nothing@
* @readNatural "-4"@ = @Nothing@
* @readNatural "12345678901234567890"@ = @Just 12345678901234567890@

-}
readNatural :: DigitStringSuperset string => string -> Maybe Natural
readNatural :: string -> Maybe Natural
readNatural = (Natural -> Maybe Natural
forall a. a -> Maybe a
Just (Natural -> Maybe Natural)
-> (NonEmpty Digit -> Natural) -> NonEmpty Digit -> Maybe Natural
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty Digit -> Natural
readNaturalDigits) (NonEmpty Digit -> Maybe Natural)
-> (string -> Maybe (NonEmpty Digit)) -> string -> Maybe Natural
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< [Digit] -> Maybe (NonEmpty Digit)
forall a. [a] -> Maybe (NonEmpty a)
nonEmpty ([Digit] -> Maybe (NonEmpty Digit))
-> (string -> Maybe [Digit]) -> string -> Maybe (NonEmpty Digit)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< string -> Maybe [Digit]
forall string.
DigitStringSuperset string =>
string -> Maybe [Digit]
toDigitListMaybe
  where
    readNaturalDigits :: NonEmpty Digit -> Natural
    readNaturalDigits :: NonEmpty Digit -> Natural
readNaturalDigits = (Natural -> Digit -> Natural)
-> Natural -> NonEmpty Digit -> Natural
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
List.foldl' (\Natural
total Digit
x -> (Natural
10 Natural -> Natural -> Natural
forall a. Num a => a -> a -> a
* Natural
total) Natural -> Natural -> Natural
forall a. Num a => a -> a -> a
+ Int -> Natural
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Digit -> Int
forall a. Enum a => a -> Int
fromEnum Digit
x)) Natural
0

{- |

Examples:

* @readInteger "0"@ = @Just 0@
* @readInteger "268"@ = @Just 268@
* @readInteger "0004"@ = @Just 4@
* @readInteger ""@ = @Nothing@
* @readInteger "-4"@ = @Just (-4)@
* @readInteger "12345678901234567890"@ = @Just 12345678901234567890@

-}
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 Digit -> Integer) -> NonEmpty Digit -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Integer
forall a. Integral a => a -> Integer
toInteger (Integer -> Integer)
-> (NonEmpty Digit -> Integer) -> NonEmpty Digit -> Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty Digit -> Integer
readIntegerDigits) (NonEmpty Digit -> Maybe Integer)
-> ([Char] -> Maybe (NonEmpty Digit)) -> [Char] -> Maybe Integer
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< [Digit] -> Maybe (NonEmpty Digit)
forall a. [a] -> Maybe (NonEmpty a)
nonEmpty ([Digit] -> Maybe (NonEmpty Digit))
-> ([Char] -> Maybe [Digit]) -> [Char] -> Maybe (NonEmpty Digit)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< [Char] -> Maybe [Digit]
forall string.
DigitStringSuperset string =>
string -> Maybe [Digit]
toDigitListMaybe

    readIntegerDigits :: NonEmpty Digit -> Integer
    readIntegerDigits :: NonEmpty Digit -> Integer
readIntegerDigits = (Integer -> Digit -> Integer)
-> Integer -> NonEmpty Digit -> Integer
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
List.foldl' (\Integer
total Digit
x -> (Integer
10 Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Integer
total) Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Int -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Digit -> Int
forall a. Enum a => a -> Int
fromEnum Digit
x)) Integer
0

{- |

Examples:

* @readIntegral "0"@ = @Just (0 :: Word8)@
* @readIntegral "175"@ = @Just (175 :: Word8)@
* @readIntegral "268"@ = @(Nothing :: Maybe Word8)@
* @readIntegral "0004"@ = @Just (4 :: Word8)@
* @readIntegral ""@ = @(Nothing :: Maybe Word8)@
* @readIntegral "-4"@ = @(Nothing :: Maybe Word8)@
* @readIntegral "12345678901234567890"@ = @(Nothing :: Maybe Word8)@

-}
readIntegral :: (StringSuperset string, Integral num, Bits num) => string -> Maybe num
readIntegral :: string -> Maybe num
readIntegral = Integer -> Maybe num
forall a b.
(Integral a, Integral b, Bits a, Bits b) =>
a -> Maybe b
toIntegralSized (Integer -> Maybe num)
-> (string -> Maybe Integer) -> string -> Maybe num
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


---  Uninteresting monomorphic specializations of polymorphic functions  ---

{- |

Examples:

* @naturalDigitMaybe 5@ = @Just Digit5@
* @naturalDigitMaybe 12@ = @Nothing@

-}
naturalDigitMaybe :: Natural -> Maybe Digit
naturalDigitMaybe :: Natural -> Maybe Digit
naturalDigitMaybe Natural
n = if Natural
n Natural -> Natural -> Bool
forall a. Ord a => a -> a -> Bool
> Natural
9 then Maybe Digit
forall a. Maybe a
Nothing else Digit -> Maybe Digit
forall a. a -> Maybe a
Just (Int -> Digit
forall a. Enum a => Int -> a
toEnum (Natural -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Natural
n))

{- |

Examples:

* @integerDigitMaybe 5@ = @Just Digit5@
* @integerDigitMaybe 12@ = @Nothing@

-}
integerDigitMaybe :: Integer -> Maybe Digit
integerDigitMaybe :: Integer -> Maybe Digit
integerDigitMaybe Integer
n = if (Integer
n Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< Integer
0 Bool -> Bool -> Bool
|| Integer
n Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
> Integer
9) then Maybe Digit
forall a. Maybe a
Nothing else Digit -> Maybe Digit
forall a. a -> Maybe a
Just (Int -> Digit
forall a. Enum a => Int -> a
toEnum (Integer -> Int
forall a. Num a => Integer -> a
fromInteger Integer
n))

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

digitInteger :: Digit -> Integer
digitInteger :: Digit -> Integer
digitInteger = Int -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Integer) -> (Digit -> Int) -> Digit -> Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Digit -> Int
forall a. Enum a => a -> Int
fromEnum


---  Lift instances  ---

instance DigitSuperset char => Lift Digit char
  where
    lift :: Digit -> char
lift = Digit -> char
forall char. DigitSuperset char => Digit -> char
fromDigit

instance DigitStringSuperset string => Lift [Digit] string
  where
    lift :: [Digit] -> string
lift = [Digit] -> string
forall string. DigitStringSuperset string => [Digit] -> string
fromDigitList


---  Classes  ---

class DigitSuperset char
  where

    fromDigit :: Digit -> char

    isDigit :: char -> Bool
    isDigit = Maybe Digit -> Bool
forall a. Maybe a -> Bool
isJust (Maybe Digit -> Bool) -> (char -> Maybe Digit) -> char -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. char -> Maybe Digit
forall char. DigitSuperset char => char -> Maybe Digit
toDigitMaybe

    toDigitUnsafe :: char -> Digit
    toDigitUnsafe = Maybe Digit -> Digit
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe Digit -> Digit) -> (char -> Maybe Digit) -> char -> Digit
forall b c a. (b -> c) -> (a -> b) -> a -> c
. char -> Maybe Digit
forall char. DigitSuperset char => char -> Maybe Digit
toDigitMaybe

    toDigitMaybe :: char -> Maybe Digit
    toDigitMaybe char
x = if char -> Bool
forall char. DigitSuperset char => char -> Bool
isDigit char
x then Digit -> Maybe Digit
forall a. a -> Maybe a
Just (char -> Digit
forall char. DigitSuperset char => char -> Digit
toDigitUnsafe char
x) else Maybe Digit
forall a. Maybe a
Nothing

    {-# minimal fromDigit, ((isDigit, toDigitUnsafe) | toDigitMaybe) #-}

class DigitStringSuperset string
  where

    fromDigitList :: [Digit] -> string

    isDigitString :: string -> Bool
    isDigitString = Maybe [Digit] -> Bool
forall a. Maybe a -> Bool
isJust (Maybe [Digit] -> Bool)
-> (string -> Maybe [Digit]) -> string -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. string -> Maybe [Digit]
forall string.
DigitStringSuperset string =>
string -> Maybe [Digit]
toDigitListMaybe

    toDigitListUnsafe :: string -> [Digit]
    toDigitListUnsafe = Maybe [Digit] -> [Digit]
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe [Digit] -> [Digit])
-> (string -> Maybe [Digit]) -> string -> [Digit]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. string -> Maybe [Digit]
forall string.
DigitStringSuperset string =>
string -> Maybe [Digit]
toDigitListMaybe

    toDigitListMaybe :: string -> Maybe [Digit]
    toDigitListMaybe string
x = if string -> Bool
forall string. DigitStringSuperset string => string -> Bool
isDigitString string
x then [Digit] -> Maybe [Digit]
forall a. a -> Maybe a
Just (string -> [Digit]
forall string. DigitStringSuperset string => string -> [Digit]
toDigitListUnsafe string
x) else Maybe [Digit]
forall a. Maybe a
Nothing

    {-# minimal fromDigitList, ((isDigitString, toDigitListUnsafe) | toDigitListMaybe) #-}


---  DigitSuperset instances  ---

instance DigitSuperset Digit
  where
    isDigit :: Digit -> Bool
isDigit Digit
_ = Bool
Bool.True
    fromDigit :: Digit -> Digit
fromDigit = Digit -> Digit
forall a. a -> a
id
    toDigitUnsafe :: Digit -> Digit
toDigitUnsafe = Digit -> Digit
forall a. a -> a
id
    toDigitMaybe :: Digit -> Maybe Digit
toDigitMaybe = Digit -> Maybe Digit
forall a. a -> Maybe a
Just

instance DigitSuperset ASCII.Char
  where
    isDigit :: Char -> Bool
isDigit 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
    fromDigit :: Digit -> Char
fromDigit     = Int -> Char
forall a. Enum a => Int -> a
toEnum (Int -> Char) -> (Digit -> Int) -> Digit -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\Int
x -> Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Char -> Int
forall a. Enum a => a -> Int
fromEnum Char
ASCII.Digit0) (Int -> Int) -> (Digit -> Int) -> Digit -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Digit -> Int
forall a. Enum a => a -> Int
fromEnum
    toDigitUnsafe :: Char -> Digit
toDigitUnsafe = Int -> Digit
forall a. Enum a => Int -> a
toEnum (Int -> Digit) -> (Char -> Int) -> Char -> Digit
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\Int
x -> Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- Char -> Int
forall a. Enum a => a -> Int
fromEnum Char
ASCII.Digit0) (Int -> Int) -> (Char -> Int) -> Char -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
forall a. Enum a => a -> Int
fromEnum

instance DigitSuperset Unicode.Char
  where
    isDigit :: Char -> Bool
isDigit Char
x = Char
x Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
>= Char
'0' Bool -> Bool -> Bool
&& Char
x Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
'9'
    fromDigit :: Digit -> Char
fromDigit     = Int -> Char
Unicode.chr (Int -> Char) -> (Digit -> Int) -> Digit -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\Int
x -> Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Char -> Int
Unicode.ord Char
'0') (Int -> Int) -> (Digit -> Int) -> Digit -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Digit -> Int
forall a. Enum a => a -> Int
fromEnum
    toDigitUnsafe :: Char -> Digit
toDigitUnsafe = Int -> Digit
forall a. Enum a => Int -> a
toEnum      (Int -> Digit) -> (Char -> Int) -> Char -> Digit
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\Int
x -> Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- Char -> Int
Unicode.ord Char
'0') (Int -> Int) -> (Char -> Int) -> Char -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
Unicode.ord

instance DigitSuperset Word8
  where
    fromDigit :: Digit -> Word8
fromDigit Digit
x = Char -> Word8
forall char. CharSuperset char => Char -> char
fromChar (Digit -> Char
forall char. DigitSuperset char => Digit -> char
fromDigit Digit
x :: ASCII.Char)
    toDigitMaybe :: Word8 -> Maybe Digit
toDigitMaybe Word8
w = Char -> Maybe Digit
forall char. DigitSuperset char => char -> Maybe Digit
toDigitMaybe (Char -> Maybe Digit) -> Maybe Char -> Maybe Digit
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 DigitSuperset char => DigitSuperset (ASCII char)
  where
    isDigit :: ASCII char -> Bool
isDigit = char -> Bool
forall char. DigitSuperset char => char -> Bool
isDigit (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
    fromDigit :: Digit -> ASCII char
fromDigit = char -> ASCII char
forall superset. superset -> ASCII superset
asciiUnsafe (char -> ASCII char) -> (Digit -> char) -> Digit -> ASCII char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Digit -> char
forall char. DigitSuperset char => Digit -> char
fromDigit
    toDigitUnsafe :: ASCII char -> Digit
toDigitUnsafe = char -> Digit
forall char. DigitSuperset char => char -> Digit
toDigitUnsafe (char -> Digit) -> (ASCII char -> char) -> ASCII char -> Digit
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ASCII char -> char
forall superset. ASCII superset -> superset
ASCII.Refinement.lift
    toDigitMaybe :: ASCII char -> Maybe Digit
toDigitMaybe = char -> Maybe Digit
forall char. DigitSuperset char => char -> Maybe Digit
toDigitMaybe (char -> Maybe Digit)
-> (ASCII char -> char) -> ASCII char -> Maybe Digit
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ASCII char -> char
forall superset. ASCII superset -> superset
ASCII.Refinement.lift


---  DigitStringSuperset instances  ---

instance DigitStringSuperset [Digit]
  where
    isDigitString :: [Digit] -> Bool
isDigitString [Digit]
_ = Bool
Bool.True
    fromDigitList :: [Digit] -> [Digit]
fromDigitList = [Digit] -> [Digit]
forall a. a -> a
id
    toDigitListUnsafe :: [Digit] -> [Digit]
toDigitListUnsafe = [Digit] -> [Digit]
forall a. a -> a
id
    toDigitListMaybe :: [Digit] -> Maybe [Digit]
toDigitListMaybe = [Digit] -> Maybe [Digit]
forall a. a -> Maybe a
Just

instance DigitStringSuperset [ASCII.Char]
  where
    isDigitString :: [Char] -> Bool
isDigitString = (Char -> Bool) -> [Char] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
List.all Char -> Bool
forall char. DigitSuperset char => char -> Bool
isDigit
    fromDigitList :: [Digit] -> [Char]
fromDigitList = (Digit -> Char) -> [Digit] -> [Char]
forall a b. (a -> b) -> [a] -> [b]
List.map Digit -> Char
forall char. DigitSuperset char => Digit -> char
fromDigit
    toDigitListUnsafe :: [Char] -> [Digit]
toDigitListUnsafe = (Char -> Digit) -> [Char] -> [Digit]
forall a b. (a -> b) -> [a] -> [b]
List.map Char -> Digit
forall char. DigitSuperset char => char -> Digit
toDigitUnsafe

instance DigitStringSuperset [Unicode.Char]
  where
    isDigitString :: String -> Bool
isDigitString = (Char -> Bool) -> String -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
List.all Char -> Bool
forall char. DigitSuperset char => char -> Bool
isDigit
    fromDigitList :: [Digit] -> String
fromDigitList = (Digit -> Char) -> [Digit] -> String
forall a b. (a -> b) -> [a] -> [b]
List.map Digit -> Char
forall char. DigitSuperset char => Digit -> char
fromDigit
    toDigitListUnsafe :: String -> [Digit]
toDigitListUnsafe = (Char -> Digit) -> String -> [Digit]
forall a b. (a -> b) -> [a] -> [b]
List.map Char -> Digit
forall char. DigitSuperset char => char -> Digit
toDigitUnsafe

instance DigitStringSuperset T.Text
  where
    isDigitString :: Text -> Bool
isDigitString = (Char -> Bool) -> Text -> Bool
T.all Char -> Bool
forall char. DigitSuperset char => char -> Bool
isDigit
    fromDigitList :: [Digit] -> Text
fromDigitList = String -> Text
T.pack (String -> Text) -> ([Digit] -> String) -> [Digit] -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Digit -> Char) -> [Digit] -> String
forall a b. (a -> b) -> [a] -> [b]
List.map Digit -> Char
forall char. DigitSuperset char => Digit -> char
fromDigit
    toDigitListUnsafe :: Text -> [Digit]
toDigitListUnsafe = (Char -> Digit) -> String -> [Digit]
forall a b. (a -> b) -> [a] -> [b]
List.map Char -> Digit
forall char. DigitSuperset char => char -> Digit
toDigitUnsafe (String -> [Digit]) -> (Text -> String) -> Text -> [Digit]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
T.unpack

instance DigitStringSuperset LT.Text
  where
    isDigitString :: Text -> Bool
isDigitString = (Char -> Bool) -> Text -> Bool
LT.all Char -> Bool
forall char. DigitSuperset char => char -> Bool
isDigit
    fromDigitList :: [Digit] -> Text
fromDigitList = String -> Text
LT.pack (String -> Text) -> ([Digit] -> String) -> [Digit] -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Digit -> Char) -> [Digit] -> String
forall a b. (a -> b) -> [a] -> [b]
List.map Digit -> Char
forall char. DigitSuperset char => Digit -> char
fromDigit
    toDigitListUnsafe :: Text -> [Digit]
toDigitListUnsafe = (Char -> Digit) -> String -> [Digit]
forall a b. (a -> b) -> [a] -> [b]
List.map Char -> Digit
forall char. DigitSuperset char => char -> Digit
toDigitUnsafe (String -> [Digit]) -> (Text -> String) -> Text -> [Digit]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
LT.unpack

instance DigitStringSuperset TB.Builder
  where
    fromDigitList :: [Digit] -> Builder
fromDigitList = Text -> Builder
TB.fromLazyText (Text -> Builder) -> ([Digit] -> Text) -> [Digit] -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Digit] -> Text
forall string. DigitStringSuperset string => [Digit] -> string
fromDigitList
    toDigitListMaybe :: Builder -> Maybe [Digit]
toDigitListMaybe = Text -> Maybe [Digit]
forall string.
DigitStringSuperset string =>
string -> Maybe [Digit]
toDigitListMaybe (Text -> Maybe [Digit])
-> (Builder -> Text) -> Builder -> Maybe [Digit]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Builder -> Text
TB.toLazyText

instance DigitStringSuperset BS.ByteString
  where
    isDigitString :: ByteString -> Bool
isDigitString = (Word8 -> Bool) -> ByteString -> Bool
BS.all Word8 -> Bool
forall char. DigitSuperset char => char -> Bool
isDigit
    fromDigitList :: [Digit] -> ByteString
fromDigitList = [Word8] -> ByteString
BS.pack ([Word8] -> ByteString)
-> ([Digit] -> [Word8]) -> [Digit] -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Digit -> Word8) -> [Digit] -> [Word8]
forall a b. (a -> b) -> [a] -> [b]
List.map Digit -> Word8
forall char. DigitSuperset char => Digit -> char
fromDigit
    toDigitListUnsafe :: ByteString -> [Digit]
toDigitListUnsafe = (Word8 -> Digit) -> [Word8] -> [Digit]
forall a b. (a -> b) -> [a] -> [b]
List.map Word8 -> Digit
forall char. DigitSuperset char => char -> Digit
toDigitUnsafe ([Word8] -> [Digit])
-> (ByteString -> [Word8]) -> ByteString -> [Digit]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> [Word8]
BS.unpack

instance DigitStringSuperset LBS.ByteString
  where
    isDigitString :: ByteString -> Bool
isDigitString = (Word8 -> Bool) -> ByteString -> Bool
LBS.all Word8 -> Bool
forall char. DigitSuperset char => char -> Bool
isDigit
    fromDigitList :: [Digit] -> ByteString
fromDigitList = [Word8] -> ByteString
LBS.pack ([Word8] -> ByteString)
-> ([Digit] -> [Word8]) -> [Digit] -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Digit -> Word8) -> [Digit] -> [Word8]
forall a b. (a -> b) -> [a] -> [b]
List.map Digit -> Word8
forall char. DigitSuperset char => Digit -> char
fromDigit
    toDigitListUnsafe :: ByteString -> [Digit]
toDigitListUnsafe = (Word8 -> Digit) -> [Word8] -> [Digit]
forall a b. (a -> b) -> [a] -> [b]
List.map Word8 -> Digit
forall char. DigitSuperset char => char -> Digit
toDigitUnsafe ([Word8] -> [Digit])
-> (ByteString -> [Word8]) -> ByteString -> [Digit]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> [Word8]
LBS.unpack

instance DigitStringSuperset BSB.Builder
  where
    fromDigitList :: [Digit] -> Builder
fromDigitList = ByteString -> Builder
BSB.lazyByteString (ByteString -> Builder)
-> ([Digit] -> ByteString) -> [Digit] -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Digit] -> ByteString
forall string. DigitStringSuperset string => [Digit] -> string
fromDigitList
    toDigitListMaybe :: Builder -> Maybe [Digit]
toDigitListMaybe = ByteString -> Maybe [Digit]
forall string.
DigitStringSuperset string =>
string -> Maybe [Digit]
toDigitListMaybe (ByteString -> Maybe [Digit])
-> (Builder -> ByteString) -> Builder -> Maybe [Digit]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Builder -> ByteString
BSB.toLazyByteString

instance DigitStringSuperset char => DigitStringSuperset (ASCII char)
  where
    isDigitString :: ASCII char -> Bool
isDigitString = char -> Bool
forall string. DigitStringSuperset string => string -> Bool
isDigitString (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
    fromDigitList :: [Digit] -> ASCII char
fromDigitList = char -> ASCII char
forall superset. superset -> ASCII superset
asciiUnsafe (char -> ASCII char) -> ([Digit] -> char) -> [Digit] -> ASCII char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Digit] -> char
forall string. DigitStringSuperset string => [Digit] -> string
fromDigitList
    toDigitListUnsafe :: ASCII char -> [Digit]
toDigitListUnsafe = char -> [Digit]
forall string. DigitStringSuperset string => string -> [Digit]
toDigitListUnsafe (char -> [Digit]) -> (ASCII char -> char) -> ASCII char -> [Digit]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ASCII char -> char
forall superset. ASCII superset -> superset
ASCII.Refinement.lift
    toDigitListMaybe :: ASCII char -> Maybe [Digit]
toDigitListMaybe = char -> Maybe [Digit]
forall string.
DigitStringSuperset string =>
string -> Maybe [Digit]
toDigitListMaybe (char -> Maybe [Digit])
-> (ASCII char -> char) -> ASCII char -> Maybe [Digit]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ASCII char -> char
forall superset. ASCII superset -> superset
ASCII.Refinement.lift