where
import Control.Monad.State.Strict
-import Data.ByteString.Base (LazyByteString)
-import Data.ByteString.Lazy ()
-import qualified Data.ByteString.Lazy.Char8 as B
+import qualified Data.ByteString.Lazy as Lazy (ByteString)
+import qualified Data.ByteString.Lazy.Char8 as B hiding (ByteString)
-- |@'Parser' a@ is obviously a parser which parses and returns @a@.
newtype Parser a = Parser {
data ParserState
= PST {
- pstInput :: LazyByteString
+ pstInput :: Lazy.ByteString
, pstIsEOFFatal :: !Bool
}
deriving (Eq, Show)
-- |@'parse' p bstr@ parses @bstr@ with @p@ and returns @(# result,
-- remaining #)@.
-parse :: Parser a -> LazyByteString -> (# ParserResult a, LazyByteString #)
+parse :: Parser a -> Lazy.ByteString -> (# ParserResult a, Lazy.ByteString #)
parse p input -- input は lazy である必要有り。
= p `seq`
let (result, state') = runState (runParser p) (PST input True)
result `seq` (# result, pstInput state' #) -- pstInput state' も lazy である必要有り。
-- |@'parseStr' p str@ packs @str@ and parses it.
-parseStr :: Parser a -> String -> (# ParserResult a, LazyByteString #)
+parseStr :: Parser a -> String -> (# ParserResult a, Lazy.ByteString #)
parseStr p input
= p `seq` -- input は lazy である必要有り。
parse p (B.pack input)
Parser $! do saved <- get -- 状態を保存
result <- runParser p
case result of
- Success a -> do put saved -- 状態を復歸
+ Success _ -> do put saved -- 状態を復歸
return IllegalInput
IllegalInput -> do put saved -- 状態を復歸
return $! Success ()