par is:module -package:monad-par

See http://pubs.opengroup.org/onlinepubs/9699919799/utilities/awk.html for the full awk grammar.

This module includes everything you need to get started writing a parser. By default this module is set up to parse character data. If you'd like to parse the result of your own tokenizer you should start with the following imports:

import Text.Parsec.Prim
import Text.Parsec.Combinator

Then you can implement your own version of satisfy on top of the tokenPrim primitive.

Parsec compatibility module

ConstraintKind synonym for marking partial functions

drastically, or be entirely removed, in a future release.

This module provides the generated Happy parser for Haskell. It exports a number of parsers which may be used in any library that uses the GHC API. A common usage pattern is to initialize the parser state with a given string and then parse that string:

runParser :: ParserOpts -> String -> P a -> ParseResult a
runParser opts str parser = unP parser parseState
where
filename = "<interactive>"
location = mkRealSrcLoc (mkFastString filename) 1 1
buffer = stringToStringBuffer str
parseState = initParserState opts buffer location

Parsers for unit/module identifiers

A very simple bytearray parser related to Parsec and Attoparsec Simple example:

> parse ((,,) <$> take 2 <*> byte 0x20 <*> (bytes "abc" *> anyByte)) "xx abctest"
ParseOK "est" ("xx", 116)

Parallel Constructs

Some helpers for parsing data out of a raw WAI Request.

Annotated parser for Haskell with extensions.

This module provides both a native Haskell solution for parsing XML documents into a stream of events, and a set of parser combinators for dealing with a stream of events. As a simple example:

>>> :set -XOverloadedStrings

>>> import Conduit (runConduit, (.|))

>>> import Data.Text (Text, unpack)

>>> import Data.XML.Types (Event)

>>> data Person = Person Int Text Text deriving Show

>>> :{
let parsePerson :: MonadThrow m => ConduitT Event o m (Maybe Person)
parsePerson = tag' "person" parseAttributes $ \(age, goodAtHaskell) -> do
name <- content
return $ Person (read $ unpack age) name goodAtHaskell
where parseAttributes = (,) <$> requireAttr "age" <*> requireAttr "goodAtHaskell" <* ignoreAttrs
parsePeople :: MonadThrow m => ConduitT Event o m (Maybe [Person])
parsePeople = tagNoAttr "people" $ many parsePerson
inputXml = mconcat
[ "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
, "<people>"
, "  <person age=\"25\" goodAtHaskell=\"yes\">Michael</person>"
, "  <person age=\"2\" goodAtHaskell=\"might become\">Eliezer</person>"
, "</people>"
]
:}

>>> runConduit $ parseLBS def inputXml .| force "people required" parsePeople
[Person 25 "Michael" "yes",Person 2 "Eliezer" "might become"]

This module also supports streaming results using yield. This allows parser results to be processed using conduits while a particular parser (e.g. many) is still running. Without using streaming results, you have to wait until the parser finished before you can process the result list. Large XML files might be easier to process by using streaming results. See http://stackoverflow.com/q/21367423/2597135 for a related discussion.

>>> import Data.Conduit.List as CL

>>> :{
let parsePeople' :: MonadThrow m => ConduitT Event Person m (Maybe ())
parsePeople' = tagNoAttr "people" $ manyYield parsePerson
:}

>>> runConduit $ parseLBS def inputXml .| force "people required" parsePeople' .| CL.mapM_ print
Person 25 "Michael" "yes"
Person 2 "Eliezer" "might become"

Previous versions of this module contained a number of more sophisticated functions written by Aristid Breitkreuz and Dmitry Olshansky. To keep this package simpler, those functions are being moved to a separate package. This note will be updated with the name of the package(s) when available.

A CSV parser. The parser defined here is RFC 4180 compliant, with the following extensions:

• Empty lines are ignored.
• Non-escaped fields may contain any characters except double-quotes, commas, carriage returns, and newlines.
• Escaped fields may contain any characters (but double-quotes need to be escaped).

The functions in this module can be used to implement e.g. a resumable parser that is fed input incrementally.

This module corresponds to section 3.8.4 (Texture Parameters), section 3.8.7 (Texture Wrap Mode), section 3.8.8 (Texture Minification), and section 3.8.9 (Texture Magnification) of the OpenGL 2.1 specs.

A utility library with parsers used in pandoc readers.

interface to the HXT XML and DTD parsers

This module provides a simple parser for parsing input event control sequences.