polyparse change log
++ +
Changes in polyparse-1.4.1
++
-
+
- Bugfix for 'discard', so that in the lazy variation it actually checks + that the item to be discarded satisfies the given parser. +
- Bugfixes in Text.Parse, such that 'optionalParens' is used more
+ consistently.
+
+
Changes in polyparse-1.4
++
-
+
- New API: the primitive parser 'eof' is now available in all variations of + the Poly combinators. +
- New implementation of Text.Parse.word - it no longer uses the + Haskell'98 Prelude.lex, but provides its own proper lexer, with better + error messages. +
- New module: Text.ParserCombinators.Poly.ByteString is an instance of + the PolyParse class specialised to ByteString input, rather than being + polymorphic over the input token type. +
- New module: Text.Parse.ByteString, is like Text.Parse but with + ByteString input rather than String. +
- New API calls: Text.Parse.readByParse and readsPrecByParsePrec, + to make it easy to create instances of the old Read class (for + backwards compatibility) from your TextParser. +
- Bugfix: in Text.Parse, parseInt, parseDec, parseOct, and parseHex had an + extra spurious argument that was unused, so it has been removed (API + change). In addition parseLitChar relied on the non-existent use of + that argument, so it has been fixed too. +
- Bugfix: Text.Parse.parseFloat now accepts a plain integer as a float, + to match the H'98 behaviour of readFloat. +
- Bugfix: the `discard` combinator now forces the discarded item; + previously incorrect parses could hide inside, without triggering an error. +
Changes in polyparse-1.3
++
-
+
- Bugfix: Text.Parse.parseFloat now accepts ordinary floating point + notation, in addition to scientific (exponent) notation. +
Changes in polyparse-1.2
++
-
+
- Improves the Text.Parse implementation significantly. Where + previously all the parsers for builtin basic datatype (Int,Float,Char) + were just thin wrappers over the H'98 Read instances, now they are all + proper parsers, therefore they should (a) be faster; (b) give better + error messages. +
- Reduced the number of implementation variations to choose from. + In particular, NoLeak has become the default implementation, and + the previous default has been dropped (because it space-leaks). + +
Changes in polyparse-1.1
++
-
+
- Much improved the laziness of the PolyLazy combinators. +
- Addition of a class-based interface to the Poly libraries, to + reduce code duplication amongst the variations, and to allow for + more experimentation with different implementations. +
- Several new experimental implementations of the interface. +
Changes in polyparse-1.0
++
-
+
- Version number change from 1.00 to 1.0, for silly cabal/hackage. +
- Minor fix to parsing strings in Text.Parse. +
Changes in polyparse-1.00
++
-
+
- No changes, but released separately from HaXml +
Changes in HaXml-1.16
++
-
+
- New: lazier parsers
+
-
+
- Text.XML.HaXml.ParseLazy +
- Text.XML.HaXml.Html.ParseLazy +
- Text.ParserCombinators.PolyLazy +
- Text.ParserCombinators.PolyStateLazy +
Changes in HaXml-1.15
++
-
+
- New: DrIFT has now been fully updated to + produce instances of Text.ParserCombinators.TextParser.Parse. +
- New: the parser combinator library Poly has been split into two + variations, Poly and PolyState. They have almost the same API, + only the latter includes a running state where the former does not. +
- The TextParser library (a replacement for the Haskell'98 Read class) + has also been improved with more new combinators. Really, these + parser combinator experiments do not belong in HaXml, and will + eventually be split out into a separate package. +
Text.Parse.ByteString
diff --git a/docs/haddock/Text-Parse.html b/docs/haddock/Text-Parse.html new file mode 100644 --- /dev/null +++ b/docs/haddock/Text-Parse.html @@ -0,0 +1,1311 @@ + + +
polyparse Source code Contents Index Text.Parse.ByteString Contents 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. + Methods parse :: TextParser a Source A straightforward parser for an item. (A minimal definition of + a class instance requires either |parse| or |parsePrec|.) + 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 "". + 
InstancesparseByRead :: 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 string 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.) + 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. + Parsers for literal numerics and characters + parseSigned :: Real a => TextParser a -> TextParser a Source parseInt :: Integral a => String -> a -> (Char -> Bool) -> (Char -> Int) -> TextParser a Source parseDec :: Integral a => TextParser a Source parseOct :: Integral a => TextParser a Source parseHex :: Integral a => TextParser a Source parseUnsignedInteger :: TextParser Integer Source parseUnsignedInteger uses the underlying ByteString readInteger, so + will be a lot faster than the generic character-by-character parseInt. + parseFloat :: RealFrac a => TextParser a Source parseLitChar :: TextParser Char Source Re-export all the more general combinators from Poly too + module Text.ParserCombinators.Poly.ByteString ByteStrings and Strings as whole entities + allAsByteString :: TextParser ByteString Source Simply return the remaining input ByteString. + allAsString :: TextParser String Source Simply return the remaining input as a String. + Produced by Haddock version 2.4.2 Text.Parse
diff --git a/docs/haddock/Text-ParserCombinators-HuttonMeijer.html b/docs/haddock/Text-ParserCombinators-HuttonMeijer.html new file mode 100644 --- /dev/null +++ b/docs/haddock/Text-ParserCombinators-HuttonMeijer.html @@ -0,0 +1,1636 @@ + + +polyparse Source code Contents Index Text.Parse Contents 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 a Source A synonym for Parser Char, i.e. string 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. + Methods parse :: TextParser a Source A straightforward parser for an item. (A minimal definition of + a class instance requires either |parse| or |parsePrec|.) + 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 "". + InstancesparseByRead :: 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). + 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. + 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. + Combinators specific to string input, lexed haskell-style + word :: TextParser String Source One lexical chunk. This is Haskell'98-style lexing - the result + should match Prelude.lex apart from better error-reporting. + 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.) + optionalParens :: TextParser a -> TextParser a Source Allow nested 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. + Parsers for literal numerics and characters + parseSigned :: Real a => TextParser a -> TextParser a Source parseInt :: Integral a => String -> a -> (Char -> Bool) -> (Char -> Int) -> TextParser a Source parseDec :: Integral a => TextParser a Source parseOct :: Integral a => TextParser a Source parseHex :: Integral a => TextParser a Source parseFloat :: RealFrac a => TextParser a Source parseLitChar :: TextParser Char Source Re-export all the more general combinators from Poly too + module Text.ParserCombinators.Poly Produced by Haddock version 2.4.2 Text.ParserCombinators.HuttonMeijer
diff --git a/docs/haddock/Text-ParserCombinators-HuttonMeijerWallace.html b/docs/haddock/Text-ParserCombinators-HuttonMeijerWallace.html new file mode 100644 --- /dev/null +++ b/docs/haddock/Text-ParserCombinators-HuttonMeijerWallace.html @@ -0,0 +1,1418 @@ + + +polyparse Source code Contents Index Text.ParserCombinators.HuttonMeijer Portability All + + A LIBRARY OF MONADIC PARSER COMBINATORS + + 29th July 1996 + + Graham Hutton Erik Meijer + University of Nottingham University of Utrecht Stability Stable Maintainer Malcolm Wallace <Malcolm.Wallace@cs.york.ac.uk> Description This Haskell script defines a library of parser combinators, and is + taken from sections 1-6 of our article Monadic Parser Combinators. + Some changes to the library have been made in the move from Gofer + to Haskell: +
- Do notation is used in place of monad comprehension notation; +
- The parser datatype is defined using newtype, to avoid the overhead + of tagging and untagging parsers with the P constructor. +
Synopsis newtype Parser a = P ([Token] -> [(a, [Token])]) item :: Parser Token first :: Parser a -> Parser a papply :: Parser a -> [Token] -> [(a, [Token])] (+++) :: Parser a -> Parser a -> Parser a sat :: (Token -> Bool) -> Parser Token many :: Parser a -> Parser [a] many1 :: Parser a -> Parser [a] sepby :: Parser a -> Parser b -> Parser [a] sepby1 :: Parser a -> Parser b -> Parser [a] chainl :: Parser a -> Parser (a -> a -> a) -> a -> Parser a chainl1 :: Parser a -> Parser (a -> a -> a) -> Parser a chainr :: Parser a -> Parser (a -> a -> a) -> a -> Parser a chainr1 :: Parser a -> Parser (a -> a -> a) -> Parser a ops :: [(Parser a, b)] -> Parser b bracket :: Parser a -> Parser b -> Parser c -> Parser b char :: Char -> Parser Char digit :: Parser Char lower :: Parser Char upper :: Parser Char letter :: Parser Char alphanum :: Parser Char string :: String -> Parser String ident :: Parser String nat :: Parser Int int :: Parser Int spaces :: Parser () comment :: Parser () junk :: Parser () skip :: Parser a -> Parser a token :: Parser a -> Parser a natural :: Parser Int integer :: Parser Int symbol :: String -> Parser String identifier :: [String] -> Parser String Documentation newtype Parser a Source The parser monad + Constructors P ([Token] -> [(a, [Token])]) Instancesitem :: Parser Token Source first :: Parser a -> Parser a Source papply :: Parser a -> [Token] -> [(a, [Token])] Source (+++) :: Parser a -> Parser a -> Parser a Source sat :: (Token -> Bool) -> Parser Token Source many :: Parser a -> Parser [a] Source many1 :: Parser a -> Parser [a] Source sepby :: Parser a -> Parser b -> Parser [a] Source sepby1 :: Parser a -> Parser b -> Parser [a] Source chainl :: Parser a -> Parser (a -> a -> a) -> a -> Parser a Source chainl1 :: Parser a -> Parser (a -> a -> a) -> Parser a Source chainr :: Parser a -> Parser (a -> a -> a) -> a -> Parser a Source chainr1 :: Parser a -> Parser (a -> a -> a) -> Parser a Source ops :: [(Parser a, b)] -> Parser b Source bracket :: Parser a -> Parser b -> Parser c -> Parser b Source char :: Char -> Parser Char Source digit :: Parser Char Source lower :: Parser Char Source upper :: Parser Char Source letter :: Parser Char Source alphanum :: Parser Char Source string :: String -> Parser String Source ident :: Parser String Source nat :: Parser Int Source int :: Parser Int Source spaces :: Parser () Source comment :: Parser () Source junk :: Parser () Source skip :: Parser a -> Parser a Source token :: Parser a -> Parser a Source natural :: Parser Int Source integer :: Parser Int Source symbol :: String -> Parser String Source identifier :: [String] -> Parser String Source Produced by Haddock version 2.4.2 Text.ParserCombinators.HuttonMeijerWallace
diff --git a/docs/haddock/Text-ParserCombinators-Poly-Base.html b/docs/haddock/Text-ParserCombinators-Poly-Base.html new file mode 100644 --- /dev/null +++ b/docs/haddock/Text-ParserCombinators-Poly-Base.html @@ -0,0 +1,1196 @@ + + +polyparse Source code Contents Index Text.ParserCombinators.HuttonMeijerWallace Contents Description This library of monadic parser combinators is based on the ones + defined by Graham Hutton and Erik Meijer. It has been extended by + Malcolm Wallace to use an abstract token type (no longer just a + string) as input, and to incorporate state in the monad, useful + for symbol tables, macros, and so on. Basic facilities for error + reporting have also been added, and later extended by Graham Klyne + to return the errors through an Either type, rather than just + calling error. + Synopsis newtype Parser s t e a = P (s -> [Either e t] -> ParseResult s t e a) item :: Parser s t e t eof :: Show p => Parser s (p, t) String () papply :: Parser s t String a -> s -> [Either String t] -> [(a, s, [Either String t])] papply' :: Parser s t e a -> s -> [Either e t] -> Either e [(a, s, [Either e t])] (+++) :: Parser s t e a -> Parser s t e a -> Parser s t e a tok :: Eq t => t -> Parser s (p, t) e t nottok :: Eq t => [t] -> Parser s (p, t) e t many :: Parser s t e a -> Parser s t e [a] many1 :: Parser s t e a -> Parser s t e [a] sepby :: Parser s t e a -> Parser s t e b -> Parser s t e [a] sepby1 :: Parser s t e a -> Parser s t e b -> Parser s t e [a] chainl :: Parser s t e a -> Parser s t e (a -> a -> a) -> a -> Parser s t e a chainl1 :: Parser s t e a -> Parser s t e (a -> a -> a) -> Parser s t e a chainr :: Parser s t e a -> Parser s t e (a -> a -> a) -> a -> Parser s t e a chainr1 :: Parser s t e a -> Parser s t e (a -> a -> a) -> Parser s t e a ops :: [(Parser s t e a, b)] -> Parser s t e b bracket :: (Show p, Show t) => Parser s (p, t) e a -> Parser s (p, t) e b -> Parser s (p, t) e c -> Parser s (p, t) e b toEOF :: Show p => Parser s (p, t) String a -> Parser s (p, t) String a elserror :: (Show p, Show t) => Parser s (p, t) String a -> String -> Parser s (p, t) String a stupd :: (s -> s) -> Parser s t e () stquery :: (s -> a) -> Parser s t e a stget :: Parser s t e s reparse :: [Either e t] -> Parser s t e () The parser monad + newtype Parser s t e a Source Constructors P (s -> [Either e t] -> ParseResult s t e a) The parser type is parametrised on the types of the state s, + the input tokens t, error-type e, and the result value a. + The state and remaining input are threaded through the monad. + InstancesPrimitive parser combinators + item :: Parser s t e t Source Deliver the first remaining token. + eof :: Show p => Parser s (p, t) String () Source Fail if end of input is not reached + papply :: Parser s t String a -> s -> [Either String t] -> [(a, s, [Either String t])] Source Apply the parser to some real input, given an initial state value. + If the parser fails, raise error to halt the program. + (This is the original exported behaviour - to allow the caller to + deal with the error differently, see papply'.) + papply' :: Parser s t e a -> s -> [Either e t] -> Either e [(a, s, [Either e t])] Source Apply the parser to some real input, given an initial state value. + If the parser fails, return a diagnostic message to the caller. + Derived combinators + (+++) :: Parser s t e a -> Parser s t e a -> Parser s t e a Source A choice between parsers. Keep only the first success. + tok :: Eq t => t -> Parser s (p, t) e t Source Deliver the first token if it equals the argument. + nottok :: Eq t => [t] -> Parser s (p, t) e t Source Deliver the first token if it does not equal the argument. + many :: Parser s t e a -> Parser s t e [a] Source Deliver zero or more values of a. + many1 :: Parser s t e a -> Parser s t e [a] Source Deliver one or more values of a. + sepby :: Parser s t e a -> Parser s t e b -> Parser s t e [a] Source Deliver zero or more values of a separated by b's. + sepby1 :: Parser s t e a -> Parser s t e b -> Parser s t e [a] Source Deliver one or more values of a separated by b's. + chainl :: Parser s t e a -> Parser s t e (a -> a -> a) -> a -> Parser s t e a Source chainl1 :: Parser s t e a -> Parser s t e (a -> a -> a) -> Parser s t e a Source chainr :: Parser s t e a -> Parser s t e (a -> a -> a) -> a -> Parser s t e a Source chainr1 :: Parser s t e a -> Parser s t e (a -> a -> a) -> Parser s t e a Source ops :: [(Parser s t e a, b)] -> Parser s t e b Source bracket :: (Show p, Show t) => Parser s (p, t) e a -> Parser s (p, t) e b -> Parser s (p, t) e c -> Parser s (p, t) e b Source toEOF :: Show p => Parser s (p, t) String a -> Parser s (p, t) String a Source Accept a complete parse of the input only, no partial parses. + Error handling + elserror :: (Show p, Show t) => Parser s (p, t) String a -> String -> Parser s (p, t) String a Source If the parser fails, generate an error message. + State handling + stupd :: (s -> s) -> Parser s t e () Source Update the internal state. + stquery :: (s -> a) -> Parser s t e a Source Query the internal state. + stget :: Parser s t e s Source Deliver the entire internal state. + Re-parsing + reparse :: [Either e t] -> Parser s t e () Source This is useful for recursively expanding macros. When the + user-parser recognises a macro use, it can lookup the macro + expansion from the parse state, lex it, and then stuff the + lexed expansion back down into the parser. + Produced by Haddock version 2.4.2 Text.ParserCombinators.Poly.Base
diff --git a/docs/haddock/Text-ParserCombinators-Poly-ByteString.html b/docs/haddock/Text-ParserCombinators-Poly-ByteString.html new file mode 100644 --- /dev/null +++ b/docs/haddock/Text-ParserCombinators-Poly-ByteString.html @@ -0,0 +1,675 @@ + + +polyparse Source code Contents Index Text.ParserCombinators.Poly.Base Contents Synopsis class (Functor p, Monad p) => PolyParse p where commit :: p a -> p a adjustErr :: p a -> (String -> String) -> p a onFail :: p a -> p a -> p a oneOf' :: [(String, p a)] -> p a apply :: p (a -> b) -> p a -> p b discard :: PolyParse p => p a -> p b -> p a failBad :: PolyParse p => String -> p a adjustErrBad :: PolyParse p => p a -> (String -> String) -> p a indent :: Int -> String -> String oneOf :: PolyParse p => [p a] -> p a optional :: PolyParse p => p a -> p (Maybe a) exactly :: PolyParse p => Int -> p a -> p [a] many :: PolyParse p => p a -> p [a] many1 :: PolyParse p => p a -> p [a] sepBy :: PolyParse p => p a -> p sep -> p [a] sepBy1 :: PolyParse p => p a -> p sep -> p [a] bracketSep :: PolyParse p => p bra -> p sep -> p ket -> p a -> p [a] bracket :: PolyParse p => p bra -> p ket -> p a -> p a manyFinally :: PolyParse p => p a -> p z -> p [a] The PolyParse class + class (Functor p, Monad p) => PolyParse p where Source The PolyParse class is an abstraction over all the current + concrete representations of monadic parser combinators in this + package. The common feature is two-level error-handling. + Some primitives must be implemented specific to each parser type + (e.g. depending on whether the parser has a running state, or + whether it is lazy). But given those primitives, large numbers of + combinators do not depend any further on the internal structure of + the particular parser. +
There are two additional basic combinators that we expect to be implemented + afresh for every concrete type, but which (for technical reasons) + cannot be class methods. They are next and satisfy. +
Methods commit :: p a -> p a Source Commit is a way of raising the severity of any errors found within + its argument. Used in the middle of a parser definition, it means that + any operations prior to commitment fail softly, but after commitment, + they fail hard. + adjustErr :: p a -> (String -> String) -> p a Source p adjustErr f applies the transformation f to any error message + generated in p, having no effect if p succeeds. + onFail :: p a -> p a -> p a Source p onFail q means parse p, unless p fails, in which case + parse q instead. + Can be chained together to give multiple attempts to parse something. + (Note that q could itself be a failing parser, e.g. to change the error + message from that defined in p to something different.) + However, a severe failure in p cannot be ignored. + oneOf' :: [(String, p a)] -> p a Source Parse the first alternative that succeeds, but if none succeed, + report only the severe errors, and if none of those, then report + all the soft errors. + apply :: p (a -> b) -> p a -> p b Source Apply a parsed function to a parsed value. + Rather like ordinary function application lifted into parsers. + InstancesCombinators general to all parser types. + Simple combinators + discard :: PolyParse p => p a -> p b -> p a Source x discard y parses both x and y, but discards the result of y. + Rather like const lifted into parsers. + Error-handling + failBad :: PolyParse p => String -> p a Source When a simple fail is not strong enough, use failBad for emphasis. + An emphasised (severe) error cannot be overridden by choice + operators. + adjustErrBad :: PolyParse p => p a -> (String -> String) -> p a Source adjustErrBad is just like adjustErr except it also raises the + severity of the error. + indent :: Int -> String -> String Source Helper for formatting error messages: indents all lines by a fixed amount. + Choices + oneOf :: PolyParse p => [p a] -> p a Source Parse the first alternative in the list that succeeds. + optional :: PolyParse p => p a -> p (Maybe a) Source optional indicates whether the parser succeeded through the Maybe type. + Sequences + exactly :: PolyParse p => Int -> p a -> p [a] Source 'exactly n p' parses precisely n items, using the parser p, in sequence. + many :: PolyParse p => p a -> p [a] Source 'many p' parses a list of elements with individual parser p. + Cannot fail, since an empty list is a valid return value. + many1 :: PolyParse p => p a -> p [a] Source Parse a non-empty list of items. + sepBy :: PolyParse p => p a -> p sep -> p [a] Source Parse a list of items separated by discarded junk. + sepBy1 :: PolyParse p => p a -> p sep -> p [a] Source Parse a non-empty list of items separated by discarded junk. + bracketSep :: PolyParse p => p bra -> p sep -> p ket -> p a -> p [a] Source Parse a list of items, discarding the start, end, and separator + items. + bracket :: PolyParse p => p bra -> p ket -> p a -> p a Source Parse a bracketed item, discarding the brackets. + manyFinally :: PolyParse p => p a -> p z -> p [a] Source 'manyFinally e t' parses a possibly-empty sequence of e's, + terminated by a t. The final t is discarded. Any parse failures + could be due either to a badly-formed terminator or a badly-formed + element, so it raises both possible errors. + Produced by Haddock version 2.4.2 Text.ParserCombinators.Poly.ByteString
diff --git a/docs/haddock/Text-ParserCombinators-Poly-Lazy.html b/docs/haddock/Text-ParserCombinators-Poly-Lazy.html new file mode 100644 --- /dev/null +++ b/docs/haddock/Text-ParserCombinators-Poly-Lazy.html @@ -0,0 +1,676 @@ + + +polyparse Source code Contents Index Text.ParserCombinators.Poly.ByteString Contents Synopsis newtype Parser a = P (ByteString -> Result ByteString a) data Result z a = Success z a | Failure z String | Committed (Result z a) runParser :: Parser a -> ByteString -> (Either String a, ByteString) next :: Parser Char eof :: Parser () satisfy :: (Char -> Bool) -> Parser Char reparse :: ByteString -> Parser () module Text.ParserCombinators.Poly.Base The Parser datatype + newtype Parser a Source This Parser datatype is a specialised parsing monad with error + reporting. Whereas the standard version can be used for arbitrary + token types, this version is specialised to ByteString input only. + Constructors P (ByteString -> Result ByteString a) Instancesdata Result z a Source A return type like Either, that distinguishes not only between + right and wrong answers, but also has commitment, so that a failure + cannot be undone. This should only be used for writing very primitive + parsers - really it is an internal detail of the library. + Constructors Success z a Failure z String Committed (Result z a) InstancesFunctor (Result z) runParser :: Parser a -> ByteString -> (Either String a, ByteString) Source Apply a parser to an input token sequence. + basic parsers + next :: Parser Char Source eof :: Parser () Source satisfy :: (Char -> Bool) -> Parser Char Source re-parsing + reparse :: ByteString -> Parser () Source Push some tokens back onto the front of the input stream and reparse. + This is useful e.g. for recursively expanding macros. When the + user-parser recognises a macro use, it can lookup the macro + expansion from the parse state, lex it, and then stuff the + lexed expansion back down into the parser. + Re-export all more general combinators + module Text.ParserCombinators.Poly.Base Produced by Haddock version 2.4.2 Text.ParserCombinators.Poly.Lazy
diff --git a/docs/haddock/Text-ParserCombinators-Poly-Plain.html b/docs/haddock/Text-ParserCombinators-Poly-Plain.html new file mode 100644 --- /dev/null +++ b/docs/haddock/Text-ParserCombinators-Poly-Plain.html @@ -0,0 +1,676 @@ + + +polyparse Source code Contents Index Text.ParserCombinators.Poly.Lazy Contents Synopsis newtype Parser t a = P ([t] -> Result [t] a) data Result z a = Success z a | Failure z String | Committed (Result z a) runParser :: Parser t a -> [t] -> (a, [t]) next :: Parser t t eof :: Parser t () satisfy :: (t -> Bool) -> Parser t t reparse :: [t] -> Parser t () module Text.ParserCombinators.Poly.Base The Parser datatype + newtype Parser t a Source This Parser datatype is a fairly generic parsing monad with error + reporting. It can be used for arbitrary token types, not just + String input. (If you require a running state, use module PolyState + instead) + Constructors P ([t] -> Result [t] a) Instancesdata Result z a Source A return type like Either, that distinguishes not only between + right and wrong answers, but also has gradations of wrongness. + This should only be used for writing very primitive + parsers - really it is an internal detail of the library. + Constructors Success z a Failure z String Committed (Result z a) InstancesFunctor (Result z) runParser :: Parser t a -> [t] -> (a, [t]) Source Apply a parser to an input token sequence. + basic parsers + next :: Parser t t Source eof :: Parser t () Source satisfy :: (t -> Bool) -> Parser t t Source re-parsing + reparse :: [t] -> Parser t () Source Push some tokens back onto the front of the input stream and reparse. + This is useful e.g. for recursively expanding macros. When the + user-parser recognises a macro use, it can lookup the macro + expansion from the parse state, lex it, and then stuff the + lexed expansion back down into the parser. + Re-export all more general combinators + module Text.ParserCombinators.Poly.Base Produced by Haddock version 2.4.2 Text.ParserCombinators.Poly.Plain
diff --git a/docs/haddock/Text-ParserCombinators-Poly-State.html b/docs/haddock/Text-ParserCombinators-Poly-State.html new file mode 100644 --- /dev/null +++ b/docs/haddock/Text-ParserCombinators-Poly-State.html @@ -0,0 +1,823 @@ + + +polyparse Source code Contents Index Text.ParserCombinators.Poly.Plain Contents Synopsis newtype Parser t a = P ([t] -> Result [t] a) data Result z a = Success z a | Failure z String | Committed (Result z a) runParser :: Parser t a -> [t] -> (Either String a, [t]) next :: Parser t t eof :: Parser t () satisfy :: (t -> Bool) -> Parser t t reparse :: [t] -> Parser t () module Text.ParserCombinators.Poly.Base The Parser datatype + newtype Parser t a Source This Parser datatype is a fairly generic parsing monad with error + reporting. It can be used for arbitrary token types, not just + String input. (If you require a running state, use module PolyState + instead) + Constructors P ([t] -> Result [t] a) Instancesdata Result z a Source A return type like Either, that distinguishes not only between + right and wrong answers, but also has commitment, so that a failure + cannot be undone. This should only be used for writing very primitive + parsers - really it is an internal detail of the library. + Constructors Success z a Failure z String Committed (Result z a) InstancesFunctor (Result z) runParser :: Parser t a -> [t] -> (Either String a, [t]) Source Apply a parser to an input token sequence. + basic parsers + next :: Parser t t Source eof :: Parser t () Source satisfy :: (t -> Bool) -> Parser t t Source re-parsing + reparse :: [t] -> Parser t () Source Push some tokens back onto the front of the input stream and reparse. + This is useful e.g. for recursively expanding macros. When the + user-parser recognises a macro use, it can lookup the macro + expansion from the parse state, lex it, and then stuff the + lexed expansion back down into the parser. + Re-export all more general combinators + module Text.ParserCombinators.Poly.Base Produced by Haddock version 2.4.2 Text.ParserCombinators.Poly.State
diff --git a/docs/haddock/Text-ParserCombinators-Poly-StateLazy.html b/docs/haddock/Text-ParserCombinators-Poly-StateLazy.html new file mode 100644 --- /dev/null +++ b/docs/haddock/Text-ParserCombinators-Poly-StateLazy.html @@ -0,0 +1,869 @@ + + +polyparse Source code Contents Index Text.ParserCombinators.Poly.State Contents Synopsis newtype Parser s t a = P (s -> [t] -> Result [t] s a) data Result z s a = Success z s a | Failure z s String | Committed (Result z s a) runParser :: Parser s t a -> s -> [t] -> (Either String a, s, [t]) next :: Parser s t t eof :: Parser s t () satisfy :: (t -> Bool) -> Parser s t t stUpdate :: (s -> s) -> Parser s t () stQuery :: (s -> a) -> Parser s t a stGet :: Parser s t s reparse :: [t] -> Parser s t () module Text.ParserCombinators.Poly.Base The Parser datatype + newtype Parser s t a Source This Parser datatype is a fairly generic parsing monad with error + reporting. It can be used for arbitrary token types, not just + String input. (If you require a running state, use module PolyState + instead) + Constructors P (s -> [t] -> Result [t] s a) Instancesdata Result z s a Source A return type like Either, that distinguishes not only between + right and wrong answers, but also has gradations of wrongness. + This should only be used for writing very primitive + parsers - really it is an internal detail of the library. + Constructors Success z s a Failure z s String Committed (Result z s a) InstancesFunctor (Result z s) runParser :: Parser s t a -> s -> [t] -> (Either String a, s, [t]) Source Apply a parser to an input token sequence. + basic parsers + next :: Parser s t t Source eof :: Parser s t () Source satisfy :: (t -> Bool) -> Parser s t t Source State-handling + stUpdate :: (s -> s) -> Parser s t () Source Update the internal state. + stQuery :: (s -> a) -> Parser s t a Source Query the internal state. + stGet :: Parser s t s Source Deliver the entire internal state. + re-parsing + reparse :: [t] -> Parser s t () Source Push some tokens back onto the front of the input stream and reparse. + This is useful e.g. for recursively expanding macros. When the + user-parser recognises a macro use, it can lookup the macro + expansion from the parse state, lex it, and then stuff the + lexed expansion back down into the parser. + Re-export all more general combinators + module Text.ParserCombinators.Poly.Base Produced by Haddock version 2.4.2 Text.ParserCombinators.Poly.StateLazy
diff --git a/docs/haddock/Text-ParserCombinators-Poly.html b/docs/haddock/Text-ParserCombinators-Poly.html new file mode 100644 --- /dev/null +++ b/docs/haddock/Text-ParserCombinators-Poly.html @@ -0,0 +1,92 @@ + + +polyparse Source code Contents Index Text.ParserCombinators.Poly.StateLazy Contents Synopsis newtype Parser s t a = P (s -> [t] -> Result [t] s a) data Result z s a = Success z s a | Failure z s String | Committed (Result z s a) runParser :: Parser s t a -> s -> [t] -> (a, s, [t]) next :: Parser s t t eof :: Parser s t () satisfy :: (t -> Bool) -> Parser s t t manyFinally :: Parser s t a -> Parser s t z -> Parser s t [a] stUpdate :: (s -> s) -> Parser s t () stQuery :: (s -> a) -> Parser s t a stGet :: Parser s t s reparse :: [t] -> Parser s t () module Text.ParserCombinators.Poly.Base The Parser datatype + newtype Parser s t a Source This Parser datatype is a fairly generic parsing monad with error + reporting. It can be used for arbitrary token types, not just + String input. (If you require a running state, use module PolyState + instead) + Constructors P (s -> [t] -> Result [t] s a) Instancesdata Result z s a Source A return type like Either, that distinguishes not only between + right and wrong answers, but also has gradations of wrongness. + This should only be used for writing very primitive + parsers - really it is an internal detail of the library. + Constructors Success z s a Failure z s String Committed (Result z s a) InstancesFunctor (Result z s) runParser :: Parser s t a -> s -> [t] -> (a, s, [t]) Source Apply a parser to an input token sequence. + basic parsers + next :: Parser s t t Source eof :: Parser s t () Source satisfy :: (t -> Bool) -> Parser s t t Source manyFinally :: Parser s t a -> Parser s t z -> Parser s t [a] Source State-handling + stUpdate :: (s -> s) -> Parser s t () Source Update the internal state. + stQuery :: (s -> a) -> Parser s t a Source Query the internal state. + stGet :: Parser s t s Source Deliver the entire internal state. + re-parsing + reparse :: [t] -> Parser s t () Source Push some tokens back onto the front of the input stream and reparse. + This is useful e.g. for recursively expanding macros. When the + user-parser recognises a macro use, it can lookup the macro + expansion from the parse state, lex it, and then stuff the + lexed expansion back down into the parser. + Re-export all more general combinators + module Text.ParserCombinators.Poly.Base Produced by Haddock version 2.4.2 Text.ParserCombinators.Poly
diff --git a/docs/haddock/doc-index.html b/docs/haddock/doc-index.html new file mode 100644 --- /dev/null +++ b/docs/haddock/doc-index.html @@ -0,0 +1,1774 @@ + + +polyparse Source code Contents Index Text.ParserCombinators.Poly Documentation module Text.ParserCombinators.Poly.Plain Produced by Haddock version 2.4.2 polyparse (Index)
diff --git a/docs/haddock/frames.html b/docs/haddock/frames.html new file mode 100644 --- /dev/null +++ b/docs/haddock/frames.html @@ -0,0 +1,27 @@ + + + + + + diff --git a/docs/haddock/haddock-util.js b/docs/haddock/haddock-util.js new file mode 100644 --- /dev/null +++ b/docs/haddock/haddock-util.js @@ -0,0 +1,139 @@ +// Haddock JavaScript utilities +function toggle(button,id) +{ + var n = document.getElementById(id).style; + if (n.display == "none") + { + button.src = "minus.gif"; + n.display = "block"; + } + else + { + button.src = "plus.gif"; + n.display = "none"; + } +} + + +var max_results = 75; // 50 is not enough to search for map in the base libraries +var shown_range = null; +var last_search = null; + +function quick_search() +{ + perform_search(false); +} + +function full_search() +{ + perform_search(true); +} + + +function perform_search(full) +{ + var text = document.getElementById("searchbox").value.toLowerCase(); + if (text == last_search && !full) return; + last_search = text; + + var table = document.getElementById("indexlist"); + var status = document.getElementById("searchmsg"); + var children = table.firstChild.childNodes; + + // first figure out the first node with the prefix + var first = bisect(-1); + var last = (first == -1 ? -1 : bisect(1)); + + if (first == -1) + { + table.className = ""; + status.innerHTML = "No results found, displaying all"; + } + else if (first == 0 && last == children.length - 1) + { + table.className = ""; + status.innerHTML = ""; + } + else if (last - first >= max_results && !full) + { + table.className = ""; + status.innerHTML = "More than " + max_results + ", press Search to display"; + } + else + { + // decide what you need to clear/show + if (shown_range) + setclass(shown_range[0], shown_range[1], "indexrow"); + setclass(first, last, "indexshow"); + shown_range = [first, last]; + table.className = "indexsearch"; + status.innerHTML = ""; + } + + + function setclass(first, last, status) + { + for (var i = first; i <= last; i++) + { + children[i].className = status; + } + } + + + // do a binary search, treating 0 as ... + // return either -1 (no 0's found) or location of most far match + function bisect(dir) + { + var first = 0, finish = children.length - 1; + var mid, success = false; + + while (finish - first > 3) + { + mid = Math.floor((finish + first) / 2); + + var i = checkitem(mid); + if (i == 0) i = dir; + if (i == -1) + finish = mid; + else + first = mid; + } + var a = (dir == 1 ? first : finish); + var b = (dir == 1 ? finish : first); + for (var i = b; i != a - dir; i -= dir) + { + if (checkitem(i) == 0) return i; + } + return -1; + } + + + // from an index, decide what the result is + // 0 = match, -1 is lower, 1 is higher + function checkitem(i) + { + var s = getitem(i).toLowerCase().substr(0, text.length); + if (s == text) return 0; + else return (s > text ? -1 : 1); + } + + + // from an index, get its string + // this abstracts over alternates + function getitem(i) + { + for ( ; i >= 0; i--) + { + var s = children[i].firstChild.firstChild.data; + if (s.indexOf(' ') == -1) + return s; + } + return ""; // should never be reached + } +} + +function setSynopsis(filename) { + if (parent.window.synopsis) { + parent.window.synopsis.location = filename; + } +} diff --git a/docs/haddock/haddock.css b/docs/haddock/haddock.css new file mode 100644 --- /dev/null +++ b/docs/haddock/haddock.css @@ -0,0 +1,297 @@ +/* -------- Global things --------- */ + +BODY { + background-color: #ffffff; + color: #000000; + font-family: sans-serif; + padding: 0 0; + } + +A:link { color: #0000e0; text-decoration: none } +A:visited { color: #0000a0; text-decoration: none } +A:hover { background-color: #e0e0ff; text-decoration: none } + +TABLE.vanilla { + width: 100%; + border-width: 0px; + /* I can't seem to specify cellspacing or cellpadding properly using CSS... */ +} + +TABLE.vanilla2 { + border-width: 0px; +} + +/* font is a little too small in MSIE */ +TT { font-size: 100%; } +PRE { font-size: 100%; } + +LI P { margin: 0pt } + +TD { + border-width: 0px; +} + +TABLE.narrow { + border-width: 0px; +} + +TD.s8 { height: 8px; } +TD.s15 { height: 15px; } + +SPAN.keyword { text-decoration: underline; } + +/* Resize the buttom image to match the text size */ +IMG.coll { width : 0.75em; height: 0.75em; margin-bottom: 0; margin-right: 0.5em } + +/* --------- Contents page ---------- */ + +DIV.node { + padding-left: 3em; +} + +DIV.cnode { + padding-left: 1.75em; +} + +SPAN.pkg { + position: absolute; + left: 50em; +} + +/* --------- Documentation elements ---------- */ + +TD.children { + padding-left: 25px; + } + +TD.synopsis { + padding: 2px; + background-color: #f0f0f0; + font-family: monospace + } + +TD.decl { + padding: 2px; + background-color: #f0f0f0; + font-family: monospace; + vertical-align: top; + } + +TD.topdecl { + padding: 2px; + background-color: #f0f0f0; + font-family: monospace; + vertical-align: top; +} + +TABLE.declbar { + border-spacing: 0px; + } + +TD.declname { + width: 100%; + } + +TD.declbut { + padding-left: 5px; + padding-right: 5px; + border-left-width: 1px; + border-left-color: #000099; + border-left-style: solid; + white-space: nowrap; + font-size: small; + } + +/* + arg is just like decl, except that wrapping is not allowed. It is + used for function and constructor arguments which have a text box + to the right, where if wrapping is allowed the text box squashes up + the declaration by wrapping it. +*/ +TD.arg { + padding: 2px; + background-color: #f0f0f0; + font-family: monospace; + vertical-align: top; + white-space: nowrap; + } + +TD.recfield { padding-left: 20px } + +TD.doc { + padding-top: 2px; + padding-left: 10px; + } + +TD.ndoc { + padding: 2px; + } + +TD.rdoc { + padding: 2px; + padding-left: 10px; + width: 100%; + } + +TD.body { + padding-left: 10px + } + +TD.pkg { + width: 100%; + padding-left: 10px +} + +TABLE.indexsearch TR.indexrow { + display: none; +} +TABLE.indexsearch TR.indexshow { + display: table-row; +} + +TD.indexentry { + vertical-align: top; + padding-right: 10px + } + +TD.indexannot { + vertical-align: top; + padding-left: 20px; + white-space: nowrap + } + +TD.indexlinks { + width: 100% + } + +/* ------- Section Headings ------- */ + +TD.section1 { + padding-top: 15px; + font-weight: bold; + font-size: 150% + } + +TD.section2 { + padding-top: 10px; + font-weight: bold; + font-size: 130% + } + +TD.section3 { + padding-top: 5px; + font-weight: bold; + font-size: 110% + } + +TD.section4 { + font-weight: bold; + font-size: 100% + } + +/* -------------- The title bar at the top of the page */ + +TD.infohead { + color: #ffffff; + font-weight: bold; + padding-right: 10px; + text-align: left; +} + +TD.infoval { + color: #ffffff; + padding-right: 10px; + text-align: left; +} + +TD.topbar { + background-color: #000099; + padding: 5px; +} + +TD.title { + color: #ffffff; + padding-left: 10px; + width: 100% + } + +TD.topbut { + padding-left: 5px; + padding-right: 5px; + border-left-width: 1px; + border-left-color: #ffffff; + border-left-style: solid; + white-space: nowrap; + } + +TD.topbut A:link { + color: #ffffff + } + +TD.topbut A:visited { + color: #ffff00 + } + +TD.topbut A:hover { + background-color: #6060ff; + } + +TD.topbut:hover { + background-color: #6060ff + } + +TD.modulebar { + background-color: #0077dd; + padding: 5px; + border-top-width: 1px; + border-top-color: #ffffff; + border-top-style: solid; + } + +/* --------- The page footer --------- */ + +TD.botbar { + background-color: #000099; + color: #ffffff; + padding: 5px + } +TD.botbar A:link { + color: #ffffff; + text-decoration: underline + } +TD.botbar A:visited { + color: #ffff00 + } +TD.botbar A:hover { + background-color: #6060ff + } + +/* --------- Mini Synopsis for Frame View --------- */ + +.outer { + margin: 0 0; + padding: 0 0; +} + +.mini-synopsis { + padding: 0.25em 0.25em; +} + +.mini-synopsis H1 { font-size: 130%; } +.mini-synopsis H2 { font-size: 110%; } +.mini-synopsis H3 { font-size: 100%; } +.mini-synopsis H1, .mini-synopsis H2, .mini-synopsis H3 { + margin-top: 0.5em; + margin-bottom: 0.25em; + padding: 0 0; +} + +.mini-synopsis H1 { border-bottom: 1px solid #ccc; } + +.mini-topbar { + font-size: 130%; + background: #0077dd; + padding: 0.25em; +} + + diff --git a/docs/haddock/haskell_icon.gif b/docs/haddock/haskell_icon.gif new file mode 100644 Binary files /dev/null and b/docs/haddock/haskell_icon.gif differ diff --git a/docs/haddock/index-frames.html b/docs/haddock/index-frames.html new file mode 100644 --- /dev/null +++ b/docs/haddock/index-frames.html @@ -0,0 +1,52 @@ + + +polyparse Contents Index +++ 1 (Function) Text.ParserCombinators.HuttonMeijerWallace 2 (Function) Text.ParserCombinators.HuttonMeijer adjustErr Text.ParserCombinators.Poly.Base, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString, Text.ParserCombinators.Poly, Text.Parse adjustErrBad Text.ParserCombinators.Poly.Base, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString, Text.ParserCombinators.Poly, Text.Parse allAsByteString Text.Parse.ByteString allAsString Text.Parse.ByteString alphanum Text.ParserCombinators.HuttonMeijer apply Text.ParserCombinators.Poly.Base, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString, Text.ParserCombinators.Poly, Text.Parse bracket 1 (Function) Text.ParserCombinators.Poly.Base, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString, Text.ParserCombinators.Poly, Text.Parse 2 (Function) Text.ParserCombinators.HuttonMeijerWallace 3 (Function) Text.ParserCombinators.HuttonMeijer bracketSep Text.ParserCombinators.Poly.Base, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString, Text.ParserCombinators.Poly, Text.Parse chainl 1 (Function) Text.ParserCombinators.HuttonMeijerWallace 2 (Function) Text.ParserCombinators.HuttonMeijer chainl1 1 (Function) Text.ParserCombinators.HuttonMeijerWallace 2 (Function) Text.ParserCombinators.HuttonMeijer chainr 1 (Function) Text.ParserCombinators.HuttonMeijerWallace 2 (Function) Text.ParserCombinators.HuttonMeijer chainr1 1 (Function) Text.ParserCombinators.HuttonMeijerWallace 2 (Function) Text.ParserCombinators.HuttonMeijer char Text.ParserCombinators.HuttonMeijer comment Text.ParserCombinators.HuttonMeijer commit Text.ParserCombinators.Poly.Base, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString, Text.ParserCombinators.Poly, Text.Parse Committed 1 (Data Constructor) Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly, Text.Parse 2 (Data Constructor) Text.ParserCombinators.Poly.Lazy 3 (Data Constructor) Text.ParserCombinators.Poly.State 4 (Data Constructor) Text.ParserCombinators.Poly.StateLazy 5 (Data Constructor) Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString constructors 1 (Function) Text.Parse.ByteString 2 (Function) Text.Parse digit Text.ParserCombinators.HuttonMeijer discard Text.ParserCombinators.Poly.Base, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString, Text.ParserCombinators.Poly, Text.Parse elserror Text.ParserCombinators.HuttonMeijerWallace enumeration 1 (Function) Text.Parse.ByteString 2 (Function) Text.Parse eof 1 (Function) Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly, Text.Parse 2 (Function) Text.ParserCombinators.Poly.Lazy 3 (Function) Text.ParserCombinators.Poly.State 4 (Function) Text.ParserCombinators.Poly.StateLazy 5 (Function) Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString 6 (Function) Text.ParserCombinators.HuttonMeijerWallace exactly Text.ParserCombinators.Poly.Base, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString, Text.ParserCombinators.Poly, Text.Parse failBad Text.ParserCombinators.Poly.Base, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString, Text.ParserCombinators.Poly, Text.Parse Failure 1 (Data Constructor) Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly, Text.Parse 2 (Data Constructor) Text.ParserCombinators.Poly.Lazy 3 (Data Constructor) Text.ParserCombinators.Poly.State 4 (Data Constructor) Text.ParserCombinators.Poly.StateLazy 5 (Data Constructor) Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString field 1 (Function) Text.Parse.ByteString 2 (Function) Text.Parse first Text.ParserCombinators.HuttonMeijer ident Text.ParserCombinators.HuttonMeijer identifier Text.ParserCombinators.HuttonMeijer indent Text.ParserCombinators.Poly.Base, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString, Text.ParserCombinators.Poly, Text.Parse int Text.ParserCombinators.HuttonMeijer integer Text.ParserCombinators.HuttonMeijer isWord 1 (Function) Text.Parse.ByteString 2 (Function) Text.Parse item 1 (Function) Text.ParserCombinators.HuttonMeijerWallace 2 (Function) Text.ParserCombinators.HuttonMeijer junk Text.ParserCombinators.HuttonMeijer letter Text.ParserCombinators.HuttonMeijer lower Text.ParserCombinators.HuttonMeijer many 1 (Function) Text.ParserCombinators.Poly.Base, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString, Text.ParserCombinators.Poly, Text.Parse 2 (Function) Text.ParserCombinators.HuttonMeijerWallace 3 (Function) Text.ParserCombinators.HuttonMeijer many1 1 (Function) Text.ParserCombinators.Poly.Base, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString, Text.ParserCombinators.Poly, Text.Parse 2 (Function) Text.ParserCombinators.HuttonMeijerWallace 3 (Function) Text.ParserCombinators.HuttonMeijer manyFinally 1 (Function) Text.ParserCombinators.Poly.Base, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString, Text.ParserCombinators.Poly, Text.Parse 2 (Function) Text.ParserCombinators.Poly.StateLazy nat Text.ParserCombinators.HuttonMeijer natural Text.ParserCombinators.HuttonMeijer next 1 (Function) Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly, Text.Parse 2 (Function) Text.ParserCombinators.Poly.Lazy 3 (Function) Text.ParserCombinators.Poly.State 4 (Function) Text.ParserCombinators.Poly.StateLazy 5 (Function) Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString nottok Text.ParserCombinators.HuttonMeijerWallace oneOf Text.ParserCombinators.Poly.Base, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString, Text.ParserCombinators.Poly, Text.Parse oneOf' Text.ParserCombinators.Poly.Base, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString, Text.ParserCombinators.Poly, Text.Parse onFail Text.ParserCombinators.Poly.Base, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString, Text.ParserCombinators.Poly, Text.Parse ops 1 (Function) Text.ParserCombinators.HuttonMeijerWallace 2 (Function) Text.ParserCombinators.HuttonMeijer optional Text.ParserCombinators.Poly.Base, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString, Text.ParserCombinators.Poly, Text.Parse optionalParens 1 (Function) Text.Parse.ByteString 2 (Function) Text.Parse P 1 (Data Constructor) Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly, Text.Parse 2 (Data Constructor) Text.ParserCombinators.Poly.Lazy 3 (Data Constructor) Text.ParserCombinators.Poly.State 4 (Data Constructor) Text.ParserCombinators.Poly.StateLazy 5 (Data Constructor) Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString 6 (Data Constructor) Text.ParserCombinators.HuttonMeijerWallace 7 (Data Constructor) Text.ParserCombinators.HuttonMeijer papply 1 (Function) Text.ParserCombinators.HuttonMeijerWallace 2 (Function) Text.ParserCombinators.HuttonMeijer papply' Text.ParserCombinators.HuttonMeijerWallace parens 1 (Function) Text.Parse.ByteString 2 (Function) Text.Parse Parse 1 (Type/Class) Text.Parse.ByteString 2 (Type/Class) Text.Parse parse 1 (Function) Text.Parse.ByteString 2 (Function) Text.Parse parseByRead 1 (Function) Text.Parse.ByteString 2 (Function) Text.Parse parseDec 1 (Function) Text.Parse.ByteString 2 (Function) Text.Parse parseFloat 1 (Function) Text.Parse.ByteString 2 (Function) Text.Parse parseHex 1 (Function) Text.Parse.ByteString 2 (Function) Text.Parse parseInt 1 (Function) Text.Parse.ByteString 2 (Function) Text.Parse parseList 1 (Function) Text.Parse.ByteString 2 (Function) Text.Parse parseLitChar 1 (Function) Text.Parse.ByteString 2 (Function) Text.Parse parseOct 1 (Function) Text.Parse.ByteString 2 (Function) Text.Parse parsePrec 1 (Function) Text.Parse.ByteString 2 (Function) Text.Parse Parser 1 (Type/Class) Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly, Text.Parse 2 (Type/Class) Text.ParserCombinators.Poly.Lazy 3 (Type/Class) Text.ParserCombinators.Poly.State 4 (Type/Class) Text.ParserCombinators.Poly.StateLazy 5 (Type/Class) Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString 6 (Type/Class) Text.ParserCombinators.HuttonMeijerWallace 7 (Type/Class) Text.ParserCombinators.HuttonMeijer parseSigned 1 (Function) Text.Parse.ByteString 2 (Function) Text.Parse parseUnsignedInteger Text.Parse.ByteString PolyParse Text.ParserCombinators.Poly.Base, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString, Text.ParserCombinators.Poly, Text.Parse readByParse 1 (Function) Text.Parse.ByteString 2 (Function) Text.Parse readsPrecByParsePrec 1 (Function) Text.Parse.ByteString 2 (Function) Text.Parse reparse 1 (Function) Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly, Text.Parse 2 (Function) Text.ParserCombinators.Poly.Lazy 3 (Function) Text.ParserCombinators.Poly.State 4 (Function) Text.ParserCombinators.Poly.StateLazy 5 (Function) Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString 6 (Function) Text.ParserCombinators.HuttonMeijerWallace Result 1 (Type/Class) Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly, Text.Parse 2 (Type/Class) Text.ParserCombinators.Poly.Lazy 3 (Type/Class) Text.ParserCombinators.Poly.State 4 (Type/Class) Text.ParserCombinators.Poly.StateLazy 5 (Type/Class) Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString runParser 1 (Function) Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly, Text.Parse 2 (Function) Text.ParserCombinators.Poly.Lazy 3 (Function) Text.ParserCombinators.Poly.State 4 (Function) Text.ParserCombinators.Poly.StateLazy 5 (Function) Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString sat Text.ParserCombinators.HuttonMeijer satisfy 1 (Function) Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly, Text.Parse 2 (Function) Text.ParserCombinators.Poly.Lazy 3 (Function) Text.ParserCombinators.Poly.State 4 (Function) Text.ParserCombinators.Poly.StateLazy 5 (Function) Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString sepBy Text.ParserCombinators.Poly.Base, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString, Text.ParserCombinators.Poly, Text.Parse sepby 1 (Function) Text.ParserCombinators.HuttonMeijerWallace 2 (Function) Text.ParserCombinators.HuttonMeijer sepBy1 Text.ParserCombinators.Poly.Base, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString, Text.ParserCombinators.Poly, Text.Parse sepby1 1 (Function) Text.ParserCombinators.HuttonMeijerWallace 2 (Function) Text.ParserCombinators.HuttonMeijer skip Text.ParserCombinators.HuttonMeijer spaces Text.ParserCombinators.HuttonMeijer stGet 1 (Function) Text.ParserCombinators.Poly.State 2 (Function) Text.ParserCombinators.Poly.StateLazy stget Text.ParserCombinators.HuttonMeijerWallace stQuery 1 (Function) Text.ParserCombinators.Poly.State 2 (Function) Text.ParserCombinators.Poly.StateLazy stquery Text.ParserCombinators.HuttonMeijerWallace string Text.ParserCombinators.HuttonMeijer stupd Text.ParserCombinators.HuttonMeijerWallace stUpdate 1 (Function) Text.ParserCombinators.Poly.State 2 (Function) Text.ParserCombinators.Poly.StateLazy Success 1 (Data Constructor) Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly, Text.Parse 2 (Data Constructor) Text.ParserCombinators.Poly.Lazy 3 (Data Constructor) Text.ParserCombinators.Poly.State 4 (Data Constructor) Text.ParserCombinators.Poly.StateLazy 5 (Data Constructor) Text.ParserCombinators.Poly.ByteString, Text.Parse.ByteString symbol Text.ParserCombinators.HuttonMeijer TextParser 1 (Type/Class) Text.Parse.ByteString 2 (Type/Class) Text.Parse toEOF Text.ParserCombinators.HuttonMeijerWallace tok Text.ParserCombinators.HuttonMeijerWallace token Text.ParserCombinators.HuttonMeijer upper Text.ParserCombinators.HuttonMeijer word 1 (Function) Text.Parse.ByteString 2 (Function) Text.Parse polyparse
diff --git a/docs/haddock/index.html b/docs/haddock/index.html new file mode 100644 --- /dev/null +++ b/docs/haddock/index.html @@ -0,0 +1,212 @@ + + +Text.Parse
Text.Parse.ByteString
Text.ParserCombinators.HuttonMeijer
Text.ParserCombinators.HuttonMeijerWallace
Text.ParserCombinators.Poly
Text.ParserCombinators.Poly.Base
Text.ParserCombinators.Poly.ByteString
Text.ParserCombinators.Poly.Lazy
Text.ParserCombinators.Poly.Plain
Text.ParserCombinators.Poly.State
Text.ParserCombinators.Poly.StateLazypolyparse
diff --git a/docs/haddock/mini_Text-Parse-ByteString.html b/docs/haddock/mini_Text-Parse-ByteString.html new file mode 100644 --- /dev/null +++ b/docs/haddock/mini_Text-Parse-ByteString.html @@ -0,0 +1,128 @@ + + +polyparse Contents Index Modules TextText.ParseText.Parse.ByteString ParserCombinatorsText.ParserCombinators.HuttonMeijer Text.ParserCombinators.HuttonMeijerWallace Text.ParserCombinators.PolyText.ParserCombinators.Poly.Base Text.ParserCombinators.Poly.ByteString Text.ParserCombinators.Poly.Lazy Text.ParserCombinators.Poly.Plain Text.ParserCombinators.Poly.State Text.ParserCombinators.Poly.StateLazy Produced by Haddock version 2.4.2 Text.Parse.ByteString diff --git a/docs/haddock/mini_Text-Parse.html b/docs/haddock/mini_Text-Parse.html new file mode 100644 --- /dev/null +++ b/docs/haddock/mini_Text-Parse.html @@ -0,0 +1,113 @@ + + +The Parse class is a replacement for the standard Read class. +
type TextParser aclass Parse aCombinators specific to string 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 +
Text.Parse diff --git a/docs/haddock/mini_Text-ParserCombinators-HuttonMeijer.html b/docs/haddock/mini_Text-ParserCombinators-HuttonMeijer.html new file mode 100644 --- /dev/null +++ b/docs/haddock/mini_Text-ParserCombinators-HuttonMeijer.html @@ -0,0 +1,163 @@ + + +The Parse class is a replacement for the standard Read class. +
type TextParser aclass Parse aCombinators specific to string input, lexed haskell-style +
Parsers for literal numerics and characters +
Re-export all the more general combinators from Poly too +
Text.ParserCombinators.HuttonMeijer diff --git a/docs/haddock/mini_Text-ParserCombinators-HuttonMeijerWallace.html b/docs/haddock/mini_Text-ParserCombinators-HuttonMeijerWallace.html new file mode 100644 --- /dev/null +++ b/docs/haddock/mini_Text-ParserCombinators-HuttonMeijerWallace.html @@ -0,0 +1,137 @@ + + +Text.ParserCombinators.HuttonMeijerWallace diff --git a/docs/haddock/mini_Text-ParserCombinators-Poly-Base.html b/docs/haddock/mini_Text-ParserCombinators-Poly-Base.html new file mode 100644 --- /dev/null +++ b/docs/haddock/mini_Text-ParserCombinators-Poly-Base.html @@ -0,0 +1,101 @@ + + +Text.ParserCombinators.Poly.Base diff --git a/docs/haddock/mini_Text-ParserCombinators-Poly-ByteString.html b/docs/haddock/mini_Text-ParserCombinators-Poly-ByteString.html new file mode 100644 --- /dev/null +++ b/docs/haddock/mini_Text-ParserCombinators-Poly-ByteString.html @@ -0,0 +1,65 @@ + + +The PolyParse class +
class PolyParse pCombinators general to all parser types. +
Simple combinators +
Error-handling +
Choices +
Sequences +
Text.ParserCombinators.Poly.ByteString diff --git a/docs/haddock/mini_Text-ParserCombinators-Poly-Lazy.html b/docs/haddock/mini_Text-ParserCombinators-Poly-Lazy.html new file mode 100644 --- /dev/null +++ b/docs/haddock/mini_Text-ParserCombinators-Poly-Lazy.html @@ -0,0 +1,65 @@ + + +Text.ParserCombinators.Poly.Lazy diff --git a/docs/haddock/mini_Text-ParserCombinators-Poly-Plain.html b/docs/haddock/mini_Text-ParserCombinators-Poly-Plain.html new file mode 100644 --- /dev/null +++ b/docs/haddock/mini_Text-ParserCombinators-Poly-Plain.html @@ -0,0 +1,65 @@ + + +Text.ParserCombinators.Poly.Plain diff --git a/docs/haddock/mini_Text-ParserCombinators-Poly-State.html b/docs/haddock/mini_Text-ParserCombinators-Poly-State.html new file mode 100644 --- /dev/null +++ b/docs/haddock/mini_Text-ParserCombinators-Poly-State.html @@ -0,0 +1,80 @@ + + +Text.ParserCombinators.Poly.State diff --git a/docs/haddock/mini_Text-ParserCombinators-Poly-StateLazy.html b/docs/haddock/mini_Text-ParserCombinators-Poly-StateLazy.html new file mode 100644 --- /dev/null +++ b/docs/haddock/mini_Text-ParserCombinators-Poly-StateLazy.html @@ -0,0 +1,84 @@ + + +Text.ParserCombinators.Poly.StateLazy diff --git a/docs/haddock/mini_Text-ParserCombinators-Poly.html b/docs/haddock/mini_Text-ParserCombinators-Poly.html new file mode 100644 --- /dev/null +++ b/docs/haddock/mini_Text-ParserCombinators-Poly.html @@ -0,0 +1,21 @@ + + +Text.ParserCombinators.Poly diff --git a/docs/haddock/minus.gif b/docs/haddock/minus.gif new file mode 100644 Binary files /dev/null and b/docs/haddock/minus.gif differ diff --git a/docs/haddock/plus.gif b/docs/haddock/plus.gif new file mode 100644 Binary files /dev/null and b/docs/haddock/plus.gif differ diff --git a/docs/haddock/src/Text/Parse.html b/docs/haddock/src/Text/Parse.html new file mode 100644 --- /dev/null +++ b/docs/haddock/src/Text/Parse.html @@ -0,0 +1,435 @@ + + +module Text.Parse + ( -- * The Parse class is a replacement for the standard Read class. + -- $parser + TextParser -- synonym for Parser Char, i.e. string input, no state + , Parse(..) -- instances: (), (a,b), (a,b,c), Maybe a, Either a, [a], + -- Int, Integer, Float, Double, Char, Bool + , parseByRead -- :: Read a => String -> TextParser a + , readByParse -- :: TextParser a -> ReadS a + , readsPrecByParsePrec -- :: (Int->TextParser a) -> Int -> ReadS a + -- ** Combinators specific to string input, lexed haskell-style + , word -- :: TextParser String + , isWord -- :: String -> TextParser () + , 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 + -- ** Parsers for literal numerics and characters + , parseSigned + , parseInt + , parseDec + , parseOct + , parseHex + , parseFloat + , parseLitChar + -- ** Re-export all the more general combinators from Poly too + , module Text.ParserCombinators.Poly + ) where + +import Char (isSpace,toLower,isUpper,isDigit,isOctDigit,isHexDigit,digitToInt + ,isAlpha,isAlphaNum,ord,chr) +import List (intersperse) +import Ratio +import Text.ParserCombinators.Poly + +------------------------------------------------------------------------ +-- $parser +-- 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 !-} + +-- | A synonym for Parser Char, i.e. string input (no state) +type TextParser a = Parser Char a + +-- | 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@. +class Parse a where + -- | A straightforward parser for an item. (A minimal definition of + -- a class instance requires either |parse| or |parsePrec|.) + parse :: TextParser a + parse = parsePrec 0 + -- | A straightforward parser for an item, given the precedence of + -- any surrounding expression. (Precedence determines whether + -- parentheses are mandatory or optional.) + parsePrec :: Int -> TextParser a + parsePrec _ = optionalParens parse + -- | Parsing a list of items by default accepts the [] and comma syntax, + -- except when the list is really a character string using \"\". + parseList :: TextParser [a] -- only to distinguish [] and "" + parseList = do { isWord "[]"; return [] } + `onFail` + do { isWord "["; isWord "]"; return [] } + `onFail` + bracketSep (isWord "[") (isWord ",") (isWord "]") + (optionalParens parse) + `adjustErr` ("Expected a list, but\n"++) + +-- | 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). +parseByRead :: Read a => String -> TextParser a +parseByRead name = + P (\s-> case reads s of + [] -> Failure s ("no parse, expected a "++name) + [(a,s')] -> Success s' a + _ -> Failure s ("ambiguous parse, expected a "++name) + ) + +-- | If you have a TextParser for a type, you can easily make it into +-- a Read instance, by throwing away any error messages. +readByParse :: TextParser a -> ReadS a +readByParse p = \inp-> + case runParser p inp of + (Left err, rest) -> [] + (Right val, rest) -> [(val,rest)] + +-- | 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 a +readsPrecByParsePrec p = \prec inp-> + case runParser (p prec) inp of + (Left err, rest) -> [] + (Right val, rest) -> [(val,rest)] + +-- | One lexical chunk. This is Haskell'98-style lexing - the result +-- should match Prelude.lex apart from better error-reporting. +word :: TextParser String +word = P p + where + p "" = Failure "" "end of input" + p (c:s) | isSpace c = p (dropWhile isSpace s) + p ('\'':s) = let (P lit) = parseLitChar in fmap show (lit ('\'':s)) + p ('"':s) = lexString "\"" s + where lexString acc ('"':s) = Success s (reverse ('"':acc)) + lexString acc ('\\':'"':s) = lexString ("\"\\"++acc) s + lexString acc (c:s) = lexString (c:acc) s + lexString acc [] = Failure [] ("end of input in " + ++"string literal " + ++acc) + p ('0':'x':s) = Success t ('0':'x':ds) where (ds,t) = span isHexDigit s + p ('0':'X':s) = Success t ('0':'X':ds) where (ds,t) = span isHexDigit s + p ('0':'o':s) = Success t ('0':'o':ds) where (ds,t) = span isOctDigit s + p ('0':'O':s) = Success t ('0':'O':ds) where (ds,t) = span isOctDigit s + p (c:s) | isSingle c = Success s [c] + | isSym c = let (sym,t) = span isSym s in Success t (c:sym) + | isIdInit c = let (nam,t) = span isIdChar s in Success t (c:nam) + | isDigit c = let (ds,t) = span isDigit s in + lexFracExp (c:ds) t + | otherwise = Failure (c:s) ("Bad character: "++show c) + where isSingle c = c `elem` ",;()[]{}`" + isSym c = c `elem` "!@#$%&*+./<=>?\\^|:-~" + isIdInit c = isAlpha c || c == '_' + isIdChar c = isAlphaNum c || c `elem` "_'" + lexFracExp acc ('.':d:s) | isDigit d = + lexExp (acc++'.':d:ds) t + where (ds,t) = span isDigit s + lexFracExp acc s = lexExp acc s + lexExp acc (e:s) | e`elem`"eE" = + case s of + ('+':d:t) | isDigit d -> + let (ds,u)=span isDigit t in + Success u (acc++"e+"++d:ds) + ('-':d:t) | isDigit d -> + let (ds,u)=span isDigit t in + Success u (acc++"e-"++d:ds) + (d:t) |isDigit d -> + let (ds,u)=span isDigit t in + Success u (acc++"e"++d:ds) + _ -> Failure s ("missing +/-/digit " + ++"after e in float " + ++"literal: " + ++show (acc++"e"++"...")) + lexExp acc s = Success s acc + + + +-- | One lexical chunk (Haskell'98-style lexing - the result should match +-- Prelude.lex apart from error-reporting). +oldword :: TextParser String +oldword = P (\s-> case lex s of + [] -> Failure s ("no input? (impossible)") + [("","")] -> Failure "" ("no input?") + [("",s')] -> Failure s ("lexing failed?") + ((x,s'):_) -> Success s' x + ) + +-- | Ensure that the next input word is the given string. (Note the input +-- is lexed as haskell, so wordbreaks at spaces, symbols, etc.) +isWord :: String -> TextParser String +isWord w = do { w' <- word + ; if w'==w then return w else fail ("expected "++w++" got "++w') + } + +-- | Allow nested parens around an item. +optionalParens :: TextParser a -> TextParser a +optionalParens p = parens False p + +-- | Allow nested parens around an item (one set required when Bool is True). +parens :: Bool -> TextParser a -> TextParser a +parens True p = bracket (isWord "(") (isWord ")") (parens False p) +parens False p = parens True p `onFail` p + +-- | Deal with named field syntax. The string argument is the field name, +-- and the parser returns the value of the field. +field :: Parse a => String -> TextParser a +field name = do { isWord name; commit $ do { isWord "="; parse } } + +-- | 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. +constructors :: [(String,TextParser a)] -> TextParser a +constructors cs = oneOf' (map cons cs) + where cons (name,p) = + ( name + , do { isWord name + ; p `adjustErrBad` (("got constructor, but within " + ++name++",\n")++) + } + ) + +-- | 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. +enumeration :: (Show a) => String -> [a] -> TextParser a +enumeration typ cs = oneOf (map (\c-> do { isWord (show c); return c }) cs) + `adjustErr` + (++("\n expected "++typ++" value ("++e++")")) + where e = concat (intersperse ", " (map show (init cs))) + ++ ", or " ++ show (last cs) + +------------------------------------------------------------------------ +-- Instances for all the Standard Prelude types. + +-- Numeric types +parseSigned :: Real a => TextParser a -> TextParser a +parseSigned p = do '-' <- next; commit (fmap negate p) + `onFail` + do p + +parseInt :: (Integral a) => String -> + a -> (Char -> Bool) -> (Char -> Int) -> + TextParser a +parseInt base radix isDigit digitToInt = + do cs <- many1 (satisfy isDigit) + return (foldl1 (\n d-> n*radix+d) + (map (fromIntegral.digitToInt) cs)) + `adjustErr` (++("\nexpected one or more "++base++" digits")) +parseDec, parseOct, parseHex :: (Integral a) => TextParser a +parseDec = parseInt "decimal" 10 Char.isDigit Char.digitToInt +parseOct = parseInt "octal" 8 Char.isOctDigit Char.digitToInt +parseHex = parseInt "hex" 16 Char.isHexDigit Char.digitToInt + +parseFloat :: (RealFrac a) => TextParser a +parseFloat = do ds <- many1 (satisfy isDigit) + frac <- (do '.' <- next + many (satisfy isDigit) + `adjustErrBad` (++"expected digit after .") + `onFail` return [] ) + exp <- exponent `onFail` return 0 + ( return . fromRational . (* (10^^(exp - length frac))) + . (%1) . (\ (Right x)->x) . fst + . runParser parseDec ) (ds++frac) + `onFail` + do w <- many (satisfy (not.isSpace)) + case map toLower w of + "nan" -> return (0/0) + "infinity" -> return (1/0) + _ -> fail "expected a floating point number" + where exponent = do 'e' <- fmap toLower next + commit (do '+' <- next; parseDec + `onFail` + parseSigned parseDec ) + +parseLitChar :: TextParser Char +parseLitChar = do '\'' <- next `adjustErr` (++"expected a literal char") + c <- next + char <- case c of + '\\' -> next >>= escape + '\'' -> fail "expected a literal char, got ''" + _ -> return c + '\'' <- next `adjustErrBad` (++"literal char has no final '") + return char + where + escape 'a' = return '\a' + escape 'b' = return '\b' + escape 'f' = return '\f' + escape 'n' = return '\n' + escape 'r' = return '\r' + escape 't' = return '\t' + escape 'v' = return '\v' + escape '\\' = return '\\' + escape '"' = return '"' + escape '\'' = return '\'' + escape '^' = do ctrl <- next + if ctrl >= '@' && ctrl <= '_' + then return (chr (ord ctrl - ord '@')) + else fail ("literal char ctrl-escape malformed: \\^" + ++[ctrl]) + escape d | isDigit d + = fmap chr $ (reparse [d] >> parseDec) + escape 'o' = fmap chr $ parseOct + escape 'x' = fmap chr $ parseHex + escape c | isUpper c + = mnemonic c + escape c = fail ("unrecognised escape sequence in literal char: \\"++[c]) + + mnemonic 'A' = do 'C' <- next; 'K' <- next; return '\ACK' + `wrap` "'\\ACK'" + mnemonic 'B' = do 'E' <- next; 'L' <- next; return '\BEL' + `onFail` + do 'S' <- next; return '\BS' + `wrap` "'\\BEL' or '\\BS'" + mnemonic 'C' = do 'R' <- next; return '\CR' + `onFail` + do 'A' <- next; 'N' <- next; return '\CAN' + `wrap` "'\\CR' or '\\CAN'" + mnemonic 'D' = do 'E' <- next; 'L' <- next; return '\DEL' + `onFail` + do 'L' <- next; 'E' <- next; return '\DLE' + `onFail` + do 'C' <- next; ( do '1' <- next; return '\DC1' + `onFail` + do '2' <- next; return '\DC2' + `onFail` + do '3' <- next; return '\DC3' + `onFail` + do '4' <- next; return '\DC4' ) + `wrap` "'\\DEL' or '\\DLE' or '\\DC[1..4]'" + mnemonic 'E' = do 'T' <- next; 'X' <- next; return '\ETX' + `onFail` + do 'O' <- next; 'T' <- next; return '\EOT' + `onFail` + do 'N' <- next; 'Q' <- next; return '\ENQ' + `onFail` + do 'T' <- next; 'B' <- next; return '\ETB' + `onFail` + do 'M' <- next; return '\EM' + `onFail` + do 'S' <- next; 'C' <- next; return '\ESC' + `wrap` "one of '\\ETX' '\\EOT' '\\ENQ' '\\ETB' '\\EM' or '\\ESC'" + mnemonic 'F' = do 'F' <- next; return '\FF' + `onFail` + do 'S' <- next; return '\FS' + `wrap` "'\\FF' or '\\FS'" + mnemonic 'G' = do 'S' <- next; return '\GS' + `wrap` "'\\GS'" + mnemonic 'H' = do 'T' <- next; return '\HT' + `wrap` "'\\HT'" + mnemonic 'L' = do 'F' <- next; return '\LF' + `wrap` "'\\LF'" + mnemonic 'N' = do 'U' <- next; 'L' <- next; return '\NUL' + `onFail` + do 'A' <- next; 'K' <- next; return '\NAK' + `wrap` "'\\NUL' or '\\NAK'" + mnemonic 'R' = do 'S' <- next; return '\RS' + `wrap` "'\\RS'" + mnemonic 'S' = do 'O' <- next; 'H' <- next; return '\SOH' + `onFail` + do 'O' <- next; return '\SO' + `onFail` + do 'T' <- next; 'X' <- next; return '\STX' + `onFail` + do 'I' <- next; return '\SI' + `onFail` + do 'Y' <- next; 'N' <- next; return '\SYN' + `onFail` + do 'U' <- next; 'B' <- next; return '\SUB' + `onFail` + do 'P' <- next; return '\SP' + `wrap` "'\\SOH' '\\SO' '\\STX' '\\SI' '\\SYN' '\\SUB' or '\\SP'" + mnemonic 'U' = do 'S' <- next; return '\US' + `wrap` "'\\US'" + mnemonic 'V' = do 'T' <- next; return '\VT' + `wrap` "'\\VT'" + wrap p s = p `onFail` fail ("expected literal char "++s) + +-- Basic types +instance Parse Int where + -- parse = parseByRead "Int" -- convert from Integer, deals with minInt + parse = fmap fromInteger $ + do many (satisfy isSpace); parseSigned parseDec +instance Parse Integer where + -- parse = parseByRead "Integer" + parse = do many (satisfy isSpace); parseSigned parseDec +instance Parse Float where + -- parse = parseByRead "Float" + parse = do many (satisfy isSpace); parseSigned parseFloat +instance Parse Double where + -- parse = parseByRead "Double" + parse = do many (satisfy isSpace); parseSigned parseFloat +instance Parse Char where +-- parse = parseByRead "Char" + parse = do many (satisfy isSpace); parseLitChar + -- parse = do { w <- word; if head w == '\'' then readLitChar (tail w) + -- else fail "expected a char" } + -- parseList = bracket (isWord "\"") (satisfy (=='"')) + -- (many (satisfy (/='"'))) + -- not totally correct for strings... + parseList = do { w <- word; if head w == '"' then return (init (tail w)) + else fail "not a string" } + +instance Parse Bool where + parse = enumeration "Bool" [False,True] + +instance Parse Ordering where + parse = enumeration "Ordering" [LT,EQ,GT] + +-- Structural types +instance Parse () where + parse = P p + where p [] = Failure [] "no input: expected a ()" + p ('(':cs) = case dropWhile isSpace cs of + (')':s) -> Success s () + _ -> Failure cs "Expected ) after (" + p (c:cs) | isSpace c = p cs + | otherwise = Failure (c:cs) ("Expected a (), got "++show c) + +instance (Parse a, Parse b) => Parse (a,b) where + parse = do{ isWord "(" `adjustErr` ("Opening a 2-tuple\n"++) + ; x <- parse `adjustErr` ("In 1st item of a 2-tuple\n"++) + ; isWord "," `adjustErr` ("Separating a 2-tuple\n"++) + ; y <- parse `adjustErr` ("In 2nd item of a 2-tuple\n"++) + ; isWord ")" `adjustErr` ("Closing a 2-tuple\n"++) + ; return (x,y) } + +instance (Parse a, Parse b, Parse c) => Parse (a,b,c) where + parse = do{ isWord "(" `adjustErr` ("Opening a 3-tuple\n"++) + ; x <- parse `adjustErr` ("In 1st item of a 3-tuple\n"++) + ; isWord "," `adjustErr` ("Separating(1) a 3-tuple\n"++) + ; y <- parse `adjustErr` ("In 2nd item of a 3-tuple\n"++) + ; isWord "," `adjustErr` ("Separating(2) a 3-tuple\n"++) + ; z <- parse `adjustErr` ("In 3rd item of a 3-tuple\n"++) + ; isWord ")" `adjustErr` ("Closing a 3-tuple\n"++) + ; return (x,y,z) } + +instance Parse a => Parse (Maybe a) where + parsePrec p = + optionalParens (do { isWord "Nothing"; return Nothing }) + `onFail` + parens (p>9) (do { isWord "Just" + ; fmap Just $ parsePrec 10 + `adjustErrBad` ("but within Just, "++) }) + `adjustErr` (("expected a Maybe (Just or Nothing)\n"++).indent 2) + +instance (Parse a, Parse b) => Parse (Either a b) where + parsePrec p = + parens (p>9) $ + constructors [ ("Left", do { fmap Left $ parsePrec 10 } ) + , ("Right", do { fmap Right $ parsePrec 10 } ) + ] + +instance Parse a => Parse [a] where + parse = parseList + +------------------------------------------------------------------------ +
+ diff --git a/docs/haddock/src/Text/Parse/ByteString.html b/docs/haddock/src/Text/Parse/ByteString.html new file mode 100644 --- /dev/null +++ b/docs/haddock/src/Text/Parse/ByteString.html @@ -0,0 +1,412 @@ + + +module Text.Parse.ByteString + ( -- * The Parse class is a replacement for the standard Read class. + -- This particular instance reads from ByteString rather than String. + -- $parser + TextParser -- synonym for Text.ParserCombinators.Poly.ByteString + , Parse(..) -- instances: (), (a,b), (a,b,c), Maybe a, Either a, [a], + -- Int, Integer, Float, Double, Char, Bool + , parseByRead -- :: Read a => String -> TextParser a + , readByParse -- :: TextParser a -> ReadS a + , readsPrecByParsePrec -- :: (Int->TextParser a) -> Int -> ReadS a + -- ** Combinators specific to string input, lexed haskell-style + , word -- :: TextParser String + , isWord -- :: String -> TextParser () + , 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 + -- ** Parsers for literal numerics and characters + , parseSigned + , parseInt + , parseDec + , parseOct + , parseHex + , parseUnsignedInteger + , parseFloat + , parseLitChar + -- ** Re-export all the more general combinators from Poly too + , module Text.ParserCombinators.Poly.ByteString + -- ** ByteStrings and Strings as whole entities + , allAsByteString + , allAsString + ) where + +import Char (isSpace,toLower,isUpper,isDigit,isOctDigit,isHexDigit,digitToInt + ,ord,chr) +import List (intersperse) +import Ratio +import qualified Data.ByteString.Lazy.Char8 as BS +import Data.ByteString.Lazy.Char8 (ByteString) +import Text.ParserCombinators.Poly.ByteString + +------------------------------------------------------------------------ +-- $parser +-- 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 !-} + +-- | A synonym for a ByteString Parser, i.e. bytestring input (no state) +type TextParser a = Parser a + +-- | 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@. +class Parse a where + -- | A straightforward parser for an item. (A minimal definition of + -- a class instance requires either |parse| or |parsePrec|.) + parse :: TextParser a + parse = parsePrec 0 + -- | A straightforward parser for an item, given the precedence of + -- any surrounding expression. (Precedence determines whether + -- parentheses are mandatory or optional.) + parsePrec :: Int -> TextParser a + parsePrec _ = optionalParens parse + -- | Parsing a list of items by default accepts the [] and comma syntax, + -- except when the list is really a character string using \"\". + parseList :: TextParser [a] -- only to distinguish [] and "" + parseList = do { isWord "[]"; return [] } + `onFail` + do { isWord "["; isWord "]"; return [] } + `onFail` + bracketSep (isWord "[") (isWord ",") (isWord "]") + (optionalParens parse) + `adjustErr` ("Expected a list, but\n"++) + +-- | 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. +parseByRead :: Read a => String -> TextParser a +parseByRead name = + P (\s-> case reads (BS.unpack s) of + [] -> Failure s ("no parse, expected a "++name) + [(a,s')] -> Success (BS.pack s') a + _ -> Failure s ("ambiguous parse, expected a "++name) + ) + +-- | 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. +readByParse :: TextParser a -> ReadS a +readByParse p = \inp-> + case runParser p (BS.pack inp) of + (Left err, rest) -> [] + (Right val, rest) -> [(val, BS.unpack rest)] + +-- | 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 +readsPrecByParsePrec p = \prec inp-> + case runParser (p prec) (BS.pack inp) of + (Left err, rest) -> [] + (Right val, rest) -> [(val, BS.unpack rest)] + + +-- | One lexical chunk (Haskell-style lexing). +word :: TextParser String +word = P (\s-> case lex (BS.unpack s) of + [] -> Failure s ("no input? (impossible)") + [("","")] -> Failure s ("no input?") + [("",_)] -> Failure s ("lexing failed?") + ((x,_):_) -> Success (BS.drop (fromIntegral (length x)) s) x + ) + +-- | Ensure that the next input word is the given string. (Note the input +-- is lexed as haskell, so wordbreaks at spaces, symbols, etc.) +isWord :: String -> TextParser String +isWord w = do { w' <- word + ; if w'==w then return w else fail ("expected "++w++" got "++w') + } + +-- | Allow optional nested string parens around an item. +optionalParens :: TextParser a -> TextParser a +optionalParens p = parens False p + +-- | Allow nested parens around an item (one set required when Bool is True). +parens :: Bool -> TextParser a -> TextParser a +parens True p = bracket (isWord "(") (isWord ")") (parens False p) +parens False p = parens True p `onFail` p + +-- | Deal with named field syntax. The string argument is the field name, +-- and the parser returns the value of the field. +field :: Parse a => String -> TextParser a +field name = do { isWord name; commit $ do { isWord "="; parse } } + +-- | 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. +constructors :: [(String,TextParser a)] -> TextParser a +constructors cs = oneOf' (map cons cs) + where cons (name,p) = + ( name + , do { isWord name + ; p `adjustErrBad` (("got constructor, but within " + ++name++",\n")++) + } + ) + +-- | 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. +enumeration :: (Show a) => String -> [a] -> TextParser a +enumeration typ cs = oneOf (map (\c-> do { isWord (show c); return c }) cs) + `adjustErr` + (++("\n expected "++typ++" value ("++e++")")) + where e = concat (intersperse ", " (map show (init cs))) + ++ ", or " ++ show (last cs) + +------------------------------------------------------------------------ +-- Instances for all the Standard Prelude types. + +-- Numeric types +parseSigned :: Real a => TextParser a -> TextParser a +parseSigned p = do '-' <- next; commit (fmap negate p) + `onFail` + do p + +parseInt :: (Integral a) => String -> + a -> (Char -> Bool) -> (Char -> Int) -> + TextParser a +parseInt base radix isDigit digitToInt = + do cs <- many1 (satisfy isDigit) + return (foldl1 (\n d-> n*radix+d) + (map (fromIntegral.digitToInt) cs)) + `adjustErr` (++("\nexpected one or more "++base++" digits")) +parseDec, parseOct, parseHex :: (Integral a) => TextParser a +parseDec = parseInt "decimal" 10 Char.isDigit Char.digitToInt +parseOct = parseInt "octal" 8 Char.isOctDigit Char.digitToInt +parseHex = parseInt "hex" 16 Char.isHexDigit Char.digitToInt + +-- | parseUnsignedInteger uses the underlying ByteString readInteger, so +-- will be a lot faster than the generic character-by-character parseInt. +parseUnsignedInteger :: TextParser Integer +parseUnsignedInteger = P (\bs -> case BS.uncons bs of + Just (c, _) + | Char.isDigit c -> + case BS.readInteger bs of + Just (i, bs') -> Success bs' i + Nothing -> error "XXX Can't happen" + _ -> Failure bs "parsing Integer: not a digit") + `adjustErr` (++("\nexpected one or more decimal digits")) + + +parseFloat :: (RealFrac a) => TextParser a +parseFloat = do ds <- many1 (satisfy isDigit) + frac <- (do '.' <- next + many (satisfy isDigit) + `adjustErrBad` (++"expected digit after .") + `onFail` return [] ) + exp <- exponent `onFail` return 0 + ( return . fromRational . (* (10^^(exp - length frac))) + . (%1) . (\ (Right x)->x) . fst + . runParser parseDec ) (BS.pack (ds++frac)) + `onFail` + do w <- many (satisfy (not.isSpace)) + case map toLower w of + "nan" -> return (0/0) + "infinity" -> return (1/0) + _ -> fail "expected a floating point number" + where exponent = do 'e' <- fmap toLower next + commit (do '+' <- next; parseDec + `onFail` + parseSigned parseDec ) + +parseLitChar :: TextParser Char +parseLitChar = do '\'' <- next `adjustErr` (++"expected a literal char") + c <- next + char <- case c of + '\\' -> next >>= escape + '\'' -> fail "expected a literal char, got ''" + _ -> return c + '\'' <- next `adjustErrBad` (++"literal char has no final '") + return char + where + escape 'a' = return '\a' + escape 'b' = return '\b' + escape 'f' = return '\f' + escape 'n' = return '\n' + escape 'r' = return '\r' + escape 't' = return '\t' + escape 'v' = return '\v' + escape '\\' = return '\\' + escape '"' = return '"' + escape '\'' = return '\'' + escape '^' = do ctrl <- next + if ctrl >= '@' && ctrl <= '_' + then return (chr (ord ctrl - ord '@')) + else fail ("literal char ctrl-escape malformed: \\^" + ++[ctrl]) + escape d | isDigit d + = fmap chr $ (reparse (BS.pack [d]) >> parseDec) + escape 'o' = fmap chr $ parseOct + escape 'x' = fmap chr $ parseHex + escape c | isUpper c + = mnemonic c + escape c = fail ("unrecognised escape sequence in literal char: \\"++[c]) + + mnemonic 'A' = do 'C' <- next; 'K' <- next; return '\ACK' + `wrap` "'\\ACK'" + mnemonic 'B' = do 'E' <- next; 'L' <- next; return '\BEL' + `onFail` + do 'S' <- next; return '\BS' + `wrap` "'\\BEL' or '\\BS'" + mnemonic 'C' = do 'R' <- next; return '\CR' + `onFail` + do 'A' <- next; 'N' <- next; return '\CAN' + `wrap` "'\\CR' or '\\CAN'" + mnemonic 'D' = do 'E' <- next; 'L' <- next; return '\DEL' + `onFail` + do 'L' <- next; 'E' <- next; return '\DLE' + `onFail` + do 'C' <- next; ( do '1' <- next; return '\DC1' + `onFail` + do '2' <- next; return '\DC2' + `onFail` + do '3' <- next; return '\DC3' + `onFail` + do '4' <- next; return '\DC4' ) + `wrap` "'\\DEL' or '\\DLE' or '\\DC[1..4]'" + mnemonic 'E' = do 'T' <- next; 'X' <- next; return '\ETX' + `onFail` + do 'O' <- next; 'T' <- next; return '\EOT' + `onFail` + do 'N' <- next; 'Q' <- next; return '\ENQ' + `onFail` + do 'T' <- next; 'B' <- next; return '\ETB' + `onFail` + do 'M' <- next; return '\EM' + `onFail` + do 'S' <- next; 'C' <- next; return '\ESC' + `wrap` "one of '\\ETX' '\\EOT' '\\ENQ' '\\ETB' '\\EM' or '\\ESC'" + mnemonic 'F' = do 'F' <- next; return '\FF' + `onFail` + do 'S' <- next; return '\FS' + `wrap` "'\\FF' or '\\FS'" + mnemonic 'G' = do 'S' <- next; return '\GS' + `wrap` "'\\GS'" + mnemonic 'H' = do 'T' <- next; return '\HT' + `wrap` "'\\HT'" + mnemonic 'L' = do 'F' <- next; return '\LF' + `wrap` "'\\LF'" + mnemonic 'N' = do 'U' <- next; 'L' <- next; return '\NUL' + `onFail` + do 'A' <- next; 'K' <- next; return '\NAK' + `wrap` "'\\NUL' or '\\NAK'" + mnemonic 'R' = do 'S' <- next; return '\RS' + `wrap` "'\\RS'" + mnemonic 'S' = do 'O' <- next; 'H' <- next; return '\SOH' + `onFail` + do 'O' <- next; return '\SO' + `onFail` + do 'T' <- next; 'X' <- next; return '\STX' + `onFail` + do 'I' <- next; return '\SI' + `onFail` + do 'Y' <- next; 'N' <- next; return '\SYN' + `onFail` + do 'U' <- next; 'B' <- next; return '\SUB' + `onFail` + do 'P' <- next; return '\SP' + `wrap` "'\\SOH' '\\SO' '\\STX' '\\SI' '\\SYN' '\\SUB' or '\\SP'" + mnemonic 'U' = do 'S' <- next; return '\US' + `wrap` "'\\US'" + mnemonic 'V' = do 'T' <- next; return '\VT' + `wrap` "'\\VT'" + wrap p s = p `onFail` fail ("expected literal char "++s) + +-- Basic types +instance Parse Int where + parse = fmap fromInteger $ -- convert from Integer, deals with minInt + do many (satisfy isSpace); parseSigned parseUnsignedInteger +instance Parse Integer where + parse = do many (satisfy isSpace); parseSigned parseUnsignedInteger +instance Parse Float where + parse = do many (satisfy isSpace); parseSigned parseFloat +instance Parse Double where + parse = do many (satisfy isSpace); parseSigned parseFloat +instance Parse Char where + parse = do many (satisfy isSpace); parseLitChar + -- not totally correct for strings... + parseList = do { w <- word; if head w == '"' then return (init (tail w)) + else fail "not a string" } + +instance Parse Bool where + parse = enumeration "Bool" [False,True] + +instance Parse Ordering where + parse = enumeration "Ordering" [LT,EQ,GT] + +-- Structural types +instance Parse () where + parse = P (p . BS.uncons) + where p Nothing = Failure BS.empty "no input: expected a ()" + p (Just ('(',cs)) = case BS.uncons (BS.dropWhile isSpace cs) of + Just (')',s) -> Success s () + _ -> Failure cs "Expected ) after (" + p (Just (c,cs)) | isSpace c = p (BS.uncons cs) + | otherwise = Failure (BS.cons c cs) + ("Expected a (), got "++show c) + +instance (Parse a, Parse b) => Parse (a,b) where + parse = do{ isWord "(" `adjustErr` ("Opening a 2-tuple\n"++) + ; x <- parse `adjustErr` ("In 1st item of a 2-tuple\n"++) + ; isWord "," `adjustErr` ("Separating a 2-tuple\n"++) + ; y <- parse `adjustErr` ("In 2nd item of a 2-tuple\n"++) + ; isWord ")" `adjustErr` ("Closing a 2-tuple\n"++) + ; return (x,y) } + +instance (Parse a, Parse b, Parse c) => Parse (a,b,c) where + parse = do{ isWord "(" `adjustErr` ("Opening a 3-tuple\n"++) + ; x <- parse `adjustErr` ("In 1st item of a 3-tuple\n"++) + ; isWord "," `adjustErr` ("Separating(1) a 3-tuple\n"++) + ; y <- parse `adjustErr` ("In 2nd item of a 3-tuple\n"++) + ; isWord "," `adjustErr` ("Separating(2) a 3-tuple\n"++) + ; z <- parse `adjustErr` ("In 3rd item of a 3-tuple\n"++) + ; isWord ")" `adjustErr` ("Closing a 3-tuple\n"++) + ; return (x,y,z) } + +instance Parse a => Parse (Maybe a) where + parsePrec p = + optionalParens (do { isWord "Nothing"; return Nothing }) + `onFail` + parens (p>9) (do { isWord "Just" + ; fmap Just $ parsePrec 10 + `adjustErrBad` ("but within Just, "++) }) + `adjustErr` (("expected a Maybe (Just or Nothing)\n"++).indent 2) + +instance (Parse a, Parse b) => Parse (Either a b) where + parsePrec p = + parens (p>9) $ + constructors [ ("Left", do { fmap Left $ parsePrec 10 } ) + , ("Right", do { fmap Right $ parsePrec 10 } ) + ] + +instance Parse a => Parse [a] where + parse = parseList + +------------------------------------------------------------------------ +-- ByteStrings as a whole entity. + +-- | Simply return the remaining input ByteString. +allAsByteString :: TextParser ByteString +allAsByteString = P (\bs-> Success BS.empty bs) + +-- | Simply return the remaining input as a String. +allAsString :: TextParser String +allAsString = fmap BS.unpack allAsByteString + +------------------------------------------------------------------------ +
+ diff --git a/docs/haddock/src/Text/ParserCombinators/HuttonMeijer.html b/docs/haddock/src/Text/ParserCombinators/HuttonMeijer.html new file mode 100644 --- /dev/null +++ b/docs/haddock/src/Text/ParserCombinators/HuttonMeijer.html @@ -0,0 +1,222 @@ + + +----------------------------------------------------------------------------- +-- | +-- Module : Text.ParserCombinators.HuttonMeijer +-- Copyright : Graham Hutton (University of Nottingham), Erik Meijer (University of Utrecht) +-- Licence : BSD +-- +-- Maintainer : Malcolm Wallace <Malcolm.Wallace@cs.york.ac.uk> +-- Stability : Stable +-- Portability : All +-- +-- A LIBRARY OF MONADIC PARSER COMBINATORS +-- +-- 29th July 1996 +-- +-- Graham Hutton Erik Meijer +-- University of Nottingham University of Utrecht +-- +-- This Haskell script defines a library of parser combinators, and is +-- taken from sections 1-6 of our article "Monadic Parser Combinators". +-- Some changes to the library have been made in the move from Gofer +-- to Haskell: +-- +-- * Do notation is used in place of monad comprehension notation; +-- +-- * The parser datatype is defined using "newtype", to avoid the overhead +-- of tagging and untagging parsers with the P constructor. +----------------------------------------------------------------------------- + + +module Text.ParserCombinators.HuttonMeijer + (Parser(..), item, first, papply, (+++), sat, {-tok,-} many, many1, + sepby, sepby1, chainl, + chainl1, chainr, chainr1, ops, bracket, char, digit, lower, upper, + letter, alphanum, string, ident, nat, int, spaces, comment, junk, + skip, token, natural, integer, symbol, identifier) where + +import Char +import Monad + +infixr 5 +++ + +type Token = Char + +--------------------------------------------------------- +-- | The parser monad + +newtype Parser a = P ([Token] -> [(a,[Token])]) + +instance Functor Parser where + -- map :: (a -> b) -> (Parser a -> Parser b) + fmap f (P p) = P (\inp -> [(f v, out) | (v,out) <- p inp]) + +instance Monad Parser where + -- return :: a -> Parser a + return v = P (\inp -> [(v,inp)]) + + -- >>= :: Parser a -> (a -> Parser b) -> Parser b + (P p) >>= f = P (\inp -> concat [papply (f v) out | (v,out) <- p inp]) + + -- fail :: String -> Parser a + fail _ = P (\_ -> []) + +instance MonadPlus Parser where + -- mzero :: Parser a + mzero = P (\_ -> []) + + -- mplus :: Parser a -> Parser a -> Parser a + (P p) `mplus` (P q) = P (\inp -> (p inp ++ q inp)) + +-- ------------------------------------------------------------ +-- * Other primitive parser combinators +-- ------------------------------------------------------------ + +item :: Parser Token +item = P (\inp -> case inp of + [] -> [] + (x:xs) -> [(x,xs)]) + +first :: Parser a -> Parser a +first (P p) = P (\inp -> case p inp of + [] -> [] + (x:_) -> [x]) + +papply :: Parser a -> [Token] -> [(a,[Token])] +papply (P p) inp = p inp + +-- ------------------------------------------------------------ +-- * Derived combinators +-- ------------------------------------------------------------ + +(+++) :: Parser a -> Parser a -> Parser a +p +++ q = first (p `mplus` q) + +sat :: (Token -> Bool) -> Parser Token +sat p = do {x <- item; if p x then return x else mzero} + +--tok :: Token -> Parser Token +--tok t = do {x <- item; if t==snd x then return t else mzero} + +many :: Parser a -> Parser [a] +many p = many1 p +++ return [] +--many p = force (many1 p +++ return []) + +many1 :: Parser a -> Parser [a] +many1 p = do {x <- p; xs <- many p; return (x:xs)} + +sepby :: Parser a -> Parser b -> Parser [a] +p `sepby` sep = (p `sepby1` sep) +++ return [] + +sepby1 :: Parser a -> Parser b -> Parser [a] +p `sepby1` sep = do {x <- p; xs <- many (do {sep; p}); return (x:xs)} + +chainl :: Parser a -> Parser (a -> a -> a) -> a -> Parser a +chainl p op v = (p `chainl1` op) +++ return v + +chainl1 :: Parser a -> Parser (a -> a -> a) -> Parser a +p `chainl1` op = do {x <- p; rest x} + where + rest x = do {f <- op; y <- p; rest (f x y)} + +++ return x + +chainr :: Parser a -> Parser (a -> a -> a) -> a -> Parser a +chainr p op v = (p `chainr1` op) +++ return v + +chainr1 :: Parser a -> Parser (a -> a -> a) -> Parser a +p `chainr1` op = do {x <- p; rest x} + where + rest x = do {f <- op; y <- p `chainr1` op; return (f x y)} + +++ return x + +ops :: [(Parser a, b)] -> Parser b +ops xs = foldr1 (+++) [do {p; return op} | (p,op) <- xs] + +bracket :: Parser a -> Parser b -> Parser c -> Parser b +bracket open p close = do {open; x <- p; close; return x} + +-- ------------------------------------------------------------ +-- * Useful parsers +-- ------------------------------------------------------------ + +char :: Char -> Parser Char +char x = sat (\y -> x == y) + +digit :: Parser Char +digit = sat isDigit + +lower :: Parser Char +lower = sat isLower + +upper :: Parser Char +upper = sat isUpper + +letter :: Parser Char +letter = sat isAlpha + +alphanum :: Parser Char +alphanum = sat isAlphaNum +++ char '_' + +string :: String -> Parser String +string "" = return "" +string (x:xs) = do {char x; string xs; return (x:xs)} + +ident :: Parser String +ident = do {x <- lower; xs <- many alphanum; return (x:xs)} + +nat :: Parser Int +nat = do {x <- digit; return (fromEnum x - fromEnum '0')} `chainl1` return op + where + m `op` n = 10*m + n + +int :: Parser Int +int = do {char '-'; n <- nat; return (-n)} +++ nat + +-- ------------------------------------------------------------ +-- * Lexical combinators +-- ------------------------------------------------------------ + +spaces :: Parser () +spaces = do {many1 (sat isSpace); return ()} + +comment :: Parser () +--comment = do {string "--"; many (sat (\x -> x /= '\n')); return ()} +--comment = do +-- _ <- string "--" +-- _ <- many (sat (\x -> x /= '\n')) +-- return () +comment = do + bracket (string "/*") (many item) (string "*/") + return () + +junk :: Parser () +junk = do {many (spaces +++ comment); return ()} + +skip :: Parser a -> Parser a +skip p = do {junk; p} + +token :: Parser a -> Parser a +token p = do {v <- p; junk; return v} + +-- ------------------------------------------------------------ +-- * Token parsers +-- ------------------------------------------------------------ + +natural :: Parser Int +natural = token nat + +integer :: Parser Int +integer = token int + +symbol :: String -> Parser String +symbol xs = token (string xs) + +identifier :: [String] -> Parser String +identifier ks = token (do {x <- ident; + if not (elem x ks) then return x + else return mzero}) + +------------------------------------------------------------------------------ +
+ diff --git a/docs/haddock/src/Text/ParserCombinators/HuttonMeijerWallace.html b/docs/haddock/src/Text/ParserCombinators/HuttonMeijerWallace.html new file mode 100644 --- /dev/null +++ b/docs/haddock/src/Text/ParserCombinators/HuttonMeijerWallace.html @@ -0,0 +1,301 @@ + + +{----------------------------------------------------------------------------- + + A LIBRARY OF MONADIC PARSER COMBINATORS + + 29th July 1996 + + Graham Hutton Erik Meijer + University of Nottingham University of Utrecht + +This Haskell 1.3 script defines a library of parser combinators, and is taken +from sections 1-6 of our article "Monadic Parser Combinators". Some changes +to the library have been made in the move from Gofer to Haskell: + + * Do notation is used in place of monad comprehension notation; + + * The parser datatype is defined using "newtype", to avoid the overhead + of tagging and untagging parsers with the P constructor. + +------------------------------------------------------------------------------ +** Extended to allow a symbol table/state to be threaded through the monad. +** Extended to allow a parameterised token type, rather than just strings. +** Extended to allow error-reporting. + +(Extensions: 1998-2000 Malcolm.Wallace@cs.york.ac.uk) +(More extensions: 2004 gk-haskell@ninebynine.org) + +------------------------------------------------------------------------------} + +-- | This library of monadic parser combinators is based on the ones +-- defined by Graham Hutton and Erik Meijer. It has been extended by +-- Malcolm Wallace to use an abstract token type (no longer just a +-- string) as input, and to incorporate state in the monad, useful +-- for symbol tables, macros, and so on. Basic facilities for error +-- reporting have also been added, and later extended by Graham Klyne +-- to return the errors through an @Either@ type, rather than just +-- calling @error@. + +module Text.ParserCombinators.HuttonMeijerWallace + ( + -- * The parser monad + Parser(..) + -- * Primitive parser combinators + , item, eof, papply, papply' + -- * Derived combinators + , (+++), {-sat,-} tok, nottok, many, many1 + , sepby, sepby1, chainl, chainl1, chainr, chainr1, ops, bracket + , toEOF + -- * Error handling + , elserror + -- * State handling + , stupd, stquery, stget + -- * Re-parsing + , reparse + ) where + +import Char +import Monad + +infixr 5 +++ + +--- The parser monad --------------------------------------------------------- + +type ParseResult s t e a = Either e [(a,s,[Either e t])] + +newtype Parser s t e a = P ( s -> [Either e t] -> ParseResult s t e a ) + -- ^ The parser type is parametrised on the types of the state @s@, + -- the input tokens @t@, error-type @e@, and the result value @a@. + -- The state and remaining input are threaded through the monad. + +instance Functor (Parser s t e) where + -- fmap :: (a -> b) -> (Parser s t e a -> Parser s t e b) + fmap f (P p) = P (\st inp -> case p st inp of + Right res -> Right [(f v, s, out) | (v,s,out) <- res] + Left err -> Left err + ) + +instance Monad (Parser s t e) where + -- return :: a -> Parser s t e a + return v = P (\st inp -> Right [(v,st,inp)]) + -- >>= :: Parser s t e a -> (a -> Parser s t e b) -> Parser s t e b + (P p) >>= f = P (\st inp -> case p st inp of + Right res -> foldr joinresults (Right []) + [ papply' (f v) s out | (v,s,out) <- res ] + Left err -> Left err + ) + -- fail :: String -> Parser s t e a + fail err = P (\st inp -> Right []) + -- I know it's counterintuitive, but we want no-parse, not an error. + +instance MonadPlus (Parser s t e) where + -- mzero :: Parser s t e a + mzero = P (\st inp -> Right []) + -- mplus :: Parser s t e a -> Parser s t e a -> Parser s t e a + (P p) `mplus` (P q) = P (\st inp -> joinresults (p st inp) (q st inp)) + +-- joinresults ensures that explicitly raised errors are dominant, +-- provided no parse has yet been found. The commented out code is +-- a slightly stricter specification of the real code. +joinresults :: ParseResult s t e a -> ParseResult s t e a -> ParseResult s t e a +{- +joinresults (Left p) (Left q) = Left p +joinresults (Left p) (Right _) = Left p +joinresults (Right []) (Left q) = Left q +joinresults (Right p) (Left q) = Right p +joinresults (Right p) (Right q) = Right (p++q) +-} +joinresults (Left p) q = Left p +joinresults (Right []) q = q +joinresults (Right p) q = Right (p++ case q of Left _ -> [] + Right r -> r) + + +--- Primitive parser combinators --------------------------------------------- + +-- | Deliver the first remaining token. +item :: Parser s t e t +item = P (\st inp -> case inp of + [] -> Right [] + (Left e: _) -> Left e + (Right x: xs) -> Right [(x,st,xs)] + ) + +-- | Fail if end of input is not reached +eof :: Show p => Parser s (p,t) String () +eof = P (\st inp -> case inp of + [] -> Right [((),st,[])] + (Left e:_) -> Left e + (Right (p,_):_) -> Left ("End of input expected at " + ++show p++"\n but found text") + ) + +{- +-- | Ensure the value delivered by the parser is evaluated to WHNF. +force :: Parser s t e a -> Parser s t e a +force (P p) = P (\st inp -> let Right xs = p st inp + h = head xs in + h `seq` Right (h: tail xs) + ) +-- [[[GK]]] ^^^^^^ +-- WHNF = Weak Head Normal Form, meaning that it has no top-level redex. +-- In this case, I think that means that the first element of the list +-- is fully evaluated. +-- +-- NOTE: the original form of this function fails if there is no parse +-- result for p st inp (head xs fails if xs is null), so the modified +-- form can assume a Right value only. +-- +-- Why is this needed? +-- It's not exported, and the only use of this I see is commented out. +--------------------------------------- +-} + + +-- | Deliver the first parse result only, eliminating any backtracking. +first :: Parser s t e a -> Parser s t e a +first (P p) = P (\st inp -> case p st inp of + Right (x:xs) -> Right [x] + otherwise -> otherwise + ) + +-- | Apply the parser to some real input, given an initial state value. +-- If the parser fails, raise 'error' to halt the program. +-- (This is the original exported behaviour - to allow the caller to +-- deal with the error differently, see @papply'@.) +papply :: Parser s t String a -> s -> [Either String t] + -> [(a,s,[Either String t])] +papply (P p) st inp = either error id (p st inp) + +-- | Apply the parser to some real input, given an initial state value. +-- If the parser fails, return a diagnostic message to the caller. +papply' :: Parser s t e a -> s -> [Either e t] + -> Either e [(a,s,[Either e t])] +papply' (P p) st inp = p st inp + +--- Derived combinators ------------------------------------------------------ + +-- | A choice between parsers. Keep only the first success. +(+++) :: Parser s t e a -> Parser s t e a -> Parser s t e a +p +++ q = first (p `mplus` q) + +-- | Deliver the first token if it satisfies a predicate. +sat :: (t -> Bool) -> Parser s (p,t) e t +sat p = do {(_,x) <- item; if p x then return x else mzero} + +-- | Deliver the first token if it equals the argument. +tok :: Eq t => t -> Parser s (p,t) e t +tok t = do {(_,x) <- item; if x==t then return t else mzero} + +-- | Deliver the first token if it does not equal the argument. +nottok :: Eq t => [t] -> Parser s (p,t) e t +nottok ts = do {(_,x) <- item; if x `notElem` ts then return x + else mzero} + +-- | Deliver zero or more values of @a@. +many :: Parser s t e a -> Parser s t e [a] +many p = many1 p +++ return [] +--many p = force (many1 p +++ return []) + +-- | Deliver one or more values of @a@. +many1 :: Parser s t e a -> Parser s t e [a] +many1 p = do {x <- p; xs <- many p; return (x:xs)} + +-- | Deliver zero or more values of @a@ separated by @b@'s. +sepby :: Parser s t e a -> Parser s t e b -> Parser s t e [a] +p `sepby` sep = (p `sepby1` sep) +++ return [] + +-- | Deliver one or more values of @a@ separated by @b@'s. +sepby1 :: Parser s t e a -> Parser s t e b -> Parser s t e [a] +p `sepby1` sep = do {x <- p; xs <- many (do {sep; p}); return (x:xs)} + +chainl :: Parser s t e a -> Parser s t e (a->a->a) -> a + -> Parser s t e a +chainl p op v = (p `chainl1` op) +++ return v + +chainl1 :: Parser s t e a -> Parser s t e (a->a->a) -> Parser s t e a +p `chainl1` op = do {x <- p; rest x} + where + rest x = do {f <- op; y <- p; rest (f x y)} + +++ return x + +chainr :: Parser s t e a -> Parser s t e (a->a->a) -> a + -> Parser s t e a +chainr p op v = (p `chainr1` op) +++ return v + +chainr1 :: Parser s t e a -> Parser s t e (a->a->a) -> Parser s t e a +p `chainr1` op = do {x <- p; rest x} + where + rest x = do { f <- op + ; y <- p `chainr1` op + ; return (f x y) + } + +++ return x + +ops :: [(Parser s t e a, b)] -> Parser s t e b +ops xs = foldr1 (+++) [do {p; return op} | (p,op) <- xs] + +bracket :: (Show p,Show t) => + Parser s (p,t) e a -> Parser s (p,t) e b -> + Parser s (p,t) e c -> Parser s (p,t) e b +bracket open p close = do { open + ; x <- p + ; close -- `elserror` "improperly matched construct"; + ; return x + } + +-- | Accept a complete parse of the input only, no partial parses. +toEOF :: Show p => + Parser s (p,t) String a -> Parser s (p,t) String a +toEOF p = do { x <- p; eof; return x } + + +--- Error handling ----------------------------------------------------------- + +-- | Return an error using the supplied diagnostic string, and a token type +-- which includes position information. +parseerror :: (Show p,Show t) => String -> Parser s (p,t) String a +parseerror err = P (\st inp -> + case inp of + [] -> Left "Parse error: unexpected EOF\n" + (Left e:_) -> Left ("Lexical error: "++e) + (Right (p,t):_) -> + Left ("Parse error: in "++show p++"\n " + ++err++"\n "++"Found "++show t) + ) + + +-- | If the parser fails, generate an error message. +elserror :: (Show p,Show t) => Parser s (p,t) String a -> String + -> Parser s (p,t) String a +p `elserror` s = p +++ parseerror s + +--- State handling ----------------------------------------------------------- + +-- | Update the internal state. +stupd :: (s->s) -> Parser s t e () +stupd f = P (\st inp-> {-let newst = f st in newst `seq`-} + Right [((), f st, inp)]) + +-- | Query the internal state. +stquery :: (s->a) -> Parser s t e a +stquery f = P (\st inp-> Right [(f st, st, inp)]) + +-- | Deliver the entire internal state. +stget :: Parser s t e s +stget = P (\st inp-> Right [(st, st, inp)]) + + +--- Push some tokens back onto the input stream and reparse ------------------ + +-- | This is useful for recursively expanding macros. When the +-- user-parser recognises a macro use, it can lookup the macro +-- expansion from the parse state, lex it, and then stuff the +-- lexed expansion back down into the parser. +reparse :: [Either e t] -> Parser s t e () +reparse ts = P (\st inp-> Right [((), st, ts++inp)]) + +------------------------------------------------------------------------------ +
+ diff --git a/docs/haddock/src/Text/ParserCombinators/Poly.html b/docs/haddock/src/Text/ParserCombinators/Poly.html new file mode 100644 --- /dev/null +++ b/docs/haddock/src/Text/ParserCombinators/Poly.html @@ -0,0 +1,9 @@ + + +module Text.ParserCombinators.Poly + ( module Text.ParserCombinators.Poly.Plain + ) where + +import Text.ParserCombinators.Poly.Plain +
+ diff --git a/docs/haddock/src/Text/ParserCombinators/Poly/Base.html b/docs/haddock/src/Text/ParserCombinators/Poly/Base.html new file mode 100644 --- /dev/null +++ b/docs/haddock/src/Text/ParserCombinators/Poly/Base.html @@ -0,0 +1,199 @@ + + +module Text.ParserCombinators.Poly.Base + ( -- * The PolyParse class + PolyParse(..) -- class of all monadic two-level-error parsers + + -- * Combinators general to all parser types. + -- ** Simple combinators + , discard -- :: PolyParse p => p a -> p b -> p a + -- ** Error-handling + , failBad -- :: PolyParse p => String -> p a + , adjustErrBad-- :: PolyParse p => p a -> (String->String) -> p a + , indent -- :: Int -> String -> String + -- ** Choices + , oneOf -- :: PolyParse p => [p a] -> p a + , optional -- :: PolyParse p => p a -> p (Maybe a) + -- ** Sequences + , exactly -- :: PolyParse p => Int -> p a -> p [a] + , many -- :: PolyParse p => p a -> p [a] + , many1 -- :: PolyParse p => p a -> p [a] + , sepBy -- :: PolyParse p => p a -> p sep -> p [a] + , sepBy1 -- :: PolyParse p => p a -> p sep -> p [a] + , bracketSep -- :: PolyParse p => p bra -> p sep -> p ket -> p a -> p [a] + , bracket -- :: PolyParse p => p bra -> p ket -> p a -> p a + , manyFinally -- :: PolyParse p => p a -> p z -> p [a] + ) where + +#ifdef __NHC__ +default (Integer,Double,[]) -- hack to avoid bizarre type defaulting error +instance PolyParse [] +#endif + +-- | The @PolyParse@ class is an abstraction over all the current +-- concrete representations of monadic parser combinators in this +-- package. The common feature is two-level error-handling. +-- Some primitives must be implemented specific to each parser type +-- (e.g. depending on whether the parser has a running state, or +-- whether it is lazy). But given those primitives, large numbers of +-- combinators do not depend any further on the internal structure of +-- the particular parser. +-- +-- There are two additional basic combinators that we expect to be implemented +-- afresh for every concrete type, but which (for technical reasons) +-- cannot be class methods. They are @next@ and @satisfy@. +class (Functor p, Monad p) => PolyParse p where + -- | Commit is a way of raising the severity of any errors found within + -- its argument. Used in the middle of a parser definition, it means that + -- any operations prior to commitment fail softly, but after commitment, + -- they fail hard. + commit :: p a -> p a + -- | @p `adjustErr` f@ applies the transformation @f@ to any error message + -- generated in @p@, having no effect if @p@ succeeds. + adjustErr :: p a -> (String -> String) -> p a + -- | @p `onFail` q@ means parse p, unless p fails, in which case + -- parse q instead. + -- Can be chained together to give multiple attempts to parse something. + -- (Note that q could itself be a failing parser, e.g. to change the error + -- message from that defined in p to something different.) + -- However, a severe failure in p cannot be ignored. + onFail :: p a -> p a -> p a + -- | Parse the first alternative that succeeds, but if none succeed, + -- report only the severe errors, and if none of those, then report + -- all the soft errors. + oneOf' :: [(String, p a)] -> p a + -- | Apply a parsed function to a parsed value. + -- Rather like ordinary function application lifted into parsers. + apply :: p (a->b) -> p a -> p b + pf `apply` px = do { f <- pf; x <- px; return (f x) } + -- note: the Poly.Lazy variants override this defn with a lazier one. + +infixl 6 `onFail` -- not sure about precedence 6? +infixl 3 `apply` +infixl 3 `discard` + +{- +-- Combinators we expect most concrete parser types to implement. +-- For technical reasons, they cannot be class members. + +-- | Yield the next token +next :: PolyParse p => p t + -- where t is constrained to be the input token type + +-- | One token satisfying a predicate. +satisfy :: PolyParse p => (t->Bool) -> p t t +satisfy p = do{ x <- next + ; if p x then return x else fail "Parse.satisfy: failed" + } + -- note: must be re-defined for each implementation because + -- its type cannot be expressed otherwise. +-} + +-- | When a simple fail is not strong enough, use failBad for emphasis. +-- An emphasised (severe) error cannot be overridden by choice +-- operators. +failBad :: PolyParse p => String -> p a +failBad e = commit (fail e) + +-- | @x `discard` y@ parses both x and y, but discards the result of y. +-- Rather like @const@ lifted into parsers. +discard :: PolyParse p => p a -> p b -> p a +px `discard` py = do { x <- px; py; return x; } + +-- | @adjustErrBad@ is just like @adjustErr@ except it also raises the +-- severity of the error. +adjustErrBad :: PolyParse p => p a -> (String->String) -> p a +p `adjustErrBad` f = commit (p `adjustErr` f) + +-- | Parse the first alternative in the list that succeeds. +oneOf :: PolyParse p => [p a] -> p a +oneOf [] = fail ("failed to parse any of the possible choices") +oneOf (p:ps) = p `onFail` oneOf ps +--oneOf :: Show t => [Parser t a] -> Parser t a +--oneOf [] = do { n <- next +-- ; fail ("failed to parse any of the possible choices" +-- ++"\n next token is "++show n) +-- } +--oneOf (p:ps) = p `onFail` oneOf ps + +-- | Helper for formatting error messages: indents all lines by a fixed amount. +indent :: Int -> String -> String +indent n = unlines . map (replicate n ' ' ++) . lines + +-- | 'optional' indicates whether the parser succeeded through the Maybe type. +optional :: PolyParse p => p a -> p (Maybe a) +optional p = fmap Just p `onFail` return Nothing + +-- | 'exactly n p' parses precisely n items, using the parser p, in sequence. +exactly :: PolyParse p => Int -> p a -> p [a] +exactly 0 p = return [] +exactly n p = return (:) `apply` (p `adjustErr` (("When expecting exactly " + ++show n++" more items")++)) + `apply` exactly (n-1) p + +-- | 'many p' parses a list of elements with individual parser p. +-- Cannot fail, since an empty list is a valid return value. +many :: PolyParse p => p a -> p [a] +many p = many1 p `onFail` return [] + +-- | Parse a non-empty list of items. +many1 :: PolyParse p => p a -> p [a] +many1 p = do { x <- p `adjustErr` (("In a sequence:\n"++). indent 2) + ; return (x:) `apply` many p + } +-- `adjustErr` ("When looking for a non-empty sequence:\n\t"++) + +-- | Parse a list of items separated by discarded junk. +sepBy :: PolyParse p => p a -> p sep -> p [a] +sepBy p sep = do sepBy1 p sep `onFail` return [] + +-- | Parse a non-empty list of items separated by discarded junk. +sepBy1 :: PolyParse p => p a -> p sep -> p [a] +sepBy1 p sep = do { x <- p + ; return (x:) `apply` many (do {sep; p}) + } + `adjustErr` ("When looking for a non-empty sequence with separators:\n\t"++) + +-- | Parse a list of items, discarding the start, end, and separator +-- items. +bracketSep :: PolyParse p => p bra -> p sep -> p ket -> p a -> p [a] +bracketSep open sep close p = + do { open; close; return [] } + `onFail` + do { open `adjustErr` ("Missing opening bracket:\n\t"++) + ; x <- p `adjustErr` ("After first bracket in a group:\n\t"++) + ; return (x:) + `apply` manyFinally (do {sep; p}) + (close `adjustErrBad` ("When looking for closing bracket:\n\t"++)) + } + +-- | Parse a bracketed item, discarding the brackets. +bracket :: PolyParse p => p bra -> p ket -> p a -> p a +bracket open close p = do + do { open `adjustErr` ("Missing opening bracket:\n\t"++) + ; p `discard` (close `adjustErrBad` ("Missing closing bracket:\n\t"++)) + } + +-- | 'manyFinally e t' parses a possibly-empty sequence of e's, +-- terminated by a t. The final t is discarded. Any parse failures +-- could be due either to a badly-formed terminator or a badly-formed +-- element, so it raises both possible errors. +manyFinally :: PolyParse p => p a -> p z -> p [a] +manyFinally p t = + (many p `discard` t) + `onFail` + oneOf' [ ("sequence terminator", do { t; return [] } ) + , ("item in a sequence", do { p; return [] } ) + ] +{- +manyFinally p t = + do { xs <- many p + ; oneOf' [ ("sequence terminator", do { t; return () } ) + , ("item in a sequence", do { p; return () } ) + ] + ; return xs + } +-} +------------------------------------------------------------------------ +
+ diff --git a/docs/haddock/src/Text/ParserCombinators/Poly/ByteString.html b/docs/haddock/src/Text/ParserCombinators/Poly/ByteString.html new file mode 100644 --- /dev/null +++ b/docs/haddock/src/Text/ParserCombinators/Poly/ByteString.html @@ -0,0 +1,117 @@ + + +module Text.ParserCombinators.Poly.ByteString + ( -- * The Parser datatype + Parser(P) + , Result(..) + , runParser + -- ** basic parsers + , next + , eof + , satisfy + -- ** re-parsing + , reparse + -- * Re-export all more general combinators + , module Text.ParserCombinators.Poly.Base + ) where + + +import Text.ParserCombinators.Poly.Base +import qualified Data.ByteString.Lazy.Char8 as BS +import Data.ByteString.Lazy.Char8 (ByteString) + +-- | This @Parser@ datatype is a specialised parsing monad with error +-- reporting. Whereas the standard version can be used for arbitrary +-- token types, this version is specialised to ByteString input only. +newtype Parser a = P (ByteString -> Result ByteString a) + +-- | A return type like Either, that distinguishes not only between +-- right and wrong answers, but also has commitment, so that a failure +-- cannot be undone. This should only be used for writing very primitive +-- parsers - really it is an internal detail of the library. +data Result z a = Success z a + | Failure z String + | Committed (Result z a) + +instance Functor (Result z) where + fmap f (Success z a) = Success z (f a) + fmap _ (Failure z e) = Failure z e + fmap f (Committed r) = Committed (fmap f r) + +-- | Apply a parser to an input token sequence. +runParser :: Parser a -> ByteString -> (Either String a, ByteString) +runParser (P p) = resultToEither . p + where + resultToEither :: Result z a -> (Either String a, z) + resultToEither (Success z a) = (Right a, z) + resultToEither (Failure z e) = (Left e, z) + resultToEither (Committed r) = resultToEither r + +instance Functor Parser where + fmap f (P p) = P (fmap f . p) + +instance Monad Parser where + return x = P (\ts-> Success ts x) + fail e = P (\ts-> Failure ts e) + (P f) >>= g = P (continue . f) + where + continue (Success ts x) = let (P g') = g x in g' ts + continue (Committed (Committed r)) = continue (Committed r) + continue (Committed r) = Committed (continue r) + continue (Failure ts e) = Failure ts e + +instance PolyParse Parser where + commit (P p) = P (Committed . p) + (P p) `adjustErr` f = P (adjust . p) + where + adjust (Failure z e) = Failure z (f e) + adjust (Committed r) = Committed (adjust r) + adjust good = good + + (P p) `onFail` (P q) = P (\ts-> continue ts $ p ts) + where + continue ts (Failure _ _) = q ts + -- continue _ (Committed r) = r -- no, remain Committed + continue _ r = r + + oneOf' = accum [] + where accum errs [] = + fail ("failed to parse any of the possible choices:\n" + ++indent 2 (concatMap showErr (reverse errs))) + accum errs ((e,P p):ps) = + P (\ts-> case p ts of + Failure _ err -> + let (P p') = accum ((e,err):errs) ps + in p' ts + r@(Success _ _) -> r + r@(Committed _) -> r ) + showErr (name,err) = name++":\n"++indent 2 err + +------------------------------------------------------------------------ +next :: Parser Char +next = P (\bs-> case BS.uncons bs of + Nothing -> Failure bs "Ran out of input (EOF)" + Just (c, bs') -> Success bs' c ) + +eof :: Parser () +eof = P (\bs -> if BS.null bs + then Success bs () + else Failure bs "Expected end of input (EOF)" ) + +satisfy :: (Char -> Bool) -> Parser Char +satisfy f = do { x <- next + ; if f x then return x else fail "Parse.satisfy: failed" + } + +------------------------------------------------------------------------ +-- | Push some tokens back onto the front of the input stream and reparse. +-- This is useful e.g. for recursively expanding macros. When the +-- user-parser recognises a macro use, it can lookup the macro +-- expansion from the parse state, lex it, and then stuff the +-- lexed expansion back down into the parser. +reparse :: ByteString -> Parser () +reparse ts = P (\inp-> Success (ts `BS.append` inp) ()) + +------------------------------------------------------------------------ +
+ diff --git a/docs/haddock/src/Text/ParserCombinators/Poly/Lazy.html b/docs/haddock/src/Text/ParserCombinators/Poly/Lazy.html new file mode 100644 --- /dev/null +++ b/docs/haddock/src/Text/ParserCombinators/Poly/Lazy.html @@ -0,0 +1,139 @@ + + +module Text.ParserCombinators.Poly.Lazy + ( -- * The Parser datatype + Parser(P) -- datatype, instance of: Functor, Monad, PolyParse + , Result(..) -- internal to the parser monad + , runParser -- :: Parser t a -> [t] -> (Either String a, [t]) + -- ** basic parsers + , next -- :: Parser t t + , eof -- :: Parser t () + , satisfy -- :: (t->Bool) -> Parser t t + + -- ** re-parsing + , reparse -- :: [t] -> Parser t () + -- * Re-export all more general combinators + , module Text.ParserCombinators.Poly.Base + ) where + + +import Text.ParserCombinators.Poly.Base + +#if __GLASGOW_HASKELL__ +import Control.Exception hiding (bracket) +throwE :: String -> a +throwE msg = throw (ErrorCall msg) +#else +throwE :: String -> a +throwE msg = error msg +#endif + + +-- | This @Parser@ datatype is a fairly generic parsing monad with error +-- reporting. It can be used for arbitrary token types, not just +-- String input. (If you require a running state, use module PolyState +-- instead) +newtype Parser t a = P ([t] -> Result [t] a) + +-- | A return type like Either, that distinguishes not only between +-- right and wrong answers, but also has gradations of wrongness. +-- This should only be used for writing very primitive +-- parsers - really it is an internal detail of the library. +data Result z a = Success z a + | Failure z String + | Committed (Result z a) -- still needed + +instance Functor (Result z) where + fmap f (Success z a) = Success z (f a) + fmap f (Failure z e) = Failure z e + fmap f (Committed r) = Committed (fmap f r) + +-- | Apply a parser to an input token sequence. +runParser :: Parser t a -> [t] -> (a, [t]) +runParser (P p) = fromResult . p + where + fromResult :: Result z a -> (a, z) + fromResult (Success z a) = (a, z) + fromResult (Failure z e) = throwE e + fromResult (Committed r) = fromResult r + +instance Functor (Parser t) where + fmap f (P p) = P (fmap f . p) + +instance Monad (Parser t) where + return x = P (\ts-> Success ts x) + fail e = P (\ts-> Failure ts e) + (P f) >>= g = P (continue . f) + where + continue (Success ts x) = let (P g') = g x in g' ts + continue (Committed (Committed r)) = continue (Committed r) + continue (Committed r) = Committed (continue r) + continue (Failure ts e) = Failure ts e + +instance PolyParse (Parser t) where + commit (P p) = P (Committed . p) + (P p) `adjustErr` f = P (adjust . p) + where + adjust (Failure z e) = Failure z (f e) + adjust (Committed r) = Committed (adjust r) + adjust good = good + + (P p) `onFail` (P q) = P (\ts-> continue ts $ p ts) + where + continue ts (Failure z e) = q ts + -- continue _ (Committed r) = r -- no, remain Committed + continue _ r = r + + oneOf' = accum [] + where accum errs [] = + fail ("failed to parse any of the possible choices:\n" + ++indent 2 (concatMap showErr (reverse errs))) + accum errs ((e,P p):ps) = + P (\ts-> case p ts of + Failure _ err -> + let (P p) = accum ((e,err):errs) ps + in p ts + r@(Success z a) -> r + r@(Committed _) -> r ) + showErr (name,err) = name++":\n"++indent 2 err + + -- Apply a parsed function to a parsed value. This version + -- is strict in the result of the function parser, but + -- lazy in the result of the argument parser. (Argument laziness is + -- the distinctive feature over other implementations.) + (P pf) `apply` px = P (continue . pf) + where + continue (Success z f) = let (x,z') = runParser px z + in Success z' (f x) + continue (Committed r) = Committed (continue r) + continue (Failure z e) = Failure z e + + +------------------------------------------------------------------------ +next :: Parser t t +next = P (\ts-> case ts of + [] -> Failure [] "Ran out of input (EOF)" + (t:ts') -> Success ts' t ) + +eof :: Parser t () +eof = P (\ts-> case ts of + [] -> Success [] () + (t:ts') -> Failure ts "Expected end of input (EOF)" ) + +satisfy :: (t->Bool) -> Parser t t +satisfy pred = do { x <- next + ; if pred x then return x else fail "Parse.satisfy: failed" + } + +------------------------------------------------------------------------ +-- | Push some tokens back onto the front of the input stream and reparse. +-- This is useful e.g. for recursively expanding macros. When the +-- user-parser recognises a macro use, it can lookup the macro +-- expansion from the parse state, lex it, and then stuff the +-- lexed expansion back down into the parser. +reparse :: [t] -> Parser t () +reparse ts = P (\inp-> Success (ts++inp) ()) + +------------------------------------------------------------------------ +
+ diff --git a/docs/haddock/src/Text/ParserCombinators/Poly/Plain.html b/docs/haddock/src/Text/ParserCombinators/Poly/Plain.html new file mode 100644 --- /dev/null +++ b/docs/haddock/src/Text/ParserCombinators/Poly/Plain.html @@ -0,0 +1,117 @@ + + +module Text.ParserCombinators.Poly.Plain + ( -- * The Parser datatype + Parser(P) -- datatype, instance of: Functor, Monad, PolyParse + , Result(..) -- internal to the Parser Monad. + , runParser -- :: Parser t a -> [t] -> (Either String a, [t]) + -- ** basic parsers + , next -- :: Parser t t + , eof -- :: Parser t () + , satisfy -- :: (t->Bool) -> Parser t t + + -- ** re-parsing + , reparse -- :: [t] -> Parser t () + -- * Re-export all more general combinators + , module Text.ParserCombinators.Poly.Base + ) where + + +import Text.ParserCombinators.Poly.Base + +-- | This @Parser@ datatype is a fairly generic parsing monad with error +-- reporting. It can be used for arbitrary token types, not just +-- String input. (If you require a running state, use module PolyState +-- instead) +newtype Parser t a = P ([t] -> Result [t] a) + +-- | A return type like Either, that distinguishes not only between +-- right and wrong answers, but also has commitment, so that a failure +-- cannot be undone. This should only be used for writing very primitive +-- parsers - really it is an internal detail of the library. +data Result z a = Success z a + | Failure z String + | Committed (Result z a) + +instance Functor (Result z) where + fmap f (Success z a) = Success z (f a) + fmap f (Failure z e) = Failure z e + fmap f (Committed r) = Committed (fmap f r) + +-- | Apply a parser to an input token sequence. +runParser :: Parser t a -> [t] -> (Either String a, [t]) +runParser (P p) = resultToEither . p + where + resultToEither :: Result z a -> (Either String a, z) + resultToEither (Success z a) = (Right a, z) + resultToEither (Failure z e) = (Left e, z) + resultToEither (Committed r) = resultToEither r + +instance Functor (Parser t) where + fmap f (P p) = P (fmap f . p) + +instance Monad (Parser t) where + return x = P (\ts-> Success ts x) + fail e = P (\ts-> Failure ts e) + (P f) >>= g = P (continue . f) + where + continue (Success ts x) = let (P g') = g x in g' ts + continue (Committed (Committed r)) = continue (Committed r) + continue (Committed r) = Committed (continue r) + continue (Failure ts e) = Failure ts e + +instance PolyParse (Parser t) where + commit (P p) = P (Committed . p) + (P p) `adjustErr` f = P (adjust . p) + where + adjust (Failure z e) = Failure z (f e) + adjust (Committed r) = Committed (adjust r) + adjust good = good + + (P p) `onFail` (P q) = P (\ts-> continue ts $ p ts) + where + continue ts (Failure z e) = q ts + -- continue _ (Committed r) = r -- no, remain Committed + continue _ r = r + + oneOf' = accum [] + where accum errs [] = + fail ("failed to parse any of the possible choices:\n" + ++indent 2 (concatMap showErr (reverse errs))) + accum errs ((e,P p):ps) = + P (\ts-> case p ts of + Failure _ err -> + let (P p) = accum ((e,err):errs) ps + in p ts + r@(Success z a) -> r + r@(Committed _) -> r ) + showErr (name,err) = name++":\n"++indent 2 err + +------------------------------------------------------------------------ +next :: Parser t t +next = P (\ts-> case ts of + [] -> Failure [] "Ran out of input (EOF)" + (t:ts') -> Success ts' t ) + +eof :: Parser t () +eof = P (\ts-> case ts of + [] -> Success [] () + (t:ts') -> Failure ts "Expected end of input (EOF)" ) + +satisfy :: (t->Bool) -> Parser t t +satisfy pred = do { x <- next + ; if pred x then return x else fail "Parse.satisfy: failed" + } + +------------------------------------------------------------------------ +-- | Push some tokens back onto the front of the input stream and reparse. +-- This is useful e.g. for recursively expanding macros. When the +-- user-parser recognises a macro use, it can lookup the macro +-- expansion from the parse state, lex it, and then stuff the +-- lexed expansion back down into the parser. +reparse :: [t] -> Parser t () +reparse ts = P (\inp-> Success (ts++inp) ()) + +------------------------------------------------------------------------ +
+ diff --git a/docs/haddock/src/Text/ParserCombinators/Poly/State.html b/docs/haddock/src/Text/ParserCombinators/Poly/State.html new file mode 100644 --- /dev/null +++ b/docs/haddock/src/Text/ParserCombinators/Poly/State.html @@ -0,0 +1,136 @@ + + +module Text.ParserCombinators.Poly.State + ( -- * The Parser datatype + Parser(P) -- datatype, instance of: Functor, Monad, PolyParse + , Result(..) -- internal to the parser monad + , runParser -- :: Parser s t a -> s -> [t] -> (Either String a, s, [t]) + -- ** basic parsers + , next -- :: Parser s t t + , eof -- :: Parser s t () + , satisfy -- :: (t->Bool) -> Parser s t t + -- ** State-handling + , stUpdate -- :: (s->s) -> Parser s t () + , stQuery -- :: (s->a) -> Parser s t a + , stGet -- :: Parser s t s + -- ** re-parsing + , reparse -- :: [t] -> Parser s t () + -- * Re-export all more general combinators + , module Text.ParserCombinators.Poly.Base + ) where + + +import Text.ParserCombinators.Poly.Base + +-- | This @Parser@ datatype is a fairly generic parsing monad with error +-- reporting. It can be used for arbitrary token types, not just +-- String input. (If you require a running state, use module PolyState +-- instead) +newtype Parser s t a = P (s -> [t] -> Result [t] s a) + +-- | A return type like Either, that distinguishes not only between +-- right and wrong answers, but also has gradations of wrongness. +-- This should only be used for writing very primitive +-- parsers - really it is an internal detail of the library. +data Result z s a = Success z s a + | Failure z s String + | Committed (Result z s a) + +instance Functor (Result z s) where + fmap f (Success z s a) = Success z s (f a) + fmap f (Failure z s e) = Failure z s e + fmap f (Committed r) = Committed (fmap f r) + +-- | Apply a parser to an input token sequence. +runParser :: Parser s t a -> s -> [t] -> (Either String a, s, [t]) +runParser (P p) = \s-> resultToEither . p s + where + resultToEither :: Result z s a -> (Either String a, s, z) + resultToEither (Success z s a) = (Right a, s, z) + resultToEither (Failure z s e) = (Left e, s, z) + resultToEither (Committed r) = resultToEither r + +instance Functor (Parser s t) where + fmap f (P p) = P (\s-> fmap f . p s) + +instance Monad (Parser s t) where + return x = P (\s ts-> Success ts s x) + fail e = P (\s ts-> Failure ts s e) + (P f) >>= g = P (\s-> continue . f s) + where + continue (Success ts s x) = let (P g') = g x in g' s ts + continue (Committed (Committed r)) = continue (Committed r) + continue (Committed r) = Committed (continue r) + continue (Failure ts s e) = Failure ts s e + +instance PolyParse (Parser s t) where + commit (P p) = P (\s-> Committed . p s) + (P p) `adjustErr` f = P (\s-> adjust . p s) + where + adjust (Failure z s e) = Failure z s (f e) + adjust (Committed r) = Committed (adjust r) + adjust good = good + + (P p) `onFail` (P q) = P (\s ts-> continue s ts $ p s ts) + where + continue s ts (Failure _ _ _) = q s ts + -- continue _ _ (Committed r) = r -- no, remain Committed + continue _ _ r = r + + oneOf' = accum [] + where accum errs [] = + fail ("failed to parse any of the possible choices:\n" + ++indent 2 (concatMap showErr (reverse errs))) + accum errs ((e,P p):ps) = + P (\s ts-> case p s ts of + Failure _ _ err -> + let (P p) = accum ((e,err):errs) ps + in p s ts + r@(Success z _ a) -> r + r@(Committed _) -> r ) + showErr (name,err) = name++":\n"++indent 2 err + +------------------------------------------------------------------------ +next :: Parser s t t +next = P (\s ts-> case ts of + [] -> Failure [] s "Ran out of input (EOF)" + (t:ts') -> Success ts' s t ) + +eof :: Parser s t () +eof = P (\s ts-> case ts of + [] -> Success [] s () + (t:ts') -> Failure ts s "Expected end of input (eof)" ) + + +satisfy :: (t->Bool) -> Parser s t t +satisfy pred = do { x <- next + ; if pred x then return x else fail "Parse.satisfy: failed" + } +------------------------------------------------------------------------ +-- State handling + +-- | Update the internal state. +stUpdate :: (s->s) -> Parser s t () +stUpdate f = P (\s ts-> Success ts (f s) ()) + +-- | Query the internal state. +stQuery :: (s->a) -> Parser s t a +stQuery f = P (\s ts-> Success ts s (f s)) + +-- | Deliver the entire internal state. +stGet :: Parser s t s +stGet = P (\s ts-> Success ts s s) + + +------------------------------------------------------------------------ +-- | Push some tokens back onto the front of the input stream and reparse. +-- This is useful e.g. for recursively expanding macros. When the +-- user-parser recognises a macro use, it can lookup the macro +-- expansion from the parse state, lex it, and then stuff the +-- lexed expansion back down into the parser. +reparse :: [t] -> Parser s t () +reparse ts = P (\s inp-> Success (ts++inp) s ()) + +------------------------------------------------------------------------ +
+ diff --git a/docs/haddock/src/Text/ParserCombinators/Poly/StateLazy.html b/docs/haddock/src/Text/ParserCombinators/Poly/StateLazy.html new file mode 100644 --- /dev/null +++ b/docs/haddock/src/Text/ParserCombinators/Poly/StateLazy.html @@ -0,0 +1,185 @@ + + +module Text.ParserCombinators.Poly.StateLazy + ( -- * The Parser datatype + Parser(P) -- datatype, instance of: Functor, Monad, PolyParse + , Result(..) -- internal to the parser monad + , runParser -- :: Parser s t a -> s -> [t] -> (Either String a, s, [t]) + -- ** basic parsers + , next -- :: Parser s t t + , eof -- :: Parser s t () + , satisfy -- :: (t->Bool) -> Parser s t t + , manyFinally -- :: Parser s t a -> Parser s t z -> Parser s t [a] + -- ** State-handling + , stUpdate -- :: (s->s) -> Parser s t () + , stQuery -- :: (s->a) -> Parser s t a + , stGet -- :: Parser s t s + -- ** re-parsing + , reparse -- :: [t] -> Parser s t () + -- * Re-export all more general combinators + , module Text.ParserCombinators.Poly.Base + ) where + + +import Text.ParserCombinators.Poly.Base hiding (manyFinally) + +#if __GLASGOW_HASKELL__ +import Control.Exception hiding (bracket) +throwE :: String -> a +throwE msg = throw (ErrorCall msg) +#else +throwE :: String -> a +throwE msg = error msg +#endif + + +-- | This @Parser@ datatype is a fairly generic parsing monad with error +-- reporting. It can be used for arbitrary token types, not just +-- String input. (If you require a running state, use module PolyState +-- instead) +newtype Parser s t a = P (s -> [t] -> Result [t] s a) + +-- | A return type like Either, that distinguishes not only between +-- right and wrong answers, but also has gradations of wrongness. +-- This should only be used for writing very primitive +-- parsers - really it is an internal detail of the library. +data Result z s a = Success z s a + | Failure z s String + | Committed (Result z s a) + +instance Functor (Result z s) where + fmap f (Success z s a) = Success z s (f a) + fmap f (Failure z s e) = Failure z s e + fmap f (Committed r) = Committed (fmap f r) + +-- | Apply a parser to an input token sequence. +runParser :: Parser s t a -> s -> [t] -> (a, s, [t]) +runParser (P p) = \s -> fromResult . p s + where + fromResult :: Result z s a -> (a, s, z) + fromResult (Success z s a) = (a, s, z) + fromResult (Failure z s e) = throwE e + fromResult (Committed r) = fromResult r + +instance Functor (Parser s t) where + fmap f (P p) = P (\s -> fmap f . p s) + +instance Monad (Parser s t) where + return x = P (\s ts-> Success ts s x) + fail e = P (\s ts-> Failure ts s e) + (P f) >>= g = P (\s-> continue . f s) + where + continue (Success ts s x) = let (P g') = g x in g' s ts + continue (Committed (Committed r)) = continue (Committed r) + continue (Committed r) = Committed (continue r) + continue (Failure ts s e) = Failure ts s e + +instance PolyParse (Parser s t) where + commit (P p) = P (\s-> Committed . p s) + (P p) `adjustErr` f = P (\s-> adjust . p s) + where + adjust (Failure z s e) = Failure z s (f e) + adjust (Committed r) = Committed (adjust r) + adjust good = good + + (P p) `onFail` (P q) = P (\s ts-> continue s ts $ p s ts) + where + continue s ts (Failure _ _ _) = q s ts + -- continue _ _ (Committed r) = r -- no, remain Committed + continue _ _ r = r + + oneOf' = accum [] + where accum errs [] = + fail ("failed to parse any of the possible choices:\n" + ++indent 2 (concatMap showErr (reverse errs))) + accum errs ((e,P p):ps) = + P (\s ts-> case p s ts of + Failure _ _ err -> + let (P p) = accum ((e,err):errs) ps + in p s ts + r@(Success z _ a) -> r + r@(Committed _) -> r ) + showErr (name,err) = name++":\n"++indent 2 err + + -- Apply a parsed function to a parsed value. This version + -- is strict in the result of the function parser, but + -- lazy in the result of the argument parser. (Argument laziness is + -- the distinctive feature over other implementations.) + (P pf) `apply` px = P (\s-> continue . pf s) + where + continue (Success z s f) = let (x,s',z') = runParser px s z + in Success z' s' (f x) + continue (Failure z s e) = Failure z s e + continue (Committed r) = Committed (continue r) + +manyFinally :: Parser s t a -> Parser s t z -> Parser s t [a] +{- +manyFinally pp@(P p) pt@(P t) = P (\s ts -> item s ts (p s ts)) + where + item _ _ (Success ts s x) = success ts s x + item s ts (Failure _ _ e) = terminate (t s ts) + item s ts (Committed r) = Committed (within r) + + success ts s x = + let (tail,s',ts') = runParser (manyFinally pp pt) s ts + in Success ts' s' (x:tail) + + terminate (Success ts s _) = Success ts s [] + terminate (Failure ts s e) = Failure ts s e + terminate (Committed r) = Committed (terminate r) + + within (Success ts s x) = success ts s x + within (Failure ts s e) = Failure ts s e + within (Committed r) = within r +-} + +manyFinally p z = + (do x <- p; return (x:) `apply` manyFinally p z) + `onFail` + (do z; return []) + `onFail` + oneOf' [ ("item in sequence", (do p; return [])) + , ("sequence terminator", (do z; return [])) ] + +------------------------------------------------------------------------ +next :: Parser s t t +next = P (\s ts-> case ts of + [] -> Failure [] s "Ran out of input (EOF)" + (t:ts') -> Success ts' s t ) + +eof :: Parser s t () +eof = P (\s ts-> case ts of + [] -> Success [] s () + (t:ts') -> Failure ts s "Expected end of input (eof)" ) + +satisfy :: (t->Bool) -> Parser s t t +satisfy pred = do { x <- next + ; if pred x then return x else fail "Parse.satisfy: failed" + } +------------------------------------------------------------------------ +-- State handling + +-- | Update the internal state. +stUpdate :: (s->s) -> Parser s t () +stUpdate f = P (\s ts-> Success ts (f s) ()) + +-- | Query the internal state. +stQuery :: (s->a) -> Parser s t a +stQuery f = P (\s ts-> Success ts s (f s)) + +-- | Deliver the entire internal state. +stGet :: Parser s t s +stGet = P (\s ts-> Success ts s s) + +------------------------------------------------------------------------ +-- | Push some tokens back onto the front of the input stream and reparse. +-- This is useful e.g. for recursively expanding macros. When the +-- user-parser recognises a macro use, it can lookup the macro +-- expansion from the parse state, lex it, and then stuff the +-- lexed expansion back down into the parser. +reparse :: [t] -> Parser s t () +reparse ts = P (\s inp-> Success (ts++inp) s ()) + +------------------------------------------------------------------------ +
+ diff --git a/docs/index.html b/docs/index.html new file mode 100644 --- /dev/null +++ b/docs/index.html @@ -0,0 +1,345 @@ + + + ++ polyparse: alternative parser combinator libraries + + + + + ++ + +polyparse
+
++What is polyparse?
+How do I use it?
+Downloads
++Recent news
+Contacts
+Related Work
+
+What is polyparse?
+polyparse is a collection of parser combinator libraries in +Haskell. It is distributed as a package, but you are likely to use only +one of the included modules at any one time - they are generally +alternatives to each other, as well as an alternative to other +widely-used parser libraries available elsewhere. + +
-
+
- Text.Parse The Text.Read class from Haskell'98 is widely + recognised to have many problems. It is inefficient. If a read + fails, there is no indication of why. Worst of all, a read failure + crashes your whole program! Text.Parse is a proposed replacement + for the Read class. It defines a new class, Parse, with methods + that return an explicit notification of errors, through the Either + type. It also defines a number of useful helper functions to + enable the construction of parsers for textual representations of + Haskell data structures, e.g. named fields. Unsurprisingly, + Text.Parse is really just a specialisation of the Poly combinators + for String input, and the entire Poly API is also re-exported. + The DrIFT + tool can derive instances of the Parse class for you + automatically. (Use the syntax {-! derive : Parse !-}) +
- Text.Parse.ByteString is a variant of Text.Parse, where + the input is simply ByteString instead of String. +
- Text.ParserCombinators.Poly + Currently re-exports Text.ParserCombinators.Poly.Plain. + The name Poly comes from the arbitrary token type. Thus, you can + write your own lexer if you wish, rather than needing to encode + lexical analysis within the parser itself. +
- Text.ParserCombinators.Poly.Plain This is a fresh + set of combinators, improving on the HuttonMeijer variety by + keeping only a single success, not a list of them. This is + more space-efficient, whilst still permitting backtracking. + Error-handling is also much improved: there are essentially two + kinds of failure, soft and hard. Soft failure just means that the + current parse did not work out, but another parse might be OK. + Hard failure means that no parse will succeed, because we have + already passed a point of commitment. Thus you can give far more + accurate error messages to the user, including multi-layered + locations. +
- Text.ParserCombinators.Poly.State is just like Poly, except it + adds an arbitrary running state parameter. +
- Text.ParserCombinators.Poly.Lazy is just like Poly, except it + does not return explicit failures. Instead, an exception is raised. + Thus, it can return a partial parse result, before a full parse is + complete. The word partial indicates that, having committed to + return some outer data constructor, we might later discover some + parse error further inside, so the value will be partial, as in + incomplete: containing bottom. However, if you are confident that + the input is error-free, then you will gain hugely in + space-efficiency - essentially you can stream-process your parsed + data-structure within very small constant space. This is especially + useful for large structures like e.g. XML trees. +
- Text.ParserCombinators.Poly.StateLazy combines Poly.State and + Poly.Lazy. +
- Text.ParserCombinators.Poly.Base + All of the Poly variations (Plain, Lazy, State, etc) + share a lot in common: many of the + combinators are indeed implemented identically. To reduce code + duplication in the library, we provide a class-based interface + here. The actual implementations for strict, lazy, and so on, are + instances of the class, defined in modules at the same level in the + hierarchy (e.g. T.P.Poly.Lazy etc). Every individual variation + re-exports these base combinators, so there should be no need to + import this module directly. +
- Text.ParserCombinators.Poly.ByteString is a specialised + version of the Poly parser for ByteString input only. +
- Text.ParserCombinators.HuttonMeijer The most venerable of all + monadic parser combinator libraries, this version dates from 1996. + Originally distributed with Gofer, then Hugs, as ParseLib. It uses + the idea of "failure as a list of successes" to give multiple + possible parses through backtracking. (But in practice, almost + nobody wants any parse except the first complete one.) +
- Text.ParserCombinators.HuttonMeijerWallace The + Hutton/Meijer combinators, extended to take an arbitrary token type + as input (not just characters), plus a running state (e.g. to + collect a symbol table, or macros), plus some facilities for + simple error-reporting. +
+All the Poly* variations share the same basic API, so it is easy +to switch from one set to another, when you discover you need an extra +facility, just by changing a single import. + +
+How do I use it?
+Detailed documentation of the polyparse APIs +is generated automatically by Haddock directly from the source code. + +
+In general, you can just add an import of the relevant module to your +source code, and everything should just compile OK. However, if the +package is not 'exposed' (in ghc-pkg terminology), then you might need +to use a command-line option --package polyparse at compile +time. + +
+The original Hutton/Meijer combinators are described in a very nice +tutorial tech report: +NOTTCS-TR-96-4 + +
+I wrote some motivation for Text.Parse (including simple examples) +on my blog a while back. Here is the posting. + +
+If you are familiar with the Parsec library, then the key insight for +using PolyParse is that the two libraries' approach to backtracking are +the duals of each another. In Parsec, you must explicitly add a +try combinator at any location where backtracking might be +necessary. Users often find this a bit of a black art. In PolyParse +by contrast, all parsers are backtracking unless you explicitly add a +commit (or one of its variations). It is easy to tell where to +add a commit point, because you have already parsed enough of a data +structure to know that only one outcome is possible. For instance, if +you are parsing a Haskell value produced by 'show', then as soon as you +have parsed the initial constructor, you know that no other constructor +of that datatype is possible, so you can commit to returning it. + +
+User-contributed documentation for polyparse is on the Haskell wiki at: +http://haskell.org/haskellwiki/Polyparse +Please edit the wiki if you discover any nice tricks! + +
+Known problems: +
-
+
- No problems currently known. +
- Report bugs to Malcolm.Wallace@cs.york.ac.uk +
- Even better, fix any bugs you find, and then darcs send a patch. +
+Downloads
+Development version:
+
darcs get + http://www.cs.york.ac.uk/fp/darcs/polyparse + ++Current released version:
+polyparse-1.4.1, release date 2010.05.29
+By HTTP: +.tar.gz, +.zip. +
+By FTP: + +ftp://ftp.cs.york.ac.uk/pub/haskell/polyparse/ + ++Older versions:
+polyparse-1.4, release date 2009.12.10
+By HTTP: +.tar.gz, +.zip. +
+polyparse-1.3, release date 2009.03.09
+By HTTP: +.tar.gz, +.zip. +
+polyparse-1.2, release date 2009.03.04
+By HTTP: +.tar.gz, +.zip. +
+polyparse-1.1, release date 2007.10.23
+By HTTP: +.tar.gz, +.zip. +
+polyparse-1.0, release date 2007.01.26
+By HTTP: +.tar.gz, +.zip. +
+All older versions by FTP: + +ftp://ftp.cs.york.ac.uk/pub/haskell/polyparse/ + + +
+Installation
+To install polyparse, you must have a Haskell compiler: ghc-6.2 +or later, and/or nhc98-1.16/hmake-3.06 or later, and/or +Hugs98 (Sept 2003) or later. For more recent compilers, +use the standard Cabal method of installation: +
+ cabal install polyparse +
+or ++ runhaskell Setup.hs configure [--prefix=...] [--buildwith=...] + runhaskell Setup.hs build + runhaskell Setup.hs install +
+ +For older compilers, use: ++ sh configure [--prefix=...] [--buildwith=...] + make + make install +
+to configure, build, and install polyparse as a package for your +compiler(s). If you don't use the --prefix option, you may need write +permission on the library installation directories of your compiler(s). +Afterwards, to gain access to the polyparse libraries, you only need to +add the option -package polyparse to your compiler commandline +(no option required for Hugs). + +
+Recent news
+Version 1.4.1 has two minor bugfixes: for `discard`, especially in the Lazy +variant, and for 'optionalParens' in Text.Parse. + +
+Version 1.4 has several bugfixes, improvements, and API additions. See +the complete changelog
for fuller +details. The main headline is new ByteString functionality. + ++Version 1.3 has a single bugfix: Text.Parse.parseFloat now accepts +ordinary floating point notation, in addition to scientific (exponent) +notation. + +
+Version 1.2 improves the Text.Parse implementation significantly. Where +previously all the parsers for builtin basic datatype (Int,Float,Char) +were just thin wrappers over the H'98 Read instances, now they are all +proper parsers, therefore they should (a) be faster; (b) give better +error messages. + +
+Version 1.1 much improves the laziness characteristics of the Poly* +combinators. There are also a lot of new implementations of the Poly* +parser types, all of which attempt to preserve exactly the same +combinator interface, so it is easy to switch between them. + +
+Version 1.00 is the first release of polyparse as a separate package. +It was previously part of the HaXml suite. HaXml continues to use +polyparse, but polyparse will be useful more widely. If you are looking +for examples of the usage of polyparse, the implementations of +Text.XML.HaXml.Parse, Text.XML.HaXml.ParseLazy, and +Text.XML.HaXml.XmlContent are good places to look. + +
+Complete Changelog
+ +
+Contacts
+We are interested in hearing your feedback on these parser combinators - +suggestions for improvements, comments, criticisms, bug reports. Please mail +
+ ++ +
Licence: The library is Free and Open Source Software, +i.e., the bits we wrote are copyright to us, but freely licensed +for your use, modification, and re-distribution, provided you don't +restrict anyone else's use of it. The polyparse library is distributed +under the GNU Lesser General Public Licence (LGPL) - see file +LICENCE-LGPL for more details. We allow one +special exception to the LGPL - see COPYRIGHT. +(If you don't like any of these licensing conditions, please contact us +to discuss your requirements.) + +
++
Related work
-
+
- +Parser combinators have a long history in Haskell. The first(?) monadic +combinator tutorial was introduced by +Hutton and +Meijer in 1996, and the accompanying library was distributed with +Gofer (a precursor to Hugs), and known simply as ParseLib. That library +lives on here as Text.ParserCombinators.HuttonMeijer. + +
- +Niklas Rojemo's +combinators. The parser combinators developed and used in the +implementation of the nhc98 compiler are monadic and space-efficient. +However, they do not use the standard do-notation, because in fact they +are more general than the standard monad category. + +
- + +Daan Leijen's parsec. The parsec library is widely used, since it is +distributed with ghc. Its combinators are fairly robust, but you need +to place explicit backtracking into your parsers, using the try +operator. This can be tricky. + +
- Doaitse +Swierstra's UU_Parse. +An all-singing, all-dancing parsing library. Deeply sophisticated. +Allows on-line results, which is closely related to lazy parsing. + +
- Koen Claessen's ReadP. +This is a different proposed replacement for the standard Haskell'98 +Read class. It is a whole lot more efficient that Read, but because it +is also API-compatible with Read, that unfortunately means it suffers +from not giving good error messages. Also, it requires rank-2 types, +which is a non-Haskell'98 extension. + +
+ + + diff --git a/polyparse.cabal b/polyparse.cabal --- a/polyparse.cabal +++ b/polyparse.cabal @@ -1,5 +1,5 @@ name: polyparse -version: 1.4 +version: 1.4.1 license: LGPL license-file: COPYRIGHT author: Malcolm Wallace+ +int main (int argc, char** argv) { + int i=0; + if (argc>1) { + if (strcmp(argv[1],"-n")==0) { + for (i=2; i