Text.Parse.ByteString

polyparse-1.12: A variety of alternative parser combinator libraries.

Safe Haskell | Safe
Language | Haskell98

Text.Parse.ByteString

Contents

- The Parse class is a replacement for the standard Read class.
  - Combinators specific to bytestring input, lexed haskell-style
  - Parsers for literal numerics and characters
  - Re-export all the more general combinators from Poly too
  - ByteStrings and Strings as whole entities

Synopsis

- type TextParser a = Parser a
- class Parse a where
- parseByRead :: Read a => String -> TextParser a
- readByParse :: TextParser a -> ReadS a
- readsPrecByParsePrec :: (Int -> TextParser a) -> Int -> ReadS a
- word :: TextParser String
- isWord :: String -> TextParser String
- literal :: String -> TextParser String
- optionalParens :: TextParser a -> TextParser a
- parens :: Bool -> TextParser a -> TextParser a
- field :: Parse a => String -> TextParser a
- constructors :: [(String, TextParser a)] -> TextParser a
- enumeration :: Show a => String -> [a] -> TextParser a
- parseSigned :: Real a => TextParser a -> TextParser a
- parseInt :: Integral a => String -> a -> (Char -> Bool) -> (Char -> Int) -> TextParser a
- parseDec :: Integral a => TextParser a
- parseOct :: Integral a => TextParser a
- parseHex :: Integral a => TextParser a
- parseUnsignedInteger :: TextParser Integer
- parseFloat :: RealFrac a => TextParser a
- parseLitChar :: TextParser Char
- parseLitChar' :: TextParser Char
- module Text.ParserCombinators.Poly.ByteStringChar
- allAsByteString :: TextParser ByteString
- allAsString :: TextParser String

# The Parse class is a replacement for the standard Read class.

The Parse class is a replacement for the standard Read class. It is a specialisation of the (poly) Parser monad for ByteString input. There are instances defined for all Prelude types. For user-defined types, you can write your own instance, or use DrIFT to generate them automatically, e.g. {-! derive : Parse !-}

type TextParser a = Parser a #

A synonym for a ByteString Parser, i.e. bytestring input (no state)

class Parse a where #

The class `Parse` is a replacement for `Read`, operating over String input. Essentially, it permits better error messages for why something failed to parse. It is rather important that `parse` can read back exactly what is generated by the corresponding instance of `show`. To apply a parser to some text, use `runParser`.

Methods

parse :: TextParser a #

A straightforward parser for an item. (A minimal definition of a class instance requires either |parse| or |parsePrec|. In general, for a type that never needs parens, you should define |parse|, but for a type that _may_ need parens, you should define |parsePrec|.)

parsePrec :: Int -> TextParser a #

A straightforward parser for an item, given the precedence of any surrounding expression. (Precedence determines whether parentheses are mandatory or optional.)

parseList :: TextParser [a] #

Parsing a list of items by default accepts the [] and comma syntax, except when the list is really a character string using "".

Instances

Parse Bool # |
Methods parse :: TextParser Bool # parsePrec :: Int -> TextParser Bool # parseList :: TextParser [Bool] #
Parse Char # |
Methods parse :: TextParser Char # parsePrec :: Int -> TextParser Char # parseList :: TextParser [Char] #
Parse Double # |
Methods parse :: TextParser Double # parsePrec :: Int -> TextParser Double # parseList :: TextParser [Double] #
Parse Float # |
Methods parse :: TextParser Float # parsePrec :: Int -> TextParser Float # parseList :: TextParser [Float] #
Parse Int # |
Methods parse :: TextParser Int # parsePrec :: Int -> TextParser Int # parseList :: TextParser [Int] #
Parse Integer # |
Methods parse :: TextParser Integer # parsePrec :: Int -> TextParser Integer # parseList :: TextParser [Integer] #
Parse Ordering # |
Methods parse :: TextParser Ordering # parsePrec :: Int -> TextParser Ordering # parseList :: TextParser [Ordering] #
Parse () # |
Methods parse :: TextParser () # parsePrec :: Int -> TextParser () # parseList :: TextParser [()] #
Parse a => Parse [a] # |
Methods parse :: TextParser [a] # parsePrec :: Int -> TextParser [a] # parseList :: TextParser [[a]] #
Parse a => Parse (Maybe a) # |
Methods parse :: TextParser (Maybe a) # parsePrec :: Int -> TextParser (Maybe a) # parseList :: TextParser [Maybe a] #
(Parse a, Parse b) => Parse (Either a b) # |
Methods parse :: TextParser (Either a b) # parsePrec :: Int -> TextParser (Either a b) # parseList :: TextParser [Either a b] #
(Parse a, Parse b) => Parse (a, b) # |
Methods parse :: TextParser (a, b) # parsePrec :: Int -> TextParser (a, b) # parseList :: TextParser [(a, b)] #
(Parse a, Parse b, Parse c) => Parse (a, b, c) # |
Methods parse :: TextParser (a, b, c) # parsePrec :: Int -> TextParser (a, b, c) # parseList :: TextParser [(a, b, c)] #

parseByRead :: Read a => String -> TextParser a #

If there already exists a Read instance for a type, then we can make a Parser for it, but with only poor error-reporting. The string argument is the expected type or value (for error-reporting only). Use of this wrapper function is NOT recommended with ByteString, because there is a lot of inefficiency in repeated conversions to/from String.

readByParse :: TextParser a -> ReadS a #

If you have a TextParser for a type, you can easily make it into a Read instance, by throwing away any error messages. Use of this wrapper function is NOT recommended with ByteString, because there is a lot of inefficiency in conversions to/from String.

readsPrecByParsePrec :: (Int -> TextParser a) -> Int -> ReadS a #

If you have a TextParser for a type, you can easily make it into a Read instance, by throwing away any error messages. Use of this wrapper function is NOT recommended with ByteString, because there is a lot of inefficiency in conversions to/from String.

## Combinators specific to bytestring input, lexed haskell-style

word :: TextParser String #

One lexical chunk (Haskell-style lexing).

isWord :: String -> TextParser String #

Ensure that the next input word is the given string. (Note the input is lexed as haskell, so wordbreaks at spaces, symbols, etc.)

literal :: String -> TextParser String #

Ensure that the next input word is the given string. (No lexing, so mixed spaces, symbols, are accepted.)

optionalParens :: TextParser a -> TextParser a #

Allow optional nested string parens around an item.

parens :: Bool -> TextParser a -> TextParser a #

Allow nested parens around an item (one set required when Bool is True).

field :: Parse a => String -> TextParser a #

Deal with named field syntax. The string argument is the field name, and the parser returns the value of the field.

constructors :: [(String, TextParser a)] -> TextParser a #

Parse one of a bunch of alternative constructors. In the list argument, the first element of the pair is the constructor name, and the second is the parser for the rest of the value. The first matching parse is returned.

enumeration :: Show a => String -> [a] -> TextParser a #

Parse one of the given nullary constructors (an enumeration). The string argument is the name of the type, and the list argument should contain all of the possible enumeration values.

## Parsers for literal numerics and characters

parseSigned :: Real a => TextParser a -> TextParser a #

For any numeric parser, permit a negation sign in front of it.

parseInt :: Integral a => String -> a -> (Char -> Bool) -> (Char -> Int) -> TextParser a #

Parse any (unsigned) Integral numeric literal. Needs a base, radix, isDigit predicate, and digitToInt converter, appropriate to the result type.

parseDec :: Integral a => TextParser a #

Parse a decimal, octal, or hexadecimal (unsigned) Integral numeric literal.

parseOct :: Integral a => TextParser a #

Parse a decimal, octal, or hexadecimal (unsigned) Integral numeric literal.

parseHex :: Integral a => TextParser a #

Parse a decimal, octal, or hexadecimal (unsigned) Integral numeric literal.

parseUnsignedInteger :: TextParser Integer #

parseUnsignedInteger uses the underlying ByteString readInteger, so will be a lot faster than the generic character-by-character parseInt.

parseFloat :: RealFrac a => TextParser a #

Parse any (unsigned) Floating numeric literal, e.g. Float or Double.

parseLitChar :: TextParser Char #

Parse a Haskell character literal, excluding surrounding single quotes.

parseLitChar' :: TextParser Char #

Parse a Haskell character literal, including surrounding single quotes.

## Re-export all the more general combinators from Poly too

module Text.ParserCombinators.Poly.ByteStringChar

## ByteStrings and Strings as whole entities

allAsByteString :: TextParser ByteString #

Simply return the remaining input ByteString.

allAsString :: TextParser String #

Simply return the remaining input as a String.