Does the version range have an explicit lower bound?

Note: this function only considers the user-specified lower bounds, but not the implicit >=0 lower bound.

>>> forM ["< 1", ">= 0 && < 1", ">= 0 || < 1", "^>= 4.20.0.0"] (fmap hasLowerBound . simpleParsec)
Just [False,True,False,True]

Since: 1.24.0.0

Is the lower bound version range greater than (GT, >)?

>>> forM ["< 1", ">= 0 && < 1", ">= 0 || < 1", "> 0 && < 1", "> 0 || < 1", "^>= 4.20.0.0"] (fmap hasGTLowerBound . simpleParsec)
Just [False,False,False,True,True,False]

Does the version range have an upper bound?

>>> forM ["< 1", ">= 0 && < 1", ">= 0 || < 1", "^>= 4.20.0.0"] (fmap hasUpperBound . simpleParsec)
Just [True,True,False,True]

Since: 1.24.0.0

Is the upper bound version range (less than or equal (LE, <=)?

>>> forM ["< 1", "<= 1", ">= 0 && < 1", ">= 0 || < 1", ">= 0 && <= 1", ">= 0 || <= 1", "^>= 4.20.0.0"] (fmap hasLEUpperBound . simpleParsec)
Just [False,True,False,False,True,True,False]

Does the upper bound version range have a trailing zero?

>>> forM ["< 1", "< 1.1", "< 1.0", "< 1.1.0", "^>= 4.20.0.0"] (fmap hasTrailingZeroUpperBound . simpleParsec)
Just [False,False,True,True,False]

Does this VersionRange place any restriction on the Version or is it in fact equivalent to AnyVersion.

Note this is a semantic check, not simply a syntactic check. So for example the following is True (for all v).

isAnyVersion (EarlierVersion v `UnionVersionRanges` orLaterVersion v)

The version range -any. That is, a version range containing all versions.

withinRange v anyVersion = True

The empty version range -none, that is a version range containing no versions.

This can be constructed using any unsatisfiable version range expression, for example < 0.

withinRange v noVersion = False

The version range == v.

withinRange v' (thisVersion v) = v' == v

The version range /= v.

withinRange v' (notThisVersion v) = v' /= v

The version range > v.

withinRange v' (laterVersion v) = v' > v

The version range < v.

withinRange v' (earlierVersion v) = v' < v

The version range >= v.

withinRange v' (orLaterVersion v) = v' >= v

The version range <= v.

withinRange v' (orEarlierVersion v) = v' <= v

The version range vr1 || vr2.

  withinRange v' (unionVersionRanges vr1 vr2)
= withinRange v' vr1 || withinRange v' vr2

The version range vr1 && vr2.

  withinRange v' (intersectVersionRanges vr1 vr2)
= withinRange v' vr1 && withinRange v' vr2

The version range == v.*.

For example, for version 1.2, the version range == 1.2.* is the same as >= 1.2 && < 1.3.

withinRange v' (withinVersion v) = v' >= v && v' < upper v
  where
    upper (Version lower t) = Version (init lower ++ [last lower + 1]) t

The version range ^>= v.

For example, for version 1.2.3.4, the version range ^>= 1.2.3.4 is the same as >= 1.2.3.4 && < 1.3.

Note that ^>= 1 is equivalent to >= 1 && < 1.1.

Since: 2.0.0.2

Normalise VersionRange.

In particular collapse (== v || > v) into >= v, and so on.

Remove VersionRangeParens constructors.

Since version 3.4 this function is id, there aren't VersionRangeParens constructor in VersionRange anymore.

Since: 2.2

Does this version fall within the given range?

This is the evaluation function for the VersionRange type.

Fold over the basic syntactic structure of a VersionRange.

This provides a syntactic view of the expression defining the version range. The syntactic sugar ">= v", "<= v" and "== v.*" is presented in terms of the other basic syntax.

For a semantic view use asVersionIntervals.

VersionRange parser parametrised by version digit parser.

• versionDigitParser is used for all VersionRange.
• integral is used for backward-compat pkgconfig-depends versions, PkgConfigVersionRange.

Since: 3.0

F-Algebra of VersionRange. See cataVersionRange.

Since: 2.2

Generic destructor for VersionRange.

Since: 2.2

Generic constructor for VersionRange.

Since: 2.2

Fold VersionRange.

Since: 2.2

Unfold VersionRange.

Since: 2.2

Refold VersionRange.

Since: 2.2

Increment the last version number.

Example: For 1.2 this returns 1.3 so that it can be used as upper bound when resolving == 1.2.*. For 0.4.1 it returns 0.4.2.

Since: 2.2

Compute next greater major version to be used as upper bound.

Example: 0.4.1 produces the version 0.5 which then can be used to construct a range >= 0.4.1 && < 0.5

Since: 2.2