Data.Attoparsec.Incremental.Char8

Simple, efficient, character-oriented, and incremental parser combinators for lazy L.ByteString strings, loosely based on the Parsec library.

Note: This module is intended for parsing text that is represented using an 8-bit character set, e.g. ASCII or ISO-8859-15. It does not deal with character encodings, multibyte characters, or wide characters. Any attempts to use characters above code point 255 will give wrong answers.

Parser types

data Parser r a

The parser type.

Instances

Monad (Parser r)

Functor (Parser r)

MonadPlus (Parser r)

Applicative (Parser r)

Alternative (Parser r)

data Result a

The result of a partial parse.

Constructors

Failed String

The parse failed, with the given error message.

Done ByteString a

The parse succeeded, producing the given result. The ByteString contains any unconsumed input.

Partial (ByteString -> Result a)

The parse ran out of data before finishing. To resume the parse, pass more data to the given continuation.

Instances

Show a => Show (Result a)

Running parsers

parse :: Parser r r -> ByteString -> Result r

Run a parser.

parseWith

Arguments

:: Applicative f

=> f ByteString

resupply parser with input

-> Parser r r

parser to run

-> ByteString

initial input

-> f (Result r)

Run a parser, using the given function to resupply it with input.

Here's an example that shows how to parse data from a socket, using Johan Tibbell's network-bytestring package.

  import qualified Data.ByteString.Lazy as L
  import Data.Attoparsec.Incremental (Parser, Result, parseWith)
  import Network.Socket.ByteString.Lazy (recv_)
  import Network.Socket (Socket)

  netParse :: Parser r r -> Socket -> IO (Result r)
  netParse p sock = parseWith (recv_ sock 65536) p L.empty

parseTest :: Show r => Parser r r -> ByteString -> IO ()

Try out a parser, and print its result.

Combinators

(<?>)

Arguments

:: Parser r a

-> String

the name to use if parsing fails

-> Parser r a

Name the parser, in case failure occurs.

try :: Parser r a -> Parser r a

This is a no-op combinator for compatibility.

Parsing individual characters

satisfy :: (Char -> Bool) -> Parser r Char

Character parser.

letter :: Parser r Char

digit :: Parser r Char

anyChar :: Parser r Char

space :: Parser r Char

char :: Char -> Parser r Char

Match a specific character.

notChar :: Char -> Parser r Char

Match any character except the given one.

Character classes

inClass :: String -> Char -> Bool

Match any character in a set.

 vowel = inClass "aeiou"

Range notation is supported.

 halfAlphabet = inClass "a-nA-N"

To add a literal '-' to a set, place it at the beginning or end of the string.

notInClass :: String -> Char -> Bool

Match any character not in a set.

Efficient string handling

string :: ByteString -> Parser r ByteString

Match a literal string exactly.

skipSpace :: Parser r ()

Skip over white space.

skipWhile :: (Char -> Bool) -> Parser r ()

Skip over characters while the predicate succeeds.

takeCount :: Int -> Parser r ByteString

Return exactly the given number of bytes. If not enough are available, fail.

takeTill :: (Char -> Bool) -> Parser r ByteString

Consume characters while the predicate fails.

takeWhile :: (Char -> Bool) -> Parser r ByteString

Consume characters while the predicate succeeds.

Text parsing

endOfLine :: Parser r ()

Match the end of a line. This may be any of a newline character, a carriage return character, or a carriage return followed by a newline.

Numeric parsers

int :: Parser r Int

Parse an Int.

integer :: Parser r Integer

Parse an Integer.

double :: Parser r Double

Parse a Double.

State observation and manipulation functions

endOfInput :: Parser r ()

Succeed if we have reached the end of the input string.

pushBack :: ByteString -> Parser r ()

Force the given string to appear next in the input stream.

yield :: Parser r ()

Resume our caller, handing back a Partial result. This function is probably not useful, but provided for completeness.

Combinators

module Data.Attoparsec.Combinator