-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | A highly generic parser combinators library.
--   
--   Please see the README on GitHub at
--   <a>https://github.com/nasso/comparse#readme</a>
@package comparse
@version 0.2.0.0

module Data.Stream
class Ord (Pos s) => Stream s where {
    type family Item s :: Type;
    type family Pos s :: Type;
}
next :: Stream s => s -> Maybe (Item s, s)
getPos :: Stream s => s -> Pos s

module Control.Monad.Parser.Class

-- | A monad with parsing capabilities.
class (Monad m, Stream (Input m)) => MonadParser m where {
    type family Input m :: Type;
}

-- | The current input stream.
parseStream :: MonadParser m => m (Input m)

-- | Replace the input stream.
setParseStream :: MonadParser m => Input m -> m ()

-- | A parser that always fails.
noParse :: MonadParser m => m a

-- | A parser that returns the next item.
item :: MonadParser m => m (Item (Input m))

-- | <tt>followedBy p</tt> is a parser that succeeds if <tt>p</tt>
--   succeeds, but it does not consume any input.
followedBy :: MonadParser m => m a -> m ()

-- | <tt>notFollowedBy p</tt> is a parser that only succeeds if <tt>p</tt>
--   fails. This parser will not consume any input.
notFollowedBy :: MonadParser m => m a -> m ()

-- | <tt>try p</tt> is a parser that does everything like <tt>p</tt>,
--   except it forcefully resets the position of any error reported by
--   <tt>p</tt> to the current position.
try :: MonadParser m => m a -> m a

-- | <tt>p <a>|</a> q</tt> is a parser that is equivalent to <tt>p</tt>
--   when <tt>p</tt> succeeds and <tt>q</tt> when <tt>p</tt> fails to parse
--   anything.
(<|>) :: MonadParser m => m a -> m a -> m a

-- | <tt>p <a>?</a> msg</tt> is a parser that behaves like <tt>p</tt>, but
--   when <tt>p</tt> fails, it reports an error indicating that
--   <tt>msg</tt> was the expected input.
(<?>) :: MonadParser m => m a -> String -> m a
infixl 1 <?>
infixl 3 <|>

-- | Parser that succeeds if the stream is empty. Does not consume any
--   items.
eof :: MonadParser m => m ()

-- | Fail with an "expected" message.
expected :: MonadParser m => String -> m a

-- | Succeeds only if the value parsed by the parser satisfies the
--   predicate.
satisfy :: MonadParser m => m a -> (a -> Bool) -> m a

-- | Parse a single item satisfying the given predicate.
match :: MonadParser m => (Item (Input m) -> Bool) -> m (Item (Input m))

-- | Make a parser optional.
optional :: MonadParser m => m a -> m (Maybe a)

-- | Try a series of parsers in order, returning the first one that
--   succeeds.
choice :: MonadParser m => [m a] -> m a

-- | Try to run the given parser as many times as possible.
many :: MonadParser m => m a -> m [a]

-- | Try to run the given parser as many times as possible, but at least
--   once. The result is returned as a regular list, but is guaranteed to
--   be non-empty.
many1 :: MonadParser m => m a -> m [a]

-- | Try to run the given parser as many times as possible, but at least
--   once.
some :: MonadParser m => m a -> m (NonEmpty a)

-- | Parse a non-empty series of <tt>a</tt> separated by <tt>b</tt>s
--   (without a trailing <tt>b</tt>).
sepBy1 :: MonadParser m => m a -> m b -> m (NonEmpty a)

-- | Parse a potentially empty series of <tt>a</tt> separated by
--   <tt>b</tt>s (without a trailing <tt>b</tt>).
sepBy :: MonadParser m => m a -> m b -> m [a]

-- | Parse any value equal to <tt>a</tt>.
like :: (MonadParser m, Eq (Item (Input m)), Show (Item (Input m))) => Item (Input m) -> m (Item (Input m))

-- | Parse any value not equal to <tt>a</tt>.
unlike :: (MonadParser m, Eq (Item (Input m)), Show (Item (Input m))) => Item (Input m) -> m (Item (Input m))

-- | Parse a continuous sequence of items equal to the given one.
string :: (MonadParser m, Eq (Item (Input m)), Show (Item (Input m))) => [Item (Input m)] -> m [Item (Input m)]

-- | Parse any value equal to at least one element of the given list.
oneOf :: (MonadParser m, Eq (Item (Input m)), Show (Item (Input m))) => [Item (Input m)] -> m (Item (Input m))

-- | Parse any value not equivalent to any element of the given list. For a
--   version that accepts non-Show items, see <tt>noneOf'</tt>.
noneOf :: (MonadParser m, Eq (Item (Input m)), Show (Item (Input m))) => [Item (Input m)] -> m (Item (Input m))

-- | <tt>chainl1 p op</tt> Parse a chain of *one* or more occurrences of
--   <tt>p</tt>, separated by <tt>op</tt>. Return a value obtained by a
--   left associative application of all functions returned by <tt>op</tt>
--   to the values returned by <tt>p</tt>.
--   
--   This is particularly useful for parsing left associative infix
--   operators.
chainl1 :: MonadParser m => m a -> m (a -> a -> a) -> m a

-- | <tt>chainr1 p op</tt> Parse a chain of *one* or more occurrences of
--   <tt>p</tt>, separated by <tt>op</tt>. Return a value obtained by a
--   right associative application of all functions returned by <tt>op</tt>
--   to the values returned by <tt>p</tt>.
--   
--   This is particularly useful for parsing right associative infix
--   operators.
chainr1 :: MonadParser m => m a -> m (a -> a -> a) -> m a

-- | Run a parser on a different stream of items.
withInput :: MonadParser m => Input m -> m a -> m (a, Input m)

module Control.Monad.Trans.Parser

-- | Parser monad transformer.
newtype ParserT s m a
ParserT :: (s -> m (ParseResult a s)) -> ParserT s m a
[runParserT] :: ParserT s m a -> s -> m (ParseResult a s)
data ParseResult v s
Parsed :: v -> s -> ParseError (Pos s) -> ParseResult v s
NoParse :: ParseError (Pos s) -> ParseResult v s
data ParseError p
ParseError :: p -> [ErrorDesc] -> ParseError p
data ErrorDesc
Expected :: String -> ErrorDesc
Note :: String -> ErrorDesc
instance GHC.Classes.Eq Control.Monad.Trans.Parser.ErrorDesc
instance GHC.Base.Functor m => GHC.Base.Functor (Control.Monad.Trans.Parser.ParserT s m)
instance (Data.Stream.Stream s, GHC.Base.Applicative m, GHC.Base.Monad m) => GHC.Base.Applicative (Control.Monad.Trans.Parser.ParserT s m)
instance (Data.Stream.Stream s, GHC.Base.Monad m) => GHC.Base.Monad (Control.Monad.Trans.Parser.ParserT s m)
instance (GHC.Base.Applicative m, GHC.Base.Monad m, Data.Stream.Stream s) => Control.Monad.Fail.MonadFail (Control.Monad.Trans.Parser.ParserT s m)
instance (GHC.Base.Monad m, Data.Stream.Stream s) => Control.Monad.Parser.Class.MonadParser (Control.Monad.Trans.Parser.ParserT s m)
instance Data.Stream.Stream s => Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.Parser.ParserT s)
instance (Data.Stream.Stream s, Control.Monad.IO.Class.MonadIO m) => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.Parser.ParserT s m)
instance (Data.Stream.Stream s, Control.Monad.State.Class.MonadState s' m) => Control.Monad.State.Class.MonadState s' (Control.Monad.Trans.Parser.ParserT s m)
instance (Data.Stream.Stream s, Control.Monad.Error.Class.MonadError e m) => Control.Monad.Error.Class.MonadError e (Control.Monad.Trans.Parser.ParserT s m)
instance (Data.Stream.Stream s, Control.Monad.Reader.Class.MonadReader r m) => Control.Monad.Reader.Class.MonadReader r (Control.Monad.Trans.Parser.ParserT s m)
instance (Data.Stream.Stream s, Control.Monad.Cont.Class.MonadCont m) => Control.Monad.Cont.Class.MonadCont (Control.Monad.Trans.Parser.ParserT s m)
instance (GHC.Show.Show v, GHC.Show.Show (Data.Stream.Pos s)) => GHC.Show.Show (Control.Monad.Trans.Parser.ParseResult v s)
instance GHC.Show.Show p => GHC.Show.Show (Control.Monad.Trans.Parser.ParseError p)

module Data.Stream.StringLines
data StringPos
StringPos :: Int -> Int -> String -> StringPos
data StringLines
StringLines :: String -> StringPos -> StringLines
fromString :: String -> StringLines
instance GHC.Show.Show Data.Stream.StringLines.StringLines
instance GHC.Classes.Eq Data.Stream.StringLines.StringLines
instance Data.Stream.Stream Data.Stream.StringLines.StringLines
instance GHC.Show.Show Data.Stream.StringLines.StringPos
instance GHC.Classes.Eq Data.Stream.StringLines.StringPos
instance GHC.Classes.Ord Data.Stream.StringLines.StringPos

module Data.Stream.TextLines
data TextPos
TextPos :: Int -> Int -> Vector Text -> TextPos
data TextLines
TextLines :: Text -> TextPos -> TextLines
fromText :: Text -> TextLines
instance GHC.Show.Show Data.Stream.TextLines.TextLines
instance GHC.Classes.Eq Data.Stream.TextLines.TextLines
instance Data.Stream.Stream Data.Stream.TextLines.TextLines
instance GHC.Show.Show Data.Stream.TextLines.TextPos
instance GHC.Classes.Eq Data.Stream.TextLines.TextPos
instance GHC.Classes.Ord Data.Stream.TextLines.TextPos

module Control.Monad.Parser

-- | Parser monad transformer.
newtype ParserT s m a
ParserT :: (s -> m (ParseResult a s)) -> ParserT s m a
[runParserT] :: ParserT s m a -> s -> m (ParseResult a s)
data ParseResult v s
Parsed :: v -> s -> ParseError (Pos s) -> ParseResult v s
NoParse :: ParseError (Pos s) -> ParseResult v s
data ParseError p
ParseError :: p -> [ErrorDesc] -> ParseError p
data ErrorDesc
Expected :: String -> ErrorDesc
Note :: String -> ErrorDesc
type Parser s a = ParserT s Identity a
type StringParser a = Parser StringLines a
type ParserOf i p = (MonadParser p, Item (Input p) ~ i)
type CharParser p = ParserOf Char p
runParser :: Parser s a -> s -> ParseResult a s
runStringParser :: StringParser a -> String -> ParseResult a StringLines
runTextParser :: TextParser a -> Text -> ParseResult a TextLines