polyparse change log

Changes in polyparse-1.12

• Version 1.12 contains a fix for lexing escaped chars inside a literal string in the "word" parser. It also changes the semantics of "parseLitChar" so that it no longer expects surrounding single quotes. A version that does consume surrounding single quotes is now provided under the name parseLitChar'. The new behaviour of parseLitChar matches Haskell's lexLitChar specification, from which it was derived.

Changes in polyparse-1.11

• A fix for the Applicative/Monad/Functor classes rearrangement in ghc-7.10.*.

Changes in polyparse-1.10

• A new basic text-accepting combinator "literal", accepts the given string, without lexing it into Haskell-like words ("isWord").
• A more correct implementation of "manyFinally".
• A new combinator "satisfyMsg" which has a string describing the predicate, in order to produce more informative error messages.

Changes in polyparse-1.9

• Change Text.Parse.bracket to backtrack if the closing bracket is missing. If you rely on not backtracking, you can instead use "commit" in the closing bracket parser.
• The performance of multiple-commit squashing is improved.

Changes in polyparse-1.8

• Change ByteString parser API to return Word8 instead of Char.
• The previous ByteString parser API is now called ByteStringChar.

Changes in polyparse-1.7

• Modify imports for forward compatibility with ghc-7.

Changes in polyparse-1.6

• Expose a Data.Text variant of the parser combinators, based loosely on the ByteString variant.

Changes in polyparse-1.5

• A huge internal rearrangement of the Poly variations: (1) to share as much code as possible, avoiding cut-n-paste copies; and (2) to use the standard Control.Applicative interface.
• The Result type that was previously defined afresh for each variation (Plain,Lazy,State,ByteString, etc) is now defined in one place.
• The Parser type that was previously essentially identical between Plain/Lazy, apart from a very small number of class methods, has now been pulled out into a separate module. This makes it clearer that almost everything is shared between Plain and Lazy, with the precise differences isolated to runParser and the instance of Applicative. (Likewise the Parser type shared between State/StateLazy.)
• The `apply` and `discard` methods previously were not the standard ones from Control.Applicative (<*> and <*), but now they are. The old names have been retained as synonyms.
• The `onFail` method was previously not the standard <|> from class Alternative in Control.Applicative. Now it is. The old name has been retained too.
• The use of standard classes means that the former PolyParse class was in the wrong place in the dependency hierarchy. Its remaining methods have been moved into a new class called Commitment, reflecting their purpose. Class PolyParse itself now has no methods of its own, it merely gathers all of the other classes that are required (Functor, Monad, Applicative, Alternative, and Commitment).
• The exports of the modules Plain, Lazy, State, and StateLazy, remain essentially as before, so users should not need to make too many changes. The main one is, if they defined their own parser monad, some of the methods must now be moved/defined in different classes.
• Some performance improvements to the Text.Parse.ByteString variant.
• A new Poly variant, Text.ParserCombinators.Poly.Lex, with a new iteratee-style tokenising input type.

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.