A top-level Versioning type. Acts as a wrapper for the more specific types. This allows each subtype to have its own parser, and for said parsers to be composed. This is useful for specifying custom behaviour for when a certain parser fails.

Short-hand for detecting a SemVer.

Short-hand for detecting a Version.

Short-hand for detecting a Mess.

An (Ideal) version number that conforms to Semantic Versioning. This is a prescriptive parser, meaning it follows the SemVer standard.

Legal semvers are of the form: MAJOR.MINOR.PATCH-PREREL+META

Example: 1.2.3-r1+commithash

Extra Rules:

1. Pre-release versions have lower precedence than normal versions.
2. Build metadata does not affect version precedence.
3. PREREL and META strings may only contain ASCII alphanumerics and hyphens.

For more information, see http://semver.org

A PVP version number specific to the Haskell ecosystem. Like SemVer this is a prescriptive scheme, and follows the PVP spec.

Legal PVP values are of the form: MAJOR(.MAJOR.MINOR)

Example: 1.2.3

Extra Rules:

1. Each component must be a number.
2. Only the first MAJOR component is actually necessary. Otherwise, there can be any number of components. 1.2.3.4.5.6.7 is legal.
3. Unlike SemVer there are two MAJOR components, and both indicate a breaking change. The spec otherwise designates no special meaning to components past the MINOR position.

A (General) Version. Not quite as ideal as a SemVer, but has some internal consistancy from version to version.

Generally conforms to the a.b.c-p pattern, and may optionally have an epoch and metadata. Epochs are prefixes marked by a colon, like in 1:2.3.4. Metadata is prefixed by +, and like SemVer must appear after the "prerelease" (the -p).

Examples of Version that are not SemVer: 0.25-2, 8.u51-1, 20150826-1, 1:2.3.4

A (Complex) Mess. This is a descriptive parser, based on examples of stupidly crafted version numbers used in the wild.

Groups of letters/numbers, separated by a period, can be further separated by the symbols _-+:

Some Mess values have a shape that is tantalizingly close to a SemVer. Example: 1.6.0a+2014+m872b87e73dfb-1. For values like these, we can extract the semver-compatible values out with messMajor, etc.

Not guaranteed to have well-defined ordering (Ord) behaviour, but so far internal tests show consistency. messMajor, etc., are used internally where appropriate to enhance accuracy.

Try to extract the "major" version number from Mess, as if it were a SemVer.

Try to extract the "minor" version number from Mess, as if it were a SemVer.

Try to extract the "patch" version number from Mess, as if it were a SemVer.

Okay, fine, say messPatch couldn't find a nice value. But some Messes have a "proper" patch-plus-release-candidate value in their patch position, which is parsable as a VChunk.

Example: 1.6.0a+2014+m872b87e73dfb-1 We should be able to extract 0a safely.

Possible values of a section of a Mess. A numeric value is extracted if it could be, alongside the original text it came from. This preserves both Ord and pretty-print behaviour for versions like 1.003.0.

A single unit of a Version. May be digits or a string of characters. Groups of these are called VChunks, and are the identifiers separated by periods in the source.

Smart constructor for a VUnit made of digits.

Smart constructor for a VUnit made of letters.

A logical unit of a version number. Can consist of multiple letters and numbers.

Developers use a number of symbols to seperate groups of digits/letters in their version numbers. These are:

• A colon (:). Often denotes an "epoch".
• A hyphen (-).
• A plus (+). Stop using this outside of metadata if you are. Example: 10.2+0.93+1-1
• An underscore (_). Stop using this if you are.

A synonym for the more verbose megaparsec error type.

Parse a piece of Text into either an (Ideal) SemVer, a (General) Version, or a (Complex) Mess.

Parse a (Ideal) Semantic Version.

Parse a (Haskell) PVP, as defined above.

Parse a (General) Version, as defined above.

Parse a (Complex) Mess, as defined above.

Parse a Versioning. Assumes the version number is the last token in the string.

Internal megaparsec parser of semver.

Internal megaparsec parser of pvp.

Internal megaparsec parser of version.

Internal megaparsec parser of mess.

Convert any parsed Versioning type to its textual representation.

Convert a SemVer back to its textual representation.

Convert a PVP back to its textual representation.

Convert a Version back to its textual representation.

Convert a Mess back to its textual representation.

Pretty-print a ParseErrorBundle. All ParseErrors in the bundle will be pretty-printed in order together with the corresponding offending lines by doing a single efficient pass over the input stream. The rendered String always ends with a newline.

Since: megaparsec-7.0.0

Simple Lenses compatible with both lens and microlens.

Simple Traversals compatible with both lens and microlens.

Version types which sanely and safely yield SemVer-like information about themselves. For instances other than SemVer itself however, these optics may not yield anything, depending on the actual value being traversed. Hence, the optics here are all Traversal`s.

Consider the Version 1.2.3.4.5. We can imagine wanting to increment the minor number:

λ "1.2.3.4.5" & minor %~ (+ 1)
"1.3.3.4.5"

But of course something like this would fail:

λ "1.e.3.4.5" & minor %~ (+ 1)
"1.e.3.4.5"

However!

λ "1.e.3.4.5" & major %~ (+ 1)
"2.e.3.4.5"

Traverse some Text for its inner versioning.

λ "1.2.3" & _Versioning . _Ideal . patch %~ (+ 1)  -- or just: "1.2.3" & patch %~ (+ 1)
"1.2.4"

Traverse some Text for its inner SemVer.

Traverse some Text for its inner Version.

Traverse some Text for its inner Mess.

Possibly extract a SemVer from a Versioning.

Possibly extract a Version from a Versioning.

Possibly extract a Mess from a Versioning.

A Version's inner epoch Word.

Possibly traverse the inner digit value of a VUnit.

Possibly traverse the inner text of a VUnit.