Safe Haskell	Safe-Inferred
Language	Haskell98

Text.Parse.ByteString

Contents

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

Synopsis

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 Source

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

class Parse a where Source

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.

Minimal complete definition

Nothing

Methods

parse :: TextParser a Source

parsePrec :: Int -> TextParser a Source

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

parseList :: TextParser [a] Source

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
Parse Char
Parse Double
Parse Float
Parse Int
Parse Integer
Parse Ordering
Parse ()
Parse a => Parse [a]
Parse a => Parse (Maybe a)
(Parse a, Parse b) => Parse (Either a b)
(Parse a, Parse b) => Parse (a, b)
(Parse a, Parse b, Parse c) => Parse (a, b, c)

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

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 Source

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 Source

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 Source

One lexical chunk (Haskell-style lexing).

isWord :: String -> TextParser String Source

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 Source

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

optionalParens :: TextParser a -> TextParser a Source

Allow optional nested string parens around an item.

parens :: Bool -> TextParser a -> TextParser a Source

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

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

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 Source

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 Source

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.