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

import Data.Attoparsec.Run

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

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