megaparsec

Monadic parser combinators

https://github.com/mrkkrp/megaparsec

Version on this page:5.3.0@rev:1
LTS Haskell 22.39:9.5.0@rev:4
Stackage Nightly 2024-10-31:9.6.1
Latest on Hackage:9.6.1

See all snapshots megaparsec appears in

BSD-2-Clause licensed by Megaparsec contributors, Paolo Martini, Daan Leijen
Maintained by Mark Karpov
This version can be pinned in stack with:megaparsec-5.3.0@sha256:9a4b90f2290bb982742d5580cb53250b3c924846a1090e0fa46bc7b108f1aea0,6662

Module documentation for 5.3.0

Megaparsec

License FreeBSD Hackage Stackage Nightly Stackage LTS Build Status Coverage Status

This is an industrial-strength monadic parser combinator library. Megaparsec is a fork of Parsec library originally written by Daan Leijen.

Features

This project provides flexible solutions to satisfy common parsing needs. The section describes them shortly. If you’re looking for comprehensive documentation, see the section about documentation.

Core features

The package is built around MonadParsec, a MTL-style monad transformer. All tools and features work with any instance of MonadParsec. You can achieve various effects combining monad transformers, i.e. building monad stack. Since most common monad transformers like WriterT, StateT, ReaderT and others are instances of MonadParsec, you can wrap ParsecT in these monads, achieving, for example, backtracking state.

On the other hand ParsecT is instance of many type classes as well. The most useful ones are Monad, Applicative, Alternative, and MonadParsec.

The module Text.Megaparsec.Combinator (its functions are included in Text.Megaparsec) contains traditional, general combinators that work with any instance of Alternative and some even with instances of Applicative.

Role of Monad, Applicative, and Alternative should be obvious, so let’s enumerate methods of MonadParsec type class. The class represents core, basic functions of Megaparsec parsing. The rest of library is built via combination of these primitives:

  • failure allows to fail with arbitrary collection of messages.

  • label allows to add a “label” to any parser, so when it fails the user will see the label in the error message where “expected” items are enumerated.

  • hidden hides any parser from error messages altogether, this is officially recommended way to hide things, prefer it to the label "" approach.

  • try enables backtracking in parsing.

  • lookAhead allows to parse something without consuming input.

  • notFollowedBy succeeds when its argument fails, it does not consume input.

  • withRecovery allows to recover from parse errors “on-the-fly” and continue parsing. Once parsing is finished, several parse errors may be reported or ignored altogether.

  • observing allows to “observe” parse errors without ending parsing (they are returned in Left, while normal results are wrapped in Right).

  • eof only succeeds at the end of input.

  • token is used to parse single token.

  • tokens makes it easy to parse several tokens in a row.

  • getParserState returns full parser state.

  • updateParserState applies given function on parser state.

This list of core functions is longer than in some other libraries. Our goal was efficient and readable implementation of functionality provided by every such primitive, not minimal number of them. You can read the comprehensive description of every primitive function in Megaparsec documentation.

Megaparsec can currently work with the following types of input stream out-of-box:

  • String = [Char]

  • ByteString (strict and lazy)

  • Text (strict and lazy)

Error messages

Megaparsec 5 introduces well-typed error messages and ability to use custom data types to adjust the library to your domain of interest. No need to keep your info as shapeless bunch of strings anymore.

The default error component (Dec) has constructors corresponding to fail function and indentation-related error messages. It is a decent option that should work out-of-box for most parsing needs, while you are free to use your own custom error component when necessary with little effort.

This new design allowed Megaparsec 5 to have much more helpful error messages for indentation-sensitive parsing instead of plain “incorrect indentation” phrase.

Alex and Happy support

Megaparsec works well with streams of tokens produced by tools like Alex/Happy. Megaparsec 5 adds updatePos method to Stream type class that gives you full control over textual positions that are used to report token positions in error messages. You can update current position on per character basis or extract it from token — all cases are covered.

Character parsing

Megaparsec has decent support for Unicode-aware character parsing. Functions for character parsing live in Text.Megaparsec.Char (they all are included in Text.Megaparsec). The functions can be divided into several categories:

  • Simple parsers — parsers that parse certain character or several characters of the same kind. This includes newline, crlf, eol, tab, and space.

  • Parsers corresponding to categories of characters parse single character that belongs to certain category of characters, for example: controlChar, spaceChar, upperChar, lowerChar, printChar, digitChar, and others.

  • General parsers that allow you to parse a single character you specify or one of given characters, or any character except for given ones, or character satisfying given predicate. Case-insensitive versions of the parsers are available.

  • Parsers for sequences of characters parse strings. These are more efficient and provide better error messages than other approaches most programmers can come up with. Case-sensitive string parser is available as well as case-insensitive string'.

Permutation parsing

For those who are interested in parsing of permutation phrases, there is Text.Megaparsec.Perm. You have to import the module explicitly, it’s not included in the Text.Megaparsec module.

Expression parsing

Megaparsec has a solution for parsing of expressions. Take a look at Text.Megaparsec.Expr. You have to import the module explicitly, it’s not included in the Text.Megaparsec.

Given a table of operators that describes their fixity and precedence, you can construct a parser that will parse any expression involving the operators. See documentation for comprehensive description of how it works.

Lexer

Text.Megaparsec.Lexer is a module that should help you write your lexer. If you have used Parsec in the past, this module “fixes” its particularly inflexible Text.Parsec.Token.

Text.Megaparsec.Lexer is intended to be imported qualified, it’s not included in Text.Megaparsec. The module doesn’t impose how you should write your parser, but certain approaches may be more elegant than others. An especially important theme is parsing of white space, comments, and indentation.

The design of the module allows you quickly solve simple tasks and doesn’t get in your way when you want to implement something less standard.

Since Megaparsec 5, all tools for indentation-sensitive parsing are available in Text.Megaparsec.Lexer module — no third party packages required.

Documentation

Megaparsec is well-documented. All functions and data-types are thoroughly described. We pay attention to avoid outdated info or unclear phrases in our documentation. See the current version of Megaparsec documentation on Hackage for yourself.

Tutorials

You can visit site of the project which has several tutorials that should help you to start with your parsing tasks. The site also has instructions and tips for Parsec users who decide to switch. If you want to improve an existing tutorial or add your own, open a PR against this repo.

Performance

Despite being quite flexible, Megaparsec is also faster than Parsec. The repository includes benchmarks that can be easily used to compare Megaparsec and Parsec. In most cases Megaparsec is faster, sometimes dramatically faster. If you happen to have some other benchmarks, I would appreciate if you add Megaparsec to them and let me know how it performs.

If you think your Megaparsec parser is not efficient enough, take a look at these instructions.

Comparison with other solutions

There are quite a few libraries that can be used for parsing in Haskell, let’s compare Megaparsec with some of them.

Megaparsec vs Attoparsec

Attoparsec is another prominent Haskell library for parsing. Although the both libraries deal with parsing, it’s usually easy to decide which you will need in particular project:

  • Attoparsec is much faster but not that feature-rich. It should be used when you want to process large amounts of data where performance matters more than quality of error messages.

  • Megaparsec is good for parsing of source code or other human-readable texts. It has better error messages and it’s implemented as monad transformer.

So, if you work with something human-readable where size of input data is usually not huge, just go with Megaparsec, otherwise Attoparsec may be a better choice.

Megaparsec vs Parsec

Since Megaparsec is a fork of Parsec, it’s necessary to list main differences between the two libraries:

  • Better error messages. We test our error messages using dense QuickCheck tests. Good error messages are just as important for us as correct return values of our parsers. Megaparsec will be especially useful if you write compiler or interpreter for some language.

  • Some quirks and “buggy features” (as well as plain bugs) of original Parsec are fixed. There is no undocumented surprising stuff in Megaparsec.

  • Better support for Unicode parsing in Text.Megaparsec.Char.

  • Megaparsec has more powerful combinators and can parse languages where indentation matters.

  • Comprehensive QuickCheck test suite covering nearly 100% of our code.

  • We have benchmarks to detect performance regressions.

  • Better documentation, with 100% of functions covered, without typos and obsolete information, with working examples. Megaparsec’s documentation is well-structured and doesn’t contain things useless to end users.

  • Megaparsec’s code is clearer and doesn’t contain “magic” found in original Parsec.

  • Megaparsec has well-typed error messages and custom error messages.

  • Megaparsec can recover from parse errors “on the fly” and continue parsing.

  • Megaparsec is faster.

  • Megaparsec is better supported.

If you want to see a detailed change log, CHANGELOG.md may be helpful. Also see this original announcement for another comparison.

To be honest Parsec’s development has seemingly stagnated. It has no test suite (only three per-bug tests), and all its releases beginning from version 3.1.2 (according or its change log) were about introducing and fixing regressions. Parsec is old and somewhat famous in Haskell community, so we understand there will be some kind of inertia, but we advise you use Megaparsec from now on because it solves many problems of original Parsec project. If you think you still have a reason to use original Parsec, open an issue.

Megaparsec vs Trifecta

Trifecta is another Haskell library featuring good error messages. Like some other projects of Edward Kmett, it’s probably good, but also poorly documented, arcane, and has unfixed bugs and flaws that Edward is too busy to fix (simply a fact, no offense intended). Other reasons one may question choice of Trifecta is his/her parsing library:

  • Complicated, doesn’t have any tutorials available, and documentation doesn’t help at all.

  • Trifecta can parse String and ByteString natively, but not Text.

  • Trifecta’s error messages may be different with their own features, but certainly not as flexible as Megaparsec’s error messages in the latest versions.

  • Depends on lens. This means you’ll pull in half of Hackage as transitive dependencies. Also if you’re not into lens and would like to keep your code “vanilla”, you may not like the API.

Megaparsec vs Earley

Earley is a newer library that allows to safely (it your code compiles, then it probably works) parse context-free grammars (CFG). Megaparsec is a lower-level library compared to Earley, but there are still enough reasons to choose it over Earley:

  • Megaparsec is faster.

  • Your grammar may be not context free or you may want introduce some sort of state to the parsing process. Almost all non-trivial parsers require something of this sort. Even if your grammar is context-free, state may allow to add some additional niceties. Earley does not support that.

  • Megaparsec’s error messages are more flexible allowing to include arbitrary data in them, return multiple error messages, mark regions that affect any error that happens in those regions, etc.

  • The approach Earley uses differs from conventional monadic parsing. If you work not alone, chances people you work with, especially beginners will be much more productive with libraries taking more traditional path to parsing like Megaparsec.

IOW, Megaparsec is less safe but also much more powerful.

Megaparsec vs Parsers

There is Parsers package, which is great. You can use it with Megaparsec or Parsec, but consider the following:

  • It depends on Attoparsec, Parsec, and Trifecta, which means you always grab half of Hackage as transitive dependencies by using it. This is ridiculous, by the way, because this package is supposed to be useful for parser builders, so they can write basic core functionality and get the rest “for free”.

  • It currently has a bug in definition of lookAhead for various monad transformers like StateT, etc. which is visible when you create backtracking state via monad stack, not via built-in features.

We intended to use Parsers library in Megaparsec at some point, but aside from already mentioned flaws the library has different conventions for naming of things, different set of “core” functions, etc., different approach to lexer. So it didn’t happen, Megaparsec has minimal dependencies, it is feature-rich and self-contained.

Related packages

The following packages are designed to be used with Megaparsec:

Links to announcements

Here are some blog posts mainly announcing new features of the project and describing what sort of things are now possible:

Authors

The project was started and is currently maintained by Mark Karpov. You can find complete list of contributors in AUTHORS.md file in official repository of the project. Thanks to all the people who propose features and ideas, although they are not in AUTHORS.md, without them Megaparsec would not be that good.

Contribution

Issues (bugs, feature requests or otherwise feedback) may be reported in the GitHub issue tracker for this project.

Pull requests are also welcome (and yes, they will get attention and will be merged quickly if they are good, we are progressive folks).

If you want to write a tutorial to be hosted on Megaparsec’s site, open an issue or pull request here.

License

Copyright © 2015–2017 Megaparsec contributors Copyright © 2007 Paolo Martini Copyright © 1999–2000 Daan Leijen

Distributed under FreeBSD license.

Changes

Megaparsec 5.3.0

  • Added the match combinator that allows to get collection of consumed tokens along with result of parsing.

  • Added the region combinator which allows to process parse errors happening when its argument parser is run.

  • Added the getNextTokenPosition, which returns position where the next token in the stream begins.

  • Defined Semigroup and Monoid instances of ParsecT.

  • Dropped support for GHC 7.6.

  • Added an ErrorComponent instance for ().

Megaparsec 5.2.0

  • Added MonadParsec instance for RWST.

  • Allowed many to run parsers that do not consume input. Previously this signalled an error which was ugly. Of course, in most cases giving many a parser that do not consume input will lead to non-termination bugs, but there are legal cases when this should be allowed. The test suite now contains an example of this. Non-termination issues is something inherited from the power Megaparsec gives (with more power comes more responsibility), so that error case in many really does not solve the problem, it was just a little ah-hoc guard we got from Parsec’s past.

  • The criterion benchmark was completely re-written and a new weigh benchmark to analyze memory consumption was added.

  • Performance improvements: count (marginal improvement, simpler implementation), count' (considerable improvement), and many (marginal improvement, simpler implementation).

  • Added stateTokensProcessed field to parser state and helper functions getTokensProcessed and setTokensProcessed. The field contains number of processed tokens so far. This allows, for example, create wrappers that return just parsed fragment of input stream alongside with result of parsing. (It was possible before, but very inefficient because it required traversing entire input stream twice.)

  • IndentNone option of indentBlock now picks whitespace after it like its sisters IndentMany and IndentSome do, see #161.

  • Fixed a couple of quite subtle bugs in indentBlock introduced by changing behaviour of skipLineComment in version 5.1.0. See #178 for more information.

Megaparsec 5.1.2

  • Stopped using property tests with dbg helper to avoid flood of debugging info when test suite is run.

  • Fixed the build with QuickCheck versions older than 2.9.0.

Megaparsec 5.1.1

  • Exported the observing primitive from Text.Megaparsec.

Megaparsec 5.1.0

  • Defined displayException for ParseError, so exceptions are displayed in human-friendly form now. This works with GHC 7.10 and later.

  • Line comments parsed by skipLineComment now may end at the end of input and do not necessarily require a newline to be parsed correctly. See #119.

  • Exposed parseErrorTextPretty function in Text.Megaparsec.Error to allow to render ParseErrors without stack of source positions.

  • Eliminated the old-tests test suite — Parsec legacy. The cases that are not already obviously covered in the main test suite were included into it.

  • Added Arbitrary instances for the following data types: Pos, SourcePos, ErrorItem, Dec, ParseError and State. This should make testing easier without the need to add orphan instances every time. The drawback is that we start to depend on QuickCheck, but that’s a fair price.

  • The test suite now uses the combination of Hspec and the hpesc-megaparsec package, which also improved the latter (that package is the recommended way to test Megaparsec parsers).

  • The try combinator now truly backtracks parser state when its argument parser fails (either consuming input or not). Most users will never notice the difference though. See #142.

  • Added the dbg function that should be helpful for debugging.

  • Added observing primitive combinator that allows to “observe” parse errors without ending parsing (they are returned in Left, while normal results are wrapped in Right).

  • Further documentation improvements.

Megaparsec 5.0.1

  • Derived NFData instances for Pos, InvalidPosException, SourcePos, ErrorItem, Dec, ParseError, and State.

  • Derived Data instance for ParseError, Data and Typeable instances for SourcePos and State.

  • Minor documentation improvements.

Megaparsec 5.0.0

General changes

  • Removed parseFromFile and StorableStream type-class that was necessary for it. The reason for removal is that reading from file and then parsing its contents is trivial for every instance of Stream and this function provides no way to use newer methods for running a parser, such as runParser'. So, simply put, it adds little value and was included in 4.x versions for compatibility reasons.

  • Moved position-advancing function from arguments of token and tokens functions to Stream type class (named updatePos). The new function allows to handle custom streams of tokens where every token contains information about its position in stream better (for example when stream of tokens is produced with happy/alex).

  • Support for include files (stack of positions instead of flat position) added. The new functions pushPosition and popPosition can be used to move “vertically” in the stack of positions. getPosition and setPosition still work on top (“current file”) level, but user can get full stack via getParserState if necessary. Note that ParseError and pretty-printing for it also support the new feature.

  • Added type function Token associated with Stream type class. The function returns type of token corresponding to specific token stream.

  • Type ParsecT (and also type synonym Parsec) are now parametrized over type of custom component in parse errors.

  • Parameters of MonadParsec type class are: e — type of custom component in parse errors, s — type of input stream, and m — type of underlying monad.

  • Type of failure primitive combinator was changed, now it accepts three arguments: set of unexpected items, set of expected items, and set of custom data.

  • Type of token primitive combinator was changed, now in case of failure a triple-tuple is returned with elements corresponding to arguments of failure primitive. The token primitive can also be optionally given an argument of token type to use in error messages (as expected item) in case of end of input.

  • unexpected combinator now accepts argument of type ErrorItem instead of plain String.

  • General performance improvements and improvements in speed of some combinators, manyTill in particular.

Error messages

  • The module Text.Megaparsec.Pos was completely rewritten. The new module uses Pos data type with smart constructors to ensure that things like line and column number can be only positive. SourcePos on the other hand does not require smart constructors anymore and its constructors are exported. Show and Read instances of SourcePos are derived and pretty-printing is done with help of sourcePosPretty function.

  • The module Text.Megaparsec.Error was completely rewritten. A number of new types and type-classes are introduced: ErrorItem, Dec, ErrorComponent, and ShowErrorComponent. ParseError does not need smart constructors anymore and its constructor and field selectors are exported. It uses sets (from the containers package) instead of sorted lists to enumerate unexpected and expected items. The new definition is also parametrized over token type and custom data type which can be passed around as part of parse error. Default “custom data” component is Dec, which see. All in all, we have completely well-typed and extensible error messages now. Show and Read instances of ParseError are derived and pretty-printing is done with help of parseErrorPretty.

  • The module Text.Megaparsec.ShowToken was eliminated and type class ShowToken was moved to Text.Megaparsec.Error. The only method of that class in now named showTokens and it works on streams of tokens, where single tokes are represented by NonEmpty list with single element.

Built-in combinators

  • Combinators oneOf, oneOf', noneOf, and noneOf' now accept any instance of Foldable, not only String.

Lexer

  • Error messages about incorrect indentation levels were greatly improved. Now every such message contains information about desired ordering between “reference” indentation level and actual indentation level as well as values of these levels. The information is stored in ParseError in well-typed form and can be pretty-printed when necessary. As part of this improvement, type of indentGuard was changed.

  • incorrectIndent combinator is introduced in Text.Megaparsec.Lexer module. It allows to fail with detailed information regarding incorrect indentation.

  • Introduced scientific parser that can parse arbitrary big numbers without error or memory overflow. float still returns Double, but it’s defined in terms of scientific now. Since Scientific type can reliably represent integer values as well as floating point values, number now returns Scientific instead of Either Integer Double (Integer or Double can be extracted from Scientific value anyway). This in turn makes signed parser more natural and general, because we do not need ad-hoc Signed type class anymore.

  • Added skipBlockCommentNested function that should help parse possibly nested block comments.

  • Added lineFold function that helps parse line folds.

Megaparsec 4.4.0

  • Now state returned on failure is the exact state of parser at the moment when it failed, which makes incremental parsing feature much better and opens possibilities for features like “on-the-fly” recovering from parse errors.

  • The count combinator now works with Applicative instances (previously it worked only with instances of Alternative). It’s now also faster.

  • tokens and parsers built upon it (such as string and string') backtrack automatically on failure now, that is, when they fail, they never consume any input. This is done to make their consumption model match how error messages are reported (which becomes an important thing as user gets more control with primitives like withRecovery). This means, in particular, that it’s no longer necessary to use try with tokens-based parsers. This new feature does not affect performance in any way.

  • New primitive parser withRecovery added. The parser allows to recover from parse errors “on-the-fly” and continue parsing. Once parsing is finished, several parse errors may be reported or ignored altogether.

  • eitherP combinator added.

  • Removed Enum instance of Message type. This was Parsec’s legacy that we should eliminate now. Message does not constitute enumeration, toEnum was never properly defined for it. The idea to use fromEnum to determine type of Message is also ugly, for this purpose new functions isUnexpected, isExpected, and isMessage are defined in Text.Megaparsec.Error.

  • Minor tweak in signature of MonadParsec type class. Collection of constraints changed from Alternative m, Monad m, Stream s t to Alternative m, MonadPlus m, Stream s t. This is done to make it easier to write more abstract code with older GHC where such primitives as guard are defined for instances of MonadPlus, not Alternative.

Megaparsec 4.3.0

  • Canonicalized Applicative/Monad instances. Thanks to Herbert Valerio Riedel.

  • Custom messages in ParseError are printed each on its own line.

  • Now accumulated hints are not used with ParseError records that have only custom messages in them (created with Message constructor, as opposed to Unexpected or Expected). This strips “expected” line from custom error messages where it’s unlikely to be relevant anyway.

  • Added higher-level combinators for indentation-sensitive grammars: indentLevel, nonIndented, and indentBlock.

Megaparsec 4.2.0

  • Made newPos constructor and other functions in Text.Megaparsec.Pos smarter. Now it’s impossible to create SourcePos with non-positive line number or column number. Unfortunately we cannot use Numeric.Natural because we need to support older versions of base.

  • ParseError is now a monoid. mergeError is used as mappend.

  • Added functions addErrorMessages and newErrorMessages to add several messages to existing error and to construct error with several attached messages respectively.

  • parseFromFile now lives in Text.Megaparsec.Prim. Previously we had 5 nearly identical definitions of the function, varying only in type-specific readFile function. Now the problem is solved by introduction of StorableStream type class. All supported stream types are instances of the class out of box and thus we have polymorphic version of parseFromFile.

  • ParseError is now instance of Exception (and Typeable).

  • Introduced runParser' and runParserT' functions that take and return parser state. This makes it possible to partially parse input, resume parsing, specify non-standard initial textual position, etc.

  • Introduced failure function that allows to fail with arbitrary collection of messages. unexpected is now defined in terms of failure. One consequence of this design decision is that failure is now method of MonadParsec, while unexpected is not.

  • Removed deprecated combinators from Text.Megaparsec.Combinator:

    • chainl
    • chainl1
    • chainr
    • chainr1

  • number parser in Text.Megaparsec.Lexer now can be used with signed combinator to parse either signed Integer or signed Double.

Megaparsec 4.1.1

  • Fixed bug in implementation of sepEndBy and sepEndBy1 and removed deprecation notes for these functions.

  • Added tests for sepEndBy and sepEndBy1.

Megaparsec 4.1.0

  • Relaxed dependency on base, so that minimal required version of base is now 4.6.0.0. This allows Megaparsec to compile with GHC 7.6.x.

  • Text.Megaparsec and Text.Megaparsec.Prim do not export data types Consumed and Reply anymore because they are rather low-level implementation details that should not be visible to end-user.

  • Representation of file name and textual position in error messages was made conventional.

  • Fixed some typos is documentation and other materials.

Megaparsec 4.0.0

General changes

  • Renamed many1 → some as well as other parsers that had many1 part in their names.

  • The following functions are now re-exported from Control.Applicative: (<|>), many, some, optional. See #9.

  • Introduced type class MonadParsec in the style of MTL monad transformers. Eliminated built-in user state since it was not flexible enough and can be emulated via stack of monads. Now all tools in Megaparsec work with any instance of MonadParsec, not only with ParsecT.

  • Added new function parseMaybe for lightweight parsing where error messages (and thus file name) are not important and entire input should be parsed. For example it can be used when parsing of single number according to specification of its format is desired.

  • Fixed bug with notFollowedBy always succeeded with parsers that don’t consume input, see #6.

  • Flipped order of arguments in the primitive combinator label, see #21.

  • Renamed tokenPrim → token, removed old token, because tokenPrim is more general and original token is little used.

  • Made token parser more powerful, now its second argument can return Either [Message] a instead of Maybe a, so it can influence error message when parsing of token fails. See #29.

  • Added new primitive combinator hidden p which hides “expected” tokens in error message when parser p fails.

  • Tab width is not hard-coded anymore. It can be manipulated via getTabWidth and setTabWidth. Default tab-width is defaultTabWidth, which is 8.

Error messages

  • Introduced type class ShowToken and improved representation of characters and strings in error messages, see #12.

  • Greatly improved quality of error messages. Fixed entire Text.Megaparsec.Error module, see #14 for more information. Made possible normal analysis of error messages without “render and re-parse” approach that previous maintainers had to practice to write even simplest tests, see module Utils.hs in old-tests for example.

  • Reduced number of Message constructors (now there are only Unexpected, Expected, and Message). Empty “magic” message strings are ignored now, all the library now uses explicit error messages.

  • Introduced hint system that greatly improves quality of error messages and made code of Text.Megaparsec.Prim a lot clearer.

Built-in combinators

  • All built-in combinators in Text.Megaparsec.Combinator now work with any instance of Alternative (some of them even with Applicaitve).

  • Added more powerful count' parser. This parser can be told to parse from m to n occurrences of some thing. count is defined in terms of count'.

  • Removed optionMaybe parser, because optional from Control.Applicative does the same thing.

  • Added combinator someTill.

  • These combinators are considered deprecated and will be removed in future:

    • chainl
    • chainl1
    • chainr
    • chainr1
    • sepEndBy
    • sepEndBy1

Character parsing

  • Renamed some parsers:

    • alphaNum → alphaNumChar
    • digit → digitChar
    • endOfLine → eol
    • hexDigit → hexDigitChar
    • letter → letterChar
    • lower → lowerChar
    • octDigit → octDigitChar
    • space → spaceChar
    • spaces → space
    • upper → upperChar

  • Added new character parsers in Text.Megaparsec.Char:

    • asciiChar
    • charCategory
    • controlChar
    • latin1Char
    • markChar
    • numberChar
    • printChar
    • punctuationChar
    • separatorChar
    • symbolChar

  • Descriptions of old parsers have been updated to accent some Unicode-specific moments. For example, old description of letter stated that it parses letters from “a” to “z” and from “A” to “Z”. This is wrong, since it used Data.Char.isAlpha predicate internally and thus parsed many more characters (letters of non-Latin languages, for example).

  • Added combinators char', oneOf', noneOf', and string' which are case-insensitive variants of char, oneOf, noneOf, and string respectively.

Lexer

  • Rewritten parsing of numbers, fixed #2 and #3 (in old Parsec project these are number 35 and 39 respectively), added per bug tests.

    • Since Haskell report doesn’t say anything about sign, integer and float now parse numbers without sign.

    • Removed natural parser, it’s equal to new integer now.

    • Renamed naturalOrFloat → number — this doesn’t parse sign too.

    • Added new combinator signed to parse all sorts of signed numbers.

  • Transformed Text.Parsec.Token into Text.Megaparsec.Lexer. Little of Parsec’s code remains in the new lexer module. New module doesn’t impose any assumptions on user and should be vastly more useful and general. Hairy stuff from original Parsec didn’t get here, for example built-in Haskell functions are used to parse escape sequences and the like instead of trying to re-implement the whole thing.

Other

  • Renamed the following functions:

    • permute → makePermParser
    • buildExpressionParser → makeExprParser

  • Added comprehensive QuickCheck test suite.

  • Added benchmarks.

Parsec 3.1.9

  • Many and various updates to documentation and package description (including the homepage links).

  • Add an Eq instance for ParseError.

  • Fixed a regression from 3.1.6: runP is again exported from module Text.Parsec.

Parsec 3.1.8

  • Fix a regression from 3.1.6 related to exports from the main module.

Parsec 3.1.7

  • Fix a regression from 3.1.6 related to the reported position of error messages. See bug #9 for details.

  • Reset the current error position on success of lookAhead.

Parsec 3.1.6

  • Export Text instances from Text.Parsec.

  • Make Text.Parsec exports more visible.

  • Re-arrange Text.Parsec exports.

  • Add functions crlf and endOfLine to Text.Parsec.Char for handling input streams that do not have normalized line terminators.

  • Fix off-by-one error in Token.charControl.

Parsec 3.1.4 & 3.1.5

  • Bump dependency on text.

Parsec 3.1.3

  • Fix a regression introduced in 3.1.2 related to positions reported by error messages.