{-# LANGUAGE DeriveGeneric #-}
module Distribution.Client.Dependency.Types (
    PreSolver(..),
    Solver(..),
    PackagesPreferenceDefault(..),
  ) where

import Distribution.Client.Compat.Prelude
import Prelude ()

import Text.PrettyPrint (text)

import qualified Distribution.Compat.CharParsing as P


-- | All the solvers that can be selected.
data PreSolver = AlwaysModular
  deriving (PreSolver -> PreSolver -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PreSolver -> PreSolver -> Bool
$c/= :: PreSolver -> PreSolver -> Bool
== :: PreSolver -> PreSolver -> Bool
$c== :: PreSolver -> PreSolver -> Bool
Eq, Eq PreSolver
PreSolver -> PreSolver -> Bool
PreSolver -> PreSolver -> Ordering
PreSolver -> PreSolver -> PreSolver
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 :: PreSolver -> PreSolver -> PreSolver
$cmin :: PreSolver -> PreSolver -> PreSolver
max :: PreSolver -> PreSolver -> PreSolver
$cmax :: PreSolver -> PreSolver -> PreSolver
>= :: PreSolver -> PreSolver -> Bool
$c>= :: PreSolver -> PreSolver -> Bool
> :: PreSolver -> PreSolver -> Bool
$c> :: PreSolver -> PreSolver -> Bool
<= :: PreSolver -> PreSolver -> Bool
$c<= :: PreSolver -> PreSolver -> Bool
< :: PreSolver -> PreSolver -> Bool
$c< :: PreSolver -> PreSolver -> Bool
compare :: PreSolver -> PreSolver -> Ordering
$ccompare :: PreSolver -> PreSolver -> Ordering
Ord, Int -> PreSolver -> ShowS
[PreSolver] -> ShowS
PreSolver -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PreSolver] -> ShowS
$cshowList :: [PreSolver] -> ShowS
show :: PreSolver -> String
$cshow :: PreSolver -> String
showsPrec :: Int -> PreSolver -> ShowS
$cshowsPrec :: Int -> PreSolver -> ShowS
Show, PreSolver
forall a. a -> a -> Bounded a
maxBound :: PreSolver
$cmaxBound :: PreSolver
minBound :: PreSolver
$cminBound :: PreSolver
Bounded, Int -> PreSolver
PreSolver -> Int
PreSolver -> [PreSolver]
PreSolver -> PreSolver
PreSolver -> PreSolver -> [PreSolver]
PreSolver -> PreSolver -> PreSolver -> [PreSolver]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: PreSolver -> PreSolver -> PreSolver -> [PreSolver]
$cenumFromThenTo :: PreSolver -> PreSolver -> PreSolver -> [PreSolver]
enumFromTo :: PreSolver -> PreSolver -> [PreSolver]
$cenumFromTo :: PreSolver -> PreSolver -> [PreSolver]
enumFromThen :: PreSolver -> PreSolver -> [PreSolver]
$cenumFromThen :: PreSolver -> PreSolver -> [PreSolver]
enumFrom :: PreSolver -> [PreSolver]
$cenumFrom :: PreSolver -> [PreSolver]
fromEnum :: PreSolver -> Int
$cfromEnum :: PreSolver -> Int
toEnum :: Int -> PreSolver
$ctoEnum :: Int -> PreSolver
pred :: PreSolver -> PreSolver
$cpred :: PreSolver -> PreSolver
succ :: PreSolver -> PreSolver
$csucc :: PreSolver -> PreSolver
Enum, forall x. Rep PreSolver x -> PreSolver
forall x. PreSolver -> Rep PreSolver x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PreSolver x -> PreSolver
$cfrom :: forall x. PreSolver -> Rep PreSolver x
Generic)

-- | All the solvers that can be used.
data Solver = Modular
  deriving (Solver -> Solver -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Solver -> Solver -> Bool
$c/= :: Solver -> Solver -> Bool
== :: Solver -> Solver -> Bool
$c== :: Solver -> Solver -> Bool
Eq, Eq Solver
Solver -> Solver -> Bool
Solver -> Solver -> Ordering
Solver -> Solver -> Solver
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 :: Solver -> Solver -> Solver
$cmin :: Solver -> Solver -> Solver
max :: Solver -> Solver -> Solver
$cmax :: Solver -> Solver -> Solver
>= :: Solver -> Solver -> Bool
$c>= :: Solver -> Solver -> Bool
> :: Solver -> Solver -> Bool
$c> :: Solver -> Solver -> Bool
<= :: Solver -> Solver -> Bool
$c<= :: Solver -> Solver -> Bool
< :: Solver -> Solver -> Bool
$c< :: Solver -> Solver -> Bool
compare :: Solver -> Solver -> Ordering
$ccompare :: Solver -> Solver -> Ordering
Ord, Int -> Solver -> ShowS
[Solver] -> ShowS
Solver -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Solver] -> ShowS
$cshowList :: [Solver] -> ShowS
show :: Solver -> String
$cshow :: Solver -> String
showsPrec :: Int -> Solver -> ShowS
$cshowsPrec :: Int -> Solver -> ShowS
Show, Solver
forall a. a -> a -> Bounded a
maxBound :: Solver
$cmaxBound :: Solver
minBound :: Solver
$cminBound :: Solver
Bounded, Int -> Solver
Solver -> Int
Solver -> [Solver]
Solver -> Solver
Solver -> Solver -> [Solver]
Solver -> Solver -> Solver -> [Solver]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Solver -> Solver -> Solver -> [Solver]
$cenumFromThenTo :: Solver -> Solver -> Solver -> [Solver]
enumFromTo :: Solver -> Solver -> [Solver]
$cenumFromTo :: Solver -> Solver -> [Solver]
enumFromThen :: Solver -> Solver -> [Solver]
$cenumFromThen :: Solver -> Solver -> [Solver]
enumFrom :: Solver -> [Solver]
$cenumFrom :: Solver -> [Solver]
fromEnum :: Solver -> Int
$cfromEnum :: Solver -> Int
toEnum :: Int -> Solver
$ctoEnum :: Int -> Solver
pred :: Solver -> Solver
$cpred :: Solver -> Solver
succ :: Solver -> Solver
$csucc :: Solver -> Solver
Enum, forall x. Rep Solver x -> Solver
forall x. Solver -> Rep Solver x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Solver x -> Solver
$cfrom :: forall x. Solver -> Rep Solver x
Generic)

instance Binary PreSolver
instance Binary Solver

instance Structured PreSolver
instance Structured Solver

instance Pretty PreSolver where
    pretty :: PreSolver -> Doc
pretty PreSolver
AlwaysModular = String -> Doc
text String
"modular"

instance Parsec PreSolver where
    parsec :: forall (m :: * -> *). CabalParsing m => m PreSolver
parsec = do
        String
name <- forall (m :: * -> *). CharParsing m => (Char -> Bool) -> m String
P.munch1 Char -> Bool
isAlpha
        case forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower String
name of
            String
"modular" -> forall (m :: * -> *) a. Monad m => a -> m a
return PreSolver
AlwaysModular
            String
_         -> forall (m :: * -> *) a. Parsing m => String -> m a
P.unexpected forall a b. (a -> b) -> a -> b
$ String
"PreSolver: " forall a. [a] -> [a] -> [a]
++ String
name

-- | Global policy for all packages to say if we prefer package versions that
-- are already installed locally or if we just prefer the latest available.
--
data PackagesPreferenceDefault =

     -- | Always prefer the latest version irrespective of any existing
     -- installed version.
     --
     -- * This is the standard policy for upgrade.
     --
     PreferAllLatest

     -- | Always prefer the oldest version irrespective of any existing
     -- installed version or packages explicitly requested.
     --
     -- * This is enabled by --prefer-oldest.
     --
   | PreferAllOldest

     -- | Always prefer the installed versions over ones that would need to be
     -- installed. Secondarily, prefer latest versions (eg the latest installed
     -- version or if there are none then the latest source version).
   | PreferAllInstalled

     -- | Prefer the latest version for packages that are explicitly requested
     -- but prefers the installed version for any other packages.
     --
     -- * This is the standard policy for install.
     --
   | PreferLatestForSelected
  deriving Int -> PackagesPreferenceDefault -> ShowS
[PackagesPreferenceDefault] -> ShowS
PackagesPreferenceDefault -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PackagesPreferenceDefault] -> ShowS
$cshowList :: [PackagesPreferenceDefault] -> ShowS
show :: PackagesPreferenceDefault -> String
$cshow :: PackagesPreferenceDefault -> String
showsPrec :: Int -> PackagesPreferenceDefault -> ShowS
$cshowsPrec :: Int -> PackagesPreferenceDefault -> ShowS
Show