    {-# LANGUAGE CPP #-}
    #if __GLASGOW_HASKELL__ >= 702
    {-# LANGUAGE Trustworthy #-} -- Imports internal modules
    #endif

    -- |
    -- Module      :  Data.Attoparsec.ByteString.Lazy
    -- Copyright   :  Bryan O'Sullivan 2007-2015
    -- License     :  BSD3
    --
    -- Maintainer  :  bos@serpentine.com
    -- Stability   :  experimental
    -- Portability :  unknown
    --
    -- Simple, efficient combinator parsing that can consume lazy
    -- 'ByteString' strings, loosely based on the Parsec library.
    --
    -- This is essentially the same code as in the 'Data.Attoparsec'
    -- module, only with a 'parse' function that can consume a lazy
    -- 'ByteString' incrementally, and a 'Result' type that does not allow
    -- more input to be fed in.  Think of this as suitable for use with a
    -- lazily read file, e.g. via 'L.readFile' or 'L.hGetContents'.
    --
    -- /Note:/ The various parser functions and combinators such as
    -- 'string' still expect /strict/ 'B.ByteString' parameters, and
    -- return strict 'B.ByteString' results.  Behind the scenes, strict
    -- 'B.ByteString' values are still used internally to store parser
    -- input and manipulate it efficiently.

    module Data.Attoparsec.ByteString.Lazy
        (
          Result(..)
        , module Data.Attoparsec.ByteString
        -- * Running parsers
        , parse
        , parseOnly
        , parseTest
        -- ** Result conversion
        , maybeResult
        , eitherResult
        ) where

    import Control.DeepSeq (NFData(rnf))
    import Data.ByteString.Lazy.Internal (ByteString(..), chunk)
    import Data.List (intercalate)
    import qualified Data.ByteString as B
    import qualified Data.Attoparsec.ByteString as A
    import qualified Data.Attoparsec.Internal.Types as T
    import Data.Attoparsec.ByteString
        hiding (IResult(..), Result, eitherResult, maybeResult,
                parse, parseOnly, parseWith, parseTest)

    -- | The result of a parse.
    data Result r = Fail ByteString [String] String
                  -- ^ The parse failed.  The 'ByteString' is the input
                  -- that had not yet been consumed when the failure
                  -- occurred.  The @[@'String'@]@ is a list of contexts
                  -- in which the error occurred.  The 'String' is the
                  -- message describing the error, if any.
                  | Done ByteString r
                  -- ^ The parse succeeded.  The 'ByteString' is the
                  -- input that had not yet been consumed (if any) when
                  -- the parse succeeded.

    instance NFData r => NFData (Result r) where
        rnf :: Result r -> ()
    rnf (Fail ByteString
    bs [String]
    ctxs String
    msg) = ByteString -> ()
    rnfBS ByteString
    bs () -> () -> ()
    forall a b. a -> b -> b
    `seq` [String] -> ()
    forall a. NFData a => a -> ()
    rnf [String]
    ctxs () -> () -> ()
    forall a b. a -> b -> b
    `seq` String -> ()
    forall a. NFData a => a -> ()
    rnf String
    msg
        rnf (Done ByteString
    bs r
    r)        = ByteString -> ()
    rnfBS ByteString
    bs () -> () -> ()
    forall a b. a -> b -> b
    `seq` r -> ()
    forall a. NFData a => a -> ()
    rnf r
    r
        {-# INLINE rnf #-}

    rnfBS :: ByteString -> ()
    rnfBS :: ByteString -> ()
    rnfBS (Chunk StrictByteString
    _ ByteString
    xs) = ByteString -> ()
    rnfBS ByteString
    xs
    rnfBS ByteString
    Empty        = ()
    {-# INLINE rnfBS #-}

    instance Show r => Show (Result r) where
        show :: Result r -> String
    show (Fail ByteString
    bs [String]
    stk String
    msg) =
            String
    "Fail " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ ByteString -> String
    forall a. Show a => a -> String
    show ByteString
    bs String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    " " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ [String] -> String
    forall a. Show a => a -> String
    show [String]
    stk String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    " " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ ShowS
    forall a. Show a => a -> String
    show String
    msg
        show (Done ByteString
    bs r
    r)       = String
    "Done " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ ByteString -> String
    forall a. Show a => a -> String
    show ByteString
    bs String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    " " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ r -> String
    forall a. Show a => a -> String
    show r
    r

    fmapR :: (a -> b) -> Result a -> Result b
    fmapR :: forall a b. (a -> b) -> Result a -> Result b
    fmapR a -> b
    _ (Fail ByteString
    st [String]
    stk String
    msg) = ByteString -> [String] -> String -> Result b
    forall r. ByteString -> [String] -> String -> Result r
    Fail ByteString
    st [String]
    stk String
    msg
    fmapR a -> b
    f (Done ByteString
    bs a
    r)       = ByteString -> b -> Result b
    forall r. ByteString -> r -> Result r
    Done ByteString
    bs (a -> b
    f a
    r)

    instance Functor Result where
        fmap :: forall a b. (a -> b) -> Result a -> Result b
    fmap = (a -> b) -> Result a -> Result b
    forall a b. (a -> b) -> Result a -> Result b
    fmapR

    -- | Run a parser and return its result.
    parse :: A.Parser a -> ByteString -> Result a
    parse :: forall a. Parser a -> ByteString -> Result a
    parse Parser a
    p ByteString
    s = case ByteString
    s of
                  Chunk StrictByteString
    x ByteString
    xs -> IResult StrictByteString a -> ByteString -> Result a
    forall {r}. IResult StrictByteString r -> ByteString -> Result r
    go (Parser a -> StrictByteString -> IResult StrictByteString a
    forall a. Parser a -> StrictByteString -> Result a
    A.parse Parser a
    p StrictByteString
    x) ByteString
    xs
                  ByteString
    empty      -> IResult StrictByteString a -> ByteString -> Result a
    forall {r}. IResult StrictByteString r -> ByteString -> Result r
    go (Parser a -> StrictByteString -> IResult StrictByteString a
    forall a. Parser a -> StrictByteString -> Result a
    A.parse Parser a
    p StrictByteString
    B.empty) ByteString
    empty
      where
        go :: IResult StrictByteString r -> ByteString -> Result r
    go (T.Fail StrictByteString
    x [String]
    stk String
    msg) ByteString
    ys      = ByteString -> [String] -> String -> Result r
    forall r. ByteString -> [String] -> String -> Result r
    Fail (StrictByteString -> ByteString -> ByteString
    chunk StrictByteString
    x ByteString
    ys) [String]
    stk String
    msg
        go (T.Done StrictByteString
    x r
    r) ByteString
    ys            = ByteString -> r -> Result r
    forall r. ByteString -> r -> Result r
    Done (StrictByteString -> ByteString -> ByteString
    chunk StrictByteString
    x ByteString
    ys) r
    r
        go (T.Partial StrictByteString -> IResult StrictByteString r
    k) (Chunk StrictByteString
    y ByteString
    ys) = IResult StrictByteString r -> ByteString -> Result r
    go (StrictByteString -> IResult StrictByteString r
    k StrictByteString
    y) ByteString
    ys
        go (T.Partial StrictByteString -> IResult StrictByteString r
    k) ByteString
    empty        = IResult StrictByteString r -> ByteString -> Result r
    go (StrictByteString -> IResult StrictByteString r
    k StrictByteString
    B.empty) ByteString
    empty

    -- | Run a parser and print its result to standard output.
    parseTest :: (Show a) => A.Parser a -> ByteString -> IO ()
    parseTest :: forall a. Show a => Parser a -> ByteString -> IO ()
    parseTest Parser a
    p ByteString
    s = Result a -> IO ()
    forall a. Show a => a -> IO ()
    print (Parser a -> ByteString -> Result a
    forall a. Parser a -> ByteString -> Result a
    parse Parser a
    p ByteString
    s)

    -- | Convert a 'Result' value to a 'Maybe' value.
    maybeResult :: Result r -> Maybe r
    maybeResult :: forall r. Result r -> Maybe r
    maybeResult (Done ByteString
    _ r
    r) = r -> Maybe r
    forall a. a -> Maybe a
    Just r
    r
    maybeResult Result r
    _          = Maybe r
    forall a. Maybe a
    Nothing

    -- | Convert a 'Result' value to an 'Either' value.
    eitherResult :: Result r -> Either String r
    eitherResult :: forall r. Result r -> Either String r
    eitherResult (Done ByteString
    _ r
    r)        = r -> Either String r
    forall a b. b -> Either a b
    Right r
    r
    eitherResult (Fail ByteString
    _ [] String
    msg)   = String -> Either String r
    forall a b. a -> Either a b
    Left String
    msg
    eitherResult (Fail ByteString
    _ [String]
    ctxs String
    msg) = String -> Either String r
    forall a b. a -> Either a b
    Left (String -> [String] -> String
    forall a. [a] -> [[a]] -> [a]
    intercalate String
    " > " [String]
    ctxs String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    ": " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    msg)

    -- | Run a parser that cannot be resupplied via a 'T.Partial' result.
    --
    -- This function does not force a parser to consume all of its input.
    -- Instead, any residual input will be discarded.  To force a parser
    -- to consume all of its input, use something like this:
    --
    -- @
    --'parseOnly' (myParser 'Control.Applicative.<*' 'endOfInput')
    -- @
    parseOnly :: A.Parser a -> ByteString -> Either String a
    parseOnly :: forall a. Parser a -> ByteString -> Either String a
    parseOnly Parser a
    p = Result a -> Either String a
    forall r. Result r -> Either String r
    eitherResult (Result a -> Either String a)
    -> (ByteString -> Result a) -> ByteString -> Either String a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Parser a -> ByteString -> Result a
    forall a. Parser a -> ByteString -> Result a
    parse Parser a
    p
    {-# INLINE parseOnly #-}