Salve.Internal

WARNING: This module should be considered private! If you find yourself wanting to import something from this module, please open an issue to get that thing exported from Salve.

Documentation

data Version

A semantic version number. Versions have five parts:

1. majorLens: The major version number.
2. minorLens: The minor version number.
3. patchLens: The patch version number.
4. preReleasesLens: A list of pre-release identifiers.
5. buildsLens: A list of build metadata.

Use parseVersion to create versions.

Constructors

Version

Fields

• versionMajor :: Word64
• versionMinor :: Word64
• versionPatch :: Word64
• versionPreReleases :: [PreRelease]
• versionBuilds :: [Build]

Instances

Eq Version

Defined in Salve.Internal

Methods

(==) :: Version -> Version -> Bool

(/=) :: Version -> Version -> Bool

Data Version

Defined in Salve.Internal

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 :: (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

Ord Version

In general, versions compare in the way that you would expect. First the major version numbers are compared, then the minors, then the patches.

>>> compare <$> parseVersion "1.2.3" <*> parseVersion "2.0.0"
Just LT
>>> compare <$> parseVersion "1.2.3" <*> parseVersion "1.3.0"
Just LT
>>> compare <$> parseVersion "1.2.3" <*> parseVersion "1.2.4"
Just LT

Numbers are compared numerically, not alphabetically.

>>> compare <$> parseVersion "0.0.9" <*> parseVersion "0.0.10"
Just LT

If all the numbers are the same, the pre-releases are compared.

>>> compare <$> parseVersion "1.2.3-a" <*> parseVersion "1.2.3-b"
Just LT

A version with a pre-release is always less than a version without one as long as the other parts are the same.

>>> compare <$> parseVersion "1.2.3-pre" <*> parseVersion "1.2.3"
Just LT
>>> compare <$> parseVersion "1.2.4-pre" <*> parseVersion "1.2.3"
Just GT

Builds are not considered when comparing versions.

>>> compare <$> parseVersion "1.2.3+a" <*> parseVersion "1.2.3+b"
Just EQ
>>> (==) <$> parseVersion "1.2.3+a" <*> parseVersion "1.2.3+b"
Just False

Defined in Salve.Internal

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

Read Version

Defined in Salve.Internal

Methods

readsPrec :: Int -> ReadS Version

readList :: ReadS [Version]

readPrec :: ReadPrec Version

readListPrec :: ReadPrec [Version]

Show Version

Defined in Salve.Internal

Methods

showsPrec :: Int -> Version -> ShowS

show :: Version -> String

showList :: [Version] -> ShowS

Generic Version

Defined in Salve.Internal

Associated Types

type Rep Version :: Type -> Type

Methods

from :: Version -> Rep Version x

to :: Rep Version x -> Version

type Rep Version

Defined in Salve.Internal

type Rep Version = D1 (MetaData "Version" "Salve.Internal" "salve-1.0.10-CS6HqfWAQu5RpiFvSg5on" False) (C1 (MetaCons "Version" PrefixI True) ((S1 (MetaSel (Just "versionMajor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word64) :*: S1 (MetaSel (Just "versionMinor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word64)) :*: (S1 (MetaSel (Just "versionPatch") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word64) :*: (S1 (MetaSel (Just "versionPreReleases") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [PreRelease]) :*: S1 (MetaSel (Just "versionBuilds") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Build])))))

data PreRelease

Pre-release information attached to a version. These can either be numeric or textual. They must not be empty.

• Numeric: Can be any non-negative integer. Cannot have leading zeros.
• Textual: Can be any string of ASCII digits, letters, or hyphens. Cannot be all digits, as that would be numeric.

In general, pre-releases must match the regular expression /^[-0-9A-Za-z]+$/.

Use parsePreRelease to create pre-releases.

Constructors

PreReleaseNumeric Word64

PreReleaseTextual String

Instances

Eq PreRelease

Defined in Salve.Internal

Methods

(==) :: PreRelease -> PreRelease -> Bool

(/=) :: PreRelease -> PreRelease -> Bool

Data PreRelease

Defined in Salve.Internal

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PreRelease -> c PreRelease

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PreRelease

toConstr :: PreRelease -> Constr

dataTypeOf :: PreRelease -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PreRelease)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PreRelease)

gmapT :: (forall b. Data b => b -> b) -> PreRelease -> PreRelease

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PreRelease -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PreRelease -> r

gmapQ :: (forall d. Data d => d -> u) -> PreRelease -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> PreRelease -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PreRelease -> m PreRelease

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PreRelease -> m PreRelease

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PreRelease -> m PreRelease

Ord PreRelease

Numeric pre-releases are always less than textual pre-releases.

>>> compare <$> parsePreRelease "1" <*> parsePreRelease "a"
Just LT

Numeric pre-releases are compared numerically.

>>> compare <$> parsePreRelease "9" <*> parsePreRelease "10"
Just LT

Textual pre-releases are compared alphabetically.

>>> compare <$> parsePreRelease "p10" <*> parsePreRelease "p9"
Just LT

Defined in Salve.Internal

Methods

compare :: PreRelease -> PreRelease -> Ordering

(<) :: PreRelease -> PreRelease -> Bool

(<=) :: PreRelease -> PreRelease -> Bool

(>) :: PreRelease -> PreRelease -> Bool

(>=) :: PreRelease -> PreRelease -> Bool

max :: PreRelease -> PreRelease -> PreRelease

min :: PreRelease -> PreRelease -> PreRelease

Read PreRelease

Defined in Salve.Internal

Methods

readsPrec :: Int -> ReadS PreRelease

readList :: ReadS [PreRelease]

readPrec :: ReadPrec PreRelease

readListPrec :: ReadPrec [PreRelease]

Show PreRelease

Defined in Salve.Internal

Methods

showsPrec :: Int -> PreRelease -> ShowS

show :: PreRelease -> String

showList :: [PreRelease] -> ShowS

Generic PreRelease

Defined in Salve.Internal

Associated Types

type Rep PreRelease :: Type -> Type

Methods

from :: PreRelease -> Rep PreRelease x

to :: Rep PreRelease x -> PreRelease

type Rep PreRelease

Defined in Salve.Internal

type Rep PreRelease = D1 (MetaData "PreRelease" "Salve.Internal" "salve-1.0.10-CS6HqfWAQu5RpiFvSg5on" False) (C1 (MetaCons "PreReleaseNumeric" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word64)) :+: C1 (MetaCons "PreReleaseTextual" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))

newtype Build

Build metadata attached to a version. These are similar to PreReleases with some key differences:

1. There is no such thing as numeric builds. Even though builds can look like numbers, all builds are textual.
2. As a result, builds that look numeric are allowed to have leading zeros.
3. Builds cannot be compared. That is, they do not have an Ord instance.

Use parseBuild to create builds.

Constructors

Build String

Instances

Eq Build

Defined in Salve.Internal

Methods

(==) :: Build -> Build -> Bool

(/=) :: Build -> Build -> Bool

Data Build

Defined in Salve.Internal

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Build -> c Build

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Build

toConstr :: Build -> Constr

dataTypeOf :: Build -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Build)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Build)

gmapT :: (forall b. Data b => b -> b) -> Build -> Build

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Build -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Build -> r

gmapQ :: (forall d. Data d => d -> u) -> Build -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Build -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Build -> m Build

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Build -> m Build

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Build -> m Build

Read Build

Defined in Salve.Internal

Methods

readsPrec :: Int -> ReadS Build

readList :: ReadS [Build]

readPrec :: ReadPrec Build

readListPrec :: ReadPrec [Build]

Show Build

Defined in Salve.Internal

Methods

showsPrec :: Int -> Build -> ShowS

show :: Build -> String

showList :: [Build] -> ShowS

Generic Build

Defined in Salve.Internal

Associated Types

type Rep Build :: Type -> Type

Methods

from :: Build -> Rep Build x

to :: Rep Build x -> Build

type Rep Build

Defined in Salve.Internal

type Rep Build = D1 (MetaData "Build" "Salve.Internal" "salve-1.0.10-CS6HqfWAQu5RpiFvSg5on" True) (C1 (MetaCons "Build" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))

data Constraint

Constrains allowable version numbers.

Use parseConstraint to create constraints and satisfiesConstraint to see if a version number satisfies a constraint.

Constructors

ConstraintOperator Operator Version

ConstraintHyphen Version Version

ConstraintWildcard Wildcard

ConstraintAnd Constraint Constraint

ConstraintOr Constraint Constraint

Instances

Eq Constraint

Defined in Salve.Internal

Methods

(==) :: Constraint -> Constraint -> Bool

(/=) :: Constraint -> Constraint -> Bool

Data Constraint

Defined in Salve.Internal

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Constraint -> c Constraint

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Constraint

toConstr :: Constraint -> Constr

dataTypeOf :: Constraint -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Constraint)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Constraint)

gmapT :: (forall b. Data b => b -> b) -> Constraint -> Constraint

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Constraint -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Constraint -> r

gmapQ :: (forall d. Data d => d -> u) -> Constraint -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Constraint -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Constraint -> m Constraint

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Constraint -> m Constraint

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Constraint -> m Constraint

Ord Constraint

Defined in Salve.Internal

Methods

compare :: Constraint -> Constraint -> Ordering

(<) :: Constraint -> Constraint -> Bool

(<=) :: Constraint -> Constraint -> Bool

(>) :: Constraint -> Constraint -> Bool

(>=) :: Constraint -> Constraint -> Bool

max :: Constraint -> Constraint -> Constraint

min :: Constraint -> Constraint -> Constraint

Read Constraint

Defined in Salve.Internal

Methods

readsPrec :: Int -> ReadS Constraint

readList :: ReadS [Constraint]

readPrec :: ReadPrec Constraint

readListPrec :: ReadPrec [Constraint]

Show Constraint

Defined in Salve.Internal

Methods

showsPrec :: Int -> Constraint -> ShowS

show :: Constraint -> String

showList :: [Constraint] -> ShowS

Generic Constraint

Defined in Salve.Internal

Associated Types

type Rep Constraint :: Type -> Type

Methods

from :: Constraint -> Rep Constraint x

to :: Rep Constraint x -> Constraint

type Rep Constraint

Defined in Salve.Internal

type Rep Constraint = D1 (MetaData "Constraint" "Salve.Internal" "salve-1.0.10-CS6HqfWAQu5RpiFvSg5on" False) ((C1 (MetaCons "ConstraintOperator" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Operator) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Version)) :+: C1 (MetaCons "ConstraintHyphen" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Version) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Version))) :+: (C1 (MetaCons "ConstraintWildcard" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Wildcard)) :+: (C1 (MetaCons "ConstraintAnd" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Constraint) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Constraint)) :+: C1 (MetaCons "ConstraintOr" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Constraint) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Constraint)))))

makeVersion :: Word64 -> Word64 -> Word64 -> [PreRelease] -> [Build] -> Version

Makes a new version number.

>>> makeVersion 1 2 3 [unsafeParsePreRelease "pre"] [unsafeParseBuild "build"]
Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [PreReleaseTextual "pre"], versionBuilds = [Build "build"]}

This can be a useful alternative to parseVersion if you want a total way to create a version.

initialVersion :: Version

The initial version number for development.

>>> initialVersion
Version {versionMajor = 0, versionMinor = 0, versionPatch = 0, versionPreReleases = [], versionBuilds = []}

parseVersion :: String -> Maybe Version

Attempts to parse a version. This parser follows SemVer's BNF.

>>> parseVersion "1.2.3-p.4+b.5"
Just (Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [PreReleaseTextual "p",PreReleaseNumeric 4], versionBuilds = [Build "b",Build "5"]})

Returns Nothing if the parse fails.

>>> parseVersion "wrong"
Nothing

Whitespace is allowed.

>>> parseVersion " 1.2.3 "
Just (Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [], versionBuilds = []})

parsePreRelease :: String -> Maybe PreRelease

Attempts to parse a pre-release.

>>> parsePreRelease "pre"
Just (PreReleaseTextual "pre")
>>> parsePreRelease "1"
Just (PreReleaseNumeric 1)

Returns Nothing if the parse fails.

>>> parsePreRelease "wrong!"
Nothing

Numeric pre-releases cannot contain leading zeros.

>>> parsePreRelease "01"
Nothing

parseBuild :: String -> Maybe Build

Attempts to parse a build.

>>> parseBuild "build"
Just (Build "build")
>>> parseBuild "1"
Just (Build "1")

Returns Nothing if the parse fails.

>>> parseBuild "wrong!"
Nothing

Unlike pre-releases, numeric builds can have leading zeros.

>>> parseBuild "01"
Just (Build "01")

parseConstraint :: String -> Maybe Constraint

Attempts to parse a constraint. This parser mostly follows npm's BNF.

>>> parseConstraint ">1.2.3"
Just (ConstraintOperator OperatorGT (Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [], versionBuilds = []}))

Returns Nothing if the parse fails.

>>> parseConstraint "wrong"
Nothing

The two departures from npm's BNF are that x-ranges cannot be used with other operators and partial version numbers are not allowed.

>>> parseConstraint "1.2.x"
Just (ConstraintWildcard (WildcardPatch 1 2))
>>> parseConstraint ">=1.2.x"
Nothing

>>> parseConstraint "1.2"
Nothing
>>> parseConstraint ">=1.2"
Nothing

unsafeParseVersion :: String -> Version

Parses a version.

>>> unsafeParseVersion "1.2.3-p.4+b.5"
Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [PreReleaseTextual "p",PreReleaseNumeric 4], versionBuilds = [Build "b",Build "5"]}

Raises an exception if the parse fails.

>>> unsafeParseVersion "wrong"
*** Exception: unsafeParseVersion: invalid version: "wrong"
...

See parseVersion for a safe version of this function.

unsafeParsePreRelease :: String -> PreRelease

Parses a pre-release.

>>> unsafeParsePreRelease "pre"
PreReleaseTextual "pre"

Raises an exception if the parse fails.

>>> unsafeParsePreRelease "wrong!"
*** Exception: unsafeParsePreRelease: invalid pre-release: "wrong!"
...

See parsePreRelease for a safe version of this function.

unsafeParseBuild :: String -> Build

Parses a build.

>>> unsafeParseBuild "build"
Build "build"

Raises an exception if the parse fails.

>>> unsafeParseBuild "wrong!"
Build "*** Exception: unsafeParseBuild: invalid build: "wrong!"
...

See parseBuild for a safe version of this function.

unsafeParseConstraint :: String -> Constraint

Parses a constraint.

>>> unsafeParseConstraint ">1.2.3"
ConstraintOperator OperatorGT (Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [], versionBuilds = []})

Raises an exception if the parse fails.

>>> unsafeParseConstraint "wrong"
*** Exception: unsafeParseConstraint: invalid constraint: "wrong"
...

See parseConstraint for a safe version of this function.

renderVersion :: Version -> String

Renders a version.

>>> renderVersion <$> parseVersion "1.2.3-p.4+b.5"
Just "1.2.3-p.4+b.5"

renderPreRelease :: PreRelease -> String

Renders a pre-release.

>>> renderPreRelease <$> parsePreRelease "pre"
Just "pre"
>>> renderPreRelease <$> parsePreRelease "1"
Just "1"

renderBuild :: Build -> String

Renders a build.

>>> renderBuild <$> parseBuild "build"
Just "build"
>>> renderBuild <$> parseBuild "1"
Just "1"

renderConstraint :: Constraint -> String

Renders a constraint.

>>> renderConstraint <$> parseConstraint ">1.2.3"
Just ">1.2.3"

Parsing and rendering a constraint doesn't always return what you started with.

>>> renderConstraint <$> parseConstraint "=1.2.3"
Just "1.2.3"

isUnstable :: Version -> Bool

Returns True if the major version number is zero, False otherwise.

>>> isUnstable <$> parseVersion "0.1.2"
Just True
>>> isUnstable <$> parseVersion "1.0.0"
Just False

isStable :: Version -> Bool

Returns True if the major version number is not zero, False otherwise.

>>> isStable <$> parseVersion "1.0.0"
Just True
>>> isStable <$> parseVersion "0.1.2"
Just False

fromBaseVersion :: Version -> Version

Converts from a Version from the base package.

>>> renderVersion . fromBaseVersion $ Version.makeVersion [1, 2, 3]
"1.2.3"

Missing version components are set to zero.

>>> renderVersion . fromBaseVersion $ Version.makeVersion []
"0.0.0"
>>> renderVersion . fromBaseVersion $ Version.makeVersion [1]
"1.0.0"
>>> renderVersion . fromBaseVersion $ Version.makeVersion [1, 2]
"1.2.0"

Extra version components are ignored.

>>> renderVersion . fromBaseVersion $ Version.makeVersion [1, 2, 3, 4]
"1.2.3"

Tags are ignored.

>>> renderVersion . fromBaseVersion $ Version.Version [] ["ignored"]
"0.0.0"

toBaseVersion :: Version -> Version

Converts to a Version from the base package.

>>> toBaseVersion <$> parseVersion "1.2.3"
Just (Version {versionBranch = [1,2,3], versionTags = []})

Pre-releases and builds are converted to tags.

>>> toBaseVersion <$> parseVersion "1.2.3-pre+build"
Just (Version {versionBranch = [1,2,3], versionTags = ["pre","build"]})

bumpMajor :: Version -> Version

Increments the major version number.

>>> bumpMajor <$> parseVersion "0.0.0"
Just (Version {versionMajor = 1, versionMinor = 0, versionPatch = 0, versionPreReleases = [], versionBuilds = []})

The minor and patch numbers are reset to zero.

>>> bumpMajor <$> parseVersion "1.2.3"
Just (Version {versionMajor = 2, versionMinor = 0, versionPatch = 0, versionPreReleases = [], versionBuilds = []})

The pre-releases and builds are removed.

>>> bumpMajor <$> parseVersion "0.0.0-pre+build"
Just (Version {versionMajor = 1, versionMinor = 0, versionPatch = 0, versionPreReleases = [], versionBuilds = []})

Consider using majorLens if you want to arbitrarily change the major number, or if you don't want the other parts of the version to change.

bumpMinor :: Version -> Version

Increments the minor version number.

>>> bumpMinor <$> parseVersion "0.0.0"
Just (Version {versionMajor = 0, versionMinor = 1, versionPatch = 0, versionPreReleases = [], versionBuilds = []})

The patch number is reset to zero.

>>> bumpMinor <$> parseVersion "1.2.3"
Just (Version {versionMajor = 1, versionMinor = 3, versionPatch = 0, versionPreReleases = [], versionBuilds = []})

The pre-releases and builds are removed.

>>> bumpMinor <$> parseVersion "0.0.0-pre+build"
Just (Version {versionMajor = 0, versionMinor = 1, versionPatch = 0, versionPreReleases = [], versionBuilds = []})

Consider using minorLens if you want to arbitrarily change the minor number, or if you don't want the other parts of the version to change.

bumpPatch :: Version -> Version

Increments the patch number.

>>> bumpPatch <$> parseVersion "0.0.0"
Just (Version {versionMajor = 0, versionMinor = 0, versionPatch = 1, versionPreReleases = [], versionBuilds = []})

The major and minor numbers are not changed.

>>> bumpPatch <$> parseVersion "1.2.3"
Just (Version {versionMajor = 1, versionMinor = 2, versionPatch = 4, versionPreReleases = [], versionBuilds = []})

The pre-releases and builds are removed.

>>> bumpPatch <$> parseVersion "0.0.0-pre+build"
Just (Version {versionMajor = 0, versionMinor = 0, versionPatch = 1, versionPreReleases = [], versionBuilds = []})

Consider using patchLens if you want to arbitrarily change the patch number, or if you don't want the other parts of the version to change.

satisfiesConstraint :: Constraint -> Version -> Bool

Returns True if the version satisfies the constraint, False otherwise.

>>> satisfiesConstraint <$> parseConstraint ">1.2.0" <*> parseVersion "1.2.3"
Just True

majorLens :: Functor f => (Word64 -> f Word64) -> Version -> f Version

Focuses on the major version number.

>>> view majorLens <$> parseVersion "1.2.3-pre.4+build.5"
Just 1
>>> set majorLens 4 <$> parseVersion "1.2.3"
Just (Version {versionMajor = 4, versionMinor = 2, versionPatch = 3, versionPreReleases = [], versionBuilds = []})

minorLens :: Functor f => (Word64 -> f Word64) -> Version -> f Version

Focuses on the minor version number.

>>> view minorLens <$> parseVersion "1.2.3-pre.4+build.5"
Just 2
>>> set minorLens 4 <$> parseVersion "1.2.3"
Just (Version {versionMajor = 1, versionMinor = 4, versionPatch = 3, versionPreReleases = [], versionBuilds = []})

patchLens :: Functor f => (Word64 -> f Word64) -> Version -> f Version

Focuses on the patch version number.

>>> view patchLens <$> parseVersion "1.2.3-pre.4+build.5"
Just 3
>>> set patchLens 4 <$> parseVersion "1.2.3"
Just (Version {versionMajor = 1, versionMinor = 2, versionPatch = 4, versionPreReleases = [], versionBuilds = []})

preReleasesLens :: Functor f => ([PreRelease] -> f [PreRelease]) -> Version -> f Version

Focuses on the pre-release identifiers.

>>> view preReleasesLens <$> parseVersion "1.2.3-pre.4+build.5"
Just [PreReleaseTextual "pre",PreReleaseNumeric 4]
>>> set preReleasesLens [] <$> parseVersion "1.2.3-pre"
Just (Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [], versionBuilds = []})

buildsLens :: Functor f => ([Build] -> f [Build]) -> Version -> f Version

Focuses on the build metadata.

>>> view buildsLens <$> parseVersion "1.2.3-pre.4+build.5"
Just [Build "build",Build "5"]
>>> set buildsLens [] <$> parseVersion "1.2.3+build"
Just (Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [], versionBuilds = []})

data Operator

Constructors

OperatorLT

OperatorLE

OperatorEQ

OperatorGE

OperatorGT

OperatorTilde

OperatorCaret

Instances

Eq Operator

Defined in Salve.Internal

Methods

(==) :: Operator -> Operator -> Bool

(/=) :: Operator -> Operator -> Bool

Data Operator

Defined in Salve.Internal

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Operator -> c Operator

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Operator

toConstr :: Operator -> Constr

dataTypeOf :: Operator -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Operator)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Operator)

gmapT :: (forall b. Data b => b -> b) -> Operator -> Operator

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Operator -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Operator -> r

gmapQ :: (forall d. Data d => d -> u) -> Operator -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Operator -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Operator -> m Operator

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Operator -> m Operator

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Operator -> m Operator

Ord Operator

Defined in Salve.Internal

Methods

compare :: Operator -> Operator -> Ordering

(<) :: Operator -> Operator -> Bool

(<=) :: Operator -> Operator -> Bool

(>) :: Operator -> Operator -> Bool

(>=) :: Operator -> Operator -> Bool

max :: Operator -> Operator -> Operator

min :: Operator -> Operator -> Operator

Read Operator

Defined in Salve.Internal

Methods

readsPrec :: Int -> ReadS Operator

readList :: ReadS [Operator]

readPrec :: ReadPrec Operator

readListPrec :: ReadPrec [Operator]

Show Operator

Defined in Salve.Internal

Methods

showsPrec :: Int -> Operator -> ShowS

show :: Operator -> String

showList :: [Operator] -> ShowS

Generic Operator

Defined in Salve.Internal

Associated Types

type Rep Operator :: Type -> Type

Methods

from :: Operator -> Rep Operator x

to :: Rep Operator x -> Operator

type Rep Operator

Defined in Salve.Internal

type Rep Operator = D1 (MetaData "Operator" "Salve.Internal" "salve-1.0.10-CS6HqfWAQu5RpiFvSg5on" False) ((C1 (MetaCons "OperatorLT" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "OperatorLE" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "OperatorEQ" PrefixI False) (U1 :: Type -> Type))) :+: ((C1 (MetaCons "OperatorGE" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "OperatorGT" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "OperatorTilde" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "OperatorCaret" PrefixI False) (U1 :: Type -> Type))))

data Wildcard

Constructors

WildcardMajor

WildcardMinor Word64

WildcardPatch Word64 Word64

Instances

Eq Wildcard

Defined in Salve.Internal

Methods

(==) :: Wildcard -> Wildcard -> Bool

(/=) :: Wildcard -> Wildcard -> Bool

Data Wildcard

Defined in Salve.Internal

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Wildcard -> c Wildcard

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Wildcard

toConstr :: Wildcard -> Constr

dataTypeOf :: Wildcard -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Wildcard)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Wildcard)

gmapT :: (forall b. Data b => b -> b) -> Wildcard -> Wildcard

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Wildcard -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Wildcard -> r

gmapQ :: (forall d. Data d => d -> u) -> Wildcard -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Wildcard -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Wildcard -> m Wildcard

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Wildcard -> m Wildcard

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Wildcard -> m Wildcard

Ord Wildcard

Defined in Salve.Internal

Methods

compare :: Wildcard -> Wildcard -> Ordering

(<) :: Wildcard -> Wildcard -> Bool

(<=) :: Wildcard -> Wildcard -> Bool

(>) :: Wildcard -> Wildcard -> Bool

(>=) :: Wildcard -> Wildcard -> Bool

max :: Wildcard -> Wildcard -> Wildcard

min :: Wildcard -> Wildcard -> Wildcard

Read Wildcard

Defined in Salve.Internal

Methods

readsPrec :: Int -> ReadS Wildcard

readList :: ReadS [Wildcard]

readPrec :: ReadPrec Wildcard

readListPrec :: ReadPrec [Wildcard]

Show Wildcard

Defined in Salve.Internal

Methods

showsPrec :: Int -> Wildcard -> ShowS

show :: Wildcard -> String

showList :: [Wildcard] -> ShowS

Generic Wildcard

Defined in Salve.Internal

Associated Types

type Rep Wildcard :: Type -> Type

Methods

from :: Wildcard -> Rep Wildcard x

to :: Rep Wildcard x -> Wildcard

type Rep Wildcard

Defined in Salve.Internal

type Rep Wildcard = D1 (MetaData "Wildcard" "Salve.Internal" "salve-1.0.10-CS6HqfWAQu5RpiFvSg5on" False) (C1 (MetaCons "WildcardMajor" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "WildcardMinor" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word64)) :+: C1 (MetaCons "WildcardPatch" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word64) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word64))))

constraintLT :: Version -> Constraint

Makes a new constraint that must be less than the version number.

>>> constraintLT <$> parseVersion "1.2.3"
Just (ConstraintOperator OperatorLT (Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [], versionBuilds = []}))
>>> parseConstraint "<1.2.3"
Just (ConstraintOperator OperatorLT (Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [], versionBuilds = []}))

constraintLE :: Version -> Constraint

Makes a new constraint that must be less than or euqal to the version number.

>>> constraintLE <$> parseVersion "1.2.3"
Just (ConstraintOperator OperatorLE (Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [], versionBuilds = []}))
>>> parseConstraint "<=1.2.3"
Just (ConstraintOperator OperatorLE (Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [], versionBuilds = []}))

constraintEQ :: Version -> Constraint

Makes a new constraint that must be equal to the version number.

>>> constraintEQ <$> parseVersion "1.2.3"
Just (ConstraintOperator OperatorEQ (Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [], versionBuilds = []}))
>>> parseConstraint "=1.2.3"
Just (ConstraintOperator OperatorEQ (Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [], versionBuilds = []}))

constraintGE :: Version -> Constraint

Makes a new constraint that must be greater than or equal to the version number.

>>> constraintGE <$> parseVersion "1.2.3"
Just (ConstraintOperator OperatorGE (Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [], versionBuilds = []}))
>>> parseConstraint ">=1.2.3"
Just (ConstraintOperator OperatorGE (Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [], versionBuilds = []}))

constraintGT :: Version -> Constraint

Makes a new constraint that must be greater than the version number.

>>> constraintGT <$> parseVersion "1.2.3"
Just (ConstraintOperator OperatorGT (Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [], versionBuilds = []}))
>>> parseConstraint ">1.2.3"
Just (ConstraintOperator OperatorGT (Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [], versionBuilds = []}))

constraintAnd :: Constraint -> Constraint -> Constraint

Makes a new constraint that must satisfy both constraints.

>>> constraintAnd <$> (constraintGE <$> parseVersion "1.2.3") <*> (constraintLT <$> parseVersion "2.0.0")
Just (ConstraintAnd (ConstraintOperator OperatorGE (Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [], versionBuilds = []})) (ConstraintOperator OperatorLT (Version {versionMajor = 2, versionMinor = 0, versionPatch = 0, versionPreReleases = [], versionBuilds = []})))
>>> parseConstraint ">=1.2.3 <2.0.0"
Just (ConstraintAnd (ConstraintOperator OperatorGE (Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [], versionBuilds = []})) (ConstraintOperator OperatorLT (Version {versionMajor = 2, versionMinor = 0, versionPatch = 0, versionPreReleases = [], versionBuilds = []})))

constraintOr :: Constraint -> Constraint -> Constraint

Makes a new constraint that must satisfy either constraint.

>>> constraintOr <$> (constraintEQ <$> parseVersion "1.2.3") <*> (constraintGT <$> parseVersion "1.2.3")
Just (ConstraintOr (ConstraintOperator OperatorEQ (Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [], versionBuilds = []})) (ConstraintOperator OperatorGT (Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [], versionBuilds = []})))
>>> parseConstraint "=1.2.3 || >1.2.3"
Just (ConstraintOr (ConstraintOperator OperatorEQ (Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [], versionBuilds = []})) (ConstraintOperator OperatorGT (Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [], versionBuilds = []})))

constraintHyphen :: Version -> Version -> Constraint

Makes a new constraint that must be between the versions, inclusive.

>>> constraintHyphen <$> parseVersion "1.2.3" <*> parseVersion "2.3.4"
Just (ConstraintHyphen (Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [], versionBuilds = []}) (Version {versionMajor = 2, versionMinor = 3, versionPatch = 4, versionPreReleases = [], versionBuilds = []}))
>>> parseConstraint "1.2.3 - 2.3.4"
Just (ConstraintHyphen (Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [], versionBuilds = []}) (Version {versionMajor = 2, versionMinor = 3, versionPatch = 4, versionPreReleases = [], versionBuilds = []}))

constraintTilde :: Version -> Constraint

Makes a new constraint that allows changes to the patch version number.

>>> constraintTilde <$> parseVersion "1.2.3"
Just (ConstraintOperator OperatorTilde (Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [], versionBuilds = []}))
>>> parseConstraint "~1.2.3"
Just (ConstraintOperator OperatorTilde (Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [], versionBuilds = []}))

constraintCaret :: Version -> Constraint

Makes a new constraint that allows changes that do not modify the left-most non-zero version number.

>>> constraintCaret <$> parseVersion "1.2.3"
Just (ConstraintOperator OperatorCaret (Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [], versionBuilds = []}))
>>> parseConstraint "^1.2.3"
Just (ConstraintOperator OperatorCaret (Version {versionMajor = 1, versionMinor = 2, versionPatch = 3, versionPreReleases = [], versionBuilds = []}))