{-# LANGUAGE CPP #-}
{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveLift #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE Rank2Types #-}
module Data.Versions
(
Versioning(..), isIdeal, isGeneral, isComplex
, SemVer(..)
, PVP(..)
, Version(..)
, Mess(..), messMajor, messMinor, messPatch, messPatchChunk
, Release(..)
, Chunks(..)
, Chunk(..)
, MChunk(..)
, VSep(..)
, versioningQ, semverQ, versionQ, messQ, pvpQ
, semverToVersion, versionToMess, versionToPvp
, ParsingError
, versioning, semver, pvp, version, mess
, versioning', semver', pvp', version', mess'
, prettyV, prettySemVer, prettyPVP, prettyVer, prettyMess, errorBundlePretty
, Lens'
, Traversal'
, Semantic(..)
, _Versioning, _SemVer, _Version, _Mess
, _Ideal, _General, _Complex
, epoch
) where
import qualified Control.Applicative.Combinators.NonEmpty as PC
import Control.DeepSeq
import Control.Monad (unless, void)
import Data.Char (isAlpha, isAlphaNum)
import Data.Data (Data)
import Data.Foldable (fold)
import Data.Hashable (Hashable)
import Data.List (intersperse)
import Data.List.NonEmpty (NonEmpty(..))
import qualified Data.List.NonEmpty as NEL
import Data.Maybe (fromMaybe, listToMaybe, mapMaybe)
import Data.Text (Text)
import qualified Data.Text as T
import Data.Void (Void)
import GHC.Generics (Generic)
import Language.Haskell.TH (Exp, Q)
import Language.Haskell.TH.Syntax (Lift(..))
import Text.Megaparsec hiding (chunk)
import Text.Megaparsec.Char
import qualified Text.Megaparsec.Char.Lexer as L
import Text.Megaparsec.Char.Lexer (decimal)
data Versioning = Ideal SemVer | General Version | Complex Mess
deriving (Versioning -> Versioning -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Versioning -> Versioning -> Bool
$c/= :: Versioning -> Versioning -> Bool
== :: Versioning -> Versioning -> Bool
$c== :: Versioning -> Versioning -> Bool
Eq, Int -> Versioning -> ShowS
[Versioning] -> ShowS
Versioning -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Versioning] -> ShowS
$cshowList :: [Versioning] -> ShowS
show :: Versioning -> String
$cshow :: Versioning -> String
showsPrec :: Int -> Versioning -> ShowS
$cshowsPrec :: Int -> Versioning -> ShowS
Show, forall x. Rep Versioning x -> Versioning
forall x. Versioning -> Rep Versioning x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Versioning x -> Versioning
$cfrom :: forall x. Versioning -> Rep Versioning x
Generic, Versioning -> ()
forall a. (a -> ()) -> NFData a
rnf :: Versioning -> ()
$crnf :: Versioning -> ()
NFData, Eq Versioning
Int -> Versioning -> Int
Versioning -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: Versioning -> Int
$chash :: Versioning -> Int
hashWithSalt :: Int -> Versioning -> Int
$chashWithSalt :: Int -> Versioning -> Int
Hashable, forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => Versioning -> m Exp
forall (m :: * -> *). Quote m => Versioning -> Code m Versioning
liftTyped :: forall (m :: * -> *). Quote m => Versioning -> Code m Versioning
$cliftTyped :: forall (m :: * -> *). Quote m => Versioning -> Code m Versioning
lift :: forall (m :: * -> *). Quote m => Versioning -> m Exp
$clift :: forall (m :: * -> *). Quote m => Versioning -> m Exp
Lift, Typeable Versioning
Versioning -> DataType
Versioning -> Constr
(forall b. Data b => b -> b) -> Versioning -> Versioning
forall a.
Typeable a
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Versioning -> u
forall u. (forall d. Data d => d -> u) -> Versioning -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Versioning -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Versioning -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Versioning -> m Versioning
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Versioning -> m Versioning
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Versioning
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Versioning -> c Versioning
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Versioning)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Versioning)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Versioning -> m Versioning
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Versioning -> m Versioning
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Versioning -> m Versioning
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Versioning -> m Versioning
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Versioning -> m Versioning
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Versioning -> m Versioning
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Versioning -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Versioning -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Versioning -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Versioning -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Versioning -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Versioning -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Versioning -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Versioning -> r
gmapT :: (forall b. Data b => b -> b) -> Versioning -> Versioning
$cgmapT :: (forall b. Data b => b -> b) -> Versioning -> Versioning
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Versioning)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Versioning)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Versioning)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Versioning)
dataTypeOf :: Versioning -> DataType
$cdataTypeOf :: Versioning -> DataType
toConstr :: Versioning -> Constr
$ctoConstr :: Versioning -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Versioning
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Versioning
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Versioning -> c Versioning
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Versioning -> c Versioning
Data)
isIdeal :: Versioning -> Bool
isIdeal :: Versioning -> Bool
isIdeal (Ideal SemVer
_) = Bool
True
isIdeal Versioning
_ = Bool
False
isGeneral :: Versioning -> Bool
isGeneral :: Versioning -> Bool
isGeneral (General Version
_) = Bool
True
isGeneral Versioning
_ = Bool
False
isComplex :: Versioning -> Bool
isComplex :: Versioning -> Bool
isComplex (Complex Mess
_) = Bool
True
isComplex Versioning
_ = Bool
False
instance Ord Versioning where
compare :: Versioning -> Versioning -> Ordering
compare (Ideal SemVer
s) (Ideal SemVer
s') = forall a. Ord a => a -> a -> Ordering
compare SemVer
s SemVer
s'
compare (General Version
v) (General Version
v') = forall a. Ord a => a -> a -> Ordering
compare Version
v Version
v'
compare (Complex Mess
m) (Complex Mess
m') = forall a. Ord a => a -> a -> Ordering
compare Mess
m Mess
m'
compare (Ideal SemVer
s) (General Version
v) = SemVer -> Version -> Ordering
semverAndVer SemVer
s Version
v
compare (General Version
v) (Ideal SemVer
s) = Ordering -> Ordering
opposite forall a b. (a -> b) -> a -> b
$ SemVer -> Version -> Ordering
semverAndVer SemVer
s Version
v
compare (General Version
v) (Complex Mess
m) = forall a. Ord a => a -> a -> Ordering
compare (Version -> Mess
versionToMess Version
v) Mess
m
compare (Complex Mess
m) (General Version
v) = Ordering -> Ordering
opposite forall a b. (a -> b) -> a -> b
$ forall a. Ord a => a -> a -> Ordering
compare (Version -> Mess
versionToMess Version
v) Mess
m
compare (Ideal SemVer
s) (Complex Mess
m) = SemVer -> Mess -> Ordering
semverAndMess SemVer
s Mess
m
compare (Complex Mess
m) (Ideal SemVer
s) = Ordering -> Ordering
opposite forall a b. (a -> b) -> a -> b
$ SemVer -> Mess -> Ordering
semverAndMess SemVer
s Mess
m
semverToVersion :: SemVer -> Version
semverToVersion :: SemVer -> Version
semverToVersion (SemVer Word
ma Word
mi Word
pa Maybe Release
re Maybe Text
me) =
Version
{ _vEpoch :: Maybe Word
_vEpoch = forall a. Maybe a
Nothing
, _vChunks :: Chunks
_vChunks = NonEmpty Chunk -> Chunks
Chunks forall a b. (a -> b) -> a -> b
$ Word -> Chunk
Numeric Word
ma forall a. a -> [a] -> NonEmpty a
:| [Word -> Chunk
Numeric Word
mi, Word -> Chunk
Numeric Word
pa]
, _vMeta :: Maybe Text
_vMeta = Maybe Text
me
, _vRel :: Maybe Release
_vRel = Maybe Release
re }
versionToMess :: Version -> Mess
versionToMess :: Version -> Mess
versionToMess (Version Maybe Word
me (Chunks NonEmpty Chunk
v) Maybe Release
r Maybe Text
_) = case Maybe Word
me of
Maybe Word
Nothing -> Mess
f
Just Word
e ->
let cs :: NonEmpty MChunk
cs = (forall a. a -> [a] -> NonEmpty a
:| []) forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Text -> MChunk
MDigit Word
e forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> Text
showt Word
e
in NonEmpty MChunk -> Maybe (VSep, Mess) -> Mess
Mess NonEmpty MChunk
cs forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just (VSep
VColon, Mess
f)
where
f :: Mess
f :: Mess
f = NonEmpty MChunk -> Maybe (VSep, Mess) -> Mess
Mess NonEmpty MChunk
cs forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Release -> (VSep, Mess)
g Maybe Release
r
where
cs :: NonEmpty MChunk
cs = forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
NEL.map Chunk -> MChunk
toMChunk NonEmpty Chunk
v
g :: Release -> (VSep, Mess)
g :: Release -> (VSep, Mess)
g (Release NonEmpty Chunk
cs) = (VSep
VHyphen, NonEmpty MChunk -> Maybe (VSep, Mess) -> Mess
Mess NonEmpty MChunk
ms forall a. Maybe a
Nothing)
where
ms :: NonEmpty MChunk
ms = forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
NEL.map Chunk -> MChunk
toMChunk NonEmpty Chunk
cs
versionToPvp :: Version -> Maybe PVP
versionToPvp :: Version -> Maybe PVP
versionToPvp (Version (Just Word
_) Chunks
_ Maybe Release
_ Maybe Text
_) = forall a. Maybe a
Nothing
versionToPvp (Version Maybe Word
Nothing (Chunks NonEmpty Chunk
cs) Maybe Release
_ Maybe Text
_) = NonEmpty Word -> PVP
PVP forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Chunk -> Maybe Word
f NonEmpty Chunk
cs
where
f :: Chunk -> Maybe Word
f :: Chunk -> Maybe Word
f (Numeric Word
w) = forall a. a -> Maybe a
Just Word
w
f (Alphanum Text
_) = forall a. Maybe a
Nothing
semverAndVer :: SemVer -> Version -> Ordering
semverAndVer :: SemVer -> Version -> Ordering
semverAndVer SemVer
_ (Version (Just Word
e) Chunks
_ Maybe Release
_ Maybe Text
_) | Word
e forall a. Ord a => a -> a -> Bool
> Word
0 = Ordering
LT
semverAndVer (SemVer Word
ma Word
mi Word
pa Maybe Release
sr Maybe Text
_) (Version Maybe Word
_ (Chunks NonEmpty Chunk
vc) Maybe Release
vr Maybe Text
_) =
case forall a. Ord a => a -> a -> Ordering
compare Word
ma forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Int -> [Chunk] -> Maybe Chunk
nth Int
0 [Chunk]
vc' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Chunk -> Maybe Word
singleDigitLenient) of
Maybe Ordering
Nothing -> Ordering
GT
Just Ordering
GT -> Ordering
GT
Just Ordering
LT -> Ordering
LT
Just Ordering
EQ -> case forall a. Ord a => a -> a -> Ordering
compare Word
mi forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Int -> [Chunk] -> Maybe Chunk
nth Int
1 [Chunk]
vc' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Chunk -> Maybe Word
singleDigitLenient) of
Maybe Ordering
Nothing -> Ordering
GT
Just Ordering
GT -> Ordering
GT
Just Ordering
LT -> Ordering
LT
Just Ordering
EQ -> case forall a. Ord a => a -> a -> Ordering
compare Word
pa forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Int -> [Chunk] -> Maybe Chunk
nth Int
2 [Chunk]
vc' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Chunk -> Maybe Word
singleDigitLenient) of
Maybe Ordering
Nothing -> Ordering
GT
Just Ordering
GT -> Ordering
GT
Just Ordering
LT -> Ordering
LT
Just Ordering
EQ -> case Int -> [Chunk] -> Maybe Chunk
nth Int
3 [Chunk]
vc' of
Just (Alphanum Text
_) -> Ordering
GT
Just (Numeric Word
_) -> Ordering
LT
Maybe Chunk
Nothing -> forall a. Ord a => a -> a -> Ordering
compare Maybe Release
sr Maybe Release
vr
where
vc' :: [Chunk]
vc' :: [Chunk]
vc' = forall a. NonEmpty a -> [a]
NEL.toList NonEmpty Chunk
vc
nth :: Int -> [Chunk] -> Maybe Chunk
nth :: Int -> [Chunk] -> Maybe Chunk
nth Int
_ [] = forall a. Maybe a
Nothing
nth Int
0 (Chunk
c:[Chunk]
_) = forall a. a -> Maybe a
Just Chunk
c
nth Int
n (Chunk
_:[Chunk]
cs) = Int -> [Chunk] -> Maybe Chunk
nth (Int
n forall a. Num a => a -> a -> a
- Int
1) [Chunk]
cs
semverAndMess :: SemVer -> Mess -> Ordering
semverAndMess :: SemVer -> Mess -> Ordering
semverAndMess s :: SemVer
s@(SemVer Word
ma Word
mi Word
pa Maybe Release
_ Maybe Text
_) Mess
m = case forall a. Ord a => a -> a -> Ordering
compare Word
ma forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mess -> Maybe Word
messMajor Mess
m of
Maybe Ordering
Nothing -> Ordering
fallback
Just Ordering
LT -> Ordering
LT
Just Ordering
GT -> Ordering
GT
Just Ordering
EQ -> case forall a. Ord a => a -> a -> Ordering
compare Word
mi forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mess -> Maybe Word
messMinor Mess
m of
Maybe Ordering
Nothing -> Ordering
fallback
Just Ordering
LT -> Ordering
LT
Just Ordering
GT -> Ordering
GT
Just Ordering
EQ -> case forall a. Ord a => a -> a -> Ordering
compare Word
pa forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mess -> Maybe Word
messPatch Mess
m of
Just Ordering
LT -> Ordering
LT
Just Ordering
GT -> Ordering
GT
Just Ordering
EQ -> Ordering
fallback
Maybe Ordering
Nothing -> case Mess -> Maybe Chunk
messPatchChunk Mess
m forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Chunk -> Maybe Word
singleDigitLenient of
Maybe Word
Nothing -> Ordering
fallback
Just Word
pa' -> case forall a. Ord a => a -> a -> Ordering
compare Word
pa Word
pa' of
Ordering
LT -> Ordering
LT
Ordering
GT -> Ordering
GT
Ordering
EQ -> Ordering
GT
where
fallback :: Ordering
fallback :: Ordering
fallback = forall a. Ord a => a -> a -> Ordering
compare (Version -> Versioning
General forall a b. (a -> b) -> a -> b
$ SemVer -> Version
semverToVersion SemVer
s) (Mess -> Versioning
Complex Mess
m)
instance Semantic Versioning where
major :: Traversal' Versioning Word
major Word -> f Word
f (Ideal SemVer
v) = SemVer -> Versioning
Ideal forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall v. Semantic v => Traversal' v Word
major Word -> f Word
f SemVer
v
major Word -> f Word
f (General Version
v) = Version -> Versioning
General forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall v. Semantic v => Traversal' v Word
major Word -> f Word
f Version
v
major Word -> f Word
f (Complex Mess
v) = Mess -> Versioning
Complex forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall v. Semantic v => Traversal' v Word
major Word -> f Word
f Mess
v
{-# INLINE major #-}
minor :: Traversal' Versioning Word
minor Word -> f Word
f (Ideal SemVer
v) = SemVer -> Versioning
Ideal forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall v. Semantic v => Traversal' v Word
minor Word -> f Word
f SemVer
v
minor Word -> f Word
f (General Version
v) = Version -> Versioning
General forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall v. Semantic v => Traversal' v Word
minor Word -> f Word
f Version
v
minor Word -> f Word
f (Complex Mess
v) = Mess -> Versioning
Complex forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall v. Semantic v => Traversal' v Word
minor Word -> f Word
f Mess
v
{-# INLINE minor #-}
patch :: Traversal' Versioning Word
patch Word -> f Word
f (Ideal SemVer
v) = SemVer -> Versioning
Ideal forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall v. Semantic v => Traversal' v Word
patch Word -> f Word
f SemVer
v
patch Word -> f Word
f (General Version
v) = Version -> Versioning
General forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall v. Semantic v => Traversal' v Word
patch Word -> f Word
f Version
v
patch Word -> f Word
f (Complex Mess
v) = Mess -> Versioning
Complex forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall v. Semantic v => Traversal' v Word
patch Word -> f Word
f Mess
v
{-# INLINE patch #-}
release :: Traversal' Versioning (Maybe Release)
release Maybe Release -> f (Maybe Release)
f (Ideal SemVer
v) = SemVer -> Versioning
Ideal forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall v. Semantic v => Traversal' v (Maybe Release)
release Maybe Release -> f (Maybe Release)
f SemVer
v
release Maybe Release -> f (Maybe Release)
f (General Version
v) = Version -> Versioning
General forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall v. Semantic v => Traversal' v (Maybe Release)
release Maybe Release -> f (Maybe Release)
f Version
v
release Maybe Release -> f (Maybe Release)
f (Complex Mess
v) = Mess -> Versioning
Complex forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall v. Semantic v => Traversal' v (Maybe Release)
release Maybe Release -> f (Maybe Release)
f Mess
v
{-# INLINE release #-}
meta :: Traversal' Versioning (Maybe Text)
meta Maybe Text -> f (Maybe Text)
f (Ideal SemVer
v) = SemVer -> Versioning
Ideal forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall v. Semantic v => Traversal' v (Maybe Text)
meta Maybe Text -> f (Maybe Text)
f SemVer
v
meta Maybe Text -> f (Maybe Text)
f (General Version
v) = Version -> Versioning
General forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall v. Semantic v => Traversal' v (Maybe Text)
meta Maybe Text -> f (Maybe Text)
f Version
v
meta Maybe Text -> f (Maybe Text)
f (Complex Mess
v) = Mess -> Versioning
Complex forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall v. Semantic v => Traversal' v (Maybe Text)
meta Maybe Text -> f (Maybe Text)
f Mess
v
{-# INLINE meta #-}
semantic :: Traversal' Versioning SemVer
semantic SemVer -> f SemVer
f (Ideal SemVer
v) = SemVer -> Versioning
Ideal forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall v. Semantic v => Traversal' v SemVer
semantic SemVer -> f SemVer
f SemVer
v
semantic SemVer -> f SemVer
f (General Version
v) = Version -> Versioning
General forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall v. Semantic v => Traversal' v SemVer
semantic SemVer -> f SemVer
f Version
v
semantic SemVer -> f SemVer
f (Complex Mess
v) = Mess -> Versioning
Complex forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall v. Semantic v => Traversal' v SemVer
semantic SemVer -> f SemVer
f Mess
v
{-# INLINE semantic #-}
_Versioning :: Traversal' Text Versioning
_Versioning :: Traversal' Text Versioning
_Versioning Versioning -> f Versioning
f Text
t = forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall a b. a -> b -> a
const (forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
t)) (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Versioning -> Text
prettyV forall b c a. (b -> c) -> (a -> b) -> a -> c
. Versioning -> f Versioning
f) forall a b. (a -> b) -> a -> b
$ Text -> Either ParsingError Versioning
versioning Text
t
{-# INLINE _Versioning #-}
_SemVer :: Traversal' Text SemVer
_SemVer :: Traversal' Text SemVer
_SemVer SemVer -> f SemVer
f Text
t = forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall a b. a -> b -> a
const (forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
t)) (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap SemVer -> Text
prettySemVer forall b c a. (b -> c) -> (a -> b) -> a -> c
. SemVer -> f SemVer
f) forall a b. (a -> b) -> a -> b
$ Text -> Either ParsingError SemVer
semver Text
t
{-# INLINE _SemVer #-}
_Version :: Traversal' Text Version
_Version :: Traversal' Text Version
_Version Version -> f Version
f Text
t = forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall a b. a -> b -> a
const (forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
t)) (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Version -> Text
prettyVer forall b c a. (b -> c) -> (a -> b) -> a -> c
. Version -> f Version
f) forall a b. (a -> b) -> a -> b
$ Text -> Either ParsingError Version
version Text
t
{-# INLINE _Version #-}
_Mess :: Traversal' Text Mess
_Mess :: Traversal' Text Mess
_Mess Mess -> f Mess
f Text
t = forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall a b. a -> b -> a
const (forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
t)) (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Mess -> Text
prettyMess forall b c a. (b -> c) -> (a -> b) -> a -> c
. Mess -> f Mess
f) forall a b. (a -> b) -> a -> b
$ Text -> Either ParsingError Mess
mess Text
t
{-# INLINE _Mess #-}
_Ideal :: Traversal' Versioning SemVer
_Ideal :: Traversal' Versioning SemVer
_Ideal SemVer -> f SemVer
f (Ideal SemVer
s) = SemVer -> Versioning
Ideal forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> SemVer -> f SemVer
f SemVer
s
_Ideal SemVer -> f SemVer
_ Versioning
v = forall (f :: * -> *) a. Applicative f => a -> f a
pure Versioning
v
{-# INLINE _Ideal #-}
_General :: Traversal' Versioning Version
_General :: Traversal' Versioning Version
_General Version -> f Version
f (General Version
v) = Version -> Versioning
General forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Version -> f Version
f Version
v
_General Version -> f Version
_ Versioning
v = forall (f :: * -> *) a. Applicative f => a -> f a
pure Versioning
v
{-# INLINE _General #-}
_Complex :: Traversal' Versioning Mess
_Complex :: Traversal' Versioning Mess
_Complex Mess -> f Mess
f (Complex Mess
m) = Mess -> Versioning
Complex forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mess -> f Mess
f Mess
m
_Complex Mess -> f Mess
_ Versioning
v = forall (f :: * -> *) a. Applicative f => a -> f a
pure Versioning
v
{-# INLINE _Complex #-}
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
instance Semantic Text where
major :: Traversal' Text Word
major = Traversal' Text Versioning
_Versioning forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall v. Semantic v => Traversal' v Word
major
minor :: Traversal' Text Word
minor = Traversal' Text Versioning
_Versioning forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall v. Semantic v => Traversal' v Word
minor
patch :: Traversal' Text Word
patch = Traversal' Text Versioning
_Versioning forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall v. Semantic v => Traversal' v Word
patch
release :: Traversal' Text (Maybe Release)
release = Traversal' Text Versioning
_Versioning forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall v. Semantic v => Traversal' v (Maybe Release)
release
meta :: Traversal' Text (Maybe Text)
meta = Traversal' Text Versioning
_Versioning forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall v. Semantic v => Traversal' v (Maybe Text)
meta
semantic :: Traversal' Text SemVer
semantic = Traversal' Text SemVer
_SemVer
data SemVer = SemVer
{ SemVer -> Word
_svMajor :: !Word
, SemVer -> Word
_svMinor :: !Word
, SemVer -> Word
_svPatch :: !Word
, SemVer -> Maybe Release
_svPreRel :: !(Maybe Release)
, SemVer -> Maybe Text
_svMeta :: !(Maybe Text) }
deriving stock (Int -> SemVer -> ShowS
[SemVer] -> ShowS
SemVer -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SemVer] -> ShowS
$cshowList :: [SemVer] -> ShowS
show :: SemVer -> String
$cshow :: SemVer -> String
showsPrec :: Int -> SemVer -> ShowS
$cshowsPrec :: Int -> SemVer -> ShowS
Show, forall x. Rep SemVer x -> SemVer
forall x. SemVer -> Rep SemVer x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SemVer x -> SemVer
$cfrom :: forall x. SemVer -> Rep SemVer x
Generic, forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => SemVer -> m Exp
forall (m :: * -> *). Quote m => SemVer -> Code m SemVer
liftTyped :: forall (m :: * -> *). Quote m => SemVer -> Code m SemVer
$cliftTyped :: forall (m :: * -> *). Quote m => SemVer -> Code m SemVer
lift :: forall (m :: * -> *). Quote m => SemVer -> m Exp
$clift :: forall (m :: * -> *). Quote m => SemVer -> m Exp
Lift, Typeable SemVer
SemVer -> DataType
SemVer -> Constr
(forall b. Data b => b -> b) -> SemVer -> SemVer
forall a.
Typeable a
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SemVer -> u
forall u. (forall d. Data d => d -> u) -> SemVer -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SemVer -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SemVer -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SemVer -> m SemVer
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SemVer -> m SemVer
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SemVer
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SemVer -> c SemVer
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SemVer)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SemVer)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SemVer -> m SemVer
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SemVer -> m SemVer
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SemVer -> m SemVer
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SemVer -> m SemVer
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SemVer -> m SemVer
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SemVer -> m SemVer
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SemVer -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SemVer -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> SemVer -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SemVer -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SemVer -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SemVer -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SemVer -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SemVer -> r
gmapT :: (forall b. Data b => b -> b) -> SemVer -> SemVer
$cgmapT :: (forall b. Data b => b -> b) -> SemVer -> SemVer
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SemVer)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SemVer)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SemVer)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SemVer)
dataTypeOf :: SemVer -> DataType
$cdataTypeOf :: SemVer -> DataType
toConstr :: SemVer -> Constr
$ctoConstr :: SemVer -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SemVer
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SemVer
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SemVer -> c SemVer
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SemVer -> c SemVer
Data)
deriving anyclass (SemVer -> ()
forall a. (a -> ()) -> NFData a
rnf :: SemVer -> ()
$crnf :: SemVer -> ()
NFData, Eq SemVer
Int -> SemVer -> Int
SemVer -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: SemVer -> Int
$chash :: SemVer -> Int
hashWithSalt :: Int -> SemVer -> Int
$chashWithSalt :: Int -> SemVer -> Int
Hashable)
instance Eq SemVer where
(SemVer Word
ma Word
mi Word
pa Maybe Release
pr Maybe Text
_) == :: SemVer -> SemVer -> Bool
== (SemVer Word
ma' Word
mi' Word
pa' Maybe Release
pr' Maybe Text
_) =
(Word
ma,Word
mi,Word
pa,Maybe Release
pr) forall a. Eq a => a -> a -> Bool
== (Word
ma',Word
mi',Word
pa',Maybe Release
pr')
instance Ord SemVer where
compare :: SemVer -> SemVer -> Ordering
compare (SemVer Word
ma Word
mi Word
pa Maybe Release
pr Maybe Text
_) (SemVer Word
ma' Word
mi' Word
pa' Maybe Release
pr' Maybe Text
_) =
case forall a. Ord a => a -> a -> Ordering
compare (Word
ma,Word
mi,Word
pa) (Word
ma',Word
mi',Word
pa') of
Ordering
LT -> Ordering
LT
Ordering
GT -> Ordering
GT
Ordering
EQ -> case (Maybe Release
pr, Maybe Release
pr') of
(Maybe Release
Nothing, Maybe Release
Nothing) -> Ordering
EQ
(Maybe Release
Nothing, Maybe Release
_) -> Ordering
GT
(Maybe Release
_, Maybe Release
Nothing) -> Ordering
LT
(Just Release
ap, Just Release
bp) -> forall a. Ord a => a -> a -> Ordering
compare Release
ap Release
bp
instance Semantic SemVer where
major :: Traversal' SemVer Word
major Word -> f Word
f SemVer
sv = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Word
ma -> SemVer
sv { _svMajor :: Word
_svMajor = Word
ma }) (Word -> f Word
f forall a b. (a -> b) -> a -> b
$ SemVer -> Word
_svMajor SemVer
sv)
{-# INLINE major #-}
minor :: Traversal' SemVer Word
minor Word -> f Word
f SemVer
sv = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Word
mi -> SemVer
sv { _svMinor :: Word
_svMinor = Word
mi }) (Word -> f Word
f forall a b. (a -> b) -> a -> b
$ SemVer -> Word
_svMinor SemVer
sv)
{-# INLINE minor #-}
patch :: Traversal' SemVer Word
patch Word -> f Word
f SemVer
sv = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Word
pa -> SemVer
sv { _svPatch :: Word
_svPatch = Word
pa }) (Word -> f Word
f forall a b. (a -> b) -> a -> b
$ SemVer -> Word
_svPatch SemVer
sv)
{-# INLINE patch #-}
release :: Traversal' SemVer (Maybe Release)
release Maybe Release -> f (Maybe Release)
f SemVer
sv = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe Release
pa -> SemVer
sv { _svPreRel :: Maybe Release
_svPreRel = Maybe Release
pa }) (Maybe Release -> f (Maybe Release)
f forall a b. (a -> b) -> a -> b
$ SemVer -> Maybe Release
_svPreRel SemVer
sv)
{-# INLINE release #-}
meta :: Traversal' SemVer (Maybe Text)
meta Maybe Text -> f (Maybe Text)
f SemVer
sv = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe Text
pa -> SemVer
sv { _svMeta :: Maybe Text
_svMeta = Maybe Text
pa }) (Maybe Text -> f (Maybe Text)
f forall a b. (a -> b) -> a -> b
$ SemVer -> Maybe Text
_svMeta SemVer
sv)
{-# INLINE meta #-}
semantic :: Traversal' SemVer SemVer
semantic = forall a b. (a -> b) -> a -> b
($)
{-# INLINE semantic #-}
newtype Release = Release (NonEmpty Chunk)
deriving stock (Release -> Release -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Release -> Release -> Bool
$c/= :: Release -> Release -> Bool
== :: Release -> Release -> Bool
$c== :: Release -> Release -> Bool
Eq, Int -> Release -> ShowS
[Release] -> ShowS
Release -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Release] -> ShowS
$cshowList :: [Release] -> ShowS
show :: Release -> String
$cshow :: Release -> String
showsPrec :: Int -> Release -> ShowS
$cshowsPrec :: Int -> Release -> ShowS
Show, ReadPrec [Release]
ReadPrec Release
Int -> ReadS Release
ReadS [Release]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Release]
$creadListPrec :: ReadPrec [Release]
readPrec :: ReadPrec Release
$creadPrec :: ReadPrec Release
readList :: ReadS [Release]
$creadList :: ReadS [Release]
readsPrec :: Int -> ReadS Release
$creadsPrec :: Int -> ReadS Release
Read, forall x. Rep Release x -> Release
forall x. Release -> Rep Release x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Release x -> Release
$cfrom :: forall x. Release -> Rep Release x
Generic, forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => Release -> m Exp
forall (m :: * -> *). Quote m => Release -> Code m Release
liftTyped :: forall (m :: * -> *). Quote m => Release -> Code m Release
$cliftTyped :: forall (m :: * -> *). Quote m => Release -> Code m Release
lift :: forall (m :: * -> *). Quote m => Release -> m Exp
$clift :: forall (m :: * -> *). Quote m => Release -> m Exp
Lift, Typeable Release
Release -> DataType
Release -> Constr
(forall b. Data b => b -> b) -> Release -> Release
forall a.
Typeable a
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Release -> u
forall u. (forall d. Data d => d -> u) -> Release -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Release -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Release -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Release -> m Release
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Release -> m Release
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Release
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Release -> c Release
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Release)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Release)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Release -> m Release
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Release -> m Release
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Release -> m Release
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Release -> m Release
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Release -> m Release
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Release -> m Release
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Release -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Release -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Release -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Release -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Release -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Release -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Release -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Release -> r
gmapT :: (forall b. Data b => b -> b) -> Release -> Release
$cgmapT :: (forall b. Data b => b -> b) -> Release -> Release
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Release)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Release)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Release)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Release)
dataTypeOf :: Release -> DataType
$cdataTypeOf :: Release -> DataType
toConstr :: Release -> Constr
$ctoConstr :: Release -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Release
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Release
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Release -> c Release
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Release -> c Release
Data)
deriving anyclass (Release -> ()
forall a. (a -> ()) -> NFData a
rnf :: Release -> ()
$crnf :: Release -> ()
NFData, Eq Release
Int -> Release -> Int
Release -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: Release -> Int
$chash :: Release -> Int
hashWithSalt :: Int -> Release -> Int
$chashWithSalt :: Int -> Release -> Int
Hashable)
instance Ord Release where
compare :: Release -> Release -> Ordering
compare (Release NonEmpty Chunk
as) (Release NonEmpty Chunk
bs) =
forall a. a -> Maybe a -> a
fromMaybe Ordering
EQ forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> Maybe a
listToMaybe forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe These Chunk Chunk -> Maybe Ordering
f forall a b. (a -> b) -> a -> b
$ forall a b. [a] -> [b] -> [These a b]
zipLongest (forall a. NonEmpty a -> [a]
NEL.toList NonEmpty Chunk
as) (forall a. NonEmpty a -> [a]
NEL.toList NonEmpty Chunk
bs)
where
f :: These Chunk Chunk -> Maybe Ordering
f :: These Chunk Chunk -> Maybe Ordering
f (Both Chunk
a Chunk
b) = case Chunk -> Chunk -> Ordering
cmpSemVer Chunk
a Chunk
b of
Ordering
LT -> forall a. a -> Maybe a
Just Ordering
LT
Ordering
GT -> forall a. a -> Maybe a
Just Ordering
GT
Ordering
EQ -> forall a. Maybe a
Nothing
f (This Chunk
_) = forall a. a -> Maybe a
Just Ordering
GT
f (That Chunk
_) = forall a. a -> Maybe a
Just Ordering
LT
data Chunk = Numeric Word | Alphanum Text
deriving stock (Chunk -> Chunk -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Chunk -> Chunk -> Bool
$c/= :: Chunk -> Chunk -> Bool
== :: Chunk -> Chunk -> Bool
$c== :: Chunk -> Chunk -> Bool
Eq, Int -> Chunk -> ShowS
[Chunk] -> ShowS
Chunk -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Chunk] -> ShowS
$cshowList :: [Chunk] -> ShowS
show :: Chunk -> String
$cshow :: Chunk -> String
showsPrec :: Int -> Chunk -> ShowS
$cshowsPrec :: Int -> Chunk -> ShowS
Show, ReadPrec [Chunk]
ReadPrec Chunk
Int -> ReadS Chunk
ReadS [Chunk]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Chunk]
$creadListPrec :: ReadPrec [Chunk]
readPrec :: ReadPrec Chunk
$creadPrec :: ReadPrec Chunk
readList :: ReadS [Chunk]
$creadList :: ReadS [Chunk]
readsPrec :: Int -> ReadS Chunk
$creadsPrec :: Int -> ReadS Chunk
Read, forall x. Rep Chunk x -> Chunk
forall x. Chunk -> Rep Chunk x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Chunk x -> Chunk
$cfrom :: forall x. Chunk -> Rep Chunk x
Generic, forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => Chunk -> m Exp
forall (m :: * -> *). Quote m => Chunk -> Code m Chunk
liftTyped :: forall (m :: * -> *). Quote m => Chunk -> Code m Chunk
$cliftTyped :: forall (m :: * -> *). Quote m => Chunk -> Code m Chunk
lift :: forall (m :: * -> *). Quote m => Chunk -> m Exp
$clift :: forall (m :: * -> *). Quote m => Chunk -> m Exp
Lift, Typeable Chunk
Chunk -> DataType
Chunk -> Constr
(forall b. Data b => b -> b) -> Chunk -> Chunk
forall a.
Typeable a
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Chunk -> u
forall u. (forall d. Data d => d -> u) -> Chunk -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Chunk -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Chunk -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Chunk -> m Chunk
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Chunk -> m Chunk
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Chunk
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Chunk -> c Chunk
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Chunk)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Chunk)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Chunk -> m Chunk
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Chunk -> m Chunk
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Chunk -> m Chunk
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Chunk -> m Chunk
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Chunk -> m Chunk
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Chunk -> m Chunk
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Chunk -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Chunk -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Chunk -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Chunk -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Chunk -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Chunk -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Chunk -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Chunk -> r
gmapT :: (forall b. Data b => b -> b) -> Chunk -> Chunk
$cgmapT :: (forall b. Data b => b -> b) -> Chunk -> Chunk
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Chunk)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Chunk)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Chunk)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Chunk)
dataTypeOf :: Chunk -> DataType
$cdataTypeOf :: Chunk -> DataType
toConstr :: Chunk -> Constr
$ctoConstr :: Chunk -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Chunk
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Chunk
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Chunk -> c Chunk
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Chunk -> c Chunk
Data)
deriving anyclass (Chunk -> ()
forall a. (a -> ()) -> NFData a
rnf :: Chunk -> ()
$crnf :: Chunk -> ()
NFData, Eq Chunk
Int -> Chunk -> Int
Chunk -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: Chunk -> Int
$chash :: Chunk -> Int
hashWithSalt :: Int -> Chunk -> Int
$chashWithSalt :: Int -> Chunk -> Int
Hashable)
toMChunk :: Chunk -> MChunk
toMChunk :: Chunk -> MChunk
toMChunk (Numeric Word
n) = Word -> Text -> MChunk
MDigit Word
n forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> Text
showt Word
n
toMChunk (Alphanum Text
s) = Text -> MChunk
MPlain Text
s
cmpSemVer :: Chunk -> Chunk -> Ordering
cmpSemVer :: Chunk -> Chunk -> Ordering
cmpSemVer (Numeric Word
a) (Numeric Word
b) = forall a. Ord a => a -> a -> Ordering
compare Word
a Word
b
cmpSemVer (Numeric Word
_) (Alphanum Text
_) = Ordering
LT
cmpSemVer (Alphanum Text
_) (Numeric Word
_) = Ordering
GT
cmpSemVer (Alphanum Text
a) (Alphanum Text
b) = forall a. Ord a => a -> a -> Ordering
compare Text
a Text
b
cmpLenient :: Chunk -> Chunk -> Ordering
cmpLenient :: Chunk -> Chunk -> Ordering
cmpLenient (Numeric Word
a) (Numeric Word
b) = forall a. Ord a => a -> a -> Ordering
compare Word
a Word
b
cmpLenient a :: Chunk
a@(Alphanum Text
x) b :: Chunk
b@(Alphanum Text
y) =
case (Chunk -> Maybe Word
singleDigitLenient Chunk
a, Chunk -> Maybe Word
singleDigitLenient Chunk
b) of
(Just Word
i, Just Word
j) -> forall a. Ord a => a -> a -> Ordering
compare Word
i Word
j
(Maybe Word, Maybe Word)
_ -> forall a. Ord a => a -> a -> Ordering
compare Text
x Text
y
cmpLenient (Numeric Word
n) b :: Chunk
b@(Alphanum Text
_) =
case Chunk -> Maybe Word
singleDigitLenient Chunk
b of
Maybe Word
Nothing -> Ordering
GT
Just Word
m -> case forall a. Ord a => a -> a -> Ordering
compare Word
n Word
m of
Ordering
EQ -> Ordering
GT
Ordering
c -> Ordering
c
cmpLenient a :: Chunk
a@(Alphanum Text
_) (Numeric Word
n) =
case Chunk -> Maybe Word
singleDigitLenient Chunk
a of
Maybe Word
Nothing -> Ordering
LT
Just Word
m -> case forall a. Ord a => a -> a -> Ordering
compare Word
m Word
n of
Ordering
EQ -> Ordering
LT
Ordering
c -> Ordering
c
singleDigitLenient :: Chunk -> Maybe Word
singleDigitLenient :: Chunk -> Maybe Word
singleDigitLenient (Numeric Word
n) = forall a. a -> Maybe a
Just Word
n
singleDigitLenient (Alphanum Text
s) = forall a b. Either a b -> Maybe b
hush forall a b. (a -> b) -> a -> b
$ forall e s a.
Parsec e s a -> String -> s -> Either (ParseErrorBundle s e) a
parse Parsec Void Text Word
unsignedP String
"Single Digit Lenient" Text
s
newtype PVP = PVP { PVP -> NonEmpty Word
_pComponents :: NonEmpty Word }
deriving stock (PVP -> PVP -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PVP -> PVP -> Bool
$c/= :: PVP -> PVP -> Bool
== :: PVP -> PVP -> Bool
$c== :: PVP -> PVP -> Bool
Eq, Eq PVP
PVP -> PVP -> Bool
PVP -> PVP -> Ordering
PVP -> PVP -> PVP
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: PVP -> PVP -> PVP
$cmin :: PVP -> PVP -> PVP
max :: PVP -> PVP -> PVP
$cmax :: PVP -> PVP -> PVP
>= :: PVP -> PVP -> Bool
$c>= :: PVP -> PVP -> Bool
> :: PVP -> PVP -> Bool
$c> :: PVP -> PVP -> Bool
<= :: PVP -> PVP -> Bool
$c<= :: PVP -> PVP -> Bool
< :: PVP -> PVP -> Bool
$c< :: PVP -> PVP -> Bool
compare :: PVP -> PVP -> Ordering
$ccompare :: PVP -> PVP -> Ordering
Ord, Int -> PVP -> ShowS
[PVP] -> ShowS
PVP -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PVP] -> ShowS
$cshowList :: [PVP] -> ShowS
show :: PVP -> String
$cshow :: PVP -> String
showsPrec :: Int -> PVP -> ShowS
$cshowsPrec :: Int -> PVP -> ShowS
Show, forall x. Rep PVP x -> PVP
forall x. PVP -> Rep PVP x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PVP x -> PVP
$cfrom :: forall x. PVP -> Rep PVP x
Generic, forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => PVP -> m Exp
forall (m :: * -> *). Quote m => PVP -> Code m PVP
liftTyped :: forall (m :: * -> *). Quote m => PVP -> Code m PVP
$cliftTyped :: forall (m :: * -> *). Quote m => PVP -> Code m PVP
lift :: forall (m :: * -> *). Quote m => PVP -> m Exp
$clift :: forall (m :: * -> *). Quote m => PVP -> m Exp
Lift, Typeable PVP
PVP -> DataType
PVP -> Constr
(forall b. Data b => b -> b) -> PVP -> PVP
forall a.
Typeable a
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> PVP -> u
forall u. (forall d. Data d => d -> u) -> PVP -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PVP -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PVP -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PVP -> m PVP
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PVP -> m PVP
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PVP
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PVP -> c PVP
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PVP)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PVP)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PVP -> m PVP
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PVP -> m PVP
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PVP -> m PVP
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PVP -> m PVP
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PVP -> m PVP
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PVP -> m PVP
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PVP -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PVP -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> PVP -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PVP -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PVP -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PVP -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PVP -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PVP -> r
gmapT :: (forall b. Data b => b -> b) -> PVP -> PVP
$cgmapT :: (forall b. Data b => b -> b) -> PVP -> PVP
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PVP)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PVP)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PVP)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PVP)
dataTypeOf :: PVP -> DataType
$cdataTypeOf :: PVP -> DataType
toConstr :: PVP -> Constr
$ctoConstr :: PVP -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PVP
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PVP
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PVP -> c PVP
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PVP -> c PVP
Data)
deriving anyclass (PVP -> ()
forall a. (a -> ()) -> NFData a
rnf :: PVP -> ()
$crnf :: PVP -> ()
NFData, Eq PVP
Int -> PVP -> Int
PVP -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: PVP -> Int
$chash :: PVP -> Int
hashWithSalt :: Int -> PVP -> Int
$chashWithSalt :: Int -> PVP -> Int
Hashable)
instance Semantic PVP where
major :: Traversal' PVP Word
major Word -> f Word
f (PVP (Word
m :| [Word]
rs)) = (\Word
ma -> NonEmpty Word -> PVP
PVP forall a b. (a -> b) -> a -> b
$ Word
ma forall a. a -> [a] -> NonEmpty a
:| [Word]
rs) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Word -> f Word
f Word
m
{-# INLINE major #-}
minor :: Traversal' PVP Word
minor Word -> f Word
f (PVP (Word
m :| Word
mi : [Word]
rs)) = (\Word
mi' -> NonEmpty Word -> PVP
PVP forall a b. (a -> b) -> a -> b
$ Word
m forall a. a -> [a] -> NonEmpty a
:| Word
mi' forall a. a -> [a] -> [a]
: [Word]
rs) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Word -> f Word
f Word
mi
minor Word -> f Word
f (PVP (Word
m :| [])) = (\Word
mi' -> NonEmpty Word -> PVP
PVP forall a b. (a -> b) -> a -> b
$ Word
m forall a. a -> [a] -> NonEmpty a
:| [Word
mi']) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Word -> f Word
f Word
0
{-# INLINE minor #-}
patch :: Traversal' PVP Word
patch Word -> f Word
f (PVP (Word
m :| Word
mi : Word
pa : [Word]
rs)) = (\Word
pa' -> NonEmpty Word -> PVP
PVP forall a b. (a -> b) -> a -> b
$ Word
m forall a. a -> [a] -> NonEmpty a
:| Word
mi forall a. a -> [a] -> [a]
: Word
pa' forall a. a -> [a] -> [a]
: [Word]
rs) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Word -> f Word
f Word
pa
patch Word -> f Word
f (PVP (Word
m :| [Word
mi])) = (\Word
pa' -> NonEmpty Word -> PVP
PVP forall a b. (a -> b) -> a -> b
$ Word
m forall a. a -> [a] -> NonEmpty a
:| Word
mi forall a. a -> [a] -> [a]
: [Word
pa']) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Word -> f Word
f Word
0
patch Word -> f Word
f (PVP (Word
m :| [])) = (\Word
pa' -> NonEmpty Word -> PVP
PVP forall a b. (a -> b) -> a -> b
$ Word
m forall a. a -> [a] -> NonEmpty a
:| Word
0 forall a. a -> [a] -> [a]
: [Word
pa']) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Word -> f Word
f Word
0
{-# INLINE patch #-}
release :: Traversal' PVP (Maybe Release)
release Maybe Release -> f (Maybe Release)
f PVP
p = PVP
p forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Maybe Release -> f (Maybe Release)
f forall a. Maybe a
Nothing
{-# INLINE release #-}
meta :: Traversal' PVP (Maybe Text)
meta Maybe Text -> f (Maybe Text)
f PVP
p = PVP
p forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Maybe Text -> f (Maybe Text)
f forall a. Maybe a
Nothing
{-# INLINE meta #-}
semantic :: Traversal' PVP SemVer
semantic SemVer -> f SemVer
f (PVP (Word
m :| [Word]
rs)) = (\(SemVer Word
ma Word
mi Word
pa Maybe Release
_ Maybe Text
_) -> NonEmpty Word -> PVP
PVP forall a b. (a -> b) -> a -> b
$ Word
ma forall a. a -> [a] -> NonEmpty a
:| [Word
mi, Word
pa]) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> SemVer -> f SemVer
f SemVer
s
where
s :: SemVer
s = case [Word]
rs of
Word
mi : Word
pa : [Word]
_ -> Word -> Word -> Word -> Maybe Release -> Maybe Text -> SemVer
SemVer Word
m Word
mi Word
pa forall a. Maybe a
Nothing forall a. Maybe a
Nothing
Word
mi : [Word]
_ -> Word -> Word -> Word -> Maybe Release -> Maybe Text -> SemVer
SemVer Word
m Word
mi Word
0 forall a. Maybe a
Nothing forall a. Maybe a
Nothing
[] -> Word -> Word -> Word -> Maybe Release -> Maybe Text -> SemVer
SemVer Word
m Word
0 Word
0 forall a. Maybe a
Nothing forall a. Maybe a
Nothing
{-# INLINE semantic #-}
data Version = Version
{ Version -> Maybe Word
_vEpoch :: !(Maybe Word)
, Version -> Chunks
_vChunks :: !Chunks
, Version -> Maybe Release
_vRel :: !(Maybe Release)
, Version -> Maybe Text
_vMeta :: !(Maybe Text) }
deriving stock (Version -> Version -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Version -> Version -> Bool
$c/= :: Version -> Version -> Bool
== :: Version -> Version -> Bool
$c== :: Version -> Version -> Bool
Eq, Int -> Version -> ShowS
[Version] -> ShowS
Version -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Version] -> ShowS
$cshowList :: [Version] -> ShowS
show :: Version -> String
$cshow :: Version -> String
showsPrec :: Int -> Version -> ShowS
$cshowsPrec :: Int -> Version -> ShowS
Show, forall x. Rep Version x -> Version
forall x. Version -> Rep Version x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Version x -> Version
$cfrom :: forall x. Version -> Rep Version x
Generic, forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => Version -> m Exp
forall (m :: * -> *). Quote m => Version -> Code m Version
liftTyped :: forall (m :: * -> *). Quote m => Version -> Code m Version
$cliftTyped :: forall (m :: * -> *). Quote m => Version -> Code m Version
lift :: forall (m :: * -> *). Quote m => Version -> m Exp
$clift :: forall (m :: * -> *). Quote m => Version -> m Exp
Lift, Typeable Version
Version -> DataType
Version -> Constr
(forall b. Data b => b -> b) -> Version -> Version
forall a.
Typeable a
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Version -> u
forall u. (forall d. Data d => d -> u) -> Version -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Version -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Version -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Version -> m Version
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Version -> m Version
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Version
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Version -> c Version
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Version)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Version)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Version -> m Version
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Version -> m Version
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Version -> m Version
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Version -> m Version
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Version -> m Version
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Version -> m Version
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Version -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Version -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Version -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Version -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Version -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Version -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Version -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Version -> r
gmapT :: (forall b. Data b => b -> b) -> Version -> Version
$cgmapT :: (forall b. Data b => b -> b) -> Version -> Version
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Version)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Version)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Version)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Version)
dataTypeOf :: Version -> DataType
$cdataTypeOf :: Version -> DataType
toConstr :: Version -> Constr
$ctoConstr :: Version -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Version
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Version
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Version -> c Version
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Version -> c Version
Data)
deriving anyclass (Version -> ()
forall a. (a -> ()) -> NFData a
rnf :: Version -> ()
$crnf :: Version -> ()
NFData, Eq Version
Int -> Version -> Int
Version -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: Version -> Int
$chash :: Version -> Int
hashWithSalt :: Int -> Version -> Int
$chashWithSalt :: Int -> Version -> Int
Hashable)
instance Ord Version where
compare :: Version -> Version -> Ordering
compare (Version Maybe Word
mae Chunks
ac Maybe Release
ar Maybe Text
_) (Version Maybe Word
mbe Chunks
bc Maybe Release
br Maybe Text
_) =
case forall a. Ord a => a -> a -> Ordering
compare Word
ae Word
be of
Ordering
EQ -> case forall a. Ord a => a -> a -> Ordering
compare Chunks
ac Chunks
bc of
Ordering
EQ -> forall a. Ord a => a -> a -> Ordering
compare Maybe Release
ar Maybe Release
br
Ordering
ord -> Ordering
ord
Ordering
ord -> Ordering
ord
where
ae :: Word
ae = forall a. a -> Maybe a -> a
fromMaybe Word
0 Maybe Word
mae
be :: Word
be = forall a. a -> Maybe a -> a
fromMaybe Word
0 Maybe Word
mbe
instance Semantic Version where
major :: Traversal' Version Word
major Word -> f Word
f (Version Maybe Word
e (Chunks (Numeric Word
n :| [Chunk]
cs)) Maybe Release
me Maybe Text
rs) =
(\Word
n' -> Maybe Word -> Chunks -> Maybe Release -> Maybe Text -> Version
Version Maybe Word
e (NonEmpty Chunk -> Chunks
Chunks forall a b. (a -> b) -> a -> b
$ Word -> Chunk
Numeric Word
n' forall a. a -> [a] -> NonEmpty a
:| [Chunk]
cs) Maybe Release
me Maybe Text
rs) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Word -> f Word
f Word
n
major Word -> f Word
_ Version
v = forall (f :: * -> *) a. Applicative f => a -> f a
pure Version
v
{-# INLINE major #-}
minor :: Traversal' Version Word
minor Word -> f Word
f (Version Maybe Word
e (Chunks (Chunk
c :| Numeric Word
n : [Chunk]
cs)) Maybe Release
me Maybe Text
rs) =
(\Word
n' -> Maybe Word -> Chunks -> Maybe Release -> Maybe Text -> Version
Version Maybe Word
e (NonEmpty Chunk -> Chunks
Chunks forall a b. (a -> b) -> a -> b
$ Chunk
c forall a. a -> [a] -> NonEmpty a
:| Word -> Chunk
Numeric Word
n' forall a. a -> [a] -> [a]
: [Chunk]
cs) Maybe Release
me Maybe Text
rs) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Word -> f Word
f Word
n
minor Word -> f Word
_ Version
v = forall (f :: * -> *) a. Applicative f => a -> f a
pure Version
v
{-# INLINE minor #-}
patch :: Traversal' Version Word
patch Word -> f Word
f (Version Maybe Word
e (Chunks (Chunk
c :| Chunk
d : Numeric Word
n : [Chunk]
cs)) Maybe Release
me Maybe Text
rs) =
(\Word
n' -> Maybe Word -> Chunks -> Maybe Release -> Maybe Text -> Version
Version Maybe Word
e (NonEmpty Chunk -> Chunks
Chunks forall a b. (a -> b) -> a -> b
$ Chunk
c forall a. a -> [a] -> NonEmpty a
:| Chunk
d forall a. a -> [a] -> [a]
: Word -> Chunk
Numeric Word
n' forall a. a -> [a] -> [a]
: [Chunk]
cs) Maybe Release
me Maybe Text
rs) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Word -> f Word
f Word
n
patch Word -> f Word
_ Version
v = forall (f :: * -> *) a. Applicative f => a -> f a
pure Version
v
{-# INLINE patch #-}
release :: Traversal' Version (Maybe Release)
release Maybe Release -> f (Maybe Release)
f Version
v = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe Release
vr -> Version
v { _vRel :: Maybe Release
_vRel = Maybe Release
vr }) (Maybe Release -> f (Maybe Release)
f forall a b. (a -> b) -> a -> b
$ Version -> Maybe Release
_vRel Version
v)
{-# INLINE release #-}
meta :: Traversal' Version (Maybe Text)
meta Maybe Text -> f (Maybe Text)
_ Version
v = forall (f :: * -> *) a. Applicative f => a -> f a
pure Version
v
{-# INLINE meta #-}
semantic :: Traversal' Version SemVer
semantic SemVer -> f SemVer
f (Version Maybe Word
_ (Chunks (Numeric Word
a :| Numeric Word
b : Numeric Word
c : [Chunk]
_)) Maybe Release
rs Maybe Text
me) =
SemVer -> Version
semverToVersion forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> SemVer -> f SemVer
f (Word -> Word -> Word -> Maybe Release -> Maybe Text -> SemVer
SemVer Word
a Word
b Word
c Maybe Release
rs Maybe Text
me)
semantic SemVer -> f SemVer
_ Version
v = forall (f :: * -> *) a. Applicative f => a -> f a
pure Version
v
{-# INLINE semantic #-}
epoch :: Lens' Version (Maybe Word)
epoch :: Lens' Version (Maybe Word)
epoch Maybe Word -> f (Maybe Word)
f Version
v = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe Word
ve -> Version
v { _vEpoch :: Maybe Word
_vEpoch = Maybe Word
ve }) (Maybe Word -> f (Maybe Word)
f forall a b. (a -> b) -> a -> b
$ Version -> Maybe Word
_vEpoch Version
v)
{-# INLINE epoch #-}
newtype Chunks = Chunks (NonEmpty Chunk)
deriving stock (Chunks -> Chunks -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Chunks -> Chunks -> Bool
$c/= :: Chunks -> Chunks -> Bool
== :: Chunks -> Chunks -> Bool
$c== :: Chunks -> Chunks -> Bool
Eq, Int -> Chunks -> ShowS
[Chunks] -> ShowS
Chunks -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Chunks] -> ShowS
$cshowList :: [Chunks] -> ShowS
show :: Chunks -> String
$cshow :: Chunks -> String
showsPrec :: Int -> Chunks -> ShowS
$cshowsPrec :: Int -> Chunks -> ShowS
Show, forall x. Rep Chunks x -> Chunks
forall x. Chunks -> Rep Chunks x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Chunks x -> Chunks
$cfrom :: forall x. Chunks -> Rep Chunks x
Generic, forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => Chunks -> m Exp
forall (m :: * -> *). Quote m => Chunks -> Code m Chunks
liftTyped :: forall (m :: * -> *). Quote m => Chunks -> Code m Chunks
$cliftTyped :: forall (m :: * -> *). Quote m => Chunks -> Code m Chunks
lift :: forall (m :: * -> *). Quote m => Chunks -> m Exp
$clift :: forall (m :: * -> *). Quote m => Chunks -> m Exp
Lift, Typeable Chunks
Chunks -> DataType
Chunks -> Constr
(forall b. Data b => b -> b) -> Chunks -> Chunks
forall a.
Typeable a
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Chunks -> u
forall u. (forall d. Data d => d -> u) -> Chunks -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Chunks -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Chunks -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Chunks -> m Chunks
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Chunks -> m Chunks
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Chunks
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Chunks -> c Chunks
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Chunks)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Chunks)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Chunks -> m Chunks
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Chunks -> m Chunks
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Chunks -> m Chunks
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Chunks -> m Chunks
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Chunks -> m Chunks
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Chunks -> m Chunks
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Chunks -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Chunks -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Chunks -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Chunks -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Chunks -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Chunks -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Chunks -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Chunks -> r
gmapT :: (forall b. Data b => b -> b) -> Chunks -> Chunks
$cgmapT :: (forall b. Data b => b -> b) -> Chunks -> Chunks
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Chunks)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Chunks)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Chunks)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Chunks)
dataTypeOf :: Chunks -> DataType
$cdataTypeOf :: Chunks -> DataType
toConstr :: Chunks -> Constr
$ctoConstr :: Chunks -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Chunks
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Chunks
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Chunks -> c Chunks
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Chunks -> c Chunks
Data)
deriving anyclass (Chunks -> ()
forall a. (a -> ()) -> NFData a
rnf :: Chunks -> ()
$crnf :: Chunks -> ()
NFData, Eq Chunks
Int -> Chunks -> Int
Chunks -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: Chunks -> Int
$chash :: Chunks -> Int
hashWithSalt :: Int -> Chunks -> Int
$chashWithSalt :: Int -> Chunks -> Int
Hashable)
instance Ord Chunks where
compare :: Chunks -> Chunks -> Ordering
compare (Chunks NonEmpty Chunk
as) (Chunks NonEmpty Chunk
bs) =
forall a. a -> Maybe a -> a
fromMaybe Ordering
EQ forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> Maybe a
listToMaybe forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe These Chunk Chunk -> Maybe Ordering
f forall a b. (a -> b) -> a -> b
$ forall a b. [a] -> [b] -> [These a b]
zipLongest (forall a. NonEmpty a -> [a]
NEL.toList NonEmpty Chunk
as) (forall a. NonEmpty a -> [a]
NEL.toList NonEmpty Chunk
bs)
where
f :: These Chunk Chunk -> Maybe Ordering
f :: These Chunk Chunk -> Maybe Ordering
f (Both Chunk
a Chunk
b) = case Chunk -> Chunk -> Ordering
cmpLenient Chunk
a Chunk
b of
Ordering
LT -> forall a. a -> Maybe a
Just Ordering
LT
Ordering
GT -> forall a. a -> Maybe a
Just Ordering
GT
Ordering
EQ -> forall a. Maybe a
Nothing
f (This Chunk
_) = forall a. a -> Maybe a
Just Ordering
GT
f (That Chunk
_) = forall a. a -> Maybe a
Just Ordering
LT
data MChunk
= MDigit Word Text
| MRev Word Text
| MPlain Text
deriving stock (MChunk -> MChunk -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MChunk -> MChunk -> Bool
$c/= :: MChunk -> MChunk -> Bool
== :: MChunk -> MChunk -> Bool
$c== :: MChunk -> MChunk -> Bool
Eq, Int -> MChunk -> ShowS
[MChunk] -> ShowS
MChunk -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MChunk] -> ShowS
$cshowList :: [MChunk] -> ShowS
show :: MChunk -> String
$cshow :: MChunk -> String
showsPrec :: Int -> MChunk -> ShowS
$cshowsPrec :: Int -> MChunk -> ShowS
Show, forall x. Rep MChunk x -> MChunk
forall x. MChunk -> Rep MChunk x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MChunk x -> MChunk
$cfrom :: forall x. MChunk -> Rep MChunk x
Generic, forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => MChunk -> m Exp
forall (m :: * -> *). Quote m => MChunk -> Code m MChunk
liftTyped :: forall (m :: * -> *). Quote m => MChunk -> Code m MChunk
$cliftTyped :: forall (m :: * -> *). Quote m => MChunk -> Code m MChunk
lift :: forall (m :: * -> *). Quote m => MChunk -> m Exp
$clift :: forall (m :: * -> *). Quote m => MChunk -> m Exp
Lift, Typeable MChunk
MChunk -> DataType
MChunk -> Constr
(forall b. Data b => b -> b) -> MChunk -> MChunk
forall a.
Typeable a
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> MChunk -> u
forall u. (forall d. Data d => d -> u) -> MChunk -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MChunk -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MChunk -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MChunk -> m MChunk
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MChunk -> m MChunk
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MChunk
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MChunk -> c MChunk
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MChunk)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MChunk)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MChunk -> m MChunk
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MChunk -> m MChunk
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MChunk -> m MChunk
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MChunk -> m MChunk
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MChunk -> m MChunk
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MChunk -> m MChunk
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MChunk -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MChunk -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> MChunk -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MChunk -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MChunk -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MChunk -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MChunk -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MChunk -> r
gmapT :: (forall b. Data b => b -> b) -> MChunk -> MChunk
$cgmapT :: (forall b. Data b => b -> b) -> MChunk -> MChunk
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MChunk)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MChunk)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MChunk)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MChunk)
dataTypeOf :: MChunk -> DataType
$cdataTypeOf :: MChunk -> DataType
toConstr :: MChunk -> Constr
$ctoConstr :: MChunk -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MChunk
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MChunk
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MChunk -> c MChunk
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MChunk -> c MChunk
Data)
deriving anyclass (MChunk -> ()
forall a. (a -> ()) -> NFData a
rnf :: MChunk -> ()
$crnf :: MChunk -> ()
NFData, Eq MChunk
Int -> MChunk -> Int
MChunk -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: MChunk -> Int
$chash :: MChunk -> Int
hashWithSalt :: Int -> MChunk -> Int
$chashWithSalt :: Int -> MChunk -> Int
Hashable)
instance Ord MChunk where
compare :: MChunk -> MChunk -> Ordering
compare (MDigit Word
a Text
_) (MDigit Word
b Text
_) = forall a. Ord a => a -> a -> Ordering
compare Word
a Word
b
compare (MRev Word
a Text
_) (MRev Word
b Text
_) = forall a. Ord a => a -> a -> Ordering
compare Word
a Word
b
compare (MPlain Text
a) (MPlain Text
b) = forall a. Ord a => a -> a -> Ordering
compare Text
a Text
b
compare MChunk
a MChunk
b = forall a. Ord a => a -> a -> Ordering
compare (MChunk -> Text
mchunkText MChunk
a) (MChunk -> Text
mchunkText MChunk
b)
mchunkText :: MChunk -> Text
mchunkText :: MChunk -> Text
mchunkText (MDigit Word
_ Text
t) = Text
t
mchunkText (MRev Word
_ Text
t) = Text
t
mchunkText (MPlain Text
t) = Text
t
data Mess = Mess !(NonEmpty MChunk) !(Maybe (VSep, Mess))
deriving stock (Mess -> Mess -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Mess -> Mess -> Bool
$c/= :: Mess -> Mess -> Bool
== :: Mess -> Mess -> Bool
$c== :: Mess -> Mess -> Bool
Eq, Int -> Mess -> ShowS
[Mess] -> ShowS
Mess -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Mess] -> ShowS
$cshowList :: [Mess] -> ShowS
show :: Mess -> String
$cshow :: Mess -> String
showsPrec :: Int -> Mess -> ShowS
$cshowsPrec :: Int -> Mess -> ShowS
Show, forall x. Rep Mess x -> Mess
forall x. Mess -> Rep Mess x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Mess x -> Mess
$cfrom :: forall x. Mess -> Rep Mess x
Generic, forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => Mess -> m Exp
forall (m :: * -> *). Quote m => Mess -> Code m Mess
liftTyped :: forall (m :: * -> *). Quote m => Mess -> Code m Mess
$cliftTyped :: forall (m :: * -> *). Quote m => Mess -> Code m Mess
lift :: forall (m :: * -> *). Quote m => Mess -> m Exp
$clift :: forall (m :: * -> *). Quote m => Mess -> m Exp
Lift, Typeable Mess
Mess -> DataType
Mess -> Constr
(forall b. Data b => b -> b) -> Mess -> Mess
forall a.
Typeable a
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Mess -> u
forall u. (forall d. Data d => d -> u) -> Mess -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Mess -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Mess -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Mess -> m Mess
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Mess -> m Mess
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Mess
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Mess -> c Mess
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Mess)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Mess)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Mess -> m Mess
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Mess -> m Mess
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Mess -> m Mess
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Mess -> m Mess
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Mess -> m Mess
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Mess -> m Mess
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Mess -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Mess -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Mess -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Mess -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Mess -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Mess -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Mess -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Mess -> r
gmapT :: (forall b. Data b => b -> b) -> Mess -> Mess
$cgmapT :: (forall b. Data b => b -> b) -> Mess -> Mess
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Mess)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Mess)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Mess)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Mess)
dataTypeOf :: Mess -> DataType
$cdataTypeOf :: Mess -> DataType
toConstr :: Mess -> Constr
$ctoConstr :: Mess -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Mess
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Mess
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Mess -> c Mess
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Mess -> c Mess
Data)
deriving anyclass (Mess -> ()
forall a. (a -> ()) -> NFData a
rnf :: Mess -> ()
$crnf :: Mess -> ()
NFData, Eq Mess
Int -> Mess -> Int
Mess -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: Mess -> Int
$chash :: Mess -> Int
hashWithSalt :: Int -> Mess -> Int
$chashWithSalt :: Int -> Mess -> Int
Hashable)
messMajor :: Mess -> Maybe Word
messMajor :: Mess -> Maybe Word
messMajor (Mess (MDigit Word
i Text
_ :| [MChunk]
_) Maybe (VSep, Mess)
_) = forall a. a -> Maybe a
Just Word
i
messMajor Mess
_ = forall a. Maybe a
Nothing
messMinor :: Mess -> Maybe Word
messMinor :: Mess -> Maybe Word
messMinor (Mess (MChunk
_ :| MDigit Word
i Text
_ : [MChunk]
_) Maybe (VSep, Mess)
_) = forall a. a -> Maybe a
Just Word
i
messMinor Mess
_ = forall a. Maybe a
Nothing
messPatch :: Mess -> Maybe Word
messPatch :: Mess -> Maybe Word
messPatch (Mess (MChunk
_ :| MChunk
_ : MDigit Word
i Text
_ : [MChunk]
_) Maybe (VSep, Mess)
_) = forall a. a -> Maybe a
Just Word
i
messPatch Mess
_ = forall a. Maybe a
Nothing
messPatchChunk :: Mess -> Maybe Chunk
messPatchChunk :: Mess -> Maybe Chunk
messPatchChunk (Mess (MChunk
_ :| MChunk
_ : MPlain Text
p : [MChunk]
_) Maybe (VSep, Mess)
_) = forall a b. Either a b -> Maybe b
hush forall a b. (a -> b) -> a -> b
$ forall e s a.
Parsec e s a -> String -> s -> Either (ParseErrorBundle s e) a
parse Parsec Void Text Chunk
chunkP String
"Chunk" Text
p
messPatchChunk Mess
_ = forall a. Maybe a
Nothing
instance Ord Mess where
compare :: Mess -> Mess -> Ordering
compare (Mess NonEmpty MChunk
t1 Maybe (VSep, Mess)
m1) (Mess NonEmpty MChunk
t2 Maybe (VSep, Mess)
m2) = case forall a. Ord a => a -> a -> Ordering
compare NonEmpty MChunk
t1 NonEmpty MChunk
t2 of
Ordering
EQ -> case (Maybe (VSep, Mess)
m1, Maybe (VSep, Mess)
m2) of
(Just (VSep
_, Mess
v1), Just (VSep
_, Mess
v2)) -> forall a. Ord a => a -> a -> Ordering
compare Mess
v1 Mess
v2
(Just (VSep
_, Mess
_), Maybe (VSep, Mess)
Nothing) -> Ordering
GT
(Maybe (VSep, Mess)
Nothing, Just (VSep
_, Mess
_)) -> Ordering
LT
(Maybe (VSep, Mess)
Nothing, Maybe (VSep, Mess)
Nothing) -> Ordering
EQ
Ordering
res -> Ordering
res
instance Semantic Mess where
major :: Traversal' Mess Word
major Word -> f Word
f (Mess (MDigit Word
n Text
_ :| [MChunk]
ts) Maybe (VSep, Mess)
m) = (\Word
n' -> NonEmpty MChunk -> Maybe (VSep, Mess) -> Mess
Mess (Word -> Text -> MChunk
MDigit Word
n' (forall a. Show a => a -> Text
showt Word
n') forall a. a -> [a] -> NonEmpty a
:| [MChunk]
ts) Maybe (VSep, Mess)
m) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Word -> f Word
f Word
n
major Word -> f Word
_ Mess
v = forall (f :: * -> *) a. Applicative f => a -> f a
pure Mess
v
{-# INLINE major #-}
minor :: Traversal' Mess Word
minor Word -> f Word
f (Mess (MChunk
t0 :| MDigit Word
n Text
_ : [MChunk]
ts) Maybe (VSep, Mess)
m) = (\Word
n' -> NonEmpty MChunk -> Maybe (VSep, Mess) -> Mess
Mess (MChunk
t0 forall a. a -> [a] -> NonEmpty a
:| Word -> Text -> MChunk
MDigit Word
n' (forall a. Show a => a -> Text
showt Word
n') forall a. a -> [a] -> [a]
: [MChunk]
ts) Maybe (VSep, Mess)
m) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Word -> f Word
f Word
n
minor Word -> f Word
_ Mess
v = forall (f :: * -> *) a. Applicative f => a -> f a
pure Mess
v
{-# INLINE minor #-}
patch :: Traversal' Mess Word
patch Word -> f Word
f (Mess (MChunk
t0 :| MChunk
t1 : MDigit Word
n Text
_ : [MChunk]
ts) Maybe (VSep, Mess)
m) = (\Word
n' -> NonEmpty MChunk -> Maybe (VSep, Mess) -> Mess
Mess (MChunk
t0 forall a. a -> [a] -> NonEmpty a
:| MChunk
t1 forall a. a -> [a] -> [a]
: Word -> Text -> MChunk
MDigit Word
n' (forall a. Show a => a -> Text
showt Word
n') forall a. a -> [a] -> [a]
: [MChunk]
ts) Maybe (VSep, Mess)
m) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Word -> f Word
f Word
n
patch Word -> f Word
_ Mess
v = forall (f :: * -> *) a. Applicative f => a -> f a
pure Mess
v
{-# INLINE patch #-}
release :: Traversal' Mess (Maybe Release)
release Maybe Release -> f (Maybe Release)
_ Mess
v = forall (f :: * -> *) a. Applicative f => a -> f a
pure Mess
v
{-# INLINE release #-}
meta :: Traversal' Mess (Maybe Text)
meta Maybe Text -> f (Maybe Text)
_ Mess
v = forall (f :: * -> *) a. Applicative f => a -> f a
pure Mess
v
{-# INLINE meta #-}
semantic :: Traversal' Mess SemVer
semantic SemVer -> f SemVer
f (Mess (MDigit Word
t0 Text
_ :| MDigit Word
t1 Text
_ : MDigit Word
t2 Text
_ : [MChunk]
_) Maybe (VSep, Mess)
_) =
Version -> Mess
versionToMess forall b c a. (b -> c) -> (a -> b) -> a -> c
. SemVer -> Version
semverToVersion forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> SemVer -> f SemVer
f (Word -> Word -> Word -> Maybe Release -> Maybe Text -> SemVer
SemVer Word
t0 Word
t1 Word
t2 forall a. Maybe a
Nothing forall a. Maybe a
Nothing)
semantic SemVer -> f SemVer
_ Mess
v = forall (f :: * -> *) a. Applicative f => a -> f a
pure Mess
v
{-# INLINE semantic #-}
data VSep = VColon | VHyphen | VPlus | VUnder | VTilde
deriving stock (VSep -> VSep -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VSep -> VSep -> Bool
$c/= :: VSep -> VSep -> Bool
== :: VSep -> VSep -> Bool
$c== :: VSep -> VSep -> Bool
Eq, Int -> VSep -> ShowS
[VSep] -> ShowS
VSep -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VSep] -> ShowS
$cshowList :: [VSep] -> ShowS
show :: VSep -> String
$cshow :: VSep -> String
showsPrec :: Int -> VSep -> ShowS
$cshowsPrec :: Int -> VSep -> ShowS
Show, forall x. Rep VSep x -> VSep
forall x. VSep -> Rep VSep x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep VSep x -> VSep
$cfrom :: forall x. VSep -> Rep VSep x
Generic, forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => VSep -> m Exp
forall (m :: * -> *). Quote m => VSep -> Code m VSep
liftTyped :: forall (m :: * -> *). Quote m => VSep -> Code m VSep
$cliftTyped :: forall (m :: * -> *). Quote m => VSep -> Code m VSep
lift :: forall (m :: * -> *). Quote m => VSep -> m Exp
$clift :: forall (m :: * -> *). Quote m => VSep -> m Exp
Lift, Typeable VSep
VSep -> DataType
VSep -> Constr
(forall b. Data b => b -> b) -> VSep -> VSep
forall a.
Typeable a
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> VSep -> u
forall u. (forall d. Data d => d -> u) -> VSep -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VSep -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VSep -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VSep -> m VSep
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VSep -> m VSep
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VSep
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VSep -> c VSep
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VSep)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VSep)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VSep -> m VSep
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VSep -> m VSep
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VSep -> m VSep
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VSep -> m VSep
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VSep -> m VSep
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VSep -> m VSep
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> VSep -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> VSep -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> VSep -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> VSep -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VSep -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VSep -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VSep -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VSep -> r
gmapT :: (forall b. Data b => b -> b) -> VSep -> VSep
$cgmapT :: (forall b. Data b => b -> b) -> VSep -> VSep
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VSep)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VSep)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VSep)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VSep)
dataTypeOf :: VSep -> DataType
$cdataTypeOf :: VSep -> DataType
toConstr :: VSep -> Constr
$ctoConstr :: VSep -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VSep
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VSep
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VSep -> c VSep
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VSep -> c VSep
Data)
deriving anyclass (VSep -> ()
forall a. (a -> ()) -> NFData a
rnf :: VSep -> ()
$crnf :: VSep -> ()
NFData, Eq VSep
Int -> VSep -> Int
VSep -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: VSep -> Int
$chash :: VSep -> Int
hashWithSalt :: Int -> VSep -> Int
$chashWithSalt :: Int -> VSep -> Int
Hashable)
versioningQ :: Text -> Q Exp
versioningQ :: Text -> Q Exp
versioningQ Text
nm =
case Text -> Either ParsingError Versioning
versioning Text
nm of
Left ParsingError
err -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail (forall s e.
(VisualStream s, TraversableStream s, ShowErrorComponent e) =>
ParseErrorBundle s e -> String
errorBundlePretty ParsingError
err)
Right Versioning
v -> forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
lift Versioning
v
semverQ :: T.Text -> Q Exp
semverQ :: Text -> Q Exp
semverQ Text
nm =
case Text -> Either ParsingError SemVer
semver Text
nm of
Left ParsingError
err -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail (forall s e.
(VisualStream s, TraversableStream s, ShowErrorComponent e) =>
ParseErrorBundle s e -> String
errorBundlePretty ParsingError
err)
Right SemVer
v -> forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
lift SemVer
v
versionQ :: T.Text -> Q Exp
versionQ :: Text -> Q Exp
versionQ Text
nm =
case Text -> Either ParsingError Version
version Text
nm of
Left ParsingError
err -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail (forall s e.
(VisualStream s, TraversableStream s, ShowErrorComponent e) =>
ParseErrorBundle s e -> String
errorBundlePretty ParsingError
err)
Right Version
v -> forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
lift Version
v
messQ :: T.Text -> Q Exp
messQ :: Text -> Q Exp
messQ Text
nm =
case Text -> Either ParsingError Mess
mess Text
nm of
Left ParsingError
err -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail (forall s e.
(VisualStream s, TraversableStream s, ShowErrorComponent e) =>
ParseErrorBundle s e -> String
errorBundlePretty ParsingError
err)
Right Mess
v -> forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
lift Mess
v
pvpQ :: T.Text -> Q Exp
pvpQ :: Text -> Q Exp
pvpQ Text
nm =
case Text -> Either ParsingError PVP
pvp Text
nm of
Left ParsingError
err -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail (forall s e.
(VisualStream s, TraversableStream s, ShowErrorComponent e) =>
ParseErrorBundle s e -> String
errorBundlePretty ParsingError
err)
Right PVP
v -> forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
lift PVP
v
type ParsingError = ParseErrorBundle Text Void
versioning :: Text -> Either ParsingError Versioning
versioning :: Text -> Either ParsingError Versioning
versioning = forall e s a.
Parsec e s a -> String -> s -> Either (ParseErrorBundle s e) a
parse Parsec Void Text Versioning
versioning' String
"versioning"
versioning' :: Parsec Void Text Versioning
versioning' :: Parsec Void Text Versioning
versioning' = forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, Alternative m) =>
f (m a) -> m a
choice [ forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap SemVer -> Versioning
Ideal Parsec Void Text SemVer
semver'' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall e s (m :: * -> *). MonadParsec e s m => m ()
eof)
, forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Version -> Versioning
General Parsec Void Text Version
version'' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall e s (m :: * -> *). MonadParsec e s m => m ()
eof)
, forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Mess -> Versioning
Complex Parsec Void Text Mess
mess'' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall e s (m :: * -> *). MonadParsec e s m => m ()
eof ]
semver :: Text -> Either ParsingError SemVer
semver :: Text -> Either ParsingError SemVer
semver = forall e s a.
Parsec e s a -> String -> s -> Either (ParseErrorBundle s e) a
parse (Parsec Void Text SemVer
semver'' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall e s (m :: * -> *). MonadParsec e s m => m ()
eof) String
"Semantic Version"
semver' :: Parsec Void Text SemVer
semver' :: Parsec Void Text SemVer
semver' = forall e s (m :: * -> *) a. MonadParsec e s m => m () -> m a -> m a
L.lexeme forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
space Parsec Void Text SemVer
semver''
semver'' :: Parsec Void Text SemVer
semver'' :: Parsec Void Text SemVer
semver'' = Word -> Word -> Word -> Maybe Release -> Maybe Text -> SemVer
SemVer forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parsec Void Text Word
majorP forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parsec Void Text Word
minorP forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parsec Void Text Word
patchP forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parsec Void Text Release
releaseP forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parsec Void Text Text
metaData
unsignedP :: Parsec Void Text Word
unsignedP :: Parsec Void Text Word
unsignedP = (Word
0 forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'0') forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
decimal
majorP :: Parsec Void Text Word
majorP :: Parsec Void Text Word
majorP = Parsec Void Text Word
unsignedP forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'.'
minorP :: Parsec Void Text Word
minorP :: Parsec Void Text Word
minorP = Parsec Void Text Word
majorP
patchP :: Parsec Void Text Word
patchP :: Parsec Void Text Word
patchP = Parsec Void Text Word
unsignedP
releaseP :: Parsec Void Text Release
releaseP :: Parsec Void Text Release
releaseP = forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'-' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap NonEmpty Chunk -> Release
Release (Parsec Void Text Chunk
chunkP forall (m :: * -> *) a sep.
Alternative m =>
m a -> m sep -> m (NonEmpty a)
`PC.sepBy1` forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'.')
chunkP :: Parsec Void Text Chunk
chunkP :: Parsec Void Text Chunk
chunkP = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try Parsec Void Text Chunk
alphanumP forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parsec Void Text Chunk
numericP
alphanumP :: Parsec Void Text Chunk
alphanumP :: Parsec Void Text Chunk
alphanumP = do
Text
ids <- forall e s (m :: * -> *).
MonadParsec e s m =>
Maybe String -> (Token s -> Bool) -> m (Tokens s)
takeWhile1P (forall a. a -> Maybe a
Just String
"Hyphenated Alphanums") (\Token Text
c -> Char -> Bool
isAlphaNum Token Text
c Bool -> Bool -> Bool
|| Token Text
c forall a. Eq a => a -> a -> Bool
== Char
'-')
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless ((Char -> Bool) -> Text -> Bool
T.any (\Char
c -> Char -> Bool
isAlpha Char
c Bool -> Bool -> Bool
|| Char
c forall a. Eq a => a -> a -> Bool
== Char
'-') Text
ids) forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Only numeric!"
forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Text -> Chunk
Alphanum Text
ids
alphanumWithoutHyphensP :: Parsec Void Text Chunk
alphanumWithoutHyphensP :: Parsec Void Text Chunk
alphanumWithoutHyphensP = do
Text
ids <- forall e s (m :: * -> *).
MonadParsec e s m =>
Maybe String -> (Token s -> Bool) -> m (Tokens s)
takeWhile1P (forall a. a -> Maybe a
Just String
"Unhyphenated Alphanums") Char -> Bool
isAlphaNum
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless ((Char -> Bool) -> Text -> Bool
T.any Char -> Bool
isAlpha Text
ids) forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Only numeric!"
forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Text -> Chunk
Alphanum Text
ids
numericP :: Parsec Void Text Chunk
numericP :: Parsec Void Text Chunk
numericP = Word -> Chunk
Numeric forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parsec Void Text Word
unsignedP
chunkWithoutHyphensP :: Parsec Void Text Chunk
chunkWithoutHyphensP :: Parsec Void Text Chunk
chunkWithoutHyphensP = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try Parsec Void Text Chunk
alphanumWithoutHyphensP forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parsec Void Text Chunk
numericP
metaData :: Parsec Void Text Text
metaData :: Parsec Void Text Text
metaData = do
forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'+'
forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
fold forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> NonEmpty a -> NonEmpty a
NEL.intersperse Text
"." forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parsec Void Text Text
section forall (m :: * -> *) a sep.
Alternative m =>
m a -> m sep -> m (NonEmpty a)
`PC.sepBy1` forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'.'
where
section :: Parsec Void Text Text
section :: Parsec Void Text Text
section = forall e s (m :: * -> *).
MonadParsec e s m =>
Maybe String -> (Token s -> Bool) -> m (Tokens s)
takeWhile1P (forall a. a -> Maybe a
Just String
"Metadata char") (\Token Text
c -> Char -> Bool
isAlphaNum Token Text
c Bool -> Bool -> Bool
|| Token Text
c forall a. Eq a => a -> a -> Bool
== Char
'-')
pvp :: Text -> Either ParsingError PVP
pvp :: Text -> Either ParsingError PVP
pvp = forall e s a.
Parsec e s a -> String -> s -> Either (ParseErrorBundle s e) a
parse (ParsecT Void Text Identity PVP
pvp' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall e s (m :: * -> *). MonadParsec e s m => m ()
eof) String
"PVP"
pvp' :: Parsec Void Text PVP
pvp' :: ParsecT Void Text Identity PVP
pvp' = forall e s (m :: * -> *) a. MonadParsec e s m => m () -> m a -> m a
L.lexeme forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
space (NonEmpty Word -> PVP
PVP forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> NonEmpty a
NEL.fromList forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
L.decimal forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
`sepBy` forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'.')
version :: Text -> Either ParsingError Version
version :: Text -> Either ParsingError Version
version = forall e s a.
Parsec e s a -> String -> s -> Either (ParseErrorBundle s e) a
parse (Parsec Void Text Version
version'' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall e s (m :: * -> *). MonadParsec e s m => m ()
eof) String
"Version"
version' :: Parsec Void Text Version
version' :: Parsec Void Text Version
version' = forall e s (m :: * -> *) a. MonadParsec e s m => m () -> m a -> m a
L.lexeme forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
space Parsec Void Text Version
version''
version'' :: Parsec Void Text Version
version'' :: Parsec Void Text Version
version'' = Maybe Word -> Chunks -> Maybe Release -> Maybe Text -> Version
Version forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try Parsec Void Text Word
epochP) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parsec Void Text Chunks
chunksP forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parsec Void Text Release
releaseP forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parsec Void Text Text
metaData
epochP :: Parsec Void Text Word
epochP :: Parsec Void Text Word
epochP = forall a. Read a => String -> a
read forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
some forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Token s)
digitChar forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
':')
chunksP :: Parsec Void Text Chunks
chunksP :: Parsec Void Text Chunks
chunksP = NonEmpty Chunk -> Chunks
Chunks forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parsec Void Text Chunk
chunkWithoutHyphensP forall (m :: * -> *) a sep.
Alternative m =>
m a -> m sep -> m (NonEmpty a)
`PC.sepBy1` forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'.'
mess :: Text -> Either ParsingError Mess
mess :: Text -> Either ParsingError Mess
mess = forall e s a.
Parsec e s a -> String -> s -> Either (ParseErrorBundle s e) a
parse (Parsec Void Text Mess
mess'' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall e s (m :: * -> *). MonadParsec e s m => m ()
eof) String
"Mess"
mess' :: Parsec Void Text Mess
mess' :: Parsec Void Text Mess
mess' = forall e s (m :: * -> *) a. MonadParsec e s m => m () -> m a -> m a
L.lexeme forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
space Parsec Void Text Mess
mess''
mess'' :: Parsec Void Text Mess
mess'' :: Parsec Void Text Mess
mess'' = NonEmpty MChunk -> Maybe (VSep, Mess) -> Mess
Mess forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parsec Void Text (NonEmpty MChunk)
mchunks forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional ((,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parsec Void Text VSep
sep forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parsec Void Text Mess
mess')
mchunks :: Parsec Void Text (NonEmpty MChunk)
mchunks :: Parsec Void Text (NonEmpty MChunk)
mchunks = Parsec Void Text MChunk
mchunk forall (m :: * -> *) a sep.
Alternative m =>
m a -> m sep -> m (NonEmpty a)
`PC.sepBy1` forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'.'
mchunk :: Parsec Void Text MChunk
mchunk :: Parsec Void Text MChunk
mchunk = forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, Alternative m) =>
f (m a) -> m a
choice [ forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall a b. (a -> b) -> a -> b
$ (\(Text
t, Word
i) -> Word -> Text -> MChunk
MDigit Word
i Text
t) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> m (Tokens s, a)
match (forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
L.decimal forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT Void Text Identity ()
next)
, forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall a b. (a -> b) -> a -> b
$ (\(Text
t, Word
i) -> Word -> Text -> MChunk
MRev Word
i Text
t) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> m (Tokens s, a)
match (forall e s (m :: * -> *).
MonadParsec e s m =>
Token s -> m (Token s)
single Char
'r' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
L.decimal forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT Void Text Identity ()
next)
, Text -> MChunk
MPlain forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
T.pack forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
some (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Token s)
letterChar forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Token s)
digitChar) ]
where
next :: Parsec Void Text ()
next :: ParsecT Void Text Identity ()
next = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
lookAhead (forall (f :: * -> *) a. Functor f => f a -> f ()
void (forall e s (m :: * -> *).
MonadParsec e s m =>
Token s -> m (Token s)
single Char
'.') forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (f :: * -> *) a. Functor f => f a -> f ()
void Parsec Void Text VSep
sep forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *). MonadParsec e s m => m ()
eof)
sep :: Parsec Void Text VSep
sep :: Parsec Void Text VSep
sep = forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, Alternative m) =>
f (m a) -> m a
choice [ VSep
VColon forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
':'
, VSep
VHyphen forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'-'
, VSep
VPlus forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'+'
, VSep
VUnder forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'_'
, VSep
VTilde forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'~' ]
sepCh :: VSep -> Char
sepCh :: VSep -> Char
sepCh VSep
VColon = Char
':'
sepCh VSep
VHyphen = Char
'-'
sepCh VSep
VPlus = Char
'+'
sepCh VSep
VUnder = Char
'_'
sepCh VSep
VTilde = Char
'~'
prettyV :: Versioning -> Text
prettyV :: Versioning -> Text
prettyV (Ideal SemVer
sv) = SemVer -> Text
prettySemVer SemVer
sv
prettyV (General Version
v) = Version -> Text
prettyVer Version
v
prettyV (Complex Mess
m) = Mess -> Text
prettyMess Mess
m
prettySemVer :: SemVer -> Text
prettySemVer :: SemVer -> Text
prettySemVer (SemVer Word
ma Word
mi Word
pa Maybe Release
pr Maybe Text
me) = forall a. Monoid a => [a] -> a
mconcat forall a b. (a -> b) -> a -> b
$ [Text]
ver forall a. Semigroup a => a -> a -> a
<> [Text]
pr' forall a. Semigroup a => a -> a -> a
<> [Text]
me'
where
ver :: [Text]
ver = forall a. a -> [a] -> [a]
intersperse Text
"." [ forall a. Show a => a -> Text
showt Word
ma, forall a. Show a => a -> Text
showt Word
mi, forall a. Show a => a -> Text
showt Word
pa ]
pr' :: [Text]
pr' = forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (\Release
m -> [Text
"-", Release -> Text
prettyRelease Release
m]) Maybe Release
pr
me' :: [Text]
me' = forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (\Text
m -> [Text
"+", Text
m]) Maybe Text
me
prettyPVP :: PVP -> Text
prettyPVP :: PVP -> Text
prettyPVP (PVP (Word
m :| [Word]
rs)) = Text -> [Text] -> Text
T.intercalate Text
"." forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map forall a. Show a => a -> Text
showt forall a b. (a -> b) -> a -> b
$ Word
m forall a. a -> [a] -> [a]
: [Word]
rs
prettyVer :: Version -> Text
prettyVer :: Version -> Text
prettyVer (Version Maybe Word
ep Chunks
cs Maybe Release
pr Maybe Text
me) = forall a. Monoid a => [a] -> a
mconcat forall a b. (a -> b) -> a -> b
$ [Text]
ep' forall a. Semigroup a => a -> a -> a
<> [Text
ver] forall a. Semigroup a => a -> a -> a
<> [Text]
pr' forall a. Semigroup a => a -> a -> a
<> [Text]
me'
where
ver :: Text
ver = Chunks -> Text
prettyChunks Chunks
cs
me' :: [Text]
me' = forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (\Text
m -> [Text
"+", Text
m]) Maybe Text
me
pr' :: [Text]
pr' = forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (\Release
m -> [Text
"-", Release -> Text
prettyRelease Release
m]) Maybe Release
pr
ep' :: [Text]
ep' = forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (\Word
e -> [forall a. Show a => a -> Text
showt Word
e, Text
":"]) Maybe Word
ep
prettyMess :: Mess -> Text
prettyMess :: Mess -> Text
prettyMess (Mess NonEmpty MChunk
t Maybe (VSep, Mess)
m) = case Maybe (VSep, Mess)
m of
Maybe (VSep, Mess)
Nothing -> Text
t'
Just (VSep
s, Mess
v) -> Text -> Char -> Text
T.snoc Text
t' (VSep -> Char
sepCh VSep
s) forall a. Semigroup a => a -> a -> a
<> Mess -> Text
prettyMess Mess
v
where
t' :: Text
t' :: Text
t' = forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
fold forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> NonEmpty a -> NonEmpty a
NEL.intersperse Text
"." forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
NEL.map MChunk -> Text
mchunkText NonEmpty MChunk
t
prettyChunks :: Chunks -> Text
prettyChunks :: Chunks -> Text
prettyChunks (Chunks NonEmpty Chunk
cs) = Text -> [Text] -> Text
T.intercalate Text
"." forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map Chunk -> Text
prettyChunk forall a b. (a -> b) -> a -> b
$ forall a. NonEmpty a -> [a]
NEL.toList NonEmpty Chunk
cs
prettyRelease :: Release -> Text
prettyRelease :: Release -> Text
prettyRelease (Release NonEmpty Chunk
cs) = Text -> [Text] -> Text
T.intercalate Text
"." forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map Chunk -> Text
prettyChunk forall a b. (a -> b) -> a -> b
$ forall a. NonEmpty a -> [a]
NEL.toList NonEmpty Chunk
cs
prettyChunk :: Chunk -> Text
prettyChunk :: Chunk -> Text
prettyChunk (Numeric Word
n) = forall a. Show a => a -> Text
showt Word
n
prettyChunk (Alphanum Text
s) = Text
s
opposite :: Ordering -> Ordering
opposite :: Ordering -> Ordering
opposite Ordering
EQ = Ordering
EQ
opposite Ordering
LT = Ordering
GT
opposite Ordering
GT = Ordering
LT
showt :: Show a => a -> Text
showt :: forall a. Show a => a -> Text
showt = String -> Text
T.pack forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> String
show
hush :: Either a b -> Maybe b
hush :: forall a b. Either a b -> Maybe b
hush (Left a
_) = forall a. Maybe a
Nothing
hush (Right b
b) = forall a. a -> Maybe a
Just b
b
data These a b = This a | That b | Both a b
zipLongest :: [a] -> [b] -> [These a b]
zipLongest :: forall a b. [a] -> [b] -> [These a b]
zipLongest [] [] = []
zipLongest (a
a:[a]
as) (b
b:[b]
bs) = forall a b. a -> b -> These a b
Both a
a b
b forall a. a -> [a] -> [a]
: forall a b. [a] -> [b] -> [These a b]
zipLongest [a]
as [b]
bs
zipLongest (a
a:[a]
as) [] = forall a b. a -> These a b
This a
a forall a. a -> [a] -> [a]
: forall a b. [a] -> [b] -> [These a b]
zipLongest [a]
as []
zipLongest [] (b
b:[b]
bs) = forall a b. b -> These a b
That b
b forall a. a -> [a] -> [a]
: forall a b. [a] -> [b] -> [These a b]
zipLongest [] [b]
bs