{-# LANGUAGE DeriveDataTypeable, GeneralizedNewtypeDeriving #-}

module Data.Ascii.ByteString where

-- base
import Data.Data (Data)
import Data.Typeable (Typeable)
import Data.String (IsString (..))
import qualified Data.Char as C
import Data.Monoid (Monoid)
import Data.Semigroup (Semigroup)

-- bytestring
import qualified Data.ByteString as S
import qualified Data.ByteString.Char8 as S8
import Data.ByteString (ByteString)

-- case-insensitive
import Data.CaseInsensitive (FoldCase, CI, mk, original)

-- hashable
import Data.Hashable (Hashable)

-- text
import Data.Text (Text)
import qualified Data.Text as T
import qualified Data.Text.Encoding as TE

newtype Ascii = Ascii ByteString
    deriving (Int -> Ascii -> ShowS
[Ascii] -> ShowS
Ascii -> String
(Int -> Ascii -> ShowS)
-> (Ascii -> String) -> ([Ascii] -> ShowS) -> Show Ascii
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Ascii] -> ShowS
$cshowList :: [Ascii] -> ShowS
show :: Ascii -> String
$cshow :: Ascii -> String
showsPrec :: Int -> Ascii -> ShowS
$cshowsPrec :: Int -> Ascii -> ShowS
Show, Ascii -> Ascii -> Bool
(Ascii -> Ascii -> Bool) -> (Ascii -> Ascii -> Bool) -> Eq Ascii
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Ascii -> Ascii -> Bool
$c/= :: Ascii -> Ascii -> Bool
== :: Ascii -> Ascii -> Bool
$c== :: Ascii -> Ascii -> Bool
Eq, ReadPrec [Ascii]
ReadPrec Ascii
Int -> ReadS Ascii
ReadS [Ascii]
(Int -> ReadS Ascii)
-> ReadS [Ascii]
-> ReadPrec Ascii
-> ReadPrec [Ascii]
-> Read Ascii
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Ascii]
$creadListPrec :: ReadPrec [Ascii]
readPrec :: ReadPrec Ascii
$creadPrec :: ReadPrec Ascii
readList :: ReadS [Ascii]
$creadList :: ReadS [Ascii]
readsPrec :: Int -> ReadS Ascii
$creadsPrec :: Int -> ReadS Ascii
Read, Eq Ascii
Eq Ascii
-> (Ascii -> Ascii -> Ordering)
-> (Ascii -> Ascii -> Bool)
-> (Ascii -> Ascii -> Bool)
-> (Ascii -> Ascii -> Bool)
-> (Ascii -> Ascii -> Bool)
-> (Ascii -> Ascii -> Ascii)
-> (Ascii -> Ascii -> Ascii)
-> Ord Ascii
Ascii -> Ascii -> Bool
Ascii -> Ascii -> Ordering
Ascii -> Ascii -> Ascii
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 :: Ascii -> Ascii -> Ascii
$cmin :: Ascii -> Ascii -> Ascii
max :: Ascii -> Ascii -> Ascii
$cmax :: Ascii -> Ascii -> Ascii
>= :: Ascii -> Ascii -> Bool
$c>= :: Ascii -> Ascii -> Bool
> :: Ascii -> Ascii -> Bool
$c> :: Ascii -> Ascii -> Bool
<= :: Ascii -> Ascii -> Bool
$c<= :: Ascii -> Ascii -> Bool
< :: Ascii -> Ascii -> Bool
$c< :: Ascii -> Ascii -> Bool
compare :: Ascii -> Ascii -> Ordering
$ccompare :: Ascii -> Ascii -> Ordering
$cp1Ord :: Eq Ascii
Ord, Typeable Ascii
DataType
Constr
Typeable Ascii
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Ascii -> c Ascii)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Ascii)
-> (Ascii -> Constr)
-> (Ascii -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Ascii))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ascii))
-> ((forall b. Data b => b -> b) -> Ascii -> Ascii)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ascii -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ascii -> r)
-> (forall u. (forall d. Data d => d -> u) -> Ascii -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Ascii -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Ascii -> m Ascii)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Ascii -> m Ascii)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Ascii -> m Ascii)
-> Data Ascii
Ascii -> DataType
Ascii -> Constr
(forall b. Data b => b -> b) -> Ascii -> Ascii
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ascii -> c Ascii
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Ascii
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) -> Ascii -> u
forall u. (forall d. Data d => d -> u) -> Ascii -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ascii -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ascii -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Ascii -> m Ascii
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Ascii -> m Ascii
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Ascii
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ascii -> c Ascii
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Ascii)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ascii)
$cAscii :: Constr
$tAscii :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Ascii -> m Ascii
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Ascii -> m Ascii
gmapMp :: (forall d. Data d => d -> m d) -> Ascii -> m Ascii
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Ascii -> m Ascii
gmapM :: (forall d. Data d => d -> m d) -> Ascii -> m Ascii
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Ascii -> m Ascii
gmapQi :: Int -> (forall d. Data d => d -> u) -> Ascii -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Ascii -> u
gmapQ :: (forall d. Data d => d -> u) -> Ascii -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Ascii -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ascii -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ascii -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ascii -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ascii -> r
gmapT :: (forall b. Data b => b -> b) -> Ascii -> Ascii
$cgmapT :: (forall b. Data b => b -> b) -> Ascii -> Ascii
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ascii)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ascii)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Ascii)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Ascii)
dataTypeOf :: Ascii -> DataType
$cdataTypeOf :: Ascii -> DataType
toConstr :: Ascii -> Constr
$ctoConstr :: Ascii -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Ascii
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Ascii
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ascii -> c Ascii
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ascii -> c Ascii
$cp1Data :: Typeable Ascii
Data, Typeable, String -> Ascii
(String -> Ascii) -> IsString Ascii
forall a. (String -> a) -> IsString a
fromString :: String -> Ascii
$cfromString :: String -> Ascii
IsString, [Ascii] -> [Ascii]
Ascii -> Ascii
(Ascii -> Ascii) -> ([Ascii] -> [Ascii]) -> FoldCase Ascii
forall s. (s -> s) -> ([s] -> [s]) -> FoldCase s
foldCaseList :: [Ascii] -> [Ascii]
$cfoldCaseList :: [Ascii] -> [Ascii]
foldCase :: Ascii -> Ascii
$cfoldCase :: Ascii -> Ascii
FoldCase, Int -> Ascii -> Int
Ascii -> Int
(Int -> Ascii -> Int) -> (Ascii -> Int) -> Hashable Ascii
forall a. (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: Ascii -> Int
$chash :: Ascii -> Int
hashWithSalt :: Int -> Ascii -> Int
$chashWithSalt :: Int -> Ascii -> Int
Hashable, b -> Ascii -> Ascii
NonEmpty Ascii -> Ascii
Ascii -> Ascii -> Ascii
(Ascii -> Ascii -> Ascii)
-> (NonEmpty Ascii -> Ascii)
-> (forall b. Integral b => b -> Ascii -> Ascii)
-> Semigroup Ascii
forall b. Integral b => b -> Ascii -> Ascii
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
stimes :: b -> Ascii -> Ascii
$cstimes :: forall b. Integral b => b -> Ascii -> Ascii
sconcat :: NonEmpty Ascii -> Ascii
$csconcat :: NonEmpty Ascii -> Ascii
<> :: Ascii -> Ascii -> Ascii
$c<> :: Ascii -> Ascii -> Ascii
Semigroup, Semigroup Ascii
Ascii
Semigroup Ascii
-> Ascii
-> (Ascii -> Ascii -> Ascii)
-> ([Ascii] -> Ascii)
-> Monoid Ascii
[Ascii] -> Ascii
Ascii -> Ascii -> Ascii
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
mconcat :: [Ascii] -> Ascii
$cmconcat :: [Ascii] -> Ascii
mappend :: Ascii -> Ascii -> Ascii
$cmappend :: Ascii -> Ascii -> Ascii
mempty :: Ascii
$cmempty :: Ascii
$cp1Monoid :: Semigroup Ascii
Monoid)

type CIAscii = CI Ascii

fromByteString :: ByteString -> Maybe Ascii
fromByteString :: ByteString -> Maybe Ascii
fromByteString ByteString
bs
    | (Word8 -> Bool) -> ByteString -> Bool
S.all (Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
< Word8
128) ByteString
bs = Ascii -> Maybe Ascii
forall a. a -> Maybe a
Just (Ascii -> Maybe Ascii) -> Ascii -> Maybe Ascii
forall a b. (a -> b) -> a -> b
$ ByteString -> Ascii
Ascii ByteString
bs
    | Bool
otherwise = Maybe Ascii
forall a. Maybe a
Nothing

-- | Renamed to avoid clash with 'fromString'
fromChars :: String -> Maybe Ascii
fromChars :: String -> Maybe Ascii
fromChars String
s
    | (Char -> Bool) -> String -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Char -> Bool
C.isAscii String
s = Ascii -> Maybe Ascii
forall a. a -> Maybe a
Just (Ascii -> Maybe Ascii) -> Ascii -> Maybe Ascii
forall a b. (a -> b) -> a -> b
$ ByteString -> Ascii
Ascii (ByteString -> Ascii) -> ByteString -> Ascii
forall a b. (a -> b) -> a -> b
$ String -> ByteString
S8.pack String
s
    | Bool
otherwise = Maybe Ascii
forall a. Maybe a
Nothing

fromText :: Text -> Maybe Ascii
fromText :: Text -> Maybe Ascii
fromText Text
t
    | (Char -> Bool) -> Text -> Bool
T.all Char -> Bool
C.isAscii Text
t = Ascii -> Maybe Ascii
forall a. a -> Maybe a
Just (Ascii -> Maybe Ascii) -> Ascii -> Maybe Ascii
forall a b. (a -> b) -> a -> b
$ ByteString -> Ascii
Ascii (ByteString -> Ascii) -> ByteString -> Ascii
forall a b. (a -> b) -> a -> b
$ Text -> ByteString
TE.encodeUtf8 Text
t
    | Bool
otherwise = Maybe Ascii
forall a. Maybe a
Nothing

unsafeFromByteString :: ByteString -> Ascii
unsafeFromByteString :: ByteString -> Ascii
unsafeFromByteString = ByteString -> Ascii
Ascii

unsafeFromString :: String -> Ascii
unsafeFromString :: String -> Ascii
unsafeFromString = ByteString -> Ascii
Ascii (ByteString -> Ascii) -> (String -> ByteString) -> String -> Ascii
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ByteString
S8.pack

unsafeFromText :: Text -> Ascii
unsafeFromText :: Text -> Ascii
unsafeFromText = ByteString -> Ascii
Ascii (ByteString -> Ascii) -> (Text -> ByteString) -> Text -> Ascii
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> ByteString
TE.encodeUtf8

toCIAscii :: Ascii -> CIAscii
toCIAscii :: Ascii -> CIAscii
toCIAscii = Ascii -> CIAscii
forall s. FoldCase s => s -> CI s
mk

fromCIAscii :: CIAscii -> Ascii
fromCIAscii :: CIAscii -> Ascii
fromCIAscii = CIAscii -> Ascii
forall s. CI s -> s
original

toByteString :: Ascii -> ByteString
toByteString :: Ascii -> ByteString
toByteString (Ascii ByteString
bs) = ByteString
bs

toString :: Ascii -> String
toString :: Ascii -> String
toString (Ascii ByteString
bs) = ByteString -> String
S8.unpack ByteString
bs

toText :: Ascii -> Text
toText :: Ascii -> Text
toText (Ascii ByteString
bs) = ByteString -> Text
TE.decodeUtf8 ByteString
bs

ciToByteString :: CIAscii -> ByteString
ciToByteString :: CIAscii -> ByteString
ciToByteString = Ascii -> ByteString
toByteString (Ascii -> ByteString)
-> (CIAscii -> Ascii) -> CIAscii -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CIAscii -> Ascii
forall s. CI s -> s
original