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

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

    {- * 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 ASCII.Refinement (ASCII, asciiUnsafe, lift)
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.Function (id, (.))
import Data.Functor (fmap)
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 Numeric.Natural (Natural)
import Prelude (Integer, Integral, abs, fromEnum, fromInteger, fromIntegral,
                negate, quotRem, toEnum, toInteger, (*), (+), (-))

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

import D10.Safe (D10 (..))
import qualified D10.Safe as D10


---  Show functions  ---

{- |

Examples:

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

-}
showNatural :: DigitStringSuperset string => Natural -> string
showNatural :: Natural -> string
showNatural =
    \case
        Natural
0 -> [D10] -> string
forall string. DigitStringSuperset string => [D10] -> string
fromDigitList [ D10
D0 ]
        Natural
n -> [D10] -> string
forall string. DigitStringSuperset string => [D10] -> string
fromDigitList (Natural -> [D10]
naturalList Natural
n)
  where
    naturalList :: Natural -> [D10]
    naturalList :: Natural -> [D10]
naturalList = DList D10 -> [D10]
forall a. DList a -> [a]
DList.toList (DList D10 -> [D10]) -> (Natural -> DList D10) -> Natural -> [D10]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Natural -> DList D10
r
      where
        r :: Natural -> DList D10
        r :: Natural -> DList D10
r = \case
            Natural
0 -> DList D10
forall a. Monoid a => a
mempty
            Natural
n ->
                (Natural -> DList D10)
-> (Natural -> DList D10) -> (Natural, Natural) -> DList D10
forall (p :: * -> * -> *) m a b.
(Bifoldable p, Monoid m) =>
(a -> m) -> (b -> m) -> p a b -> m
bifoldMap
                    Natural -> DList D10
r
                    (D10 -> DList D10
forall a. a -> DList a
DList.singleton (D10 -> DList D10) -> (Natural -> D10) -> Natural -> DList D10
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> D10
forall a. Enum a => Int -> a
toEnum (Int -> D10) -> (Natural -> Int) -> Natural -> D10
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
. D10 -> Char
forall char. DigitSuperset char => D10 -> char
fromDigit (D10 -> Char) -> (Integer -> D10) -> Integer -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> D10
forall a. Enum a => Int -> a
toEnum (Int -> D10) -> (Integer -> Int) -> Integer -> D10
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 D10 -> Natural) -> NonEmpty D10 -> Maybe Natural
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty D10 -> Natural
readNaturalDigits) (NonEmpty D10 -> Maybe Natural)
-> (string -> Maybe (NonEmpty D10)) -> string -> Maybe Natural
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< [D10] -> Maybe (NonEmpty D10)
forall a. [a] -> Maybe (NonEmpty a)
nonEmpty ([D10] -> Maybe (NonEmpty D10))
-> (string -> Maybe [D10]) -> string -> Maybe (NonEmpty D10)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< string -> Maybe [D10]
forall string. DigitStringSuperset string => string -> Maybe [D10]
toDigitListMaybe
  where
    readNaturalDigits :: NonEmpty D10 -> Natural
    readNaturalDigits :: NonEmpty D10 -> Natural
readNaturalDigits = (Natural -> D10 -> Natural) -> Natural -> NonEmpty D10 -> Natural
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
List.foldl' (\Natural
total D10
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 (D10 -> Int
forall a. Enum a => a -> Int
fromEnum D10
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 D10 -> Integer) -> NonEmpty D10 -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Integer
forall a. Integral a => a -> Integer
toInteger (Integer -> Integer)
-> (NonEmpty D10 -> Integer) -> NonEmpty D10 -> Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty D10 -> Integer
readIntegerDigits) (NonEmpty D10 -> Maybe Integer)
-> ([Char] -> Maybe (NonEmpty D10)) -> [Char] -> Maybe Integer
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< [D10] -> Maybe (NonEmpty D10)
forall a. [a] -> Maybe (NonEmpty a)
nonEmpty ([D10] -> Maybe (NonEmpty D10))
-> ([Char] -> Maybe [D10]) -> [Char] -> Maybe (NonEmpty D10)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< [Char] -> Maybe [D10]
forall string. DigitStringSuperset string => string -> Maybe [D10]
toDigitListMaybe

    readIntegerDigits :: NonEmpty D10 -> Integer
    readIntegerDigits :: NonEmpty D10 -> Integer
readIntegerDigits = (Integer -> D10 -> Integer) -> Integer -> NonEmpty D10 -> Integer
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
List.foldl' (\Integer
total D10
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 (D10 -> Int
forall a. Enum a => a -> Int
fromEnum D10
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 D10
naturalDigitMaybe :: Natural -> Maybe D10
naturalDigitMaybe = Natural -> Maybe D10
D10.natD10Maybe

{- |

Examples:

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

-}
integerDigitMaybe :: Integer -> Maybe D10
integerDigitMaybe :: Integer -> Maybe D10
integerDigitMaybe = Integer -> Maybe D10
D10.integerD10Maybe

digitNatural :: D10 -> Natural
digitNatural :: D10 -> Natural
digitNatural = D10 -> Natural
D10.d10Nat

digitInteger :: D10 -> Integer
digitInteger :: D10 -> Integer
digitInteger = D10 -> Integer
D10.d10Integer


---  Classes  ---

class DigitSuperset char
  where

    fromDigit :: D10 -> char

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

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

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

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

class DigitStringSuperset string
  where

    fromDigitList :: [D10] -> string

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

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

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

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


---  DigitSuperset instances  ---

instance DigitSuperset D10
  where
    isDigit :: D10 -> Bool
isDigit D10
_ = Bool
Bool.True
    fromDigit :: D10 -> D10
fromDigit = D10 -> D10
forall a. a -> a
id
    toDigitUnsafe :: D10 -> D10
toDigitUnsafe = D10 -> D10
forall a. a -> a
id
    toDigitMaybe :: D10 -> Maybe D10
toDigitMaybe = D10 -> Maybe D10
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 :: D10 -> Char
fromDigit     = Int -> Char
forall a. Enum a => Int -> a
toEnum (Int -> Char) -> (D10 -> Int) -> D10 -> 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) -> (D10 -> Int) -> D10 -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. D10 -> Int
forall a. Enum a => a -> Int
fromEnum
    toDigitUnsafe :: Char -> D10
toDigitUnsafe = Int -> D10
forall a. Enum a => Int -> a
toEnum (Int -> D10) -> (Char -> Int) -> Char -> D10
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 :: D10 -> Char
fromDigit     = Int -> Char
Unicode.chr (Int -> Char) -> (D10 -> Int) -> D10 -> 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) -> (D10 -> Int) -> D10 -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. D10 -> Int
forall a. Enum a => a -> Int
fromEnum
    toDigitUnsafe :: Char -> D10
toDigitUnsafe = Int -> D10
forall a. Enum a => Int -> a
toEnum      (Int -> D10) -> (Char -> Int) -> Char -> D10
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 :: D10 -> Word8
fromDigit D10
x = Char -> Word8
forall char. CharSuperset char => Char -> char
fromChar (D10 -> Char
forall char. DigitSuperset char => D10 -> char
fromDigit D10
x :: ASCII.Char)
    toDigitMaybe :: Word8 -> Maybe D10
toDigitMaybe Word8
w = Char -> Maybe D10
forall char. DigitSuperset char => char -> Maybe D10
toDigitMaybe (Char -> Maybe D10) -> Maybe Char -> Maybe D10
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
lift
    fromDigit :: D10 -> ASCII char
fromDigit = char -> ASCII char
forall superset. superset -> ASCII superset
asciiUnsafe (char -> ASCII char) -> (D10 -> char) -> D10 -> ASCII char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. D10 -> char
forall char. DigitSuperset char => D10 -> char
fromDigit
    toDigitUnsafe :: ASCII char -> D10
toDigitUnsafe = char -> D10
forall char. DigitSuperset char => char -> D10
toDigitUnsafe (char -> D10) -> (ASCII char -> char) -> ASCII char -> D10
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ASCII char -> char
forall superset. ASCII superset -> superset
lift
    toDigitMaybe :: ASCII char -> Maybe D10
toDigitMaybe = char -> Maybe D10
forall char. DigitSuperset char => char -> Maybe D10
toDigitMaybe (char -> Maybe D10)
-> (ASCII char -> char) -> ASCII char -> Maybe D10
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ASCII char -> char
forall superset. ASCII superset -> superset
lift


---  DigitStringSuperset instances  ---

instance DigitStringSuperset [D10]
  where
    isDigitString :: [D10] -> Bool
isDigitString [D10]
_ = Bool
Bool.True
    fromDigitList :: [D10] -> [D10]
fromDigitList = [D10] -> [D10]
forall a. a -> a
id
    toDigitListUnsafe :: [D10] -> [D10]
toDigitListUnsafe = [D10] -> [D10]
forall a. a -> a
id
    toDigitListMaybe :: [D10] -> Maybe [D10]
toDigitListMaybe = [D10] -> Maybe [D10]
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 :: [D10] -> [Char]
fromDigitList = (D10 -> Char) -> [D10] -> [Char]
forall a b. (a -> b) -> [a] -> [b]
List.map D10 -> Char
forall char. DigitSuperset char => D10 -> char
fromDigit
    toDigitListUnsafe :: [Char] -> [D10]
toDigitListUnsafe = (Char -> D10) -> [Char] -> [D10]
forall a b. (a -> b) -> [a] -> [b]
List.map Char -> D10
forall char. DigitSuperset char => char -> D10
toDigitUnsafe

instance DigitStringSuperset [Unicode.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 :: [D10] -> [Char]
fromDigitList = (D10 -> Char) -> [D10] -> [Char]
forall a b. (a -> b) -> [a] -> [b]
List.map D10 -> Char
forall char. DigitSuperset char => D10 -> char
fromDigit
    toDigitListUnsafe :: [Char] -> [D10]
toDigitListUnsafe = (Char -> D10) -> [Char] -> [D10]
forall a b. (a -> b) -> [a] -> [b]
List.map Char -> D10
forall char. DigitSuperset char => char -> D10
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 :: [D10] -> Text
fromDigitList = [Char] -> Text
T.pack ([Char] -> Text) -> ([D10] -> [Char]) -> [D10] -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (D10 -> Char) -> [D10] -> [Char]
forall a b. (a -> b) -> [a] -> [b]
List.map D10 -> Char
forall char. DigitSuperset char => D10 -> char
fromDigit
    toDigitListUnsafe :: Text -> [D10]
toDigitListUnsafe = (Char -> D10) -> [Char] -> [D10]
forall a b. (a -> b) -> [a] -> [b]
List.map Char -> D10
forall char. DigitSuperset char => char -> D10
toDigitUnsafe ([Char] -> [D10]) -> (Text -> [Char]) -> Text -> [D10]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> [Char]
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 :: [D10] -> Text
fromDigitList = [Char] -> Text
LT.pack ([Char] -> Text) -> ([D10] -> [Char]) -> [D10] -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (D10 -> Char) -> [D10] -> [Char]
forall a b. (a -> b) -> [a] -> [b]
List.map D10 -> Char
forall char. DigitSuperset char => D10 -> char
fromDigit
    toDigitListUnsafe :: Text -> [D10]
toDigitListUnsafe = (Char -> D10) -> [Char] -> [D10]
forall a b. (a -> b) -> [a] -> [b]
List.map Char -> D10
forall char. DigitSuperset char => char -> D10
toDigitUnsafe ([Char] -> [D10]) -> (Text -> [Char]) -> Text -> [D10]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> [Char]
LT.unpack

instance DigitStringSuperset TB.Builder
  where
    fromDigitList :: [D10] -> Builder
fromDigitList = Text -> Builder
TB.fromLazyText (Text -> Builder) -> ([D10] -> Text) -> [D10] -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [D10] -> Text
forall string. DigitStringSuperset string => [D10] -> string
fromDigitList
    toDigitListMaybe :: Builder -> Maybe [D10]
toDigitListMaybe = Text -> Maybe [D10]
forall string. DigitStringSuperset string => string -> Maybe [D10]
toDigitListMaybe (Text -> Maybe [D10])
-> (Builder -> Text) -> Builder -> Maybe [D10]
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 :: [D10] -> ByteString
fromDigitList = [Word8] -> ByteString
BS.pack ([Word8] -> ByteString)
-> ([D10] -> [Word8]) -> [D10] -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (D10 -> Word8) -> [D10] -> [Word8]
forall a b. (a -> b) -> [a] -> [b]
List.map D10 -> Word8
forall char. DigitSuperset char => D10 -> char
fromDigit
    toDigitListUnsafe :: ByteString -> [D10]
toDigitListUnsafe = (Word8 -> D10) -> [Word8] -> [D10]
forall a b. (a -> b) -> [a] -> [b]
List.map Word8 -> D10
forall char. DigitSuperset char => char -> D10
toDigitUnsafe ([Word8] -> [D10])
-> (ByteString -> [Word8]) -> ByteString -> [D10]
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 :: [D10] -> ByteString
fromDigitList = [Word8] -> ByteString
LBS.pack ([Word8] -> ByteString)
-> ([D10] -> [Word8]) -> [D10] -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (D10 -> Word8) -> [D10] -> [Word8]
forall a b. (a -> b) -> [a] -> [b]
List.map D10 -> Word8
forall char. DigitSuperset char => D10 -> char
fromDigit
    toDigitListUnsafe :: ByteString -> [D10]
toDigitListUnsafe = (Word8 -> D10) -> [Word8] -> [D10]
forall a b. (a -> b) -> [a] -> [b]
List.map Word8 -> D10
forall char. DigitSuperset char => char -> D10
toDigitUnsafe ([Word8] -> [D10])
-> (ByteString -> [Word8]) -> ByteString -> [D10]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> [Word8]
LBS.unpack

instance DigitStringSuperset BSB.Builder
  where
    fromDigitList :: [D10] -> Builder
fromDigitList = ByteString -> Builder
BSB.lazyByteString (ByteString -> Builder)
-> ([D10] -> ByteString) -> [D10] -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [D10] -> ByteString
forall string. DigitStringSuperset string => [D10] -> string
fromDigitList
    toDigitListMaybe :: Builder -> Maybe [D10]
toDigitListMaybe = ByteString -> Maybe [D10]
forall string. DigitStringSuperset string => string -> Maybe [D10]
toDigitListMaybe (ByteString -> Maybe [D10])
-> (Builder -> ByteString) -> Builder -> Maybe [D10]
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
lift
    fromDigitList :: [D10] -> ASCII char
fromDigitList = char -> ASCII char
forall superset. superset -> ASCII superset
asciiUnsafe (char -> ASCII char) -> ([D10] -> char) -> [D10] -> ASCII char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [D10] -> char
forall string. DigitStringSuperset string => [D10] -> string
fromDigitList
    toDigitListUnsafe :: ASCII char -> [D10]
toDigitListUnsafe = char -> [D10]
forall string. DigitStringSuperset string => string -> [D10]
toDigitListUnsafe (char -> [D10]) -> (ASCII char -> char) -> ASCII char -> [D10]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ASCII char -> char
forall superset. ASCII superset -> superset
lift
    toDigitListMaybe :: ASCII char -> Maybe [D10]
toDigitListMaybe = char -> Maybe [D10]
forall string. DigitStringSuperset string => string -> Maybe [D10]
toDigitListMaybe (char -> Maybe [D10])
-> (ASCII char -> char) -> ASCII char -> Maybe [D10]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ASCII char -> char
forall superset. ASCII superset -> superset
lift