Package Release Info


Update Info: Base Release
Available in Package Hub : 15 SP2





Change Logs

* Fri Nov 08 2019 Peter Simons <>
- Drop obsolete group attributes.
* Fri Nov 08 2019
- Update megaparsec to version 8.0.0.
  [#]# Megaparec 8.0.0
  * The methods `failure` and `fancyFailure` of `MonadParsec` are now ordinary
    functions and live in `Text.Megaparsec`. They are defined in terms of the
    new `parseError` method of `MonadParsec`. This method allows us to signal
    parse errors at a given offset without manipulating parser state manually.
  * Megaparsec now supports registration of ?delayed? parse errors. On lower
    level we added a new field called `stateParseErrors` to the `State`
    record. The type also had to change from `State s` to `State s e`. This
    field contains the list of registered `ParseErrors` that do not end
    parsing immediately but still will cause failure in the end if the list is
    not empty. Users are expected to register parse errors using the three
    functions: `registerParseError`, `registerFailure`, and
    `registerFancyFailure`. These functions are analogous to those without the
    `register` prefix, except that they have ?delayed? effect.
  * Added the `tokensLength` method to the `Stream` type class to improve
    support for custom input streams.
  * Added the `setErrorOffset` function to set offset of `ParseError`s.
  * Changed type signatures of `reachOffset` and `reachOffsetNoLine` methods
    of the `Stream` type class. Instead of three-tuple `reachOffset` now
    returns two-tuple because `SourcePos` is already contained in the returned
    `PosState` record.
  * Generalized `decimal`, `binary`, `octal`, and `hexadecimal` parsers in
    lexer modules so that they `Num` instead of just `Integral`.
  * Dropped support for GHC 8.2.x and older.
* Thu May 02 2019
- Update megaparsec to version 7.0.5.
  [#]# Megaparsec 7.0.5
  * Dropped support for GHC 7.10.
  * Adapted the code to `MonadFail` changes in `base-4.13`.
  * Separated the test suite into its own package. The reason is that we can
    avoid circular dependency on `hspec-megaparsec` and thus avoid keeping
    copies of its source files in our test suite, as we had to do before.
    Another benefit is that we can export some auxiliary functions in
    `megaparsec-tests` which can be used by other test suites, for example in
    the `parser-combinators-tests` package.
    Version of `megaparsec-tests` will be kept in sync with versions of
    `megaparsec` from now on.
Version: 5.3.1-bp150.2.3
* Thu Aug 03 2017
- Updated with latest spec-cleaner version 0.9.8-8-geadfbbf.
* Thu Jul 27 2017
- Update to version 5.3.1.
* Mon Jun 19 2017
- Update to version 5.2.0 revision 1.
* Sun Feb 12 2017
- Update to version 5.2.0 with cabal2obs.
* Thu Sep 15 2016
- Update to version 5.0.1 revision 0 with cabal2obs.
* Sun Jul 10 2016
- Update to version 4.4.0 revision 0 with cabal2obs.
Version: 7.0.4-bp151.1.9
* Fri Nov 09 2018
- Update megaparsec to version 7.0.4.
  Upstream has edited the change log file since the last release in
  a non-trivial way, i.e. they did more than just add a new entry
  at the top. You can review the file at:
* Thu Nov 01 2018
- Update megaparsec to version 7.0.3.
  [#]# Megaparsec 7.0.3
  * Fixed the build with `mtl` older than `2.2.2`.
* Mon Oct 22 2018
- Update megaparsec to version 7.0.2.
  [#]# Megaparsec 7.0.2
  * Fixed the property test for `char'` which was failing in the case when
    there is a character with different upper and title cases.
  * More descriptive error messages when `elabel` or `ulabel` from
    `Text.Megaparsec.Error.Builder` are used with empty strings.
  * Typos fixes in the docs.
* Wed Oct 10 2018
- Update megaparsec to version 7.0.1.
  [#]# Megaparsec 7.0.1
  * Fixed a bug in `errorBundlePretty`. Previously the question sign `?` was
    erroneously inserted before offending line in 2nd and later parse errors.
  [#]# Megaparsec 7.0.0
  [#]## General
  * Dropped the `Text.Megaparsec.Perm` module. Use
    `Control.Applicative.Permutations` from `parser-combinators` instead.
  * Dropped the `Text.Megaparsec.Expr` module. Use
    `Control.Monad.Combinators.Expr` from `parser-combinators` instead.
  * The debugging function `dbg` has been moved from `Text.Megaparsec` to its
    own module `Text.Megaparsec.Debug`.
  * Dropped support for GHC 7.8.
  [#]## Combinators
  * Moved some general combinators from `Text.Megaparsec.Char` and
    `Text.Megaparsec.Byte` to `Text.Megaparsec`, renaming some of them for
    Practical consequences:
  * Now there is the `single` combinator that is a generalization of `char`
    for arbitrary streams. `Text.Megaparsec.Char` and `Text.Megaparsec.Byte`
    still contain `char` as type-constrained versions of `single`.
  * Similarly, now there is the `chunk` combinator that is a generalization
    of `string` for arbitrary streams. The `string` combinator is still
    re-exported from `Text.Megaparsec.Char` and `Text.Megaparsec.Byte` for
  * `satisfy` does not depend on type of token, and so it now lives in
  * `anyChar` was renamed to `anySingle` and moved to `Text.Megaparsec`.
  * `notChar` was renamed to `anySingleBut` and moved to `Text.Megaparsec`.
  * `oneOf` and `noneOf` were moved to `Text.Megaparsec`.
  * Simplified the type of the `token` primitive. It now takes just a matching
    function `Token s -> Maybe a` as the first argument and the collection of
    expected items `Set (ErrorItem (Token s))` as the second argument. This
    makes sense because the collection of expected items cannot depend on what
    we see in the input stream.
  * The `label` primitive now doesn't prepend the phrase ?the rest of? to the
    label when its inner parser produces hints after consuming input. In that
    case `label` has no effect.
  * Fixed the `Text.Megaparsec.Char.Lexer.charLiteral` so it can accept longer
    escape sequences (max length is now 10).
  * Added the `binDigitChar` functions in `Text.Megaparsec.Byte` and
  * Added the `binary` functions in `Text.Megaparsec.Byte.Lexer` and
  * Improved case-insensitive character matching in the cases when e.g.
    `isLower` and `isUpper` both return `False`. Functions affected:
  * Renamed `getPosition` to `getSourcePos`.
  * Renamed `getTokensProcessed` to `getOffset`, `setTokensProcessed` to
  * Dropped `getTabWidth` and `setTabWidth` because tab width is irrelevant to
    parsing process now, it's only relevant for pretty-printing of parse
    errors, which is handled separately.
  * Added and `withParsecT` in `Text.Megaparsec.Internal` to allow changing
    the type of the custom data component in parse errors.
  [#]## Parser state and input stream
  * Dropped stacks of source positions. Accordingly, the functions
    `pushPosition` and `popPosition` from `Text.Megaparsec` and
    `sourcePosStackPretty` from `Text.Megaparsec.Error` were removed. The
    reason for this simplification is that I could not find any code that uses
    the feature and it makes manipulation of source positions hairy.
  * Introduced `PosState` for calculating `SourcePos` from offsets and getting
    offending line for displaying on pretty-printing of parse errors. It's now
    contained in both `State` and `ParseErrorBundle`.
  * Dropped `positionAt1`, `positionAtN`, `advance1`, and `advanceN` methods
    from `Stream`. They are no longer necessary because `reachOffset` (and its
    specialized version `reachOffsetNoLine`) takes care of `SourcePos`
  [#]## Parse errors
  * `ParseError` now contains raw offset in input stream instead of
    `SourcePos`. `errorPos` was dropped from `Text.Megaparsec.Error`.
  * `ParseError` is now parametrized over stream type `s` instead of token
    type `t`.
  * Introduced `ParseErrorBundle` which contains one or more `ParseError`
    equipped with all information that is necessary to pretty-print them
    together with offending lines from the input stream. Functions like
    `runParser` now return `ParseErrorBundle` instead of plain `ParseError`.
    By default there will be only one `ParseError` in such a bundle, but it's
    possible to add more parse errors to a bundle manually. During
    pretty-printing, the input stream will be traversed only once.
  * The primary function for pretty-printing of parse
    errors?`errorBundlePretty` always prints offending lines now.
    `parseErrorPretty` is still there, but it probably won't see a lot of use
    from now on. `parseErrorPretty'` and `parseErrorPretty_` were removed.
    `parseTest'` was removed because `parseTest` always prints offending lines
  * Added `attachSourcePos` function in `Text.Megaparsec.Error`.
  * The `ShowToken` type class has been removed and its method `showTokens`
    now lives in the `Stream` type class.
  * The `LineToken` type class is no longer necessary because the new method
    `reachOffset` of the type class `Stream` does its job.
  * In `Text.Megaparsec.Error` the following functions were added:
    `mapParseError`, `errorOffset`.
  * Implemented continuous highlighting in parse errors. For this we added the
    `errorComponentLen` method to the `ShowErrorComponent` type class.
  [#]## Parse error builder
  * The functions `err` and `errFancy` now accept offsets at which the parse
    errors are expected to have happened, i.e. `Int`s. Thus `posI` and `posN`
    are no longer necessary and were removed.
  * `ET` is now parametrized over the type of stream `s` instead of token type
  * Combinators like `utoks` and `etoks` now accept chunks of input stream
    directly, i.e. `Tokens s` instead of `[Token s]` which should be more
    natural and convenient.
* Fri Aug 17 2018
- Update Cabal build information to support GHC 8.6.x.
* Mon Jul 09 2018
- Add megaparsec at version 6.5.0.