polyparseSource codeContentsIndex
Text.Parse
Contents
The Parse class is a replacement for the standard Read class.
Combinators specific to string input, lexed haskell-style
Parsers for literal numerics and characters
Re-export all the more general combinators from Poly too
Synopsis
type TextParser a = Parser Char a
class Parse a where
parse :: TextParser a
parsePrec :: Int -> TextParser a
parseList :: TextParser [a]
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
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
parseFloat :: RealFrac a => TextParser a
parseLitChar :: TextParser Char
module Text.ParserCombinators.Poly
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 String 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 Char aSource
A synonym for Parser Char, i.e. string input (no state)
class Parse a whereSource
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 aSource
A straightforward parser for an item. (A minimal definition of a class instance requires either |parse| or |parsePrec|.)
parsePrec :: Int -> TextParser aSource
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 "".
show/hide 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 aSource
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).
readByParse :: TextParser a -> ReadS aSource
If you have a TextParser for a type, you can easily make it into a Read instance, by throwing away any error messages.
readsPrecByParsePrec :: (Int -> TextParser a) -> Int -> ReadS aSource
If you have a TextParser for a type, you can easily make it into a Read instance, by throwing away any error messages.
Combinators specific to string input, lexed haskell-style
word :: TextParser StringSource
One lexical chunk. This is Haskell'98-style lexing - the result should match Prelude.lex apart from better error-reporting.
isWord :: String -> TextParser StringSource
Ensure that the next input word is the given string. (Note the input is lexed as haskell, so wordbreaks at spaces, symbols, etc.)
optionalParens :: TextParser a -> TextParser aSource
Allow true string parens around an item.
parens :: Bool -> TextParser a -> TextParser aSource
Allow nested parens around an item (one set required when Bool is True).
field :: Parse a => String -> TextParser aSource
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 aSource
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 aSource
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 aSource
parseInt :: Integral a => String -> a -> (Char -> Bool) -> (Char -> Int) -> TextParser aSource
parseDec :: Integral a => TextParser aSource
parseOct :: Integral a => TextParser aSource
parseHex :: Integral a => TextParser aSource
parseFloat :: RealFrac a => TextParser aSource
parseLitChar :: TextParser CharSource
Re-export all the more general combinators from Poly too
module Text.ParserCombinators.Poly
Produced by Haddock version 2.4.2