versions-6.0.3: Types and parsers for software version numbers.

Copyright | (c) Colin Woodbury 2015 - 2023
License | BSD3
Maintainer | Colin Woodbury <colin@fosskers.ca>
Safe Haskell | Safe-Inferred
Language | Haskell2010

Data.Versions

Contents

- Types
  - Compile-time Constructors
  - Conversions
- Parsing Versions
  - Megaparsec Parsers
- Pretty Printing
- Lenses
  - Traversing Text
  - Versioning Traversals
  - (General) Version Lenses

Description

A library for parsing and comparing software version numbers.

We like to give version numbers to our software in a myriad of different ways. Some ways follow strict guidelines for incrementing and comparison. Some follow conventional wisdom and are generally self-consistent. Some are just plain asinine. This library provides a means of parsing and comparing any style of versioning, be it a nice Semantic Version like this:

    1.2.3-r1+git123

...or a monstrosity like this:

    2:10.2+0.0093r3+1-1

Please switch to Semantic Versioning if you aren't currently using it. It provides consistency in version incrementing and has the best constraints on comparisons.

This library implements version `2.0.0` of the SemVer spec.

## Using the Parsers

In general, `versioning` is the function you want. It attempts to parse a given `Text` using the three individual parsers, `semver`, `version` and `mess`. If one fails, it tries the next. If you know you only want to parse one specific version type, use that parser directly (e.g. `semver`).

Synopsis

- data Versioning
  - = Ideal SemVer
  - | General Version
  - | Complex Mess
- isIdeal :: Versioning -> Bool
- isGeneral :: Versioning -> Bool
- isComplex :: Versioning -> Bool
- data SemVer = SemVer {
  - _svMajor :: !Word
  - _svMinor :: !Word
  - _svPatch :: !Word
  - _svPreRel :: !(Maybe Release)
  - _svMeta :: !(Maybe Text)
  }
- newtype PVP = PVP {
  - _pComponents :: NonEmpty Word
  }
- data Version = Version {
  - _vEpoch :: !(Maybe Word)
  - _vChunks :: !Chunks
  - _vRel :: !(Maybe Release)
  - _vMeta :: !(Maybe Text)
  }
- data Mess = Mess !(NonEmpty MChunk) !(Maybe (VSep, Mess))
- messMajor :: Mess -> Maybe Word
- messMinor :: Mess -> Maybe Word
- messPatch :: Mess -> Maybe Word
- messPatchChunk :: Mess -> Maybe Chunk
- newtype Release = Release (NonEmpty Chunk)
- newtype Chunks = Chunks (NonEmpty Chunk)
- data Chunk
  - = Numeric Word
  - | Alphanum Text
- data MChunk
  - = MDigit Word Text
  - | MRev Word Text
  - | MPlain Text
- data VSep
  - = VColon
  - | VHyphen
  - | VPlus
  - | VUnder
  - | VTilde
- versioningQ :: Text -> Q Exp
- semverQ :: Text -> Q Exp
- versionQ :: Text -> Q Exp
- messQ :: Text -> Q Exp
- pvpQ :: Text -> Q Exp
- semverToVersion :: SemVer -> Version
- versionToMess :: Version -> Mess
- versionToPvp :: Version -> Maybe PVP
- type ParsingError = ParseErrorBundle Text Void
- versioning :: Text -> Either ParsingError Versioning
- semver :: Text -> Either ParsingError SemVer
- pvp :: Text -> Either ParsingError PVP
- version :: Text -> Either ParsingError Version
- mess :: Text -> Either ParsingError Mess
- versioning' :: Parsec Void Text Versioning
- semver' :: Parsec Void Text SemVer
- pvp' :: Parsec Void Text PVP
- version' :: Parsec Void Text Version
- mess' :: Parsec Void Text Mess
- prettyV :: Versioning -> Text
- prettySemVer :: SemVer -> Text
- prettyPVP :: PVP -> Text
- prettyVer :: Version -> Text
- prettyMess :: Mess -> Text
- errorBundlePretty :: (VisualStream s, TraversableStream s, ShowErrorComponent e) => ParseErrorBundle s e -> String
- type Lens' s a = forall f. Functor f => (a -> f a) -> s -> f s
- type Traversal' s a = forall f. Applicative f => (a -> f a) -> s -> f s
- class Semantic v where
  - major :: Traversal' v Word
  - minor :: Traversal' v Word
  - patch :: Traversal' v Word
  - release :: Traversal' v (Maybe Release)
  - meta :: Traversal' v (Maybe Text)
  - semantic :: Traversal' v SemVer
- _Versioning :: Traversal' Text Versioning
- _SemVer :: Traversal' Text SemVer
- _Version :: Traversal' Text Version
- _Mess :: Traversal' Text Mess
- _Ideal :: Traversal' Versioning SemVer
- _General :: Traversal' Versioning Version
- _Complex :: Traversal' Versioning Mess
- epoch :: Lens' Version (Maybe Word)

# Types

data Versioning #

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.

Constructors

Ideal SemVer |
General Version |
Complex Mess |

#### Instances

Instances details

Data Versioning # |
Instance details Defined in Data.Versions Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Versioning -> c Versioning gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Versioning toConstr :: Versioning -> Constr dataTypeOf :: Versioning -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Versioning) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Versioning) gmapT :: (forall b. Data b => b -> b) -> Versioning -> Versioning gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Versioning -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Versioning -> r gmapQ :: (forall d. Data d => d -> u) -> Versioning -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Versioning -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Versioning -> m Versioning gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Versioning -> m Versioning gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Versioning -> m Versioning
Generic Versioning # |
Instance details Defined in Data.Versions Associated Types type Rep Versioning :: Type -> Type Methods from :: Versioning -> Rep Versioning x to :: Rep Versioning x -> Versioning
Show Versioning # |
Instance details Defined in Data.Versions Methods showsPrec :: Int -> Versioning -> ShowS show :: Versioning -> String showList :: [Versioning] -> ShowS
NFData Versioning # |
Instance details Defined in Data.Versions Methods rnf :: Versioning -> ()
Eq Versioning # |
Instance details Defined in Data.Versions Methods (==) :: Versioning -> Versioning -> Bool (/=) :: Versioning -> Versioning -> Bool
Ord Versioning # | Comparison of `Ideal`s is always well defined. If comparison of `General`s is well-defined, then comparison of `Ideal` and `General` is well-defined, as there exists a perfect mapping from `Ideal` to `General`. If comparison of `Complex`es is well-defined, then comparison of `General` and `Complex` is well defined for the same reason. This implies comparison of `Ideal` and `Complex` is also well-defined.
Instance details Defined in Data.Versions Methods compare :: Versioning -> Versioning -> Ordering (<) :: Versioning -> Versioning -> Bool (<=) :: Versioning -> Versioning -> Bool (>) :: Versioning -> Versioning -> Bool (>=) :: Versioning -> Versioning -> Bool max :: Versioning -> Versioning -> Versioning min :: Versioning -> Versioning -> Versioning
Hashable Versioning # |
Instance details Defined in Data.Versions Methods hashWithSalt :: Int -> Versioning -> Int # hash :: Versioning -> Int #
Semantic Versioning # |
Instance details Defined in Data.Versions Methods major :: Traversal' Versioning Word # minor :: Traversal' Versioning Word # patch :: Traversal' Versioning Word # release :: Traversal' Versioning (Maybe Release) # meta :: Traversal' Versioning (Maybe Text) # semantic :: Traversal' Versioning SemVer #
Lift Versioning # |
Instance details Defined in Data.Versions Methods lift :: Quote m => Versioning -> m Exp liftTyped :: forall (m :: Type -> Type). Quote m => Versioning -> Code m Versioning
type Rep Versioning # |
Instance details Defined in Data.Versions type Rep Versioning = D1 ('MetaData "Versioning" "Data.Versions" "versions-6.0.3-5Hl9CfORC6I4tKyKmhjwjA" 'False) (C1 ('MetaCons "Ideal" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SemVer)) :+: (C1 ('MetaCons "General" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Version)) :+: C1 ('MetaCons "Complex" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Mess))))

isIdeal :: Versioning -> Bool #

Short-hand for detecting a `SemVer`.

isGeneral :: Versioning -> Bool #

Short-hand for detecting a `Version`.

isComplex :: Versioning -> Bool #

Short-hand for detecting a `Mess`.

data SemVer #

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

Constructors

SemVer |
Fields _svMajor :: !Word _svMinor :: !Word _svPatch :: !Word _svPreRel :: !(Maybe Release) _svMeta :: !(Maybe Text)

#### Instances

Instances details

Data SemVer # |
Instance details Defined in Data.Versions Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SemVer -> c SemVer gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SemVer toConstr :: SemVer -> Constr dataTypeOf :: SemVer -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SemVer) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SemVer) gmapT :: (forall b. Data b => b -> b) -> SemVer -> SemVer gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SemVer -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SemVer -> r gmapQ :: (forall d. Data d => d -> u) -> SemVer -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> SemVer -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> SemVer -> m SemVer gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SemVer -> m SemVer gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SemVer -> m SemVer
Generic SemVer # |
Instance details Defined in Data.Versions Associated Types type Rep SemVer :: Type -> Type Methods from :: SemVer -> Rep SemVer x to :: Rep SemVer x -> SemVer
Show SemVer # |
Instance details Defined in Data.Versions Methods showsPrec :: Int -> SemVer -> ShowS show :: SemVer -> String showList :: [SemVer] -> ShowS
NFData SemVer # |
Instance details Defined in Data.Versions Methods rnf :: SemVer -> ()
Eq SemVer # | Two SemVers are equal if all fields except metadata are equal.
Instance details Defined in Data.Versions Methods (==) :: SemVer -> SemVer -> Bool (/=) :: SemVer -> SemVer -> Bool
Ord SemVer # | Build metadata does not affect version precedence.
Instance details Defined in Data.Versions Methods compare :: SemVer -> SemVer -> Ordering (<) :: SemVer -> SemVer -> Bool (<=) :: SemVer -> SemVer -> Bool (>) :: SemVer -> SemVer -> Bool (>=) :: SemVer -> SemVer -> Bool max :: SemVer -> SemVer -> SemVer min :: SemVer -> SemVer -> SemVer
Hashable SemVer # |
Instance details Defined in Data.Versions Methods hashWithSalt :: Int -> SemVer -> Int # hash :: SemVer -> Int #
Semantic SemVer # |
Instance details Defined in Data.Versions Methods major :: Traversal' SemVer Word # minor :: Traversal' SemVer Word # patch :: Traversal' SemVer Word # release :: Traversal' SemVer (Maybe Release) # meta :: Traversal' SemVer (Maybe Text) # semantic :: Traversal' SemVer SemVer #
Lift SemVer # |
Instance details Defined in Data.Versions Methods lift :: Quote m => SemVer -> m Exp liftTyped :: forall (m :: Type -> Type). Quote m => SemVer -> Code m SemVer
type Rep SemVer # |
Instance details Defined in Data.Versions type Rep SemVer = D1 ('MetaData "SemVer" "Data.Versions" "versions-6.0.3-5Hl9CfORC6I4tKyKmhjwjA" 'False) (C1 ('MetaCons "SemVer" 'PrefixI 'True) ((S1 ('MetaSel ('Just "_svMajor") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Word) :*: S1 ('MetaSel ('Just "_svMinor") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Word)) :*: (S1 ('MetaSel ('Just "_svPatch") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Word) :*: (S1 ('MetaSel ('Just "_svPreRel") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Maybe Release)) :*: S1 ('MetaSel ('Just "_svMeta") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Maybe Text))))))

newtype PVP #

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.

Constructors

PVP |
Fields _pComponents :: NonEmpty Word

#### Instances

Instances details

Data PVP # |
Instance details Defined in Data.Versions Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PVP -> c PVP gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PVP toConstr :: PVP -> Constr dataTypeOf :: PVP -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PVP) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PVP) gmapT :: (forall b. Data b => b -> b) -> PVP -> PVP gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PVP -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PVP -> r gmapQ :: (forall d. Data d => d -> u) -> PVP -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> PVP -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> PVP -> m PVP gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PVP -> m PVP gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PVP -> m PVP
Generic PVP # |
Instance details Defined in Data.Versions Associated Types type Rep PVP :: Type -> Type Methods from :: PVP -> Rep PVP x to :: Rep PVP x -> PVP
Show PVP # |
Instance details Defined in Data.Versions Methods showsPrec :: Int -> PVP -> ShowS show :: PVP -> String showList :: [PVP] -> ShowS
NFData PVP # |
Instance details Defined in Data.Versions Methods rnf :: PVP -> ()
Eq PVP # |
Instance details Defined in Data.Versions Methods (==) :: PVP -> PVP -> Bool (/=) :: PVP -> PVP -> Bool
Ord PVP # |
Instance details Defined in Data.Versions Methods compare :: PVP -> PVP -> Ordering (<) :: PVP -> PVP -> Bool (<=) :: PVP -> PVP -> Bool (>) :: PVP -> PVP -> Bool (>=) :: PVP -> PVP -> Bool max :: PVP -> PVP -> PVP min :: PVP -> PVP -> PVP
Hashable PVP # |
Instance details Defined in Data.Versions Methods hashWithSalt :: Int -> PVP -> Int # hash :: PVP -> Int #
Semantic PVP # |
Instance details Defined in Data.Versions Methods major :: Traversal' PVP Word # minor :: Traversal' PVP Word # patch :: Traversal' PVP Word # release :: Traversal' PVP (Maybe Release) # meta :: Traversal' PVP (Maybe Text) # semantic :: Traversal' PVP SemVer #
Lift PVP # |
Instance details Defined in Data.Versions Methods lift :: Quote m => PVP -> m Exp liftTyped :: forall (m :: Type -> Type). Quote m => PVP -> Code m PVP
type Rep PVP # |
Instance details Defined in Data.Versions type Rep PVP = D1 ('MetaData "PVP" "Data.Versions" "versions-6.0.3-5Hl9CfORC6I4tKyKmhjwjA" 'True) (C1 ('MetaCons "PVP" 'PrefixI 'True) (S1 ('MetaSel ('Just "_pComponents") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (NonEmpty Word))))

data Version #

A version number with decent structure and comparison logic.

This is a descriptive scheme, meaning that it encapsulates the most common, unconscious patterns that developers use when assigning version numbers to their software. If not `SemVer`, most version numbers found in the wild will parse as a `Version`. These generally conform to the `x.x.x-x` pattern, and may optionally have an epoch.

Epochs are prefixes marked by a colon, like in `1:2.3.4`. When comparing two `Version` values, epochs take precedent. So `2:1.0.0 > 1:9.9.9`. If one of the given `Version`s has no epoch, its epoch is assumed to be 0.

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

Constructors

Version |
Fields _vEpoch :: !(Maybe Word) _vChunks :: !Chunks _vRel :: !(Maybe Release) _vMeta :: !(Maybe Text)

#### Instances

Instances details

Data Version # |
Instance details Defined in Data.Versions Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Version -> c Version gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Version toConstr :: Version -> Constr dataTypeOf :: Version -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Version) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Version) gmapT :: (forall b. Data b => b -> b) -> Version -> Version gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Version -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Version -> r gmapQ :: (forall d. Data d => d -> u) -> Version -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Version -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Version -> m Version gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Version -> m Version gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Version -> m Version
Generic Version # |
Instance details Defined in Data.Versions Associated Types type Rep Version :: Type -> Type Methods from :: Version -> Rep Version x to :: Rep Version x -> Version
Show Version # |
Instance details Defined in Data.Versions Methods showsPrec :: Int -> Version -> ShowS show :: Version -> String showList :: [Version] -> ShowS
NFData Version # |
Instance details Defined in Data.Versions Methods rnf :: Version -> ()
Eq Version # |
Instance details Defined in Data.Versions Methods (==) :: Version -> Version -> Bool (/=) :: Version -> Version -> Bool
Ord Version # | Customized. As in SemVer, metadata is ignored for the purpose of comparison.
Instance details Defined in Data.Versions Methods compare :: Version -> Version -> Ordering (<) :: Version -> Version -> Bool (<=) :: Version -> Version -> Bool (>) :: Version -> Version -> Bool (>=) :: Version -> Version -> Bool max :: Version -> Version -> Version min :: Version -> Version -> Version
Hashable Version # |
Instance details Defined in Data.Versions Methods hashWithSalt :: Int -> Version -> Int # hash :: Version -> Int #
Semantic Version # |
Instance details Defined in Data.Versions Methods major :: Traversal' Version Word # minor :: Traversal' Version Word # patch :: Traversal' Version Word # release :: Traversal' Version (Maybe Release) # meta :: Traversal' Version (Maybe Text) # semantic :: Traversal' Version SemVer #
Lift Version # |
Instance details Defined in Data.Versions Methods lift :: Quote m => Version -> m Exp liftTyped :: forall (m :: Type -> Type). Quote m => Version -> Code m Version
type Rep Version # |
Instance details Defined in Data.Versions type Rep Version = D1 ('MetaData "Version" "Data.Versions" "versions-6.0.3-5Hl9CfORC6I4tKyKmhjwjA" 'False) (C1 ('MetaCons "Version" 'PrefixI 'True) ((S1 ('MetaSel ('Just "_vEpoch") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Maybe Word)) :*: S1 ('MetaSel ('Just "_vChunks") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Chunks)) :*: (S1 ('MetaSel ('Just "_vRel") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Maybe Release)) :*: S1 ('MetaSel ('Just "_vMeta") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Maybe Text)))))

data Mess #

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.

Constructors

Mess !(NonEmpty MChunk) !(Maybe (VSep, Mess)) |

#### Instances

Instances details

Data Mess # |
Instance details Defined in Data.Versions Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Mess -> c Mess gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Mess toConstr :: Mess -> Constr dataTypeOf :: Mess -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Mess) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Mess) gmapT :: (forall b. Data b => b -> b) -> Mess -> Mess gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Mess -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Mess -> r gmapQ :: (forall d. Data d => d -> u) -> Mess -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Mess -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Mess -> m Mess gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Mess -> m Mess gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Mess -> m Mess
Generic Mess # |
Instance details Defined in Data.Versions Associated Types type Rep Mess :: Type -> Type Methods from :: Mess -> Rep Mess x to :: Rep Mess x -> Mess
Show Mess # |
Instance details Defined in Data.Versions Methods showsPrec :: Int -> Mess -> ShowS show :: Mess -> String showList :: [Mess] -> ShowS
NFData Mess # |
Instance details Defined in Data.Versions Methods rnf :: Mess -> ()
Eq Mess # |
Instance details Defined in Data.Versions Methods (==) :: Mess -> Mess -> Bool (/=) :: Mess -> Mess -> Bool
Ord Mess # |
Instance details Defined in Data.Versions Methods compare :: Mess -> Mess -> Ordering (<) :: Mess -> Mess -> Bool (<=) :: Mess -> Mess -> Bool (>) :: Mess -> Mess -> Bool (>=) :: Mess -> Mess -> Bool max :: Mess -> Mess -> Mess min :: Mess -> Mess -> Mess
Hashable Mess # |
Instance details Defined in Data.Versions Methods hashWithSalt :: Int -> Mess -> Int # hash :: Mess -> Int #
Semantic Mess # |
Instance details Defined in Data.Versions Methods major :: Traversal' Mess Word # minor :: Traversal' Mess Word # patch :: Traversal' Mess Word # release :: Traversal' Mess (Maybe Release) # meta :: Traversal' Mess (Maybe Text) # semantic :: Traversal' Mess SemVer #
Lift Mess # |
Instance details Defined in Data.Versions Methods lift :: Quote m => Mess -> m Exp liftTyped :: forall (m :: Type -> Type). Quote m => Mess -> Code m Mess
type Rep Mess # |
Instance details Defined in Data.Versions type Rep Mess = D1 ('MetaData "Mess" "Data.Versions" "versions-6.0.3-5Hl9CfORC6I4tKyKmhjwjA" 'False) (C1 ('MetaCons "Mess" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (NonEmpty MChunk)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Maybe (VSep, Mess)))))

messMajor :: Mess -> Maybe Word #

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

messMinor :: Mess -> Maybe Word #

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

messPatch :: Mess -> Maybe Word #

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

messPatchChunk :: Mess -> Maybe Chunk #

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

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

newtype Release #

`Chunk`s have comparison behaviour according to SemVer's rules for preleases.

Constructors

Release (NonEmpty Chunk) |

#### Instances

Instances details

Data Release # |
Instance details Defined in Data.Versions Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Release -> c Release gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Release toConstr :: Release -> Constr dataTypeOf :: Release -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Release) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Release) gmapT :: (forall b. Data b => b -> b) -> Release -> Release gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Release -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Release -> r gmapQ :: (forall d. Data d => d -> u) -> Release -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Release -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Release -> m Release gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Release -> m Release gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Release -> m Release
Generic Release # |
Instance details Defined in Data.Versions Associated Types type Rep Release :: Type -> Type Methods from :: Release -> Rep Release x to :: Rep Release x -> Release
Read Release # |
Instance details Defined in Data.Versions Methods readsPrec :: Int -> ReadS Release readList :: ReadS [Release] readPrec :: ReadPrec Release readListPrec :: ReadPrec [Release]
Show Release # |
Instance details Defined in Data.Versions Methods showsPrec :: Int -> Release -> ShowS show :: Release -> String showList :: [Release] -> ShowS
NFData Release # |
Instance details Defined in Data.Versions Methods rnf :: Release -> ()
Eq Release # |
Instance details Defined in Data.Versions Methods (==) :: Release -> Release -> Bool (/=) :: Release -> Release -> Bool
Ord Release # |
Instance details Defined in Data.Versions Methods compare :: Release -> Release -> Ordering (<) :: Release -> Release -> Bool (<=) :: Release -> Release -> Bool (>) :: Release -> Release -> Bool (>=) :: Release -> Release -> Bool max :: Release -> Release -> Release min :: Release -> Release -> Release
Hashable Release # |
Instance details Defined in Data.Versions Methods hashWithSalt :: Int -> Release -> Int # hash :: Release -> Int #
Lift Release # |
Instance details Defined in Data.Versions Methods lift :: Quote m => Release -> m Exp liftTyped :: forall (m :: Type -> Type). Quote m => Release -> Code m Release
type Rep Release # |
Instance details Defined in Data.Versions type Rep Release = D1 ('MetaData "Release" "Data.Versions" "versions-6.0.3-5Hl9CfORC6I4tKyKmhjwjA" 'True) (C1 ('MetaCons "Release" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (NonEmpty Chunk))))

newtype Chunks #

`Chunk`s that have a comparison behaviour specific to `Version`.

Constructors

Chunks (NonEmpty Chunk) |

#### Instances

Instances details

Data Chunks # |
Instance details Defined in Data.Versions Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Chunks -> c Chunks gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Chunks toConstr :: Chunks -> Constr dataTypeOf :: Chunks -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Chunks) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Chunks) gmapT :: (forall b. Data b => b -> b) -> Chunks -> Chunks gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Chunks -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Chunks -> r gmapQ :: (forall d. Data d => d -> u) -> Chunks -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Chunks -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Chunks -> m Chunks gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Chunks -> m Chunks gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Chunks -> m Chunks
Generic Chunks # |
Instance details Defined in Data.Versions Associated Types type Rep Chunks :: Type -> Type Methods from :: Chunks -> Rep Chunks x to :: Rep Chunks x -> Chunks
Show Chunks # |
Instance details Defined in Data.Versions Methods showsPrec :: Int -> Chunks -> ShowS show :: Chunks -> String showList :: [Chunks] -> ShowS
NFData Chunks # |
Instance details Defined in Data.Versions Methods rnf :: Chunks -> ()
Eq Chunks # |
Instance details Defined in Data.Versions Methods (==) :: Chunks -> Chunks -> Bool (/=) :: Chunks -> Chunks -> Bool
Ord Chunks # |
Instance details Defined in Data.Versions Methods compare :: Chunks -> Chunks -> Ordering (<) :: Chunks -> Chunks -> Bool (<=) :: Chunks -> Chunks -> Bool (>) :: Chunks -> Chunks -> Bool (>=) :: Chunks -> Chunks -> Bool max :: Chunks -> Chunks -> Chunks min :: Chunks -> Chunks -> Chunks
Hashable Chunks # |
Instance details Defined in Data.Versions Methods hashWithSalt :: Int -> Chunks -> Int # hash :: Chunks -> Int #
Lift Chunks # |
Instance details Defined in Data.Versions Methods lift :: Quote m => Chunks -> m Exp liftTyped :: forall (m :: Type -> Type). Quote m => Chunks -> Code m Chunks
type Rep Chunks # |
Instance details Defined in Data.Versions type Rep Chunks = D1 ('MetaData "Chunks" "Data.Versions" "versions-6.0.3-5Hl9CfORC6I4tKyKmhjwjA" 'True) (C1 ('MetaCons "Chunks" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (NonEmpty Chunk))))

data Chunk #

A logical unit of a version number.

Either entirely numerical (with no leading zeroes) or entirely alphanumerical (with a free mixture of numbers, letters, and hyphens.)

Groups of these (like `Release`) are separated by periods to form a full section of a version number.

Examples:

    1
    20150826
    r3
    0rc1-abc3

Constructors

Numeric Word |
Alphanum Text |

#### Instances

Instances details

Data Chunk # |
Instance details Defined in Data.Versions Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Chunk -> c Chunk gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Chunk toConstr :: Chunk -> Constr dataTypeOf :: Chunk -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Chunk) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Chunk) gmapT :: (forall b. Data b => b -> b) -> Chunk -> Chunk gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Chunk -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Chunk -> r gmapQ :: (forall d. Data d => d -> u) -> Chunk -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Chunk -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Chunk -> m Chunk gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Chunk -> m Chunk gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Chunk -> m Chunk
Generic Chunk # |
Instance details Defined in Data.Versions Associated Types type Rep Chunk :: Type -> Type Methods from :: Chunk -> Rep Chunk x to :: Rep Chunk x -> Chunk
Read Chunk # |
Instance details Defined in Data.Versions Methods readsPrec :: Int -> ReadS Chunk readList :: ReadS [Chunk] readPrec :: ReadPrec Chunk readListPrec :: ReadPrec [Chunk]
Show Chunk # |
Instance details Defined in Data.Versions Methods showsPrec :: Int -> Chunk -> ShowS show :: Chunk -> String showList :: [Chunk] -> ShowS
NFData Chunk # |
Instance details Defined in Data.Versions Methods rnf :: Chunk -> ()
Eq Chunk # |
Instance details Defined in Data.Versions Methods (==) :: Chunk -> Chunk -> Bool (/=) :: Chunk -> Chunk -> Bool
Hashable Chunk # |
Instance details Defined in Data.Versions Methods hashWithSalt :: Int -> Chunk -> Int # hash :: Chunk -> Int #
Lift Chunk # |
Instance details Defined in Data.Versions Methods lift :: Quote m => Chunk -> m Exp liftTyped :: forall (m :: Type -> Type). Quote m => Chunk -> Code m Chunk
type Rep Chunk # |
Instance details Defined in Data.Versions type Rep Chunk = D1 ('MetaData "Chunk" "Data.Versions" "versions-6.0.3-5Hl9CfORC6I4tKyKmhjwjA" 'False) (C1 ('MetaCons "Numeric" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Word)) :+: C1 ('MetaCons "Alphanum" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))

data MChunk #

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`.

Constructors

MDigit Word Text | A nice numeric value.
MRev Word Text | A numeric value preceeded by an `r`, indicating a revision.
MPlain Text | Anything else.

#### Instances

Instances details

Data MChunk # |
Instance details Defined in Data.Versions Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MChunk -> c MChunk gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c MChunk toConstr :: MChunk -> Constr dataTypeOf :: MChunk -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c MChunk) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MChunk) gmapT :: (forall b. Data b => b -> b) -> MChunk -> MChunk gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MChunk -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MChunk -> r gmapQ :: (forall d. Data d => d -> u) -> MChunk -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> MChunk -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> MChunk -> m MChunk gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MChunk -> m MChunk gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MChunk -> m MChunk
Generic MChunk # |
Instance details Defined in Data.Versions Associated Types type Rep MChunk :: Type -> Type Methods from :: MChunk -> Rep MChunk x to :: Rep MChunk x -> MChunk
Show MChunk # |
Instance details Defined in Data.Versions Methods showsPrec :: Int -> MChunk -> ShowS show :: MChunk -> String showList :: [MChunk] -> ShowS
NFData MChunk # |
Instance details Defined in Data.Versions Methods rnf :: MChunk -> ()
Eq MChunk # |
Instance details Defined in Data.Versions Methods (==) :: MChunk -> MChunk -> Bool (/=) :: MChunk -> MChunk -> Bool
Ord MChunk # |
Instance details Defined in Data.Versions Methods compare :: MChunk -> MChunk -> Ordering (<) :: MChunk -> MChunk -> Bool (<=) :: MChunk -> MChunk -> Bool (>) :: MChunk -> MChunk -> Bool (>=) :: MChunk -> MChunk -> Bool max :: MChunk -> MChunk -> MChunk min :: MChunk -> MChunk -> MChunk
Hashable MChunk # |
Instance details Defined in Data.Versions Methods hashWithSalt :: Int -> MChunk -> Int # hash :: MChunk -> Int #
Lift MChunk # |
Instance details Defined in Data.Versions Methods lift :: Quote m => MChunk -> m Exp liftTyped :: forall (m :: Type -> Type). Quote m => MChunk -> Code m MChunk
type Rep MChunk # |
Instance details Defined in Data.Versions type Rep MChunk = D1 ('MetaData "MChunk" "Data.Versions" "versions-6.0.3-5Hl9CfORC6I4tKyKmhjwjA" 'False) (C1 ('MetaCons "MDigit" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Word) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)) :+: (C1 ('MetaCons "MRev" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Word) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)) :+: C1 ('MetaCons "MPlain" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text))))

data VSep #

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 tilde (~). Example: `12.0.0-3ubuntu1~20.04.5`
- 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.

Constructors

VColon |
VHyphen |
VPlus |
VUnder |
VTilde |

#### Instances

Instances details

Data VSep # |
Instance details Defined in Data.Versions Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VSep -> c VSep gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VSep toConstr :: VSep -> Constr dataTypeOf :: VSep -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c VSep) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VSep) gmapT :: (forall b. Data b => b -> b) -> VSep -> VSep gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VSep -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VSep -> r gmapQ :: (forall d. Data d => d -> u) -> VSep -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> VSep -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> VSep -> m VSep gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VSep -> m VSep gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VSep -> m VSep
Generic VSep # |
Instance details Defined in Data.Versions Associated Types type Rep VSep :: Type -> Type Methods from :: VSep -> Rep VSep x to :: Rep VSep x -> VSep
Show VSep # |
Instance details Defined in Data.Versions Methods showsPrec :: Int -> VSep -> ShowS show :: VSep -> String showList :: [VSep] -> ShowS
NFData VSep # |
Instance details Defined in Data.Versions Methods rnf :: VSep -> ()
Eq VSep # |
Instance details Defined in Data.Versions Methods (==) :: VSep -> VSep -> Bool (/=) :: VSep -> VSep -> Bool
Hashable VSep # |
Instance details Defined in Data.Versions Methods hashWithSalt :: Int -> VSep -> Int # hash :: VSep -> Int #
Lift VSep # |
Instance details Defined in Data.Versions Methods lift :: Quote m => VSep -> m Exp liftTyped :: forall (m :: Type -> Type). Quote m => VSep -> Code m VSep
type Rep VSep # |
Instance details Defined in Data.Versions type Rep VSep = D1 ('MetaData "VSep" "Data.Versions" "versions-6.0.3-5Hl9CfORC6I4tKyKmhjwjA" 'False) ((C1 ('MetaCons "VColon" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "VHyphen" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "VPlus" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "VUnder" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "VTilde" 'PrefixI 'False) (U1 :: Type -> Type))))

## Compile-time Constructors

versioningQ :: Text -> Q Exp #

Parse a `Versioning` at compile time.

semverQ :: Text -> Q Exp #

Parse a `SemVer` at compile time.

versionQ :: Text -> Q Exp #

Parse a `Version` at compile time.

messQ :: Text -> Q Exp #

Parse a `Mess` at compile time.

pvpQ :: Text -> Q Exp #

Parse a `PVP` at compile time.

## Conversions

semverToVersion :: SemVer -> Version #

Convert a `SemVer` to a `Version`.

versionToMess :: Version -> Mess #

Convert a `Version` to a `Mess`.

versionToPvp :: Version -> Maybe PVP #

Convert a `Version` to a `PVP`. Fails if there is an epoch present, but otherwise ignores the `Release` and other metadata. Naturally it also fails if any of the version components contain any non-digits.

# Parsing Versions

type ParsingError = ParseErrorBundle Text Void #

A synonym for the more verbose `megaparsec` error type.

versioning :: Text -> Either ParsingError Versioning #

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

semver :: Text -> Either ParsingError SemVer #

Parse a (Ideal) Semantic Version.

pvp :: Text -> Either ParsingError PVP #

Parse a (Haskell) `PVP`, as defined above.

version :: Text -> Either ParsingError Version #

Parse a (General) `Version`, as defined above.

mess :: Text -> Either ParsingError Mess #

Parse a (Complex) `Mess`, as defined above.

## Megaparsec Parsers

For when you'd like to mix version parsing into some larger parser.

versioning' :: Parsec Void Text Versioning #

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

semver' :: Parsec Void Text SemVer #

Internal megaparsec parser of `semver`.

pvp' :: Parsec Void Text PVP #

Internal megaparsec parser of `pvp`.

version' :: Parsec Void Text Version #

Internal megaparsec parser of `version`.

mess' :: Parsec Void Text Mess #

Internal megaparsec parser of `mess`.

# Pretty Printing

prettyV :: Versioning -> Text #

Convert any parsed Versioning type to its textual representation.

prettySemVer :: SemVer -> Text #

Convert a `SemVer` back to its textual representation.

prettyPVP :: PVP -> Text #

Convert a `PVP` back to its textual representation.

prettyVer :: Version -> Text #

Convert a `Version` back to its textual representation.

prettyMess :: Mess -> Text #

Convert a `Mess` back to its textual representation.

errorBundlePretty #

Arguments

:: (VisualStream s, TraversableStream s, ShowErrorComponent e) |
=> ParseErrorBundle s e | Parse error bundle to display
-> String | Textual rendition of the bundle

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

Since: megaparsec-7.0.0

# Lenses

type Lens' s a = forall f. Functor f => (a -> f a) -> s -> f s #

Simple Lenses compatible with both lens and microlens.

type Traversal' s a = forall f. Applicative f => (a -> f a) -> s -> f s #

Simple Traversals compatible with both lens and microlens.

class Semantic v where #

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"

Methods

major :: Traversal' v Word #

    MAJOR.minor.patch-prerel+meta

minor :: Traversal' v Word #

    major.MINOR.patch-prerel+meta

patch :: Traversal' v Word #

    major.minor.PATCH-prerel+meta

release :: Traversal' v (Maybe Release) #

    major.minor.patch-PREREL+meta

meta :: Traversal' v (Maybe Text) #

    major.minor.patch-prerel+META

semantic :: Traversal' v SemVer #

A Natural Transformation into an proper `SemVer`.

#### Instances

Instances details

Semantic Text # |
Instance details Defined in Data.Versions Methods major :: Traversal' Text Word # minor :: Traversal' Text Word # patch :: Traversal' Text Word # release :: Traversal' Text (Maybe Release) # meta :: Traversal' Text (Maybe Text) # semantic :: Traversal' Text SemVer #
Semantic Mess # |
Instance details Defined in Data.Versions Methods major :: Traversal' Mess Word # minor :: Traversal' Mess Word # patch :: Traversal' Mess Word # release :: Traversal' Mess (Maybe Release) # meta :: Traversal' Mess (Maybe Text) # semantic :: Traversal' Mess SemVer #
Semantic PVP # |
Instance details Defined in Data.Versions Methods major :: Traversal' PVP Word # minor :: Traversal' PVP Word # patch :: Traversal' PVP Word # release :: Traversal' PVP (Maybe Release) # meta :: Traversal' PVP (Maybe Text) # semantic :: Traversal' PVP SemVer #
Semantic SemVer # |
Instance details Defined in Data.Versions Methods major :: Traversal' SemVer Word # minor :: Traversal' SemVer Word # patch :: Traversal' SemVer Word # release :: Traversal' SemVer (Maybe Release) # meta :: Traversal' SemVer (Maybe Text) # semantic :: Traversal' SemVer SemVer #
Semantic Version # |
Instance details Defined in Data.Versions Methods major :: Traversal' Version Word # minor :: Traversal' Version Word # patch :: Traversal' Version Word # release :: Traversal' Version (Maybe Release) # meta :: Traversal' Version (Maybe Text) # semantic :: Traversal' Version SemVer #
Semantic Versioning # |
Instance details Defined in Data.Versions Methods major :: Traversal' Versioning Word # minor :: Traversal' Versioning Word # patch :: Traversal' Versioning Word # release :: Traversal' Versioning (Maybe Release) # meta :: Traversal' Versioning (Maybe Text) # semantic :: Traversal' Versioning SemVer #

## Traversing Text

When traversing `Text`, leveraging its `Semantic` instance will likely benefit you more than using these Traversals directly.

_Versioning :: Traversal' Text Versioning #

Traverse some Text for its inner versioning.

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

_SemVer :: Traversal' Text SemVer #

Traverse some Text for its inner SemVer.

_Version :: Traversal' Text Version #

Traverse some Text for its inner Version.

_Mess :: Traversal' Text Mess #

Traverse some Text for its inner Mess.

## Versioning Traversals

_Ideal :: Traversal' Versioning SemVer #

Possibly extract a `SemVer` from a `Versioning`.

_General :: Traversal' Versioning Version #

Possibly extract a `Version` from a `Versioning`.

_Complex :: Traversal' Versioning Mess #

Possibly extract a `Mess` from a `Versioning`.

## (General) Version Lenses

epoch :: Lens' Version (Maybe Word) #

A `Version`'s inner epoch `Word`.