module Data.Attoparsec.Text.Run
  (
    parseStream, parseAndRestore, parseOnlyStrict, parseOnlyLazy,
    module Data.Attoparsec.Run,
  )
  where

import Data.Attoparsec.Run

import Control.Monad (unless)
import Control.Monad.State (evalState)
import Data.Attoparsec.Text (parseWith, Parser)
import Data.Text (Text, null)
import qualified Data.Text.Lazy as Lazy
import Prelude (($), (<$>), pure, mempty, Monad, Either)

parseOnlyStrict :: Text -> Parser a -> Either ParseError a
parseOnlyStrict :: forall a. Text -> Parser a -> Either ParseError a
parseOnlyStrict Text
x Parser a
p = forall s a. State s a -> s -> a
evalState (forall (m :: * -> *) a.
Monad m =>
RestorableInput m Text -> Parser a -> m (Either ParseError a)
parseAndRestore forall i (m :: * -> *).
(Monoid i, MonadState [i] m) =>
RestorableInput m i
inputState Parser a
p) [Text
x]

parseOnlyLazy :: Lazy.Text -> Parser a -> Either ParseError a
parseOnlyLazy :: forall a. Text -> Parser a -> Either ParseError a
parseOnlyLazy Text
x Parser a
p = forall s a. State s a -> s -> a
evalState (forall (m :: * -> *) a.
Monad m =>
RestorableInput m Text -> Parser a -> m (Either ParseError a)
parseAndRestore forall i (m :: * -> *).
(Monoid i, MonadState [i] m) =>
RestorableInput m i
inputState Parser a
p) (Text -> [Text]
Lazy.toChunks Text
x)

parseStream :: Monad m =>
    BufferedInput m Text -> Parser a -> m (FinalResult Text a)
parseStream :: forall (m :: * -> *) a.
Monad m =>
BufferedInput m Text -> Parser a -> m (FinalResult Text a)
parseStream (BufferedInput Text
initial m Text
get) Parser a
p =
    forall i a. IResult i a -> FinalResult i a
finalizeResult forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
Monad m =>
m Text -> Parser a -> Text -> m (Result a)
parseWith m Text
get Parser a
p Text
initial

parseAndRestore :: Monad m =>
    RestorableInput m Text -> Parser a -> m (Either ParseError a)
parseAndRestore :: forall (m :: * -> *) a.
Monad m =>
RestorableInput m Text -> Parser a -> m (Either ParseError a)
parseAndRestore (RestorableInput m Text
get Text -> m ()
restore) Parser a
p = do
    FinalResult Text
remainder Either ParseError a
value <- forall (m :: * -> *) a.
Monad m =>
BufferedInput m Text -> Parser a -> m (FinalResult Text a)
parseStream (forall (m :: * -> *) i. i -> m i -> BufferedInput m i
BufferedInput forall a. Monoid a => a
mempty m Text
get) Parser a
p
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (Text -> Bool
null Text
remainder) forall a b. (a -> b) -> a -> b
$ Text -> m ()
restore Text
remainder
    forall (f :: * -> *) a. Applicative f => a -> f a
pure Either ParseError a
value