1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
|
versions
========
[](https://hackage.haskell.org/package/versions)
[](http://stackage.org/nightly/package/versions)
[](http://stackage.org/lts/package/versions)
A Haskell library for parsing and comparing software version numbers.
About
-----
We like to give version numbers to our software in a myriad of 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](http://semver.org) if you aren't
currently using it. It provides consistency in version incrementing and has
the best constraints on comparisons.
Usage
-----
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`).
#### Lenses and Traversals
The parse result types have Lenses/Traversals for accessing their data
fields. For instance, to increment the patch number of a parsed SemVer, you
could:
```haskell
incPatch :: SemVer -> SemVer
incPatch s = s & patch %~ (+ 1)
```
Or, something more involved:
```haskell
-- | Get all major versions of legally parsed SemVers.
majors :: [Text] -> [Word]
majors vs = vs ^.. each . to semver . _Right . major
```
The `to semver . _Right` is clunky, so we provide some direct `Text`
Traverals inspired by
([micro](http://hackage.haskell.org/package/microlens-aeson))
[lens-aeson](http://hackage.haskell.org/package/lens-aeson):
```haskell
-- | Get the major version of any `Text` that has one.
majors :: [Text] -> [Word]
majors vs = vs ^.. each . major
```
We can also use these `Text` Traversals to increment versions, as above:
```haskell
incPatch :: Text -> Text
incPatch s = s & patch %~ (+ 1)
> incPatch "1.2.3"
"1.2.4"
```
#### Caveats
The largest number that can be parsed as part of a version is:
``` haskell
ghci> maxBound :: Word64
18446744073709551615
```
However, on 32-bit systems (or smaller), the maximum is their `maxBound :: Word`.
A number larger than that, even if smaller than `maxBound :: Word64`,
will yield a parse error.
|
