module SimpleParser.Chunked
( Chunked (..)
, TextualChunked (..)
) where
import Data.ByteString (ByteString)
import qualified Data.ByteString as BS
import qualified Data.ByteString.Lazy as BSL
import Data.Foldable (toList)
import Data.List (uncons)
import Data.Sequence (Seq (..))
import qualified Data.Sequence as Seq
import Data.Text (Text)
import qualified Data.Text as T
import qualified Data.Text.Lazy as TL
import Data.Word (Word8)
import Text.Builder (Builder)
import qualified Text.Builder as TB
class Monoid chunk => Chunked chunk token | chunk -> token where
consChunk :: token -> chunk -> chunk
unconsChunk :: chunk -> Maybe (token, chunk)
tokenToChunk :: token -> chunk
tokensToChunk :: [token] -> chunk
chunkToTokens :: chunk -> [token]
chunkLength :: chunk -> Int
chunkEmpty :: chunk -> Bool
revTokensToChunk :: [token] -> chunk
revTokensToChunk = forall chunk token. Chunked chunk token => [token] -> chunk
tokensToChunk forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> [a]
reverse
class Chunked chunk Char => TextualChunked chunk where
buildChunk :: chunk -> Builder
buildChunk = Text -> Builder
TB.text forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall chunk. TextualChunked chunk => chunk -> Text
packChunk
packChunk :: chunk -> Text
packChunk = Builder -> Text
TB.run forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall chunk. TextualChunked chunk => chunk -> Builder
buildChunk
unpackChunk :: Text -> chunk
{-# MINIMAL (buildChunk | packChunk), unpackChunk #-}
instance Chunked [a] a where
consChunk :: a -> [a] -> [a]
consChunk = (:)
unconsChunk :: [a] -> Maybe (a, [a])
unconsChunk = forall a. [a] -> Maybe (a, [a])
uncons
tokenToChunk :: a -> [a]
tokenToChunk a
a = [a
a]
tokensToChunk :: [a] -> [a]
tokensToChunk = forall a. a -> a
id
chunkToTokens :: [a] -> [a]
chunkToTokens = forall a. a -> a
id
chunkLength :: [a] -> Int
chunkLength = forall (t :: * -> *) a. Foldable t => t a -> Int
length
chunkEmpty :: [a] -> Bool
chunkEmpty = forall (t :: * -> *) a. Foldable t => t a -> Bool
null
instance (a ~ Char) => TextualChunked [a] where
buildChunk :: [a] -> Builder
buildChunk = [Char] -> Builder
TB.string
packChunk :: [a] -> Text
packChunk = [Char] -> Text
T.pack
unpackChunk :: Text -> [a]
unpackChunk = Text -> [Char]
T.unpack
instance Chunked (Seq a) a where
consChunk :: a -> Seq a -> Seq a
consChunk = forall a. a -> Seq a -> Seq a
(:<|)
unconsChunk :: Seq a -> Maybe (a, Seq a)
unconsChunk Seq a
s =
case Seq a
s of
Seq a
Empty -> forall a. Maybe a
Nothing
a
a :<| Seq a
b -> forall a. a -> Maybe a
Just (a
a, Seq a
b)
tokenToChunk :: a -> Seq a
tokenToChunk = forall a. a -> Seq a
Seq.singleton
tokensToChunk :: [a] -> Seq a
tokensToChunk = forall a. [a] -> Seq a
Seq.fromList
chunkToTokens :: Seq a -> [a]
chunkToTokens = forall (t :: * -> *) a. Foldable t => t a -> [a]
toList
chunkLength :: Seq a -> Int
chunkLength = forall a. Seq a -> Int
Seq.length
chunkEmpty :: Seq a -> Bool
chunkEmpty = forall a. Seq a -> Bool
Seq.null
revTokensToChunk :: [a] -> Seq a
revTokensToChunk = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (forall a b c. (a -> b -> c) -> b -> a -> c
flip forall a. Seq a -> a -> Seq a
(:|>)) forall a. Seq a
Empty
instance (a ~ Char) => TextualChunked (Seq a) where
buildChunk :: Seq a -> Builder
buildChunk = [Char] -> Builder
TB.string forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t a -> [a]
toList
packChunk :: Seq a -> Text
packChunk = [Char] -> Text
T.pack forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t a -> [a]
toList
unpackChunk :: Text -> Seq a
unpackChunk = forall a. [a] -> Seq a
Seq.fromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> [Char]
T.unpack
instance Chunked Text Char where
consChunk :: Char -> Text -> Text
consChunk = Char -> Text -> Text
T.cons
unconsChunk :: Text -> Maybe (Char, Text)
unconsChunk = Text -> Maybe (Char, Text)
T.uncons
tokenToChunk :: Char -> Text
tokenToChunk = Char -> Text
T.singleton
tokensToChunk :: [Char] -> Text
tokensToChunk = [Char] -> Text
T.pack
chunkToTokens :: Text -> [Char]
chunkToTokens = Text -> [Char]
T.unpack
chunkLength :: Text -> Int
chunkLength = Text -> Int
T.length
chunkEmpty :: Text -> Bool
chunkEmpty = Text -> Bool
T.null
instance TextualChunked Text where
buildChunk :: Text -> Builder
buildChunk = Text -> Builder
TB.text
packChunk :: Text -> Text
packChunk = forall a. a -> a
id
unpackChunk :: Text -> Text
unpackChunk = forall a. a -> a
id
instance Chunked TL.Text Char where
consChunk :: Char -> Text -> Text
consChunk = Char -> Text -> Text
TL.cons
unconsChunk :: Text -> Maybe (Char, Text)
unconsChunk = Text -> Maybe (Char, Text)
TL.uncons
tokenToChunk :: Char -> Text
tokenToChunk = Char -> Text
TL.singleton
tokensToChunk :: [Char] -> Text
tokensToChunk = [Char] -> Text
TL.pack
chunkToTokens :: Text -> [Char]
chunkToTokens = Text -> [Char]
TL.unpack
chunkLength :: Text -> Int
chunkLength = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Int64
TL.length
chunkEmpty :: Text -> Bool
chunkEmpty = Text -> Bool
TL.null
instance TextualChunked TL.Text where
buildChunk :: Text -> Builder
buildChunk = Text -> Builder
TB.text forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text
TL.toStrict
packChunk :: Text -> Text
packChunk = Text -> Text
TL.toStrict
unpackChunk :: Text -> Text
unpackChunk = Text -> Text
TL.fromStrict
instance Chunked ByteString Word8 where
consChunk :: Word8 -> ByteString -> ByteString
consChunk = Word8 -> ByteString -> ByteString
BS.cons
unconsChunk :: ByteString -> Maybe (Word8, ByteString)
unconsChunk = ByteString -> Maybe (Word8, ByteString)
BS.uncons
tokenToChunk :: Word8 -> ByteString
tokenToChunk = Word8 -> ByteString
BS.singleton
tokensToChunk :: [Word8] -> ByteString
tokensToChunk = [Word8] -> ByteString
BS.pack
chunkToTokens :: ByteString -> [Word8]
chunkToTokens = ByteString -> [Word8]
BS.unpack
chunkLength :: ByteString -> Int
chunkLength = ByteString -> Int
BS.length
chunkEmpty :: ByteString -> Bool
chunkEmpty = ByteString -> Bool
BS.null
instance Chunked BSL.ByteString Word8 where
consChunk :: Word8 -> ByteString -> ByteString
consChunk = Word8 -> ByteString -> ByteString
BSL.cons
unconsChunk :: ByteString -> Maybe (Word8, ByteString)
unconsChunk = ByteString -> Maybe (Word8, ByteString)
BSL.uncons
tokenToChunk :: Word8 -> ByteString
tokenToChunk = Word8 -> ByteString
BSL.singleton
tokensToChunk :: [Word8] -> ByteString
tokensToChunk = [Word8] -> ByteString
BSL.pack
chunkToTokens :: ByteString -> [Word8]
chunkToTokens = ByteString -> [Word8]
BSL.unpack
chunkLength :: ByteString -> Int
chunkLength = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Int64
BSL.length
chunkEmpty :: ByteString -> Bool
chunkEmpty = ByteString -> Bool
BSL.null