{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveDataTypeable #-}
module Stack.Types.VersionIntervals -- to be removed with https://github.com/commercialhaskell/stack/issues/4213
  ( VersionIntervals
  , toVersionRange
  , fromVersionRange
  , withinIntervals
  , unionVersionIntervals
  , intersectVersionIntervals
  ) where

import Stack.Types.Version
import qualified Distribution.Version as C
import Stack.Prelude

newtype VersionIntervals = VersionIntervals [VersionInterval]
    deriving ((forall x. VersionIntervals -> Rep VersionIntervals x)
-> (forall x. Rep VersionIntervals x -> VersionIntervals)
-> Generic VersionIntervals
forall x. Rep VersionIntervals x -> VersionIntervals
forall x. VersionIntervals -> Rep VersionIntervals x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep VersionIntervals x -> VersionIntervals
$cfrom :: forall x. VersionIntervals -> Rep VersionIntervals x
Generic, Int -> VersionIntervals -> ShowS
[VersionIntervals] -> ShowS
VersionIntervals -> String
(Int -> VersionIntervals -> ShowS)
-> (VersionIntervals -> String)
-> ([VersionIntervals] -> ShowS)
-> Show VersionIntervals
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VersionIntervals] -> ShowS
$cshowList :: [VersionIntervals] -> ShowS
show :: VersionIntervals -> String
$cshow :: VersionIntervals -> String
showsPrec :: Int -> VersionIntervals -> ShowS
$cshowsPrec :: Int -> VersionIntervals -> ShowS
Show, VersionIntervals -> VersionIntervals -> Bool
(VersionIntervals -> VersionIntervals -> Bool)
-> (VersionIntervals -> VersionIntervals -> Bool)
-> Eq VersionIntervals
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VersionIntervals -> VersionIntervals -> Bool
$c/= :: VersionIntervals -> VersionIntervals -> Bool
== :: VersionIntervals -> VersionIntervals -> Bool
$c== :: VersionIntervals -> VersionIntervals -> Bool
Eq, Typeable VersionIntervals
DataType
Constr
Typeable VersionIntervals
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> VersionIntervals -> c VersionIntervals)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c VersionIntervals)
-> (VersionIntervals -> Constr)
-> (VersionIntervals -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c VersionIntervals))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c VersionIntervals))
-> ((forall b. Data b => b -> b)
    -> VersionIntervals -> VersionIntervals)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> VersionIntervals -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> VersionIntervals -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> VersionIntervals -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> VersionIntervals -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> VersionIntervals -> m VersionIntervals)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> VersionIntervals -> m VersionIntervals)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> VersionIntervals -> m VersionIntervals)
-> Data VersionIntervals
VersionIntervals -> DataType
VersionIntervals -> Constr
(forall b. Data b => b -> b)
-> VersionIntervals -> VersionIntervals
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VersionIntervals -> c VersionIntervals
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VersionIntervals
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) -> VersionIntervals -> u
forall u. (forall d. Data d => d -> u) -> VersionIntervals -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VersionIntervals -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VersionIntervals -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> VersionIntervals -> m VersionIntervals
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> VersionIntervals -> m VersionIntervals
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VersionIntervals
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VersionIntervals -> c VersionIntervals
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VersionIntervals)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c VersionIntervals)
$cVersionIntervals :: Constr
$tVersionIntervals :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> VersionIntervals -> m VersionIntervals
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> VersionIntervals -> m VersionIntervals
gmapMp :: (forall d. Data d => d -> m d)
-> VersionIntervals -> m VersionIntervals
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> VersionIntervals -> m VersionIntervals
gmapM :: (forall d. Data d => d -> m d)
-> VersionIntervals -> m VersionIntervals
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> VersionIntervals -> m VersionIntervals
gmapQi :: Int -> (forall d. Data d => d -> u) -> VersionIntervals -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> VersionIntervals -> u
gmapQ :: (forall d. Data d => d -> u) -> VersionIntervals -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> VersionIntervals -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VersionIntervals -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VersionIntervals -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VersionIntervals -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VersionIntervals -> r
gmapT :: (forall b. Data b => b -> b)
-> VersionIntervals -> VersionIntervals
$cgmapT :: (forall b. Data b => b -> b)
-> VersionIntervals -> VersionIntervals
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c VersionIntervals)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c VersionIntervals)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c VersionIntervals)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VersionIntervals)
dataTypeOf :: VersionIntervals -> DataType
$cdataTypeOf :: VersionIntervals -> DataType
toConstr :: VersionIntervals -> Constr
$ctoConstr :: VersionIntervals -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VersionIntervals
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VersionIntervals
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VersionIntervals -> c VersionIntervals
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VersionIntervals -> c VersionIntervals
$cp1Data :: Typeable VersionIntervals
Data, Typeable)
instance NFData VersionIntervals

data VersionInterval = VersionInterval
  { VersionInterval -> Version
viLowerVersion :: !Version
  , VersionInterval -> Bound
viLowerBound :: !Bound
  , VersionInterval -> Maybe (Version, Bound)
viUpper :: !(Maybe (Version, Bound))
  }
    deriving ((forall x. VersionInterval -> Rep VersionInterval x)
-> (forall x. Rep VersionInterval x -> VersionInterval)
-> Generic VersionInterval
forall x. Rep VersionInterval x -> VersionInterval
forall x. VersionInterval -> Rep VersionInterval x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep VersionInterval x -> VersionInterval
$cfrom :: forall x. VersionInterval -> Rep VersionInterval x
Generic, Int -> VersionInterval -> ShowS
[VersionInterval] -> ShowS
VersionInterval -> String
(Int -> VersionInterval -> ShowS)
-> (VersionInterval -> String)
-> ([VersionInterval] -> ShowS)
-> Show VersionInterval
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VersionInterval] -> ShowS
$cshowList :: [VersionInterval] -> ShowS
show :: VersionInterval -> String
$cshow :: VersionInterval -> String
showsPrec :: Int -> VersionInterval -> ShowS
$cshowsPrec :: Int -> VersionInterval -> ShowS
Show, VersionInterval -> VersionInterval -> Bool
(VersionInterval -> VersionInterval -> Bool)
-> (VersionInterval -> VersionInterval -> Bool)
-> Eq VersionInterval
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VersionInterval -> VersionInterval -> Bool
$c/= :: VersionInterval -> VersionInterval -> Bool
== :: VersionInterval -> VersionInterval -> Bool
$c== :: VersionInterval -> VersionInterval -> Bool
Eq, Typeable VersionInterval
DataType
Constr
Typeable VersionInterval
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> VersionInterval -> c VersionInterval)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c VersionInterval)
-> (VersionInterval -> Constr)
-> (VersionInterval -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c VersionInterval))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c VersionInterval))
-> ((forall b. Data b => b -> b)
    -> VersionInterval -> VersionInterval)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> VersionInterval -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> VersionInterval -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> VersionInterval -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> VersionInterval -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> VersionInterval -> m VersionInterval)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> VersionInterval -> m VersionInterval)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> VersionInterval -> m VersionInterval)
-> Data VersionInterval
VersionInterval -> DataType
VersionInterval -> Constr
(forall b. Data b => b -> b) -> VersionInterval -> VersionInterval
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VersionInterval -> c VersionInterval
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VersionInterval
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) -> VersionInterval -> u
forall u. (forall d. Data d => d -> u) -> VersionInterval -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VersionInterval -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VersionInterval -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> VersionInterval -> m VersionInterval
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> VersionInterval -> m VersionInterval
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VersionInterval
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VersionInterval -> c VersionInterval
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VersionInterval)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c VersionInterval)
$cVersionInterval :: Constr
$tVersionInterval :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> VersionInterval -> m VersionInterval
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> VersionInterval -> m VersionInterval
gmapMp :: (forall d. Data d => d -> m d)
-> VersionInterval -> m VersionInterval
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> VersionInterval -> m VersionInterval
gmapM :: (forall d. Data d => d -> m d)
-> VersionInterval -> m VersionInterval
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> VersionInterval -> m VersionInterval
gmapQi :: Int -> (forall d. Data d => d -> u) -> VersionInterval -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> VersionInterval -> u
gmapQ :: (forall d. Data d => d -> u) -> VersionInterval -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> VersionInterval -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VersionInterval -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VersionInterval -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VersionInterval -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VersionInterval -> r
gmapT :: (forall b. Data b => b -> b) -> VersionInterval -> VersionInterval
$cgmapT :: (forall b. Data b => b -> b) -> VersionInterval -> VersionInterval
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c VersionInterval)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c VersionInterval)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c VersionInterval)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VersionInterval)
dataTypeOf :: VersionInterval -> DataType
$cdataTypeOf :: VersionInterval -> DataType
toConstr :: VersionInterval -> Constr
$ctoConstr :: VersionInterval -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VersionInterval
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VersionInterval
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VersionInterval -> c VersionInterval
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VersionInterval -> c VersionInterval
$cp1Data :: Typeable VersionInterval
Data, Typeable)
instance NFData VersionInterval

data Bound = ExclusiveBound | InclusiveBound
    deriving ((forall x. Bound -> Rep Bound x)
-> (forall x. Rep Bound x -> Bound) -> Generic Bound
forall x. Rep Bound x -> Bound
forall x. Bound -> Rep Bound x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Bound x -> Bound
$cfrom :: forall x. Bound -> Rep Bound x
Generic, Int -> Bound -> ShowS
[Bound] -> ShowS
Bound -> String
(Int -> Bound -> ShowS)
-> (Bound -> String) -> ([Bound] -> ShowS) -> Show Bound
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Bound] -> ShowS
$cshowList :: [Bound] -> ShowS
show :: Bound -> String
$cshow :: Bound -> String
showsPrec :: Int -> Bound -> ShowS
$cshowsPrec :: Int -> Bound -> ShowS
Show, Bound -> Bound -> Bool
(Bound -> Bound -> Bool) -> (Bound -> Bound -> Bool) -> Eq Bound
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Bound -> Bound -> Bool
$c/= :: Bound -> Bound -> Bool
== :: Bound -> Bound -> Bool
$c== :: Bound -> Bound -> Bool
Eq, Typeable Bound
DataType
Constr
Typeable Bound
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Bound -> c Bound)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Bound)
-> (Bound -> Constr)
-> (Bound -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Bound))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bound))
-> ((forall b. Data b => b -> b) -> Bound -> Bound)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bound -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bound -> r)
-> (forall u. (forall d. Data d => d -> u) -> Bound -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Bound -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Bound -> m Bound)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bound -> m Bound)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bound -> m Bound)
-> Data Bound
Bound -> DataType
Bound -> Constr
(forall b. Data b => b -> b) -> Bound -> Bound
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bound -> c Bound
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Bound
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) -> Bound -> u
forall u. (forall d. Data d => d -> u) -> Bound -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bound -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bound -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Bound -> m Bound
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bound -> m Bound
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Bound
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bound -> c Bound
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Bound)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bound)
$cInclusiveBound :: Constr
$cExclusiveBound :: Constr
$tBound :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Bound -> m Bound
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bound -> m Bound
gmapMp :: (forall d. Data d => d -> m d) -> Bound -> m Bound
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bound -> m Bound
gmapM :: (forall d. Data d => d -> m d) -> Bound -> m Bound
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Bound -> m Bound
gmapQi :: Int -> (forall d. Data d => d -> u) -> Bound -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Bound -> u
gmapQ :: (forall d. Data d => d -> u) -> Bound -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Bound -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bound -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bound -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bound -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bound -> r
gmapT :: (forall b. Data b => b -> b) -> Bound -> Bound
$cgmapT :: (forall b. Data b => b -> b) -> Bound -> Bound
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bound)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bound)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Bound)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Bound)
dataTypeOf :: Bound -> DataType
$cdataTypeOf :: Bound -> DataType
toConstr :: Bound -> Constr
$ctoConstr :: Bound -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Bound
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Bound
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bound -> c Bound
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bound -> c Bound
$cp1Data :: Typeable Bound
Data, Typeable)
instance NFData Bound

toVersionRange :: VersionIntervals -> C.VersionRange
toVersionRange :: VersionIntervals -> VersionRange
toVersionRange = VersionIntervals -> VersionRange
C.fromVersionIntervals (VersionIntervals -> VersionRange)
-> (VersionIntervals -> VersionIntervals)
-> VersionIntervals
-> VersionRange
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VersionIntervals -> VersionIntervals
toCabal

fromVersionRange :: C.VersionRange -> VersionIntervals
fromVersionRange :: VersionRange -> VersionIntervals
fromVersionRange = VersionIntervals -> VersionIntervals
fromCabal (VersionIntervals -> VersionIntervals)
-> (VersionRange -> VersionIntervals)
-> VersionRange
-> VersionIntervals
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VersionRange -> VersionIntervals
C.toVersionIntervals

withinIntervals :: Version -> VersionIntervals -> Bool
withinIntervals :: Version -> VersionIntervals -> Bool
withinIntervals Version
v VersionIntervals
vi = Version -> VersionIntervals -> Bool
C.withinIntervals Version
v (VersionIntervals -> VersionIntervals
toCabal VersionIntervals
vi)

unionVersionIntervals :: VersionIntervals -> VersionIntervals -> VersionIntervals
unionVersionIntervals :: VersionIntervals -> VersionIntervals -> VersionIntervals
unionVersionIntervals VersionIntervals
x VersionIntervals
y = VersionIntervals -> VersionIntervals
fromCabal (VersionIntervals -> VersionIntervals)
-> VersionIntervals -> VersionIntervals
forall a b. (a -> b) -> a -> b
$ VersionIntervals -> VersionIntervals -> VersionIntervals
C.unionVersionIntervals
    (VersionIntervals -> VersionIntervals
toCabal VersionIntervals
x)
    (VersionIntervals -> VersionIntervals
toCabal VersionIntervals
y)

intersectVersionIntervals :: VersionIntervals -> VersionIntervals -> VersionIntervals
intersectVersionIntervals :: VersionIntervals -> VersionIntervals -> VersionIntervals
intersectVersionIntervals VersionIntervals
x VersionIntervals
y = VersionIntervals -> VersionIntervals
fromCabal (VersionIntervals -> VersionIntervals)
-> VersionIntervals -> VersionIntervals
forall a b. (a -> b) -> a -> b
$ VersionIntervals -> VersionIntervals -> VersionIntervals
C.intersectVersionIntervals
    (VersionIntervals -> VersionIntervals
toCabal VersionIntervals
x)
    (VersionIntervals -> VersionIntervals
toCabal VersionIntervals
y)

toCabal :: VersionIntervals -> C.VersionIntervals
toCabal :: VersionIntervals -> VersionIntervals
toCabal (VersionIntervals [VersionInterval]
vi) =
  [VersionInterval] -> VersionIntervals
C.mkVersionIntervals ([VersionInterval] -> VersionIntervals)
-> [VersionInterval] -> VersionIntervals
forall a b. (a -> b) -> a -> b
$ (VersionInterval -> VersionInterval)
-> [VersionInterval] -> [VersionInterval]
forall a b. (a -> b) -> [a] -> [b]
map VersionInterval -> VersionInterval
go [VersionInterval]
vi
  where
    go :: VersionInterval -> VersionInterval
go (VersionInterval Version
lowerV Bound
lowerB Maybe (Version, Bound)
mupper) =
        ( Version -> Bound -> LowerBound
C.LowerBound Version
lowerV (Bound -> Bound
toCabalBound Bound
lowerB)
        , case Maybe (Version, Bound)
mupper of
            Maybe (Version, Bound)
Nothing -> UpperBound
C.NoUpperBound
            Just (Version
v, Bound
b) -> Version -> Bound -> UpperBound
C.UpperBound Version
v (Bound -> Bound
toCabalBound Bound
b)
        )

fromCabal :: C.VersionIntervals -> VersionIntervals
fromCabal :: VersionIntervals -> VersionIntervals
fromCabal =
    [VersionInterval] -> VersionIntervals
VersionIntervals ([VersionInterval] -> VersionIntervals)
-> (VersionIntervals -> [VersionInterval])
-> VersionIntervals
-> VersionIntervals
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (VersionInterval -> VersionInterval)
-> [VersionInterval] -> [VersionInterval]
forall a b. (a -> b) -> [a] -> [b]
map VersionInterval -> VersionInterval
go ([VersionInterval] -> [VersionInterval])
-> (VersionIntervals -> [VersionInterval])
-> VersionIntervals
-> [VersionInterval]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VersionIntervals -> [VersionInterval]
C.versionIntervals
  where
    go :: VersionInterval -> VersionInterval
go (C.LowerBound Version
lowerV Bound
lowerB, UpperBound
upper) = VersionInterval :: Version -> Bound -> Maybe (Version, Bound) -> VersionInterval
VersionInterval
      { viLowerVersion :: Version
viLowerVersion = Version
lowerV
      , viLowerBound :: Bound
viLowerBound = Bound -> Bound
fromCabalBound Bound
lowerB
      , viUpper :: Maybe (Version, Bound)
viUpper =
          case UpperBound
upper of
            UpperBound
C.NoUpperBound -> Maybe (Version, Bound)
forall a. Maybe a
Nothing
            C.UpperBound Version
v Bound
b -> (Version, Bound) -> Maybe (Version, Bound)
forall a. a -> Maybe a
Just (Version
v, Bound -> Bound
fromCabalBound Bound
b)
      }

toCabalBound :: Bound -> C.Bound
toCabalBound :: Bound -> Bound
toCabalBound Bound
ExclusiveBound = Bound
C.ExclusiveBound
toCabalBound Bound
InclusiveBound = Bound
C.InclusiveBound

fromCabalBound :: C.Bound -> Bound
fromCabalBound :: Bound -> Bound
fromCabalBound Bound
C.ExclusiveBound = Bound
ExclusiveBound
fromCabalBound Bound
C.InclusiveBound = Bound
InclusiveBound