{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE DeriveFoldable #-}
{-# LANGUAGE DeriveTraversable #-}

-----------------------------------------------------------------------------
-- |
-- Module      :  Distribution.Compiler
-- Copyright   :  Isaac Jones 2003-2004
-- License     :  BSD3
--
-- Maintainer  :  cabal-devel@haskell.org
-- Portability :  portable
--
-- This has an enumeration of the various compilers that Cabal knows about. It
-- also specifies the default compiler. Sadly you'll often see code that does
-- case analysis on this compiler flavour enumeration like:
--
-- > case compilerFlavor comp of
-- >   GHC -> GHC.getInstalledPackages verbosity packageDb progdb
--
-- Obviously it would be better to use the proper 'Compiler' abstraction
-- because that would keep all the compiler-specific code together.
-- Unfortunately we cannot make this change yet without breaking the
-- 'UserHooks' api, which would break all custom @Setup.hs@ files, so for the
-- moment we just have to live with this deficiency. If you're interested, see
-- ticket #57.

module Distribution.Compiler (
  -- * Compiler flavor
  CompilerFlavor(..),
  buildCompilerId,
  buildCompilerFlavor,
  defaultCompilerFlavor,
  classifyCompilerFlavor,
  knownCompilerFlavors,

  -- * Per compiler flavor
  PerCompilerFlavor (..),
  perCompilerFlavorToList,

  -- * Compiler id
  CompilerId(..),

  -- * Compiler info
  CompilerInfo(..),
  unknownCompilerInfo,
  AbiTag(..), abiTagString
  ) where

import Prelude ()
import Distribution.Compat.Prelude

import Language.Haskell.Extension

import Distribution.Version (Version, mkVersion', nullVersion)

import qualified System.Info (compilerName, compilerVersion)
import Distribution.Parsec (Parsec (..))
import Distribution.Pretty (Pretty (..), prettyShow)
import qualified Distribution.Compat.CharParsing as P
import qualified Text.PrettyPrint as Disp

data CompilerFlavor =
  GHC | GHCJS | NHC | YHC | Hugs | HBC | Helium | JHC | LHC | UHC | Eta
  | HaskellSuite String -- string is the id of the actual compiler
  | OtherCompiler String
  deriving ((forall x. CompilerFlavor -> Rep CompilerFlavor x)
-> (forall x. Rep CompilerFlavor x -> CompilerFlavor)
-> Generic CompilerFlavor
forall x. Rep CompilerFlavor x -> CompilerFlavor
forall x. CompilerFlavor -> Rep CompilerFlavor x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CompilerFlavor x -> CompilerFlavor
$cfrom :: forall x. CompilerFlavor -> Rep CompilerFlavor x
Generic, Int -> CompilerFlavor -> ShowS
[CompilerFlavor] -> ShowS
CompilerFlavor -> String
(Int -> CompilerFlavor -> ShowS)
-> (CompilerFlavor -> String)
-> ([CompilerFlavor] -> ShowS)
-> Show CompilerFlavor
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CompilerFlavor] -> ShowS
$cshowList :: [CompilerFlavor] -> ShowS
show :: CompilerFlavor -> String
$cshow :: CompilerFlavor -> String
showsPrec :: Int -> CompilerFlavor -> ShowS
$cshowsPrec :: Int -> CompilerFlavor -> ShowS
Show, ReadPrec [CompilerFlavor]
ReadPrec CompilerFlavor
Int -> ReadS CompilerFlavor
ReadS [CompilerFlavor]
(Int -> ReadS CompilerFlavor)
-> ReadS [CompilerFlavor]
-> ReadPrec CompilerFlavor
-> ReadPrec [CompilerFlavor]
-> Read CompilerFlavor
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CompilerFlavor]
$creadListPrec :: ReadPrec [CompilerFlavor]
readPrec :: ReadPrec CompilerFlavor
$creadPrec :: ReadPrec CompilerFlavor
readList :: ReadS [CompilerFlavor]
$creadList :: ReadS [CompilerFlavor]
readsPrec :: Int -> ReadS CompilerFlavor
$creadsPrec :: Int -> ReadS CompilerFlavor
Read, CompilerFlavor -> CompilerFlavor -> Bool
(CompilerFlavor -> CompilerFlavor -> Bool)
-> (CompilerFlavor -> CompilerFlavor -> Bool) -> Eq CompilerFlavor
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CompilerFlavor -> CompilerFlavor -> Bool
$c/= :: CompilerFlavor -> CompilerFlavor -> Bool
== :: CompilerFlavor -> CompilerFlavor -> Bool
$c== :: CompilerFlavor -> CompilerFlavor -> Bool
Eq, Eq CompilerFlavor
Eq CompilerFlavor
-> (CompilerFlavor -> CompilerFlavor -> Ordering)
-> (CompilerFlavor -> CompilerFlavor -> Bool)
-> (CompilerFlavor -> CompilerFlavor -> Bool)
-> (CompilerFlavor -> CompilerFlavor -> Bool)
-> (CompilerFlavor -> CompilerFlavor -> Bool)
-> (CompilerFlavor -> CompilerFlavor -> CompilerFlavor)
-> (CompilerFlavor -> CompilerFlavor -> CompilerFlavor)
-> Ord CompilerFlavor
CompilerFlavor -> CompilerFlavor -> Bool
CompilerFlavor -> CompilerFlavor -> Ordering
CompilerFlavor -> CompilerFlavor -> CompilerFlavor
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 :: CompilerFlavor -> CompilerFlavor -> CompilerFlavor
$cmin :: CompilerFlavor -> CompilerFlavor -> CompilerFlavor
max :: CompilerFlavor -> CompilerFlavor -> CompilerFlavor
$cmax :: CompilerFlavor -> CompilerFlavor -> CompilerFlavor
>= :: CompilerFlavor -> CompilerFlavor -> Bool
$c>= :: CompilerFlavor -> CompilerFlavor -> Bool
> :: CompilerFlavor -> CompilerFlavor -> Bool
$c> :: CompilerFlavor -> CompilerFlavor -> Bool
<= :: CompilerFlavor -> CompilerFlavor -> Bool
$c<= :: CompilerFlavor -> CompilerFlavor -> Bool
< :: CompilerFlavor -> CompilerFlavor -> Bool
$c< :: CompilerFlavor -> CompilerFlavor -> Bool
compare :: CompilerFlavor -> CompilerFlavor -> Ordering
$ccompare :: CompilerFlavor -> CompilerFlavor -> Ordering
$cp1Ord :: Eq CompilerFlavor
Ord, Typeable, Typeable CompilerFlavor
DataType
Constr
Typeable CompilerFlavor
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CompilerFlavor -> c CompilerFlavor)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CompilerFlavor)
-> (CompilerFlavor -> Constr)
-> (CompilerFlavor -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CompilerFlavor))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CompilerFlavor))
-> ((forall b. Data b => b -> b)
    -> CompilerFlavor -> CompilerFlavor)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CompilerFlavor -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CompilerFlavor -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> CompilerFlavor -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CompilerFlavor -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> CompilerFlavor -> m CompilerFlavor)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CompilerFlavor -> m CompilerFlavor)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CompilerFlavor -> m CompilerFlavor)
-> Data CompilerFlavor
CompilerFlavor -> DataType
CompilerFlavor -> Constr
(forall b. Data b => b -> b) -> CompilerFlavor -> CompilerFlavor
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CompilerFlavor -> c CompilerFlavor
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CompilerFlavor
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) -> CompilerFlavor -> u
forall u. (forall d. Data d => d -> u) -> CompilerFlavor -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CompilerFlavor -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CompilerFlavor -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CompilerFlavor -> m CompilerFlavor
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CompilerFlavor -> m CompilerFlavor
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CompilerFlavor
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CompilerFlavor -> c CompilerFlavor
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CompilerFlavor)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CompilerFlavor)
$cOtherCompiler :: Constr
$cHaskellSuite :: Constr
$cEta :: Constr
$cUHC :: Constr
$cLHC :: Constr
$cJHC :: Constr
$cHelium :: Constr
$cHBC :: Constr
$cHugs :: Constr
$cYHC :: Constr
$cNHC :: Constr
$cGHCJS :: Constr
$cGHC :: Constr
$tCompilerFlavor :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> CompilerFlavor -> m CompilerFlavor
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CompilerFlavor -> m CompilerFlavor
gmapMp :: (forall d. Data d => d -> m d)
-> CompilerFlavor -> m CompilerFlavor
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CompilerFlavor -> m CompilerFlavor
gmapM :: (forall d. Data d => d -> m d)
-> CompilerFlavor -> m CompilerFlavor
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CompilerFlavor -> m CompilerFlavor
gmapQi :: Int -> (forall d. Data d => d -> u) -> CompilerFlavor -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> CompilerFlavor -> u
gmapQ :: (forall d. Data d => d -> u) -> CompilerFlavor -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CompilerFlavor -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CompilerFlavor -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CompilerFlavor -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CompilerFlavor -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CompilerFlavor -> r
gmapT :: (forall b. Data b => b -> b) -> CompilerFlavor -> CompilerFlavor
$cgmapT :: (forall b. Data b => b -> b) -> CompilerFlavor -> CompilerFlavor
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CompilerFlavor)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CompilerFlavor)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c CompilerFlavor)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CompilerFlavor)
dataTypeOf :: CompilerFlavor -> DataType
$cdataTypeOf :: CompilerFlavor -> DataType
toConstr :: CompilerFlavor -> Constr
$ctoConstr :: CompilerFlavor -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CompilerFlavor
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CompilerFlavor
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CompilerFlavor -> c CompilerFlavor
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CompilerFlavor -> c CompilerFlavor
$cp1Data :: Typeable CompilerFlavor
Data)

instance Binary CompilerFlavor
instance Structured CompilerFlavor
instance NFData CompilerFlavor where rnf :: CompilerFlavor -> ()
rnf = CompilerFlavor -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf

knownCompilerFlavors :: [CompilerFlavor]
knownCompilerFlavors :: [CompilerFlavor]
knownCompilerFlavors =
  [CompilerFlavor
GHC, CompilerFlavor
GHCJS, CompilerFlavor
NHC, CompilerFlavor
YHC, CompilerFlavor
Hugs, CompilerFlavor
HBC, CompilerFlavor
Helium, CompilerFlavor
JHC, CompilerFlavor
LHC, CompilerFlavor
UHC, CompilerFlavor
Eta]

instance Pretty CompilerFlavor where
  pretty :: CompilerFlavor -> Doc
pretty (OtherCompiler String
name) = String -> Doc
Disp.text String
name
  pretty (HaskellSuite String
name)  = String -> Doc
Disp.text String
name
  pretty CompilerFlavor
NHC                  = String -> Doc
Disp.text String
"nhc98"
  pretty CompilerFlavor
other                = String -> Doc
Disp.text (ShowS
lowercase (CompilerFlavor -> String
forall a. Show a => a -> String
show CompilerFlavor
other))

instance Parsec CompilerFlavor where
    parsec :: m CompilerFlavor
parsec = String -> CompilerFlavor
classifyCompilerFlavor (String -> CompilerFlavor) -> m String -> m CompilerFlavor
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m String
component
      where
        component :: m String
component = do
          String
cs <- (Char -> Bool) -> m String
forall (m :: * -> *). CharParsing m => (Char -> Bool) -> m String
P.munch1 Char -> Bool
isAlphaNum
          if (Char -> Bool) -> String -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Char -> Bool
isDigit String
cs then String -> m String
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"all digits compiler name" else String -> m String
forall (m :: * -> *) a. Monad m => a -> m a
return String
cs

classifyCompilerFlavor :: String -> CompilerFlavor
classifyCompilerFlavor :: String -> CompilerFlavor
classifyCompilerFlavor String
s =
  CompilerFlavor -> Maybe CompilerFlavor -> CompilerFlavor
forall a. a -> Maybe a -> a
fromMaybe (String -> CompilerFlavor
OtherCompiler String
s) (Maybe CompilerFlavor -> CompilerFlavor)
-> Maybe CompilerFlavor -> CompilerFlavor
forall a b. (a -> b) -> a -> b
$ String -> [(String, CompilerFlavor)] -> Maybe CompilerFlavor
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup (ShowS
lowercase String
s) [(String, CompilerFlavor)]
compilerMap
  where
    compilerMap :: [(String, CompilerFlavor)]
compilerMap = [ (ShowS
lowercase (CompilerFlavor -> String
forall a. Pretty a => a -> String
prettyShow CompilerFlavor
compiler), CompilerFlavor
compiler)
                  | CompilerFlavor
compiler <- [CompilerFlavor]
knownCompilerFlavors ]

buildCompilerFlavor :: CompilerFlavor
buildCompilerFlavor :: CompilerFlavor
buildCompilerFlavor = String -> CompilerFlavor
classifyCompilerFlavor String
System.Info.compilerName

buildCompilerVersion :: Version
buildCompilerVersion :: Version
buildCompilerVersion = Version -> Version
mkVersion' Version
System.Info.compilerVersion

buildCompilerId :: CompilerId
buildCompilerId :: CompilerId
buildCompilerId = CompilerFlavor -> Version -> CompilerId
CompilerId CompilerFlavor
buildCompilerFlavor Version
buildCompilerVersion

-- | The default compiler flavour to pick when compiling stuff. This defaults
-- to the compiler used to build the Cabal lib.
--
-- However if it's not a recognised compiler then it's 'Nothing' and the user
-- will have to specify which compiler they want.
--
defaultCompilerFlavor :: Maybe CompilerFlavor
defaultCompilerFlavor :: Maybe CompilerFlavor
defaultCompilerFlavor = case CompilerFlavor
buildCompilerFlavor of
  OtherCompiler String
_ -> Maybe CompilerFlavor
forall a. Maybe a
Nothing
  CompilerFlavor
_               -> CompilerFlavor -> Maybe CompilerFlavor
forall a. a -> Maybe a
Just CompilerFlavor
buildCompilerFlavor

-------------------------------------------------------------------------------
-- Per compiler data
-------------------------------------------------------------------------------

-- | 'PerCompilerFlavor' carries only info per GHC and GHCJS
--
-- Cabal parses only @ghc-options@ and @ghcjs-options@, others are omitted.
--
data PerCompilerFlavor v = PerCompilerFlavor v v
  deriving ((forall x. PerCompilerFlavor v -> Rep (PerCompilerFlavor v) x)
-> (forall x. Rep (PerCompilerFlavor v) x -> PerCompilerFlavor v)
-> Generic (PerCompilerFlavor v)
forall x. Rep (PerCompilerFlavor v) x -> PerCompilerFlavor v
forall x. PerCompilerFlavor v -> Rep (PerCompilerFlavor v) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall v x. Rep (PerCompilerFlavor v) x -> PerCompilerFlavor v
forall v x. PerCompilerFlavor v -> Rep (PerCompilerFlavor v) x
$cto :: forall v x. Rep (PerCompilerFlavor v) x -> PerCompilerFlavor v
$cfrom :: forall v x. PerCompilerFlavor v -> Rep (PerCompilerFlavor v) x
Generic, Int -> PerCompilerFlavor v -> ShowS
[PerCompilerFlavor v] -> ShowS
PerCompilerFlavor v -> String
(Int -> PerCompilerFlavor v -> ShowS)
-> (PerCompilerFlavor v -> String)
-> ([PerCompilerFlavor v] -> ShowS)
-> Show (PerCompilerFlavor v)
forall v. Show v => Int -> PerCompilerFlavor v -> ShowS
forall v. Show v => [PerCompilerFlavor v] -> ShowS
forall v. Show v => PerCompilerFlavor v -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PerCompilerFlavor v] -> ShowS
$cshowList :: forall v. Show v => [PerCompilerFlavor v] -> ShowS
show :: PerCompilerFlavor v -> String
$cshow :: forall v. Show v => PerCompilerFlavor v -> String
showsPrec :: Int -> PerCompilerFlavor v -> ShowS
$cshowsPrec :: forall v. Show v => Int -> PerCompilerFlavor v -> ShowS
Show, ReadPrec [PerCompilerFlavor v]
ReadPrec (PerCompilerFlavor v)
Int -> ReadS (PerCompilerFlavor v)
ReadS [PerCompilerFlavor v]
(Int -> ReadS (PerCompilerFlavor v))
-> ReadS [PerCompilerFlavor v]
-> ReadPrec (PerCompilerFlavor v)
-> ReadPrec [PerCompilerFlavor v]
-> Read (PerCompilerFlavor v)
forall v. Read v => ReadPrec [PerCompilerFlavor v]
forall v. Read v => ReadPrec (PerCompilerFlavor v)
forall v. Read v => Int -> ReadS (PerCompilerFlavor v)
forall v. Read v => ReadS [PerCompilerFlavor v]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PerCompilerFlavor v]
$creadListPrec :: forall v. Read v => ReadPrec [PerCompilerFlavor v]
readPrec :: ReadPrec (PerCompilerFlavor v)
$creadPrec :: forall v. Read v => ReadPrec (PerCompilerFlavor v)
readList :: ReadS [PerCompilerFlavor v]
$creadList :: forall v. Read v => ReadS [PerCompilerFlavor v]
readsPrec :: Int -> ReadS (PerCompilerFlavor v)
$creadsPrec :: forall v. Read v => Int -> ReadS (PerCompilerFlavor v)
Read, PerCompilerFlavor v -> PerCompilerFlavor v -> Bool
(PerCompilerFlavor v -> PerCompilerFlavor v -> Bool)
-> (PerCompilerFlavor v -> PerCompilerFlavor v -> Bool)
-> Eq (PerCompilerFlavor v)
forall v.
Eq v =>
PerCompilerFlavor v -> PerCompilerFlavor v -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PerCompilerFlavor v -> PerCompilerFlavor v -> Bool
$c/= :: forall v.
Eq v =>
PerCompilerFlavor v -> PerCompilerFlavor v -> Bool
== :: PerCompilerFlavor v -> PerCompilerFlavor v -> Bool
$c== :: forall v.
Eq v =>
PerCompilerFlavor v -> PerCompilerFlavor v -> Bool
Eq, Typeable, Typeable (PerCompilerFlavor v)
DataType
Constr
Typeable (PerCompilerFlavor v)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> PerCompilerFlavor v
    -> c (PerCompilerFlavor v))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (PerCompilerFlavor v))
-> (PerCompilerFlavor v -> Constr)
-> (PerCompilerFlavor v -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (PerCompilerFlavor v)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (PerCompilerFlavor v)))
-> ((forall b. Data b => b -> b)
    -> PerCompilerFlavor v -> PerCompilerFlavor v)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PerCompilerFlavor v -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PerCompilerFlavor v -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> PerCompilerFlavor v -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> PerCompilerFlavor v -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> PerCompilerFlavor v -> m (PerCompilerFlavor v))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PerCompilerFlavor v -> m (PerCompilerFlavor v))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PerCompilerFlavor v -> m (PerCompilerFlavor v))
-> Data (PerCompilerFlavor v)
PerCompilerFlavor v -> DataType
PerCompilerFlavor v -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (PerCompilerFlavor v))
(forall b. Data b => b -> b)
-> PerCompilerFlavor v -> PerCompilerFlavor v
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PerCompilerFlavor v
-> c (PerCompilerFlavor v)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PerCompilerFlavor v)
forall v. Data v => Typeable (PerCompilerFlavor v)
forall v. Data v => PerCompilerFlavor v -> DataType
forall v. Data v => PerCompilerFlavor v -> Constr
forall v.
Data v =>
(forall b. Data b => b -> b)
-> PerCompilerFlavor v -> PerCompilerFlavor v
forall v u.
Data v =>
Int -> (forall d. Data d => d -> u) -> PerCompilerFlavor v -> u
forall v u.
Data v =>
(forall d. Data d => d -> u) -> PerCompilerFlavor v -> [u]
forall v r r'.
Data v =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PerCompilerFlavor v -> r
forall v r r'.
Data v =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PerCompilerFlavor v -> r
forall v (m :: * -> *).
(Data v, Monad m) =>
(forall d. Data d => d -> m d)
-> PerCompilerFlavor v -> m (PerCompilerFlavor v)
forall v (m :: * -> *).
(Data v, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> PerCompilerFlavor v -> m (PerCompilerFlavor v)
forall v (c :: * -> *).
Data v =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PerCompilerFlavor v)
forall v (c :: * -> *).
Data v =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PerCompilerFlavor v
-> c (PerCompilerFlavor v)
forall v (t :: * -> *) (c :: * -> *).
(Data v, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (PerCompilerFlavor v))
forall v (t :: * -> * -> *) (c :: * -> *).
(Data v, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PerCompilerFlavor v))
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) -> PerCompilerFlavor v -> u
forall u.
(forall d. Data d => d -> u) -> PerCompilerFlavor v -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PerCompilerFlavor v -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PerCompilerFlavor v -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PerCompilerFlavor v -> m (PerCompilerFlavor v)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PerCompilerFlavor v -> m (PerCompilerFlavor v)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PerCompilerFlavor v)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PerCompilerFlavor v
-> c (PerCompilerFlavor v)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (PerCompilerFlavor v))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PerCompilerFlavor v))
$cPerCompilerFlavor :: Constr
$tPerCompilerFlavor :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> PerCompilerFlavor v -> m (PerCompilerFlavor v)
$cgmapMo :: forall v (m :: * -> *).
(Data v, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> PerCompilerFlavor v -> m (PerCompilerFlavor v)
gmapMp :: (forall d. Data d => d -> m d)
-> PerCompilerFlavor v -> m (PerCompilerFlavor v)
$cgmapMp :: forall v (m :: * -> *).
(Data v, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> PerCompilerFlavor v -> m (PerCompilerFlavor v)
gmapM :: (forall d. Data d => d -> m d)
-> PerCompilerFlavor v -> m (PerCompilerFlavor v)
$cgmapM :: forall v (m :: * -> *).
(Data v, Monad m) =>
(forall d. Data d => d -> m d)
-> PerCompilerFlavor v -> m (PerCompilerFlavor v)
gmapQi :: Int -> (forall d. Data d => d -> u) -> PerCompilerFlavor v -> u
$cgmapQi :: forall v u.
Data v =>
Int -> (forall d. Data d => d -> u) -> PerCompilerFlavor v -> u
gmapQ :: (forall d. Data d => d -> u) -> PerCompilerFlavor v -> [u]
$cgmapQ :: forall v u.
Data v =>
(forall d. Data d => d -> u) -> PerCompilerFlavor v -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PerCompilerFlavor v -> r
$cgmapQr :: forall v r r'.
Data v =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PerCompilerFlavor v -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PerCompilerFlavor v -> r
$cgmapQl :: forall v r r'.
Data v =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PerCompilerFlavor v -> r
gmapT :: (forall b. Data b => b -> b)
-> PerCompilerFlavor v -> PerCompilerFlavor v
$cgmapT :: forall v.
Data v =>
(forall b. Data b => b -> b)
-> PerCompilerFlavor v -> PerCompilerFlavor v
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PerCompilerFlavor v))
$cdataCast2 :: forall v (t :: * -> * -> *) (c :: * -> *).
(Data v, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PerCompilerFlavor v))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (PerCompilerFlavor v))
$cdataCast1 :: forall v (t :: * -> *) (c :: * -> *).
(Data v, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (PerCompilerFlavor v))
dataTypeOf :: PerCompilerFlavor v -> DataType
$cdataTypeOf :: forall v. Data v => PerCompilerFlavor v -> DataType
toConstr :: PerCompilerFlavor v -> Constr
$ctoConstr :: forall v. Data v => PerCompilerFlavor v -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PerCompilerFlavor v)
$cgunfold :: forall v (c :: * -> *).
Data v =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PerCompilerFlavor v)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PerCompilerFlavor v
-> c (PerCompilerFlavor v)
$cgfoldl :: forall v (c :: * -> *).
Data v =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PerCompilerFlavor v
-> c (PerCompilerFlavor v)
$cp1Data :: forall v. Data v => Typeable (PerCompilerFlavor v)
Data, a -> PerCompilerFlavor b -> PerCompilerFlavor a
(a -> b) -> PerCompilerFlavor a -> PerCompilerFlavor b
(forall a b.
 (a -> b) -> PerCompilerFlavor a -> PerCompilerFlavor b)
-> (forall a b. a -> PerCompilerFlavor b -> PerCompilerFlavor a)
-> Functor PerCompilerFlavor
forall a b. a -> PerCompilerFlavor b -> PerCompilerFlavor a
forall a b. (a -> b) -> PerCompilerFlavor a -> PerCompilerFlavor b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> PerCompilerFlavor b -> PerCompilerFlavor a
$c<$ :: forall a b. a -> PerCompilerFlavor b -> PerCompilerFlavor a
fmap :: (a -> b) -> PerCompilerFlavor a -> PerCompilerFlavor b
$cfmap :: forall a b. (a -> b) -> PerCompilerFlavor a -> PerCompilerFlavor b
Functor, PerCompilerFlavor a -> Bool
(a -> m) -> PerCompilerFlavor a -> m
(a -> b -> b) -> b -> PerCompilerFlavor a -> b
(forall m. Monoid m => PerCompilerFlavor m -> m)
-> (forall m a. Monoid m => (a -> m) -> PerCompilerFlavor a -> m)
-> (forall m a. Monoid m => (a -> m) -> PerCompilerFlavor a -> m)
-> (forall a b. (a -> b -> b) -> b -> PerCompilerFlavor a -> b)
-> (forall a b. (a -> b -> b) -> b -> PerCompilerFlavor a -> b)
-> (forall b a. (b -> a -> b) -> b -> PerCompilerFlavor a -> b)
-> (forall b a. (b -> a -> b) -> b -> PerCompilerFlavor a -> b)
-> (forall a. (a -> a -> a) -> PerCompilerFlavor a -> a)
-> (forall a. (a -> a -> a) -> PerCompilerFlavor a -> a)
-> (forall a. PerCompilerFlavor a -> [a])
-> (forall a. PerCompilerFlavor a -> Bool)
-> (forall a. PerCompilerFlavor a -> Int)
-> (forall a. Eq a => a -> PerCompilerFlavor a -> Bool)
-> (forall a. Ord a => PerCompilerFlavor a -> a)
-> (forall a. Ord a => PerCompilerFlavor a -> a)
-> (forall a. Num a => PerCompilerFlavor a -> a)
-> (forall a. Num a => PerCompilerFlavor a -> a)
-> Foldable PerCompilerFlavor
forall a. Eq a => a -> PerCompilerFlavor a -> Bool
forall a. Num a => PerCompilerFlavor a -> a
forall a. Ord a => PerCompilerFlavor a -> a
forall m. Monoid m => PerCompilerFlavor m -> m
forall a. PerCompilerFlavor a -> Bool
forall a. PerCompilerFlavor a -> Int
forall a. PerCompilerFlavor a -> [a]
forall a. (a -> a -> a) -> PerCompilerFlavor a -> a
forall m a. Monoid m => (a -> m) -> PerCompilerFlavor a -> m
forall b a. (b -> a -> b) -> b -> PerCompilerFlavor a -> b
forall a b. (a -> b -> b) -> b -> PerCompilerFlavor a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: PerCompilerFlavor a -> a
$cproduct :: forall a. Num a => PerCompilerFlavor a -> a
sum :: PerCompilerFlavor a -> a
$csum :: forall a. Num a => PerCompilerFlavor a -> a
minimum :: PerCompilerFlavor a -> a
$cminimum :: forall a. Ord a => PerCompilerFlavor a -> a
maximum :: PerCompilerFlavor a -> a
$cmaximum :: forall a. Ord a => PerCompilerFlavor a -> a
elem :: a -> PerCompilerFlavor a -> Bool
$celem :: forall a. Eq a => a -> PerCompilerFlavor a -> Bool
length :: PerCompilerFlavor a -> Int
$clength :: forall a. PerCompilerFlavor a -> Int
null :: PerCompilerFlavor a -> Bool
$cnull :: forall a. PerCompilerFlavor a -> Bool
toList :: PerCompilerFlavor a -> [a]
$ctoList :: forall a. PerCompilerFlavor a -> [a]
foldl1 :: (a -> a -> a) -> PerCompilerFlavor a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> PerCompilerFlavor a -> a
foldr1 :: (a -> a -> a) -> PerCompilerFlavor a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> PerCompilerFlavor a -> a
foldl' :: (b -> a -> b) -> b -> PerCompilerFlavor a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> PerCompilerFlavor a -> b
foldl :: (b -> a -> b) -> b -> PerCompilerFlavor a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> PerCompilerFlavor a -> b
foldr' :: (a -> b -> b) -> b -> PerCompilerFlavor a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> PerCompilerFlavor a -> b
foldr :: (a -> b -> b) -> b -> PerCompilerFlavor a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> PerCompilerFlavor a -> b
foldMap' :: (a -> m) -> PerCompilerFlavor a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> PerCompilerFlavor a -> m
foldMap :: (a -> m) -> PerCompilerFlavor a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> PerCompilerFlavor a -> m
fold :: PerCompilerFlavor m -> m
$cfold :: forall m. Monoid m => PerCompilerFlavor m -> m
Foldable
           , Functor PerCompilerFlavor
Foldable PerCompilerFlavor
Functor PerCompilerFlavor
-> Foldable PerCompilerFlavor
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> PerCompilerFlavor a -> f (PerCompilerFlavor b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    PerCompilerFlavor (f a) -> f (PerCompilerFlavor a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> PerCompilerFlavor a -> m (PerCompilerFlavor b))
-> (forall (m :: * -> *) a.
    Monad m =>
    PerCompilerFlavor (m a) -> m (PerCompilerFlavor a))
-> Traversable PerCompilerFlavor
(a -> f b) -> PerCompilerFlavor a -> f (PerCompilerFlavor b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
PerCompilerFlavor (m a) -> m (PerCompilerFlavor a)
forall (f :: * -> *) a.
Applicative f =>
PerCompilerFlavor (f a) -> f (PerCompilerFlavor a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> PerCompilerFlavor a -> m (PerCompilerFlavor b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PerCompilerFlavor a -> f (PerCompilerFlavor b)
sequence :: PerCompilerFlavor (m a) -> m (PerCompilerFlavor a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
PerCompilerFlavor (m a) -> m (PerCompilerFlavor a)
mapM :: (a -> m b) -> PerCompilerFlavor a -> m (PerCompilerFlavor b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> PerCompilerFlavor a -> m (PerCompilerFlavor b)
sequenceA :: PerCompilerFlavor (f a) -> f (PerCompilerFlavor a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
PerCompilerFlavor (f a) -> f (PerCompilerFlavor a)
traverse :: (a -> f b) -> PerCompilerFlavor a -> f (PerCompilerFlavor b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PerCompilerFlavor a -> f (PerCompilerFlavor b)
$cp2Traversable :: Foldable PerCompilerFlavor
$cp1Traversable :: Functor PerCompilerFlavor
Traversable)

instance Binary a => Binary (PerCompilerFlavor a)
instance Structured a => Structured (PerCompilerFlavor a)
instance NFData a => NFData (PerCompilerFlavor a)

perCompilerFlavorToList :: PerCompilerFlavor v -> [(CompilerFlavor, v)]
perCompilerFlavorToList :: PerCompilerFlavor v -> [(CompilerFlavor, v)]
perCompilerFlavorToList (PerCompilerFlavor v
a v
b) = [(CompilerFlavor
GHC, v
a), (CompilerFlavor
GHCJS, v
b)]

instance Semigroup a => Semigroup (PerCompilerFlavor a) where
    PerCompilerFlavor a
a a
b <> :: PerCompilerFlavor a -> PerCompilerFlavor a -> PerCompilerFlavor a
<> PerCompilerFlavor a
a' a
b' = a -> a -> PerCompilerFlavor a
forall v. v -> v -> PerCompilerFlavor v
PerCompilerFlavor
        (a
a a -> a -> a
forall a. Semigroup a => a -> a -> a
<> a
a') (a
b a -> a -> a
forall a. Semigroup a => a -> a -> a
<> a
b')

instance (Semigroup a, Monoid a) => Monoid (PerCompilerFlavor a) where
    mempty :: PerCompilerFlavor a
mempty = a -> a -> PerCompilerFlavor a
forall v. v -> v -> PerCompilerFlavor v
PerCompilerFlavor a
forall a. Monoid a => a
mempty a
forall a. Monoid a => a
mempty
    mappend :: PerCompilerFlavor a -> PerCompilerFlavor a -> PerCompilerFlavor a
mappend = PerCompilerFlavor a -> PerCompilerFlavor a -> PerCompilerFlavor a
forall a. Semigroup a => a -> a -> a
(<>)

-- ------------------------------------------------------------
-- * Compiler Id
-- ------------------------------------------------------------

data CompilerId = CompilerId CompilerFlavor Version
  deriving (CompilerId -> CompilerId -> Bool
(CompilerId -> CompilerId -> Bool)
-> (CompilerId -> CompilerId -> Bool) -> Eq CompilerId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CompilerId -> CompilerId -> Bool
$c/= :: CompilerId -> CompilerId -> Bool
== :: CompilerId -> CompilerId -> Bool
$c== :: CompilerId -> CompilerId -> Bool
Eq, (forall x. CompilerId -> Rep CompilerId x)
-> (forall x. Rep CompilerId x -> CompilerId) -> Generic CompilerId
forall x. Rep CompilerId x -> CompilerId
forall x. CompilerId -> Rep CompilerId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CompilerId x -> CompilerId
$cfrom :: forall x. CompilerId -> Rep CompilerId x
Generic, Eq CompilerId
Eq CompilerId
-> (CompilerId -> CompilerId -> Ordering)
-> (CompilerId -> CompilerId -> Bool)
-> (CompilerId -> CompilerId -> Bool)
-> (CompilerId -> CompilerId -> Bool)
-> (CompilerId -> CompilerId -> Bool)
-> (CompilerId -> CompilerId -> CompilerId)
-> (CompilerId -> CompilerId -> CompilerId)
-> Ord CompilerId
CompilerId -> CompilerId -> Bool
CompilerId -> CompilerId -> Ordering
CompilerId -> CompilerId -> CompilerId
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 :: CompilerId -> CompilerId -> CompilerId
$cmin :: CompilerId -> CompilerId -> CompilerId
max :: CompilerId -> CompilerId -> CompilerId
$cmax :: CompilerId -> CompilerId -> CompilerId
>= :: CompilerId -> CompilerId -> Bool
$c>= :: CompilerId -> CompilerId -> Bool
> :: CompilerId -> CompilerId -> Bool
$c> :: CompilerId -> CompilerId -> Bool
<= :: CompilerId -> CompilerId -> Bool
$c<= :: CompilerId -> CompilerId -> Bool
< :: CompilerId -> CompilerId -> Bool
$c< :: CompilerId -> CompilerId -> Bool
compare :: CompilerId -> CompilerId -> Ordering
$ccompare :: CompilerId -> CompilerId -> Ordering
$cp1Ord :: Eq CompilerId
Ord, ReadPrec [CompilerId]
ReadPrec CompilerId
Int -> ReadS CompilerId
ReadS [CompilerId]
(Int -> ReadS CompilerId)
-> ReadS [CompilerId]
-> ReadPrec CompilerId
-> ReadPrec [CompilerId]
-> Read CompilerId
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CompilerId]
$creadListPrec :: ReadPrec [CompilerId]
readPrec :: ReadPrec CompilerId
$creadPrec :: ReadPrec CompilerId
readList :: ReadS [CompilerId]
$creadList :: ReadS [CompilerId]
readsPrec :: Int -> ReadS CompilerId
$creadsPrec :: Int -> ReadS CompilerId
Read, Int -> CompilerId -> ShowS
[CompilerId] -> ShowS
CompilerId -> String
(Int -> CompilerId -> ShowS)
-> (CompilerId -> String)
-> ([CompilerId] -> ShowS)
-> Show CompilerId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CompilerId] -> ShowS
$cshowList :: [CompilerId] -> ShowS
show :: CompilerId -> String
$cshow :: CompilerId -> String
showsPrec :: Int -> CompilerId -> ShowS
$cshowsPrec :: Int -> CompilerId -> ShowS
Show, Typeable)

instance Binary CompilerId
instance Structured CompilerId
instance NFData CompilerId where rnf :: CompilerId -> ()
rnf = CompilerId -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf

instance Pretty CompilerId where
  pretty :: CompilerId -> Doc
pretty (CompilerId CompilerFlavor
f Version
v)
    | Version
v Version -> Version -> Bool
forall a. Eq a => a -> a -> Bool
== Version
nullVersion = CompilerFlavor -> Doc
forall a. Pretty a => a -> Doc
pretty CompilerFlavor
f
    | Bool
otherwise        = CompilerFlavor -> Doc
forall a. Pretty a => a -> Doc
pretty CompilerFlavor
f Doc -> Doc -> Doc
<<>> Char -> Doc
Disp.char Char
'-' Doc -> Doc -> Doc
<<>> Version -> Doc
forall a. Pretty a => a -> Doc
pretty Version
v

instance Parsec CompilerId where
  parsec :: m CompilerId
parsec = do
    CompilerFlavor
flavour <- m CompilerFlavor
forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec
    Version
version <- (Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
P.char Char
'-' m Char -> m Version -> m Version
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> m Version
forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec) m Version -> m Version -> m Version
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Version -> m Version
forall (m :: * -> *) a. Monad m => a -> m a
return Version
nullVersion
    CompilerId -> m CompilerId
forall (m :: * -> *) a. Monad m => a -> m a
return (CompilerFlavor -> Version -> CompilerId
CompilerId CompilerFlavor
flavour Version
version)

lowercase :: String -> String
lowercase :: ShowS
lowercase = (Char -> Char) -> ShowS
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower

-- ------------------------------------------------------------
-- * Compiler Info
-- ------------------------------------------------------------

-- | Compiler information used for resolving configurations. Some
--   fields can be set to Nothing to indicate that the information is
--   unknown.

data CompilerInfo = CompilerInfo {
         CompilerInfo -> CompilerId
compilerInfoId         :: CompilerId,
         -- ^ Compiler flavour and version.
         CompilerInfo -> AbiTag
compilerInfoAbiTag     :: AbiTag,
         -- ^ Tag for distinguishing incompatible ABI's on the same
         -- architecture/os.
         CompilerInfo -> Maybe [CompilerId]
compilerInfoCompat     :: Maybe [CompilerId],
         -- ^ Other implementations that this compiler claims to be
         -- compatible with, if known.
         CompilerInfo -> Maybe [Language]
compilerInfoLanguages  :: Maybe [Language],
         -- ^ Supported language standards, if known.
         CompilerInfo -> Maybe [Extension]
compilerInfoExtensions :: Maybe [Extension]
         -- ^ Supported extensions, if known.
     }
     deriving ((forall x. CompilerInfo -> Rep CompilerInfo x)
-> (forall x. Rep CompilerInfo x -> CompilerInfo)
-> Generic CompilerInfo
forall x. Rep CompilerInfo x -> CompilerInfo
forall x. CompilerInfo -> Rep CompilerInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CompilerInfo x -> CompilerInfo
$cfrom :: forall x. CompilerInfo -> Rep CompilerInfo x
Generic, Int -> CompilerInfo -> ShowS
[CompilerInfo] -> ShowS
CompilerInfo -> String
(Int -> CompilerInfo -> ShowS)
-> (CompilerInfo -> String)
-> ([CompilerInfo] -> ShowS)
-> Show CompilerInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CompilerInfo] -> ShowS
$cshowList :: [CompilerInfo] -> ShowS
show :: CompilerInfo -> String
$cshow :: CompilerInfo -> String
showsPrec :: Int -> CompilerInfo -> ShowS
$cshowsPrec :: Int -> CompilerInfo -> ShowS
Show, ReadPrec [CompilerInfo]
ReadPrec CompilerInfo
Int -> ReadS CompilerInfo
ReadS [CompilerInfo]
(Int -> ReadS CompilerInfo)
-> ReadS [CompilerInfo]
-> ReadPrec CompilerInfo
-> ReadPrec [CompilerInfo]
-> Read CompilerInfo
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CompilerInfo]
$creadListPrec :: ReadPrec [CompilerInfo]
readPrec :: ReadPrec CompilerInfo
$creadPrec :: ReadPrec CompilerInfo
readList :: ReadS [CompilerInfo]
$creadList :: ReadS [CompilerInfo]
readsPrec :: Int -> ReadS CompilerInfo
$creadsPrec :: Int -> ReadS CompilerInfo
Read)

instance Binary CompilerInfo

data AbiTag
  = NoAbiTag
  | AbiTag String
  deriving (AbiTag -> AbiTag -> Bool
(AbiTag -> AbiTag -> Bool)
-> (AbiTag -> AbiTag -> Bool) -> Eq AbiTag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AbiTag -> AbiTag -> Bool
$c/= :: AbiTag -> AbiTag -> Bool
== :: AbiTag -> AbiTag -> Bool
$c== :: AbiTag -> AbiTag -> Bool
Eq, (forall x. AbiTag -> Rep AbiTag x)
-> (forall x. Rep AbiTag x -> AbiTag) -> Generic AbiTag
forall x. Rep AbiTag x -> AbiTag
forall x. AbiTag -> Rep AbiTag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep AbiTag x -> AbiTag
$cfrom :: forall x. AbiTag -> Rep AbiTag x
Generic, Int -> AbiTag -> ShowS
[AbiTag] -> ShowS
AbiTag -> String
(Int -> AbiTag -> ShowS)
-> (AbiTag -> String) -> ([AbiTag] -> ShowS) -> Show AbiTag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AbiTag] -> ShowS
$cshowList :: [AbiTag] -> ShowS
show :: AbiTag -> String
$cshow :: AbiTag -> String
showsPrec :: Int -> AbiTag -> ShowS
$cshowsPrec :: Int -> AbiTag -> ShowS
Show, ReadPrec [AbiTag]
ReadPrec AbiTag
Int -> ReadS AbiTag
ReadS [AbiTag]
(Int -> ReadS AbiTag)
-> ReadS [AbiTag]
-> ReadPrec AbiTag
-> ReadPrec [AbiTag]
-> Read AbiTag
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [AbiTag]
$creadListPrec :: ReadPrec [AbiTag]
readPrec :: ReadPrec AbiTag
$creadPrec :: ReadPrec AbiTag
readList :: ReadS [AbiTag]
$creadList :: ReadS [AbiTag]
readsPrec :: Int -> ReadS AbiTag
$creadsPrec :: Int -> ReadS AbiTag
Read, Typeable)

instance Binary AbiTag
instance Structured AbiTag

instance Pretty AbiTag where
  pretty :: AbiTag -> Doc
pretty AbiTag
NoAbiTag     = Doc
Disp.empty
  pretty (AbiTag String
tag) = String -> Doc
Disp.text String
tag

instance Parsec AbiTag where
  parsec :: m AbiTag
parsec = do
    String
tag <- (Char -> Bool) -> m String
forall (m :: * -> *). CharParsing m => (Char -> Bool) -> m String
P.munch (\Char
c -> Char -> Bool
isAlphaNum Char
c Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'_')
    if String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
tag then AbiTag -> m AbiTag
forall (m :: * -> *) a. Monad m => a -> m a
return AbiTag
NoAbiTag else AbiTag -> m AbiTag
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> AbiTag
AbiTag String
tag)

abiTagString :: AbiTag -> String
abiTagString :: AbiTag -> String
abiTagString AbiTag
NoAbiTag     = String
""
abiTagString (AbiTag String
tag) = String
tag

-- | Make a CompilerInfo of which only the known information is its CompilerId,
--   its AbiTag and that it does not claim to be compatible with other
--   compiler id's.
unknownCompilerInfo :: CompilerId -> AbiTag -> CompilerInfo
unknownCompilerInfo :: CompilerId -> AbiTag -> CompilerInfo
unknownCompilerInfo CompilerId
compilerId AbiTag
abiTag =
  CompilerId
-> AbiTag
-> Maybe [CompilerId]
-> Maybe [Language]
-> Maybe [Extension]
-> CompilerInfo
CompilerInfo CompilerId
compilerId AbiTag
abiTag ([CompilerId] -> Maybe [CompilerId]
forall a. a -> Maybe a
Just []) Maybe [Language]
forall a. Maybe a
Nothing Maybe [Extension]
forall a. Maybe a
Nothing