{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE MagicHash #-}
#if !(MIN_VERSION_base(4,9,0))
# if __GLASGOW_HASKELL__ >= 800
{-# LANGUAGE TemplateHaskellQuotes #-}
# else
{-# LANGUAGE TemplateHaskell #-}
# endif
#endif
module Data.Deriving.Internal where
import qualified Control.Applicative as App (liftA2)
import Control.Monad (when, unless)
import Data.Foldable (foldr')
#if !(MIN_VERSION_base(4,9,0))
import Data.Functor.Classes (Eq1(..), Ord1(..), Read1(..), Show1(..))
# if !(MIN_VERSION_transformers(0,4,0)) || MIN_VERSION_transformers(0,5,0)
import Data.Functor.Classes (Eq2(..), Ord2(..), Read2(..), Show2(..))
# endif
#endif
import qualified Data.List as List
import qualified Data.Map as Map
import Data.Map (Map)
import Data.Maybe
import qualified Data.Set as Set
import Data.Set (Set)
import qualified Data.Traversable as T
import Text.ParserCombinators.ReadPrec (ReadPrec)
import qualified Text.Read.Lex as L
#if MIN_VERSION_base(4,7,0)
import GHC.Read (expectP)
#else
import GHC.Read (lexP)
import Text.Read (pfail)
import Text.Read.Lex (Lexeme)
#endif
#if MIN_VERSION_ghc_prim(0,3,1)
import GHC.Prim (Int#, tagToEnum#)
#endif
#if defined(MIN_VERSION_ghc_boot_th)
import GHC.Lexeme (startsConSym, startsVarSym)
#else
import Data.Char (isSymbol, ord)
#endif
import Language.Haskell.TH.Datatype as Datatype
import Language.Haskell.TH.Datatype.TyVarBndr
import Language.Haskell.TH.Lib
import Language.Haskell.TH.Ppr (pprint)
import Language.Haskell.TH.Syntax
import Data.Functor ()
import Data.Functor.Classes ()
import Data.Foldable ()
import Data.Traversable ()
#ifndef CURRENT_PACKAGE_KEY
import Data.Version (showVersion)
import Paths_deriving_compat (version)
#endif
applySubstitutionKind :: Map Name Kind -> Type -> Type
#if MIN_VERSION_template_haskell(2,8,0)
applySubstitutionKind :: Map Name Type -> Type -> Type
applySubstitutionKind = forall a. TypeSubstitution a => Map Name Type -> a -> a
applySubstitution
#else
applySubstitutionKind _ t = t
#endif
substNameWithKind :: Name -> Kind -> Type -> Type
substNameWithKind :: Name -> Type -> Type -> Type
substNameWithKind Name
n Type
k = Map Name Type -> Type -> Type
applySubstitutionKind (forall k a. k -> a -> Map k a
Map.singleton Name
n Type
k)
substNamesWithKindStar :: [Name] -> Type -> Type
substNamesWithKindStar :: [Name] -> Type -> Type
substNamesWithKindStar [Name]
ns Type
t = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr' (forall a b c. (a -> b -> c) -> b -> a -> c
flip Name -> Type -> Type -> Type
substNameWithKind Type
starK) Type
t [Name]
ns
data a `Via` b
infix 0 `Via`
fmapConst :: f b -> (a -> b) -> f a -> f b
fmapConst :: forall (f :: * -> *) b a. f b -> (a -> b) -> f a -> f b
fmapConst f b
x a -> b
_ f a
_ = f b
x
{-# INLINE fmapConst #-}
replaceConst :: f a -> a -> f b -> f a
replaceConst :: forall (f :: * -> *) a b. f a -> a -> f b -> f a
replaceConst f a
x a
_ f b
_ = f a
x
{-# INLINE replaceConst #-}
foldrConst :: b -> (a -> b -> b) -> b -> t a -> b
foldrConst :: forall b a (t :: * -> *). b -> (a -> b -> b) -> b -> t a -> b
foldrConst b
x a -> b -> b
_ b
_ t a
_ = b
x
{-# INLINE foldrConst #-}
foldMapConst :: m -> (a -> m) -> t a -> m
foldMapConst :: forall m a (t :: * -> *). m -> (a -> m) -> t a -> m
foldMapConst m
x a -> m
_ t a
_ = m
x
{-# INLINE foldMapConst #-}
nullConst :: Bool -> t a -> Bool
nullConst :: forall (t :: * -> *) a. Bool -> t a -> Bool
nullConst Bool
x t a
_ = Bool
x
{-# INLINE nullConst #-}
traverseConst :: f (t b) -> (a -> f b) -> t a -> f (t b)
traverseConst :: forall (f :: * -> *) (t :: * -> *) b a.
f (t b) -> (a -> f b) -> t a -> f (t b)
traverseConst f (t b)
x a -> f b
_ t a
_ = f (t b)
x
{-# INLINE traverseConst #-}
eqConst :: Bool
-> a -> a -> Bool
eqConst :: forall a. Bool -> a -> a -> Bool
eqConst Bool
x a
_ a
_ = Bool
x
{-# INLINE eqConst #-}
eq1Const :: Bool
-> f a -> f a-> Bool
eq1Const :: forall (f :: * -> *) a. Bool -> f a -> f a -> Bool
eq1Const Bool
x f a
_ f a
_ = Bool
x
{-# INLINE eq1Const #-}
liftEqConst :: Bool
-> (a -> b -> Bool) -> f a -> f b -> Bool
liftEqConst :: forall a b (f :: * -> *).
Bool -> (a -> b -> Bool) -> f a -> f b -> Bool
liftEqConst Bool
x a -> b -> Bool
_ f a
_ f b
_ = Bool
x
{-# INLINE liftEqConst #-}
liftEq2Const :: Bool
-> (a -> b -> Bool) -> (c -> d -> Bool)
-> f a c -> f b d -> Bool
liftEq2Const :: forall a b c d (f :: * -> * -> *).
Bool
-> (a -> b -> Bool) -> (c -> d -> Bool) -> f a c -> f b d -> Bool
liftEq2Const Bool
x a -> b -> Bool
_ c -> d -> Bool
_ f a c
_ f b d
_ = Bool
x
{-# INLINE liftEq2Const #-}
compareConst :: Ordering -> a -> a -> Ordering
compareConst :: forall a. Ordering -> a -> a -> Ordering
compareConst Ordering
x a
_ a
_ = Ordering
x
{-# INLINE compareConst #-}
ltConst :: Bool -> a -> a -> Bool
ltConst :: forall a. Bool -> a -> a -> Bool
ltConst Bool
x a
_ a
_ = Bool
x
{-# INLINE ltConst #-}
compare1Const :: Ordering -> f a -> f a -> Ordering
compare1Const :: forall (f :: * -> *) a. Ordering -> f a -> f a -> Ordering
compare1Const Ordering
x f a
_ f a
_ = Ordering
x
{-# INLINE compare1Const #-}
liftCompareConst :: Ordering
-> (a -> b -> Ordering) -> f a -> f b -> Ordering
liftCompareConst :: forall a b (f :: * -> *).
Ordering -> (a -> b -> Ordering) -> f a -> f b -> Ordering
liftCompareConst Ordering
x a -> b -> Ordering
_ f a
_ f b
_ = Ordering
x
{-# INLINE liftCompareConst #-}
liftCompare2Const :: Ordering
-> (a -> b -> Ordering) -> (c -> d -> Ordering)
-> f a c -> f b d -> Ordering
liftCompare2Const :: forall a b c d (f :: * -> * -> *).
Ordering
-> (a -> b -> Ordering)
-> (c -> d -> Ordering)
-> f a c
-> f b d
-> Ordering
liftCompare2Const Ordering
x a -> b -> Ordering
_ c -> d -> Ordering
_ f a c
_ f b d
_ = Ordering
x
{-# INLINE liftCompare2Const #-}
readsPrecConst :: ReadS a -> Int -> ReadS a
readsPrecConst :: forall a. ReadS a -> Int -> ReadS a
readsPrecConst ReadS a
x Int
_ = ReadS a
x
{-# INLINE readsPrecConst #-}
readPrecConst :: ReadPrec a -> ReadPrec a
readPrecConst :: forall a. ReadPrec a -> ReadPrec a
readPrecConst ReadPrec a
x = ReadPrec a
x
{-# INLINE readPrecConst #-}
readsPrec1Const :: ReadS (f a) -> Int -> ReadS (f a)
readsPrec1Const :: forall (f :: * -> *) a. ReadS (f a) -> Int -> ReadS (f a)
readsPrec1Const ReadS (f a)
x Int
_ = ReadS (f a)
x
{-# INLINE readsPrec1Const #-}
liftReadsPrecConst :: ReadS (f a)
-> (Int -> ReadS a) -> ReadS [a]
-> Int -> ReadS (f a)
liftReadsPrecConst :: forall (f :: * -> *) a.
ReadS (f a) -> (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (f a)
liftReadsPrecConst ReadS (f a)
x Int -> ReadS a
_ ReadS [a]
_ Int
_ = ReadS (f a)
x
{-# INLINE liftReadsPrecConst #-}
liftReadPrecConst :: ReadPrec (f a)
-> ReadPrec a -> ReadPrec [a]
-> ReadPrec (f a)
liftReadPrecConst :: forall (f :: * -> *) a.
ReadPrec (f a) -> ReadPrec a -> ReadPrec [a] -> ReadPrec (f a)
liftReadPrecConst ReadPrec (f a)
x ReadPrec a
_ ReadPrec [a]
_ = ReadPrec (f a)
x
{-# INLINE liftReadPrecConst #-}
liftReadsPrec2Const :: ReadS (f a b)
-> (Int -> ReadS a) -> ReadS [a]
-> (Int -> ReadS b) -> ReadS [b]
-> Int -> ReadS (f a b)
liftReadsPrec2Const :: forall (f :: * -> * -> *) a b.
ReadS (f a b)
-> (Int -> ReadS a)
-> ReadS [a]
-> (Int -> ReadS b)
-> ReadS [b]
-> Int
-> ReadS (f a b)
liftReadsPrec2Const ReadS (f a b)
x Int -> ReadS a
_ ReadS [a]
_ Int -> ReadS b
_ ReadS [b]
_ Int
_ = ReadS (f a b)
x
{-# INLINE liftReadsPrec2Const #-}
liftReadPrec2Const :: ReadPrec (f a b)
-> ReadPrec a -> ReadPrec [a]
-> ReadPrec b -> ReadPrec [b]
-> ReadPrec (f a b)
liftReadPrec2Const :: forall (f :: * -> * -> *) a b.
ReadPrec (f a b)
-> ReadPrec a
-> ReadPrec [a]
-> ReadPrec b
-> ReadPrec [b]
-> ReadPrec (f a b)
liftReadPrec2Const ReadPrec (f a b)
x ReadPrec a
_ ReadPrec [a]
_ ReadPrec b
_ ReadPrec [b]
_ = ReadPrec (f a b)
x
{-# INLINE liftReadPrec2Const #-}
showsPrecConst :: ShowS
-> Int -> a -> ShowS
showsPrecConst :: forall a. ShowS -> Int -> a -> ShowS
showsPrecConst ShowS
x Int
_ a
_ = ShowS
x
{-# INLINE showsPrecConst #-}
showsPrec1Const :: ShowS
-> Int -> f a -> ShowS
showsPrec1Const :: forall (f :: * -> *) a. ShowS -> Int -> f a -> ShowS
showsPrec1Const ShowS
x Int
_ f a
_ = ShowS
x
{-# INLINE showsPrec1Const #-}
liftShowsPrecConst :: ShowS
-> (Int -> a -> ShowS) -> ([a] -> ShowS)
-> Int -> f a -> ShowS
liftShowsPrecConst :: forall a (f :: * -> *).
ShowS
-> (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> f a -> ShowS
liftShowsPrecConst ShowS
x Int -> a -> ShowS
_ [a] -> ShowS
_ Int
_ f a
_ = ShowS
x
{-# INLINE liftShowsPrecConst #-}
liftShowsPrec2Const :: ShowS
-> (Int -> a -> ShowS) -> ([a] -> ShowS)
-> (Int -> b -> ShowS) -> ([b] -> ShowS)
-> Int -> f a b -> ShowS
liftShowsPrec2Const :: forall a b (f :: * -> * -> *).
ShowS
-> (Int -> a -> ShowS)
-> ([a] -> ShowS)
-> (Int -> b -> ShowS)
-> ([b] -> ShowS)
-> Int
-> f a b
-> ShowS
liftShowsPrec2Const ShowS
x Int -> a -> ShowS
_ [a] -> ShowS
_ Int -> b -> ShowS
_ [b] -> ShowS
_ Int
_ f a b
_ = ShowS
x
{-# INLINE liftShowsPrec2Const #-}
data StarKindStatus = NotKindStar
| KindStar
| IsKindVar Name
deriving StarKindStatus -> StarKindStatus -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StarKindStatus -> StarKindStatus -> Bool
$c/= :: StarKindStatus -> StarKindStatus -> Bool
== :: StarKindStatus -> StarKindStatus -> Bool
$c== :: StarKindStatus -> StarKindStatus -> Bool
Eq
canRealizeKindStar :: Type -> StarKindStatus
canRealizeKindStar :: Type -> StarKindStatus
canRealizeKindStar Type
t
| Type -> Bool
hasKindStar Type
t = StarKindStatus
KindStar
| Bool
otherwise = case Type
t of
#if MIN_VERSION_template_haskell(2,8,0)
SigT Type
_ (VarT Name
k) -> Name -> StarKindStatus
IsKindVar Name
k
#endif
Type
_ -> StarKindStatus
NotKindStar
starKindStatusToName :: StarKindStatus -> Maybe Name
starKindStatusToName :: StarKindStatus -> Maybe Name
starKindStatusToName (IsKindVar Name
n) = forall a. a -> Maybe a
Just Name
n
starKindStatusToName StarKindStatus
_ = forall a. Maybe a
Nothing
catKindVarNames :: [StarKindStatus] -> [Name]
catKindVarNames :: [StarKindStatus] -> [Name]
catKindVarNames = forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe StarKindStatus -> Maybe Name
starKindStatusToName
class ClassRep a where
arity :: a -> Int
allowExQuant :: a -> Bool
fullClassName :: a -> Name
classConstraint :: a -> Int -> Maybe Name
buildTypeInstance :: ClassRep a
=> a
-> Name
-> Cxt
-> [Type]
-> DatatypeVariant
-> Q (Cxt, Type)
buildTypeInstance :: forall a.
ClassRep a =>
a
-> Name -> [Type] -> [Type] -> DatatypeVariant -> Q ([Type], Type)
buildTypeInstance a
cRep Name
tyConName [Type]
dataCxt [Type]
varTysOrig DatatypeVariant
variant = do
[Type]
varTysExp <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Type -> Q Type
resolveTypeSynonyms [Type]
varTysOrig
let remainingLength :: Int
remainingLength :: Int
remainingLength = forall (t :: * -> *) a. Foldable t => t a -> Int
length [Type]
varTysOrig forall a. Num a => a -> a -> a
- forall a. ClassRep a => a -> Int
arity a
cRep
droppedTysExp :: [Type]
droppedTysExp :: [Type]
droppedTysExp = forall a. Int -> [a] -> [a]
drop Int
remainingLength [Type]
varTysExp
droppedStarKindStati :: [StarKindStatus]
droppedStarKindStati :: [StarKindStatus]
droppedStarKindStati = forall a b. (a -> b) -> [a] -> [b]
map Type -> StarKindStatus
canRealizeKindStar [Type]
droppedTysExp
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
remainingLength forall a. Ord a => a -> a -> Bool
< Int
0 Bool -> Bool -> Bool
|| forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (forall a. Eq a => a -> a -> Bool
== StarKindStatus
NotKindStar) [StarKindStatus]
droppedStarKindStati) forall a b. (a -> b) -> a -> b
$
forall a b. ClassRep a => a -> Name -> Q b
derivingKindError a
cRep Name
tyConName
let droppedKindVarNames :: [Name]
droppedKindVarNames :: [Name]
droppedKindVarNames = [StarKindStatus] -> [Name]
catKindVarNames [StarKindStatus]
droppedStarKindStati
varTysExpSubst :: [Type]
varTysExpSubst :: [Type]
varTysExpSubst = forall a b. (a -> b) -> [a] -> [b]
map ([Name] -> Type -> Type
substNamesWithKindStar [Name]
droppedKindVarNames) [Type]
varTysExp
remainingTysExpSubst, droppedTysExpSubst :: [Type]
([Type]
remainingTysExpSubst, [Type]
droppedTysExpSubst) =
forall a. Int -> [a] -> ([a], [a])
splitAt Int
remainingLength [Type]
varTysExpSubst
droppedTyVarNames :: [Name]
droppedTyVarNames :: [Name]
droppedTyVarNames = forall a. TypeSubstitution a => a -> [Name]
freeVariables [Type]
droppedTysExpSubst
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Type -> Bool
hasKindStar [Type]
droppedTysExpSubst) forall a b. (a -> b) -> a -> b
$
forall a b. ClassRep a => a -> Name -> Q b
derivingKindError a
cRep Name
tyConName
let preds :: [Maybe Pred]
kvNames :: [[Name]]
kvNames' :: [Name]
([Maybe Type]
preds, [[Name]]
kvNames) = forall a b. [(a, b)] -> ([a], [b])
unzip forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map (forall a. ClassRep a => a -> Type -> (Maybe Type, [Name])
deriveConstraint a
cRep) [Type]
remainingTysExpSubst
kvNames' :: [Name]
kvNames' = forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [[Name]]
kvNames
remainingTysExpSubst' :: [Type]
remainingTysExpSubst' :: [Type]
remainingTysExpSubst' =
forall a b. (a -> b) -> [a] -> [b]
map ([Name] -> Type -> Type
substNamesWithKindStar [Name]
kvNames') [Type]
remainingTysExpSubst
remainingTysOrigSubst :: [Type]
remainingTysOrigSubst :: [Type]
remainingTysOrigSubst =
forall a b. (a -> b) -> [a] -> [b]
map ([Name] -> Type -> Type
substNamesWithKindStar (forall a. Eq a => [a] -> [a] -> [a]
List.union [Name]
droppedKindVarNames [Name]
kvNames'))
forall a b. (a -> b) -> a -> b
$ forall a. Int -> [a] -> [a]
take Int
remainingLength [Type]
varTysOrig
Bool
isDataFamily <-
case DatatypeVariant
variant of
DatatypeVariant
Datatype -> forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
DatatypeVariant
Newtype -> forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
DatatypeVariant
DataInstance -> forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
DatatypeVariant
NewtypeInstance -> forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
#if MIN_VERSION_th_abstraction(0,5,0)
DatatypeVariant
Datatype.TypeData -> forall a. Name -> Q a
typeDataError Name
tyConName
#endif
let remainingTysOrigSubst' :: [Type]
remainingTysOrigSubst' :: [Type]
remainingTysOrigSubst' =
if Bool
isDataFamily
then [Type]
remainingTysOrigSubst
else forall a b. (a -> b) -> [a] -> [b]
map Type -> Type
unSigT [Type]
remainingTysOrigSubst
instanceCxt :: Cxt
instanceCxt :: [Type]
instanceCxt = forall a. [Maybe a] -> [a]
catMaybes [Maybe Type]
preds
instanceType :: Type
instanceType :: Type
instanceType = Type -> Type -> Type
AppT (Name -> Type
ConT (forall a. ClassRep a => a -> Name
fullClassName a
cRep))
forall a b. (a -> b) -> a -> b
$ Name -> [Type] -> Type
applyTyCon Name
tyConName [Type]
remainingTysOrigSubst'
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (Type -> [Name] -> Bool
`predMentionsName` [Name]
droppedTyVarNames) [Type]
dataCxt) forall a b. (a -> b) -> a -> b
$
forall a. Name -> Type -> Q a
datatypeContextError Name
tyConName Type
instanceType
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless ([Type] -> [Type] -> Bool
canEtaReduce [Type]
remainingTysExpSubst' [Type]
droppedTysExpSubst) forall a b. (a -> b) -> a -> b
$
forall a. Type -> Q a
etaReductionError Type
instanceType
forall (m :: * -> *) a. Monad m => a -> m a
return ([Type]
instanceCxt, Type
instanceType)
deriveConstraint :: ClassRep a => a -> Type -> (Maybe Pred, [Name])
deriveConstraint :: forall a. ClassRep a => a -> Type -> (Maybe Type, [Name])
deriveConstraint a
cRep Type
t
| Bool -> Bool
not (Type -> Bool
isTyVar Type
t) = (forall a. Maybe a
Nothing, [])
| Type -> Bool
hasKindStar Type
t = ((Name -> Name -> Type
`applyClass` Name
tName) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` forall a. ClassRep a => a -> Int -> Maybe Name
classConstraint a
cRep Int
0, [])
| Bool
otherwise = case Int -> Type -> Maybe [Name]
hasKindVarChain Int
1 Type
t of
Just [Name]
ns | Int
cRepArity forall a. Ord a => a -> a -> Bool
>= Int
1
-> ((Name -> Name -> Type
`applyClass` Name
tName) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` forall a. ClassRep a => a -> Int -> Maybe Name
classConstraint a
cRep Int
1, [Name]
ns)
Maybe [Name]
_ -> case Int -> Type -> Maybe [Name]
hasKindVarChain Int
2 Type
t of
Just [Name]
ns | Int
cRepArity forall a. Eq a => a -> a -> Bool
== Int
2
-> ((Name -> Name -> Type
`applyClass` Name
tName) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` forall a. ClassRep a => a -> Int -> Maybe Name
classConstraint a
cRep Int
2, [Name]
ns)
Maybe [Name]
_ -> (forall a. Maybe a
Nothing, [])
where
tName :: Name
tName :: Name
tName = Type -> Name
varTToName Type
t
cRepArity :: Int
cRepArity :: Int
cRepArity = forall a. ClassRep a => a -> Int
arity a
cRep
checkExistentialContext :: ClassRep a => a -> TyVarMap b -> Cxt -> Name
-> Q c -> Q c
checkExistentialContext :: forall a b c.
ClassRep a =>
a -> TyVarMap b -> [Type] -> Name -> Q c -> Q c
checkExistentialContext a
cRep TyVarMap b
tvMap [Type]
ctxt Name
conName Q c
q =
if (forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (Type -> [Name] -> Bool
`predMentionsName` forall k a. Map k a -> [k]
Map.keys TyVarMap b
tvMap) [Type]
ctxt
Bool -> Bool -> Bool
|| forall k a. Map k a -> Int
Map.size TyVarMap b
tvMap forall a. Ord a => a -> a -> Bool
< forall a. ClassRep a => a -> Int
arity a
cRep)
Bool -> Bool -> Bool
&& Bool -> Bool
not (forall a. ClassRep a => a -> Bool
allowExQuant a
cRep)
then forall a. Name -> Q a
existentialContextError Name
conName
else Q c
q
noConstructorsError :: Q a
noConstructorsError :: forall a. Q a
noConstructorsError = forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Must have at least one data constructor"
derivingKindError :: ClassRep a => a -> Name -> Q b
derivingKindError :: forall a b. ClassRep a => a -> Name -> Q b
derivingKindError a
cRep Name
tyConName = forall (m :: * -> *) a. MonadFail m => String -> m a
fail
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
"Cannot derive well-kinded instance of form ‘"
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
className
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> ShowS -> ShowS
showParen Bool
True
( String -> ShowS
showString (Name -> String
nameBase Name
tyConName)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
" ..."
)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
"‘\n\tClass "
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
className
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
" expects an argument of kind "
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString (forall a. Ppr a => a -> String
pprint forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Type
createKindChain forall a b. (a -> b) -> a -> b
$ forall a. ClassRep a => a -> Int
arity a
cRep)
forall a b. (a -> b) -> a -> b
$ String
""
where
className :: String
className :: String
className = Name -> String
nameBase forall a b. (a -> b) -> a -> b
$ forall a. ClassRep a => a -> Name
fullClassName a
cRep
contravarianceError :: Name -> Q a
contravarianceError :: forall a. Name -> Q a
contravarianceError Name
conName = forall (m :: * -> *) a. MonadFail m => String -> m a
fail
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
"Constructor ‘"
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString (Name -> String
nameBase Name
conName)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
"‘ must not use the last type variable in a function argument"
forall a b. (a -> b) -> a -> b
$ String
""
noFunctionsError :: Name -> Q a
noFunctionsError :: forall a. Name -> Q a
noFunctionsError Name
conName = forall (m :: * -> *) a. MonadFail m => String -> m a
fail
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
"Constructor ‘"
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString (Name -> String
nameBase Name
conName)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
"‘ must not contain function types"
forall a b. (a -> b) -> a -> b
$ String
""
etaReductionError :: Type -> Q a
etaReductionError :: forall a. Type -> Q a
etaReductionError Type
instanceType = forall (m :: * -> *) a. MonadFail m => String -> m a
fail forall a b. (a -> b) -> a -> b
$
String
"Cannot eta-reduce to an instance of form \n\tinstance (...) => "
forall a. [a] -> [a] -> [a]
++ forall a. Ppr a => a -> String
pprint Type
instanceType
datatypeContextError :: Name -> Type -> Q a
datatypeContextError :: forall a. Name -> Type -> Q a
datatypeContextError Name
dataName Type
instanceType = forall (m :: * -> *) a. MonadFail m => String -> m a
fail
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
"Can't make a derived instance of ‘"
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString (forall a. Ppr a => a -> String
pprint Type
instanceType)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
"‘:\n\tData type ‘"
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString (Name -> String
nameBase Name
dataName)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
"‘ must not have a class context involving the last type argument(s)"
forall a b. (a -> b) -> a -> b
$ String
""
existentialContextError :: Name -> Q a
existentialContextError :: forall a. Name -> Q a
existentialContextError Name
conName = forall (m :: * -> *) a. MonadFail m => String -> m a
fail
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
"Constructor ‘"
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString (Name -> String
nameBase Name
conName)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
"‘ must be truly polymorphic in the last argument(s) of the data type"
forall a b. (a -> b) -> a -> b
$ String
""
outOfPlaceTyVarError :: ClassRep a => a -> Name -> Q b
outOfPlaceTyVarError :: forall a b. ClassRep a => a -> Name -> Q b
outOfPlaceTyVarError a
cRep Name
conName = forall (m :: * -> *) a. MonadFail m => String -> m a
fail
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
"Constructor ‘"
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString (Name -> String
nameBase Name
conName)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
"‘ must only use its last "
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> ShowS
shows Int
n
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
" type variable(s) within the last "
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> ShowS
shows Int
n
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
" argument(s) of a data type"
forall a b. (a -> b) -> a -> b
$ String
""
where
n :: Int
n :: Int
n = forall a. ClassRep a => a -> Int
arity a
cRep
enumerationError :: String -> Q a
enumerationError :: forall a. String -> Q a
enumerationError = forall (m :: * -> *) a. MonadFail m => String -> m a
fail forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS
enumerationErrorStr
enumerationOrProductError :: String -> Q a
enumerationOrProductError :: forall a. String -> Q a
enumerationOrProductError String
nb = forall (m :: * -> *) a. MonadFail m => String -> m a
fail forall a b. (a -> b) -> a -> b
$ [String] -> String
unlines
[ ShowS
enumerationErrorStr String
nb
, String
"\tor a product type (precisely one constructor)"
]
enumerationErrorStr :: String -> String
enumerationErrorStr :: ShowS
enumerationErrorStr String
nb =
Char
'\''forall a. a -> [a] -> [a]
:String
nb forall a. [a] -> [a] -> [a]
++ String
"’ must be an enumeration type"
forall a. [a] -> [a] -> [a]
++ String
" (one or more nullary, non-GADT constructors)"
typeDataError :: Name -> Q a
typeDataError :: forall a. Name -> Q a
typeDataError Name
dataName = forall (m :: * -> *) a. MonadFail m => String -> m a
fail
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
"Cannot derive instance for ‘"
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString (Name -> String
nameBase Name
dataName)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
"‘, which is a ‘type data‘ declaration"
forall a b. (a -> b) -> a -> b
$ String
""
type TyVarMap a = Map Name (OneOrTwoNames a)
type TyVarMap1 = TyVarMap One
type TyVarMap2 = TyVarMap Two
data OneOrTwoNames a where
OneName :: Name -> OneOrTwoNames One
TwoNames :: Name -> Name -> OneOrTwoNames Two
data One
data Two
interleave :: [a] -> [a] -> [a]
interleave :: forall a. [a] -> [a] -> [a]
interleave (a
a1:[a]
a1s) (a
a2:[a]
a2s) = a
a1forall a. a -> [a] -> [a]
:a
a2forall a. a -> [a] -> [a]
:forall a. [a] -> [a] -> [a]
interleave [a]
a1s [a]
a2s
interleave [a]
_ [a]
_ = []
#if MIN_VERSION_ghc_prim(0,3,1)
isTrue# :: Int# -> Bool
isTrue# :: Int# -> Bool
isTrue# Int#
x = forall a. Int# -> a
tagToEnum# Int#
x
#else
isTrue# :: Bool -> Bool
isTrue# x = x
#endif
{-# INLINE isTrue# #-}
filterByList :: [Bool] -> [a] -> [a]
filterByList :: forall a. [Bool] -> [a] -> [a]
filterByList (Bool
True:[Bool]
bs) (a
x:[a]
xs) = a
x forall a. a -> [a] -> [a]
: forall a. [Bool] -> [a] -> [a]
filterByList [Bool]
bs [a]
xs
filterByList (Bool
False:[Bool]
bs) (a
_:[a]
xs) = forall a. [Bool] -> [a] -> [a]
filterByList [Bool]
bs [a]
xs
filterByList [Bool]
_ [a]
_ = []
filterByLists :: [Bool] -> [a] -> [a] -> [a]
filterByLists :: forall a. [Bool] -> [a] -> [a] -> [a]
filterByLists (Bool
True:[Bool]
bs) (a
x:[a]
xs) (a
_:[a]
ys) = a
x forall a. a -> [a] -> [a]
: forall a. [Bool] -> [a] -> [a] -> [a]
filterByLists [Bool]
bs [a]
xs [a]
ys
filterByLists (Bool
False:[Bool]
bs) (a
_:[a]
xs) (a
y:[a]
ys) = a
y forall a. a -> [a] -> [a]
: forall a. [Bool] -> [a] -> [a] -> [a]
filterByLists [Bool]
bs [a]
xs [a]
ys
filterByLists [Bool]
_ [a]
_ [a]
_ = []
partitionByList :: [Bool] -> [a] -> ([a], [a])
partitionByList :: forall a. [Bool] -> [a] -> ([a], [a])
partitionByList = forall {a}. [a] -> [a] -> [Bool] -> [a] -> ([a], [a])
go [] []
where
go :: [a] -> [a] -> [Bool] -> [a] -> ([a], [a])
go [a]
trues [a]
falses (Bool
True : [Bool]
bs) (a
x : [a]
xs) = [a] -> [a] -> [Bool] -> [a] -> ([a], [a])
go (a
xforall a. a -> [a] -> [a]
:[a]
trues) [a]
falses [Bool]
bs [a]
xs
go [a]
trues [a]
falses (Bool
False : [Bool]
bs) (a
x : [a]
xs) = [a] -> [a] -> [Bool] -> [a] -> ([a], [a])
go [a]
trues (a
xforall a. a -> [a] -> [a]
:[a]
falses) [Bool]
bs [a]
xs
go [a]
trues [a]
falses [Bool]
_ [a]
_ = (forall a. [a] -> [a]
reverse [a]
trues, forall a. [a] -> [a]
reverse [a]
falses)
integerE :: Int -> Q Exp
integerE :: Int -> Q Exp
integerE = forall (m :: * -> *). Quote m => Lit -> m Exp
litE forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Lit
integerL forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral
hasKindStar :: Type -> Bool
hasKindStar :: Type -> Bool
hasKindStar VarT{} = Bool
True
#if MIN_VERSION_template_haskell(2,8,0)
hasKindStar (SigT Type
_ Type
StarT) = Bool
True
#else
hasKindStar (SigT _ StarK) = True
#endif
hasKindStar Type
_ = Bool
False
isStarOrVar :: Kind -> Bool
#if MIN_VERSION_template_haskell(2,8,0)
isStarOrVar :: Type -> Bool
isStarOrVar Type
StarT = Bool
True
isStarOrVar VarT{} = Bool
True
#else
isStarOrVar StarK = True
#endif
isStarOrVar Type
_ = Bool
False
hasKindVarChain :: Int -> Type -> Maybe [Name]
hasKindVarChain :: Int -> Type -> Maybe [Name]
hasKindVarChain Int
kindArrows Type
t =
let uk :: [Type]
uk = Type -> [Type]
uncurryKind (Type -> Type
tyKind Type
t)
in if (forall (t :: * -> *) a. Foldable t => t a -> Int
length [Type]
uk forall a. Num a => a -> a -> a
- Int
1 forall a. Eq a => a -> a -> Bool
== Int
kindArrows) Bool -> Bool -> Bool
&& forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Type -> Bool
isStarOrVar [Type]
uk
then forall a. a -> Maybe a
Just (forall a. TypeSubstitution a => a -> [Name]
freeVariables [Type]
uk)
else forall a. Maybe a
Nothing
tyKind :: Type -> Kind
tyKind :: Type -> Type
tyKind (SigT Type
_ Type
k) = Type
k
tyKind Type
_ = Type
starK
zipWithAndUnzipM :: Monad m
=> (a -> b -> m (c, d)) -> [a] -> [b] -> m ([c], [d])
zipWithAndUnzipM :: forall (m :: * -> *) a b c d.
Monad m =>
(a -> b -> m (c, d)) -> [a] -> [b] -> m ([c], [d])
zipWithAndUnzipM a -> b -> m (c, d)
f (a
x:[a]
xs) (b
y:[b]
ys) = do
(c
c, d
d) <- a -> b -> m (c, d)
f a
x b
y
([c]
cs, [d]
ds) <- forall (m :: * -> *) a b c d.
Monad m =>
(a -> b -> m (c, d)) -> [a] -> [b] -> m ([c], [d])
zipWithAndUnzipM a -> b -> m (c, d)
f [a]
xs [b]
ys
forall (m :: * -> *) a. Monad m => a -> m a
return (c
cforall a. a -> [a] -> [a]
:[c]
cs, d
dforall a. a -> [a] -> [a]
:[d]
ds)
zipWithAndUnzipM a -> b -> m (c, d)
_ [a]
_ [b]
_ = forall (m :: * -> *) a. Monad m => a -> m a
return ([], [])
{-# INLINE zipWithAndUnzipM #-}
zipWith3AndUnzipM :: Monad m
=> (a -> b -> c -> m (d, e)) -> [a] -> [b] -> [c]
-> m ([d], [e])
zipWith3AndUnzipM :: forall (m :: * -> *) a b c d e.
Monad m =>
(a -> b -> c -> m (d, e)) -> [a] -> [b] -> [c] -> m ([d], [e])
zipWith3AndUnzipM a -> b -> c -> m (d, e)
f (a
x:[a]
xs) (b
y:[b]
ys) (c
z:[c]
zs) = do
(d
d, e
e) <- a -> b -> c -> m (d, e)
f a
x b
y c
z
([d]
ds, [e]
es) <- forall (m :: * -> *) a b c d e.
Monad m =>
(a -> b -> c -> m (d, e)) -> [a] -> [b] -> [c] -> m ([d], [e])
zipWith3AndUnzipM a -> b -> c -> m (d, e)
f [a]
xs [b]
ys [c]
zs
forall (m :: * -> *) a. Monad m => a -> m a
return (d
dforall a. a -> [a] -> [a]
:[d]
ds, e
eforall a. a -> [a] -> [a]
:[e]
es)
zipWith3AndUnzipM a -> b -> c -> m (d, e)
_ [a]
_ [b]
_ [c]
_ = forall (m :: * -> *) a. Monad m => a -> m a
return ([], [])
{-# INLINE zipWith3AndUnzipM #-}
thd3 :: (a, b, c) -> c
thd3 :: forall a b c. (a, b, c) -> c
thd3 (a
_, b
_, c
c) = c
c
unsnoc :: [a] -> Maybe ([a], a)
unsnoc :: forall a. [a] -> Maybe ([a], a)
unsnoc [] = forall a. Maybe a
Nothing
unsnoc (a
x:[a]
xs) = case forall a. [a] -> Maybe ([a], a)
unsnoc [a]
xs of
Maybe ([a], a)
Nothing -> forall a. a -> Maybe a
Just ([], a
x)
Just ([a]
a,a
b) -> forall a. a -> Maybe a
Just (a
xforall a. a -> [a] -> [a]
:[a]
a, a
b)
isNullaryCon :: ConstructorInfo -> Bool
isNullaryCon :: ConstructorInfo -> Bool
isNullaryCon (ConstructorInfo { constructorFields :: ConstructorInfo -> [Type]
constructorFields = [Type]
tys }) = forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Type]
tys
conArity :: ConstructorInfo -> Int
conArity :: ConstructorInfo -> Int
conArity (ConstructorInfo { constructorFields :: ConstructorInfo -> [Type]
constructorFields = [Type]
tys }) = forall (t :: * -> *) a. Foldable t => t a -> Int
length [Type]
tys
isProductType :: [ConstructorInfo] -> Bool
isProductType :: [ConstructorInfo] -> Bool
isProductType [ConstructorInfo
con] = forall (t :: * -> *) a. Foldable t => t a -> Bool
null (ConstructorInfo -> [TyVarBndrUnit]
constructorVars ConstructorInfo
con)
isProductType [ConstructorInfo]
_ = Bool
False
isEnumerationType :: [ConstructorInfo] -> Bool
isEnumerationType :: [ConstructorInfo] -> Bool
isEnumerationType cons :: [ConstructorInfo]
cons@(ConstructorInfo
_:[ConstructorInfo]
_) = forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
App.liftA2 Bool -> Bool -> Bool
(&&) ConstructorInfo -> Bool
isNullaryCon ConstructorInfo -> Bool
isVanillaCon) [ConstructorInfo]
cons
isEnumerationType [ConstructorInfo]
_ = Bool
False
isVanillaCon :: ConstructorInfo -> Bool
isVanillaCon :: ConstructorInfo -> Bool
isVanillaCon (ConstructorInfo { constructorContext :: ConstructorInfo -> [Type]
constructorContext = [Type]
ctxt, constructorVars :: ConstructorInfo -> [TyVarBndrUnit]
constructorVars = [TyVarBndrUnit]
vars }) =
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Type]
ctxt Bool -> Bool -> Bool
&& forall (t :: * -> *) a. Foldable t => t a -> Bool
null [TyVarBndrUnit]
vars
newNameList :: String -> Int -> Q [Name]
newNameList :: String -> Int -> Q [Name]
newNameList String
prefix Int
n = forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (forall (m :: * -> *). Quote m => String -> m Name
newName forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String
prefix forall a. [a] -> [a] -> [a]
++) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> String
show) [Int
1..Int
n]
tvbKind :: TyVarBndr_ flag -> Kind
tvbKind :: forall flag. TyVarBndr_ flag -> Type
tvbKind = forall r flag.
(Name -> r) -> (Name -> Type -> r) -> TyVarBndr_ flag -> r
elimTV (\Name
_ -> Type
starK) (\Name
_ Type
k -> Type
k)
tvbToType :: TyVarBndr_ flag -> Type
tvbToType :: forall flag. TyVarBndr_ flag -> Type
tvbToType = forall r flag.
(Name -> r) -> (Name -> Type -> r) -> TyVarBndr_ flag -> r
elimTV Name -> Type
VarT (\Name
n Type
k -> Type -> Type -> Type
SigT (Name -> Type
VarT Name
n) Type
k)
applyClass :: Name -> Name -> Pred
#if MIN_VERSION_template_haskell(2,10,0)
applyClass :: Name -> Name -> Type
applyClass Name
con Name
t = Type -> Type -> Type
AppT (Name -> Type
ConT Name
con) (Name -> Type
VarT Name
t)
#else
applyClass con t = ClassP con [VarT t]
#endif
createKindChain :: Int -> Kind
createKindChain :: Int -> Type
createKindChain = Type -> Int -> Type
go Type
starK
where
go :: Kind -> Int -> Kind
go :: Type -> Int -> Type
go Type
k !Int
0 = Type
k
#if MIN_VERSION_template_haskell(2,8,0)
go Type
k !Int
n = Type -> Int -> Type
go (Type -> Type -> Type
AppT (Type -> Type -> Type
AppT Type
ArrowT Type
StarT) Type
k) (Int
n forall a. Num a => a -> a -> a
- Int
1)
#else
go k !n = go (ArrowK StarK k) (n - 1)
#endif
canEtaReduce :: [Type] -> [Type] -> Bool
canEtaReduce :: [Type] -> [Type] -> Bool
canEtaReduce [Type]
remaining [Type]
dropped =
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Type -> Bool
isTyVar [Type]
dropped
Bool -> Bool -> Bool
&& forall a. Ord a => [a] -> Bool
allDistinct [Name]
droppedNames
Bool -> Bool -> Bool
&& Bool -> Bool
not (forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (Type -> [Name] -> Bool
`mentionsName` [Name]
droppedNames) [Type]
remaining)
where
droppedNames :: [Name]
droppedNames :: [Name]
droppedNames = forall a b. (a -> b) -> [a] -> [b]
map Type -> Name
varTToName [Type]
dropped
conTToName :: Type -> Name
conTToName :: Type -> Name
conTToName (ConT Name
n) = Name
n
conTToName (SigT Type
t Type
_) = Type -> Name
conTToName Type
t
conTToName Type
_ = forall a. HasCallStack => String -> a
error String
"Not a type constructor!"
varTToName_maybe :: Type -> Maybe Name
varTToName_maybe :: Type -> Maybe Name
varTToName_maybe (VarT Name
n) = forall a. a -> Maybe a
Just Name
n
varTToName_maybe (SigT Type
t Type
_) = Type -> Maybe Name
varTToName_maybe Type
t
varTToName_maybe Type
_ = forall a. Maybe a
Nothing
varTToName :: Type -> Name
varTToName :: Type -> Name
varTToName = forall a. a -> Maybe a -> a
fromMaybe (forall a. HasCallStack => String -> a
error String
"Not a type variable!") forall b c a. (b -> c) -> (a -> b) -> a -> c
. Type -> Maybe Name
varTToName_maybe
unSigT :: Type -> Type
unSigT :: Type -> Type
unSigT (SigT Type
t Type
_) = Type
t
unSigT Type
t = Type
t
isTyVar :: Type -> Bool
isTyVar :: Type -> Bool
isTyVar (VarT Name
_) = Bool
True
isTyVar (SigT Type
t Type
_) = Type -> Bool
isTyVar Type
t
isTyVar Type
_ = Bool
False
isInTypeFamilyApp :: [Name] -> Type -> [Type] -> Q Bool
isInTypeFamilyApp :: [Name] -> Type -> [Type] -> Q Bool
isInTypeFamilyApp [Name]
names Type
tyFun [Type]
tyArgs =
case Type
tyFun of
ConT Name
tcName -> Name -> Q Bool
go Name
tcName
Type
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
where
go :: Name -> Q Bool
go :: Name -> Q Bool
go Name
tcName = do
Info
info <- Name -> Q Info
reify Name
tcName
case Info
info of
#if MIN_VERSION_template_haskell(2,11,0)
FamilyI (OpenTypeFamilyD (TypeFamilyHead Name
_ [TyVarBndrUnit]
bndrs FamilyResultSig
_ Maybe InjectivityAnn
_)) [Dec]
_
-> forall a. [a] -> Q Bool
withinFirstArgs [TyVarBndrUnit]
bndrs
#elif MIN_VERSION_template_haskell(2,7,0)
FamilyI (FamilyD TypeFam _ bndrs _) _
-> withinFirstArgs bndrs
#else
TyConI (FamilyD TypeFam _ bndrs _)
-> withinFirstArgs bndrs
#endif
#if MIN_VERSION_template_haskell(2,11,0)
FamilyI (ClosedTypeFamilyD (TypeFamilyHead Name
_ [TyVarBndrUnit]
bndrs FamilyResultSig
_ Maybe InjectivityAnn
_) [TySynEqn]
_) [Dec]
_
-> forall a. [a] -> Q Bool
withinFirstArgs [TyVarBndrUnit]
bndrs
#elif MIN_VERSION_template_haskell(2,9,0)
FamilyI (ClosedTypeFamilyD _ bndrs _ _) _
-> withinFirstArgs bndrs
#endif
Info
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
where
withinFirstArgs :: [a] -> Q Bool
withinFirstArgs :: forall a. [a] -> Q Bool
withinFirstArgs [a]
bndrs =
let firstArgs :: [Type]
firstArgs = forall a. Int -> [a] -> [a]
take (forall (t :: * -> *) a. Foldable t => t a -> Int
length [a]
bndrs) [Type]
tyArgs
argFVs :: [Name]
argFVs = forall a. TypeSubstitution a => a -> [Name]
freeVariables [Type]
firstArgs
in forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Name]
argFVs) [Name]
names
allDistinct :: Ord a => [a] -> Bool
allDistinct :: forall a. Ord a => [a] -> Bool
allDistinct = forall a. Ord a => Set a -> [a] -> Bool
allDistinct' forall a. Set a
Set.empty
where
allDistinct' :: Ord a => Set a -> [a] -> Bool
allDistinct' :: forall a. Ord a => Set a -> [a] -> Bool
allDistinct' Set a
uniqs (a
x:[a]
xs)
| a
x forall a. Ord a => a -> Set a -> Bool
`Set.member` Set a
uniqs = Bool
False
| Bool
otherwise = forall a. Ord a => Set a -> [a] -> Bool
allDistinct' (forall a. Ord a => a -> Set a -> Set a
Set.insert a
x Set a
uniqs) [a]
xs
allDistinct' Set a
_ [a]
_ = Bool
True
mentionsName :: Type -> [Name] -> Bool
mentionsName :: Type -> [Name] -> Bool
mentionsName = Type -> [Name] -> Bool
go
where
go :: Type -> [Name] -> Bool
go :: Type -> [Name] -> Bool
go (AppT Type
t1 Type
t2) [Name]
names = Type -> [Name] -> Bool
go Type
t1 [Name]
names Bool -> Bool -> Bool
|| Type -> [Name] -> Bool
go Type
t2 [Name]
names
go (SigT Type
t Type
_k) [Name]
names = Type -> [Name] -> Bool
go Type
t [Name]
names
#if MIN_VERSION_template_haskell(2,8,0)
Bool -> Bool -> Bool
|| Type -> [Name] -> Bool
go Type
_k [Name]
names
#endif
go (VarT Name
n) [Name]
names = Name
n forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Name]
names
go Type
_ [Name]
_ = Bool
False
predMentionsName :: Pred -> [Name] -> Bool
#if MIN_VERSION_template_haskell(2,10,0)
predMentionsName :: Type -> [Name] -> Bool
predMentionsName = Type -> [Name] -> Bool
mentionsName
#else
predMentionsName (ClassP n tys) names = n `elem` names || any (`mentionsName` names) tys
predMentionsName (EqualP t1 t2) names = mentionsName t1 names || mentionsName t2 names
#endif
applyTy :: Type -> [Type] -> Type
applyTy :: Type -> [Type] -> Type
applyTy = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
List.foldl' Type -> Type -> Type
AppT
applyTyCon :: Name -> [Type] -> Type
applyTyCon :: Name -> [Type] -> Type
applyTyCon = Type -> [Type] -> Type
applyTy forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> Type
ConT
unapplyTy :: Type -> (Type, [Type])
unapplyTy :: Type -> (Type, [Type])
unapplyTy Type
ty = Type -> Type -> [Type] -> (Type, [Type])
go Type
ty Type
ty []
where
go :: Type -> Type -> [Type] -> (Type, [Type])
go :: Type -> Type -> [Type] -> (Type, [Type])
go Type
_ (AppT Type
ty1 Type
ty2) [Type]
args = Type -> Type -> [Type] -> (Type, [Type])
go Type
ty1 Type
ty1 (Type
ty2forall a. a -> [a] -> [a]
:[Type]
args)
go Type
origTy (SigT Type
ty' Type
_) [Type]
args = Type -> Type -> [Type] -> (Type, [Type])
go Type
origTy Type
ty' [Type]
args
#if MIN_VERSION_template_haskell(2,11,0)
go Type
origTy (InfixT Type
ty1 Name
n Type
ty2) [Type]
args = Type -> Type -> [Type] -> (Type, [Type])
go Type
origTy (Name -> Type
ConT Name
n Type -> Type -> Type
`AppT` Type
ty1 Type -> Type -> Type
`AppT` Type
ty2) [Type]
args
go Type
origTy (ParensT Type
ty') [Type]
args = Type -> Type -> [Type] -> (Type, [Type])
go Type
origTy Type
ty' [Type]
args
#endif
go Type
origTy Type
_ [Type]
args = (Type
origTy, [Type]
args)
uncurryTy :: Type -> (Cxt, [Type])
uncurryTy :: Type -> ([Type], [Type])
uncurryTy (AppT (AppT Type
ArrowT Type
t1) Type
t2) =
let ([Type]
ctxt, [Type]
tys) = Type -> ([Type], [Type])
uncurryTy Type
t2
in ([Type]
ctxt, Type
t1forall a. a -> [a] -> [a]
:[Type]
tys)
uncurryTy (SigT Type
t Type
_) = Type -> ([Type], [Type])
uncurryTy Type
t
uncurryTy (ForallT [TyVarBndr Specificity]
_ [Type]
ctxt Type
t) =
let ([Type]
ctxt', [Type]
tys) = Type -> ([Type], [Type])
uncurryTy Type
t
in ([Type]
ctxt forall a. [a] -> [a] -> [a]
++ [Type]
ctxt', [Type]
tys)
uncurryTy Type
t = ([], [Type
t])
uncurryKind :: Kind -> [Kind]
#if MIN_VERSION_template_haskell(2,8,0)
uncurryKind :: Type -> [Type]
uncurryKind = forall a b. (a, b) -> b
snd forall b c a. (b -> c) -> (a -> b) -> a -> c
. Type -> ([Type], [Type])
uncurryTy
#else
uncurryKind (ArrowK k1 k2) = k1:uncurryKind k2
uncurryKind k = [k]
#endif
untagExpr :: [(Name, Name)] -> Q Exp -> Q Exp
untagExpr :: [(Name, Name)] -> Q Exp -> Q Exp
untagExpr [] Q Exp
e = Q Exp
e
untagExpr ((Name
untagThis, Name
putTagHere) : [(Name, Name)]
more) Q Exp
e =
forall (m :: * -> *). Quote m => m Exp -> [m Match] -> m Exp
caseE (forall (m :: * -> *). Quote m => Name -> m Exp
varE Name
getTagValName forall (m :: * -> *). Quote m => m Exp -> m Exp -> m Exp
`appE` forall (m :: * -> *). Quote m => Name -> m Exp
varE Name
untagThis)
[forall (m :: * -> *).
Quote m =>
m Pat -> m Body -> [m Dec] -> m Match
match (forall (m :: * -> *). Quote m => Name -> m Pat
varP Name
putTagHere)
(forall (m :: * -> *). Quote m => m Exp -> m Body
normalB forall a b. (a -> b) -> a -> b
$ [(Name, Name)] -> Q Exp -> Q Exp
untagExpr [(Name, Name)]
more Q Exp
e)
[]]
tag2ConExpr :: Type -> Q Exp
tag2ConExpr :: Type -> Q Exp
tag2ConExpr Type
ty = do
Name
iHash <- forall (m :: * -> *). Quote m => String -> m Name
newName String
"i#"
Type
ty' <- Type -> Q Type
freshenType Type
ty
forall (m :: * -> *). Quote m => m Pat -> m Exp -> m Exp
lam1E (forall (m :: * -> *). Quote m => Name -> [m Pat] -> m Pat
conP Name
iHashDataName [forall (m :: * -> *). Quote m => Name -> m Pat
varP Name
iHash]) forall a b. (a -> b) -> a -> b
$
forall (m :: * -> *). Quote m => Name -> m Exp
varE Name
tagToEnumHashValName forall (m :: * -> *). Quote m => m Exp -> m Exp -> m Exp
`appE` forall (m :: * -> *). Quote m => Name -> m Exp
varE Name
iHash
forall (m :: * -> *). Quote m => m Exp -> m Type -> m Exp
`sigE` forall (m :: * -> *) a. Monad m => a -> m a
return (Type -> Type
quantifyType Type
ty')
primOrdFunTbl :: Map Name (Name, Name, Name, Name, Name)
primOrdFunTbl :: Map Name (Name, Name, Name, Name, Name)
primOrdFunTbl = forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList
[ (Name
addrHashTypeName, ( Name
ltAddrHashValName
, Name
leAddrHashValName
, Name
eqAddrHashValName
, Name
geAddrHashValName
, Name
gtAddrHashValName
))
, (Name
charHashTypeName, ( Name
ltCharHashValName
, Name
leCharHashValName
, Name
eqCharHashValName
, Name
geCharHashValName
, Name
gtCharHashValName
))
, (Name
doubleHashTypeName, ( Name
ltDoubleHashValName
, Name
leDoubleHashValName
, Name
eqDoubleHashValName
, Name
geDoubleHashValName
, Name
gtDoubleHashValName
))
, (Name
floatHashTypeName, ( Name
ltFloatHashValName
, Name
leFloatHashValName
, Name
eqFloatHashValName
, Name
geFloatHashValName
, Name
gtFloatHashValName
))
, (Name
intHashTypeName, ( Name
ltIntHashValName
, Name
leIntHashValName
, Name
eqIntHashValName
, Name
geIntHashValName
, Name
gtIntHashValName
))
, (Name
wordHashTypeName, ( Name
ltWordHashValName
, Name
leWordHashValName
, Name
eqWordHashValName
, Name
geWordHashValName
, Name
gtWordHashValName
))
#if MIN_VERSION_base(4,13,0)
, (Name
int8HashTypeName, ( Name
ltInt8HashValName
, Name
leInt8HashValName
, Name
eqInt8HashValName
, Name
geInt8HashValName
, Name
gtInt8HashValName
))
, (Name
int16HashTypeName, ( Name
ltInt16HashValName
, Name
leInt16HashValName
, Name
eqInt16HashValName
, Name
geInt16HashValName
, Name
gtInt16HashValName
))
, (Name
word8HashTypeName, ( Name
ltWord8HashValName
, Name
leWord8HashValName
, Name
eqWord8HashValName
, Name
geWord8HashValName
, Name
gtWord8HashValName
))
, (Name
word16HashTypeName, ( Name
ltWord16HashValName
, Name
leWord16HashValName
, Name
eqWord16HashValName
, Name
geWord16HashValName
, Name
gtWord16HashValName
))
#endif
#if MIN_VERSION_base(4,16,0)
, (Name
int32HashTypeName, ( Name
ltInt32HashValName
, Name
leInt32HashValName
, Name
eqInt32HashValName
, Name
geInt32HashValName
, Name
gtInt32HashValName
))
, (Name
word32HashTypeName, ( Name
ltWord32HashValName
, Name
leWord32HashValName
, Name
eqWord32HashValName
, Name
geWord32HashValName
, Name
gtWord32HashValName
))
#endif
]
removeClassApp :: Type -> Type
removeClassApp :: Type -> Type
removeClassApp (AppT Type
_ Type
t2) = Type
t2
removeClassApp Type
t = Type
t
freshen :: Name -> Q Name
freshen :: Name -> Q Name
freshen Name
n = forall (m :: * -> *). Quote m => String -> m Name
newName (Name -> String
nameBase Name
n forall a. [a] -> [a] -> [a]
++ String
"_'")
freshenType :: Type -> Q Type
freshenType :: Type -> Q Type
freshenType Type
t =
do let xs :: [(Name, Q Type)]
xs = [(Name
n, Name -> Type
VarT forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` Name -> Q Name
freshen Name
n) | Name
n <- forall a. TypeSubstitution a => a -> [Name]
freeVariables Type
t]
Map Name Type
subst <- forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
T.sequence (forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Name, Q Type)]
xs)
forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. TypeSubstitution a => Map Name Type -> a -> a
applySubstitution Map Name Type
subst Type
t)
enumFromToExpr :: Q Exp -> Q Exp -> Q Exp
enumFromToExpr :: Q Exp -> Q Exp -> Q Exp
enumFromToExpr Q Exp
f Q Exp
t = forall (m :: * -> *). Quote m => Name -> m Exp
varE Name
enumFromToValName forall (m :: * -> *). Quote m => m Exp -> m Exp -> m Exp
`appE` Q Exp
f forall (m :: * -> *). Quote m => m Exp -> m Exp -> m Exp
`appE` Q Exp
t
primOpAppExpr :: Q Exp -> Name -> Q Exp -> Q Exp
primOpAppExpr :: Q Exp -> Name -> Q Exp -> Q Exp
primOpAppExpr Q Exp
e1 Name
op Q Exp
e2 = forall (m :: * -> *). Quote m => Name -> m Exp
varE Name
isTrueHashValName forall (m :: * -> *). Quote m => m Exp -> m Exp -> m Exp
`appE`
forall (m :: * -> *). Quote m => m Exp -> m Exp -> m Exp -> m Exp
infixApp Q Exp
e1 (forall (m :: * -> *). Quote m => Name -> m Exp
varE Name
op) Q Exp
e2
isNonUnitTuple :: Name -> Bool
isNonUnitTuple :: Name -> Bool
isNonUnitTuple = String -> Bool
isNonUnitTupleString forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> String
nameBase
isNonUnitTupleString :: String -> Bool
isNonUnitTupleString :: String -> Bool
isNonUnitTupleString (Char
'(':Char
',':String
_) = Bool
True
isNonUnitTupleString String
_ = Bool
False
isInfixDataCon :: String -> Bool
isInfixDataCon :: String -> Bool
isInfixDataCon (Char
':':String
_) = Bool
True
isInfixDataCon String
_ = Bool
False
isSym :: String -> Bool
isSym :: String -> Bool
isSym String
"" = Bool
False
isSym (Char
c : String
_) = Char -> Bool
startsVarSym Char
c Bool -> Bool -> Bool
|| Char -> Bool
startsConSym Char
c
#if !defined(MIN_VERSION_ghc_boot_th)
startsVarSym, startsConSym :: Char -> Bool
startsVarSym c = startsVarSymASCII c || (ord c > 0x7f && isSymbol c)
startsConSym c = c == ':'
startsVarSymASCII :: Char -> Bool
startsVarSymASCII c = c `elem` "!#$%&*+./<=>?@\\^|~-"
#endif
ghc7'8OrLater :: Bool
#if __GLASGOW_HASKELL__ >= 708
ghc7'8OrLater :: Bool
ghc7'8OrLater = Bool
True
#else
ghc7'8OrLater = False
#endif
derivingCompatPackageKey :: String
#ifdef CURRENT_PACKAGE_KEY
derivingCompatPackageKey :: String
derivingCompatPackageKey = CURRENT_PACKAGE_KEY
#else
derivingCompatPackageKey = "deriving-compat-" ++ showVersion version
#endif
gHC_IX :: String
#if MIN_VERSION_base(4,14,0)
gHC_IX :: String
gHC_IX = String
"GHC.Ix"
#else
gHC_IX = "GHC.Arr"
#endif
mkDerivingCompatName_v :: String -> Name
mkDerivingCompatName_v :: String -> Name
mkDerivingCompatName_v = String -> String -> String -> Name
mkNameG_v String
derivingCompatPackageKey String
"Data.Deriving.Internal"
mkDerivingCompatName_tc :: String -> Name
mkDerivingCompatName_tc :: String -> Name
mkDerivingCompatName_tc = String -> String -> String -> Name
mkNameG_tc String
derivingCompatPackageKey String
"Data.Deriving.Internal"
isTrueHashValName :: Name
isTrueHashValName :: Name
isTrueHashValName = String -> Name
mkDerivingCompatName_v String
"isTrue#"
fmapConstValName :: Name
fmapConstValName :: Name
fmapConstValName = String -> Name
mkDerivingCompatName_v String
"fmapConst"
replaceConstValName :: Name
replaceConstValName :: Name
replaceConstValName = String -> Name
mkDerivingCompatName_v String
"replaceConst"
foldrConstValName :: Name
foldrConstValName :: Name
foldrConstValName = String -> Name
mkDerivingCompatName_v String
"foldrConst"
foldMapConstValName :: Name
foldMapConstValName :: Name
foldMapConstValName = String -> Name
mkDerivingCompatName_v String
"foldMapConst"
nullConstValName :: Name
nullConstValName :: Name
nullConstValName = String -> Name
mkDerivingCompatName_v String
"nullConst"
traverseConstValName :: Name
traverseConstValName :: Name
traverseConstValName = String -> Name
mkDerivingCompatName_v String
"traverseConst"
eqConstValName :: Name
eqConstValName :: Name
eqConstValName = String -> Name
mkDerivingCompatName_v String
"eqConst"
eq1ConstValName :: Name
eq1ConstValName :: Name
eq1ConstValName = String -> Name
mkDerivingCompatName_v String
"eq1Const"
liftEqConstValName :: Name
liftEqConstValName :: Name
liftEqConstValName = String -> Name
mkDerivingCompatName_v String
"liftEqConst"
liftEq2ConstValName :: Name
liftEq2ConstValName :: Name
liftEq2ConstValName = String -> Name
mkDerivingCompatName_v String
"liftEq2Const"
compareConstValName :: Name
compareConstValName :: Name
compareConstValName = String -> Name
mkDerivingCompatName_v String
"compareConst"
ltConstValName :: Name
ltConstValName :: Name
ltConstValName = String -> Name
mkDerivingCompatName_v String
"ltConst"
compare1ConstValName :: Name
compare1ConstValName :: Name
compare1ConstValName = String -> Name
mkDerivingCompatName_v String
"compare1Const"
liftCompareConstValName :: Name
liftCompareConstValName :: Name
liftCompareConstValName = String -> Name
mkDerivingCompatName_v String
"liftCompareConst"
liftCompare2ConstValName :: Name
liftCompare2ConstValName :: Name
liftCompare2ConstValName = String -> Name
mkDerivingCompatName_v String
"liftCompare2Const"
readsPrecConstValName :: Name
readsPrecConstValName :: Name
readsPrecConstValName = String -> Name
mkDerivingCompatName_v String
"readsPrecConst"
readPrecConstValName :: Name
readPrecConstValName :: Name
readPrecConstValName = String -> Name
mkDerivingCompatName_v String
"readPrecConst"
readsPrec1ConstValName :: Name
readsPrec1ConstValName :: Name
readsPrec1ConstValName = String -> Name
mkDerivingCompatName_v String
"readsPrec1Const"
liftReadsPrecConstValName :: Name
liftReadsPrecConstValName :: Name
liftReadsPrecConstValName = String -> Name
mkDerivingCompatName_v String
"liftReadsPrecConst"
liftReadPrecConstValName :: Name
liftReadPrecConstValName :: Name
liftReadPrecConstValName = String -> Name
mkDerivingCompatName_v String
"liftReadPrecConst"
liftReadsPrec2ConstValName :: Name
liftReadsPrec2ConstValName :: Name
liftReadsPrec2ConstValName = String -> Name
mkDerivingCompatName_v String
"liftReadsPrec2Const"
liftReadPrec2ConstValName :: Name
liftReadPrec2ConstValName :: Name
liftReadPrec2ConstValName = String -> Name
mkDerivingCompatName_v String
"liftReadPrec2Const"
showsPrecConstValName :: Name
showsPrecConstValName :: Name
showsPrecConstValName = String -> Name
mkDerivingCompatName_v String
"showsPrecConst"
showsPrec1ConstValName :: Name
showsPrec1ConstValName :: Name
showsPrec1ConstValName = String -> Name
mkDerivingCompatName_v String
"showsPrec1Const"
liftShowsPrecConstValName :: Name
liftShowsPrecConstValName :: Name
liftShowsPrecConstValName = String -> Name
mkDerivingCompatName_v String
"liftShowsPrecConst"
liftShowsPrec2ConstValName :: Name
liftShowsPrec2ConstValName :: Name
liftShowsPrec2ConstValName = String -> Name
mkDerivingCompatName_v String
"liftShowsPrec2Const"
viaTypeName :: Name
viaTypeName :: Name
viaTypeName = String -> Name
mkDerivingCompatName_tc String
"Via"
cHashDataName :: Name
cHashDataName :: Name
cHashDataName = String -> String -> String -> Name
mkNameG_d String
"ghc-prim" String
"GHC.Types" String
"C#"
dHashDataName :: Name
dHashDataName :: Name
dHashDataName = String -> String -> String -> Name
mkNameG_d String
"ghc-prim" String
"GHC.Types" String
"D#"
fHashDataName :: Name
fHashDataName :: Name
fHashDataName = String -> String -> String -> Name
mkNameG_d String
"ghc-prim" String
"GHC.Types" String
"F#"
identDataName :: Name
identDataName :: Name
identDataName = String -> String -> String -> Name
mkNameG_d String
"base" String
"Text.Read.Lex" String
"Ident"
iHashDataName :: Name
iHashDataName :: Name
iHashDataName = String -> String -> String -> Name
mkNameG_d String
"ghc-prim" String
"GHC.Types" String
"I#"
puncDataName :: Name
puncDataName :: Name
puncDataName = String -> String -> String -> Name
mkNameG_d String
"base" String
"Text.Read.Lex" String
"Punc"
symbolDataName :: Name
symbolDataName :: Name
symbolDataName = String -> String -> String -> Name
mkNameG_d String
"base" String
"Text.Read.Lex" String
"Symbol"
wrapMonadDataName :: Name
wrapMonadDataName :: Name
wrapMonadDataName = String -> String -> String -> Name
mkNameG_d String
"base" String
"Control.Applicative" String
"WrapMonad"
addrHashTypeName :: Name
addrHashTypeName :: Name
addrHashTypeName = String -> String -> String -> Name
mkNameG_tc String
"ghc-prim" String
"GHC.Prim" String
"Addr#"
boundedTypeName :: Name
boundedTypeName :: Name
boundedTypeName = String -> String -> String -> Name
mkNameG_tc String
"base" String
"GHC.Enum" String
"Bounded"
charHashTypeName :: Name
charHashTypeName :: Name
charHashTypeName = String -> String -> String -> Name
mkNameG_tc String
"ghc-prim" String
"GHC.Prim" String
"Char#"
doubleHashTypeName :: Name
doubleHashTypeName :: Name
doubleHashTypeName = String -> String -> String -> Name
mkNameG_tc String
"ghc-prim" String
"GHC.Prim" String
"Double#"
enumTypeName :: Name
enumTypeName :: Name
enumTypeName = String -> String -> String -> Name
mkNameG_tc String
"base" String
"GHC.Enum" String
"Enum"
floatHashTypeName :: Name
floatHashTypeName :: Name
floatHashTypeName = String -> String -> String -> Name
mkNameG_tc String
"ghc-prim" String
"GHC.Prim" String
"Float#"
foldableTypeName :: Name
foldableTypeName :: Name
foldableTypeName = String -> String -> String -> Name
mkNameG_tc String
"base" String
"Data.Foldable" String
"Foldable"
functorTypeName :: Name
functorTypeName :: Name
functorTypeName = String -> String -> String -> Name
mkNameG_tc String
"base" String
"GHC.Base" String
"Functor"
intTypeName :: Name
intTypeName :: Name
intTypeName = String -> String -> String -> Name
mkNameG_tc String
"ghc-prim" String
"GHC.Types" String
"Int"
intHashTypeName :: Name
intHashTypeName :: Name
intHashTypeName = String -> String -> String -> Name
mkNameG_tc String
"ghc-prim" String
"GHC.Prim" String
"Int#"
ixTypeName :: Name
ixTypeName :: Name
ixTypeName = String -> String -> String -> Name
mkNameG_tc String
"base" String
gHC_IX String
"Ix"
readTypeName :: Name
readTypeName :: Name
readTypeName = String -> String -> String -> Name
mkNameG_tc String
"base" String
"GHC.Read" String
"Read"
showTypeName :: Name
showTypeName :: Name
showTypeName = String -> String -> String -> Name
mkNameG_tc String
"base" String
"GHC.Show" String
"Show"
traversableTypeName :: Name
traversableTypeName :: Name
traversableTypeName = String -> String -> String -> Name
mkNameG_tc String
"base" String
"Data.Traversable" String
"Traversable"
wordHashTypeName :: Name
wordHashTypeName :: Name
wordHashTypeName = String -> String -> String -> Name
mkNameG_tc String
"ghc-prim" String
"GHC.Prim" String
"Word#"
altValName :: Name
altValName :: Name
altValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Text.ParserCombinators.ReadPrec" String
"+++"
appendValName :: Name
appendValName :: Name
appendValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Base" String
"++"
chooseValName :: Name
chooseValName :: Name
chooseValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Read" String
"choose"
coerceValName :: Name
coerceValName :: Name
coerceValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"coerce"
composeValName :: Name
composeValName :: Name
composeValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Base" String
"."
constValName :: Name
constValName :: Name
constValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Base" String
"const"
enumFromValName :: Name
enumFromValName :: Name
enumFromValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Enum" String
"enumFrom"
enumFromThenValName :: Name
enumFromThenValName :: Name
enumFromThenValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Enum" String
"enumFromThen"
enumFromThenToValName :: Name
enumFromThenToValName :: Name
enumFromThenToValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Enum" String
"enumFromThenTo"
enumFromToValName :: Name
enumFromToValName :: Name
enumFromToValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Enum" String
"enumFromTo"
eqAddrHashValName :: Name
eqAddrHashValName :: Name
eqAddrHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"eqAddr#"
eqCharHashValName :: Name
eqCharHashValName :: Name
eqCharHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"eqChar#"
eqDoubleHashValName :: Name
eqDoubleHashValName :: Name
eqDoubleHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"==##"
eqFloatHashValName :: Name
eqFloatHashValName :: Name
eqFloatHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"eqFloat#"
eqIntHashValName :: Name
eqIntHashValName :: Name
eqIntHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"==#"
eqWordHashValName :: Name
eqWordHashValName :: Name
eqWordHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"eqWord#"
errorValName :: Name
errorValName :: Name
errorValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Err" String
"error"
flipValName :: Name
flipValName :: Name
flipValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Base" String
"flip"
fmapValName :: Name
fmapValName :: Name
fmapValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Base" String
"fmap"
foldrValName :: Name
foldrValName :: Name
foldrValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Data.Foldable" String
"foldr"
foldMapValName :: Name
foldMapValName :: Name
foldMapValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Data.Foldable" String
"foldMap"
fromEnumValName :: Name
= String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Enum" String
"fromEnum"
geAddrHashValName :: Name
geAddrHashValName :: Name
geAddrHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"geAddr#"
geCharHashValName :: Name
geCharHashValName :: Name
geCharHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"geChar#"
geDoubleHashValName :: Name
geDoubleHashValName :: Name
geDoubleHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
">=##"
geFloatHashValName :: Name
geFloatHashValName :: Name
geFloatHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"geFloat#"
geIntHashValName :: Name
geIntHashValName :: Name
geIntHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
">=#"
getTagValName :: Name
getTagValName :: Name
getTagValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Base" String
"getTag"
geWordHashValName :: Name
geWordHashValName :: Name
geWordHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"geWord#"
gtAddrHashValName :: Name
gtAddrHashValName :: Name
gtAddrHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"gtAddr#"
gtCharHashValName :: Name
gtCharHashValName :: Name
gtCharHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"gtChar#"
gtDoubleHashValName :: Name
gtDoubleHashValName :: Name
gtDoubleHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
">##"
gtFloatHashValName :: Name
gtFloatHashValName :: Name
gtFloatHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"gtFloat#"
gtIntHashValName :: Name
gtIntHashValName :: Name
gtIntHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
">#"
gtWordHashValName :: Name
gtWordHashValName :: Name
gtWordHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"gtWord#"
idValName :: Name
idValName :: Name
idValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Base" String
"id"
indexValName :: Name
indexValName :: Name
indexValName = String -> String -> String -> Name
mkNameG_v String
"base" String
gHC_IX String
"index"
inRangeValName :: Name
inRangeValName :: Name
inRangeValName = String -> String -> String -> Name
mkNameG_v String
"base" String
gHC_IX String
"inRange"
leAddrHashValName :: Name
leAddrHashValName :: Name
leAddrHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"leAddr#"
leCharHashValName :: Name
leCharHashValName :: Name
leCharHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"leChar#"
leDoubleHashValName :: Name
leDoubleHashValName :: Name
leDoubleHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"<=##"
leFloatHashValName :: Name
leFloatHashValName :: Name
leFloatHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"leFloat#"
leIntHashValName :: Name
leIntHashValName :: Name
leIntHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"<=#"
leWordHashValName :: Name
leWordHashValName :: Name
leWordHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"leWord#"
liftReadListPrecDefaultValName :: Name
liftReadListPrecDefaultValName :: Name
liftReadListPrecDefaultValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Data.Functor.Classes" String
"liftReadListPrecDefault"
liftReadListPrec2DefaultValName :: Name
liftReadListPrec2DefaultValName :: Name
liftReadListPrec2DefaultValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Data.Functor.Classes" String
"liftReadListPrec2Default"
liftReadListPrecValName :: Name
liftReadListPrecValName :: Name
liftReadListPrecValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Data.Functor.Classes" String
"liftReadListPrec"
liftReadListPrec2ValName :: Name
liftReadListPrec2ValName :: Name
liftReadListPrec2ValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Data.Functor.Classes" String
"liftReadListPrec2"
liftReadPrecValName :: Name
liftReadPrecValName :: Name
liftReadPrecValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Data.Functor.Classes" String
"liftReadPrec"
liftReadPrec2ValName :: Name
liftReadPrec2ValName :: Name
liftReadPrec2ValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Data.Functor.Classes" String
"liftReadPrec2"
listValName :: Name
listValName :: Name
listValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Read" String
"list"
ltAddrHashValName :: Name
ltAddrHashValName :: Name
ltAddrHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"ltAddr#"
ltCharHashValName :: Name
ltCharHashValName :: Name
ltCharHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"ltChar#"
ltDoubleHashValName :: Name
ltDoubleHashValName :: Name
ltDoubleHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"<##"
ltFloatHashValName :: Name
ltFloatHashValName :: Name
ltFloatHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"ltFloat#"
ltIntHashValName :: Name
ltIntHashValName :: Name
ltIntHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"<#"
ltWordHashValName :: Name
ltWordHashValName :: Name
ltWordHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"ltWord#"
minBoundValName :: Name
minBoundValName :: Name
minBoundValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Enum" String
"minBound"
mapValName :: Name
mapValName :: Name
mapValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Base" String
"map"
maxBoundValName :: Name
maxBoundValName :: Name
maxBoundValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Enum" String
"maxBound"
minusIntHashValName :: Name
minusIntHashValName :: Name
minusIntHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"-#"
neqIntHashValName :: Name
neqIntHashValName :: Name
neqIntHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"/=#"
parenValName :: Name
parenValName :: Name
parenValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Read" String
"paren"
parensValName :: Name
parensValName :: Name
parensValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Read" String
"parens"
pfailValName :: Name
pfailValName :: Name
pfailValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Text.ParserCombinators.ReadPrec" String
"pfail"
plusValName :: Name
plusValName :: Name
plusValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Num" String
"+"
precValName :: Name
precValName :: Name
precValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Text.ParserCombinators.ReadPrec" String
"prec"
predValName :: Name
predValName :: Name
predValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Enum" String
"pred"
rangeSizeValName :: Name
rangeSizeValName :: Name
rangeSizeValName = String -> String -> String -> Name
mkNameG_v String
"base" String
gHC_IX String
"rangeSize"
rangeValName :: Name
rangeValName :: Name
rangeValName = String -> String -> String -> Name
mkNameG_v String
"base" String
gHC_IX String
"range"
readFieldHash :: String -> ReadPrec a -> ReadPrec a
readFieldHash :: forall a. String -> ReadPrec a -> ReadPrec a
readFieldHash String
fieldName ReadPrec a
readVal = do
Lexeme -> ReadPrec ()
expectP (String -> Lexeme
L.Ident String
fieldName)
Lexeme -> ReadPrec ()
expectP (String -> Lexeme
L.Symbol String
"#")
Lexeme -> ReadPrec ()
expectP (String -> Lexeme
L.Punc String
"=")
ReadPrec a
readVal
{-# NOINLINE readFieldHash #-}
readFieldHashValName :: Name
readFieldHashValName :: Name
readFieldHashValName = String -> String -> String -> Name
mkNameG_v String
derivingCompatPackageKey String
"Data.Deriving.Internal" String
"readFieldHash"
readListValName :: Name
readListValName :: Name
readListValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Read" String
"readList"
readListPrecDefaultValName :: Name
readListPrecDefaultValName :: Name
readListPrecDefaultValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Read" String
"readListPrecDefault"
readListPrecValName :: Name
readListPrecValName :: Name
readListPrecValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Read" String
"readListPrec"
readPrec_to_SValName :: Name
readPrec_to_SValName :: Name
readPrec_to_SValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Text.ParserCombinators.ReadPrec" String
"readPrec_to_S"
readPrecValName :: Name
readPrecValName :: Name
readPrecValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Read" String
"readPrec"
readS_to_PrecValName :: Name
readS_to_PrecValName :: Name
readS_to_PrecValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Text.ParserCombinators.ReadPrec" String
"readS_to_Prec"
readsPrecValName :: Name
readsPrecValName :: Name
readsPrecValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Read" String
"readsPrec"
replaceValName :: Name
replaceValName :: Name
replaceValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Base" String
"<$"
resetValName :: Name
resetValName :: Name
resetValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Text.ParserCombinators.ReadPrec" String
"reset"
returnValName :: Name
returnValName :: Name
returnValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Base" String
"return"
seqValName :: Name
seqValName :: Name
seqValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"seq"
showCharValName :: Name
showCharValName :: Name
showCharValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Show" String
"showChar"
showListValName :: Name
showListValName :: Name
showListValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Show" String
"showList"
showListWithValName :: Name
showListWithValName :: Name
showListWithValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Text.Show" String
"showListWith"
showParenValName :: Name
showParenValName :: Name
showParenValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Show" String
"showParen"
showsPrecValName :: Name
showsPrecValName :: Name
showsPrecValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Show" String
"showsPrec"
showSpaceValName :: Name
showSpaceValName :: Name
showSpaceValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Show" String
"showSpace"
showStringValName :: Name
showStringValName :: Name
showStringValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Show" String
"showString"
stepValName :: Name
stepValName :: Name
stepValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Text.ParserCombinators.ReadPrec" String
"step"
succValName :: Name
succValName :: Name
succValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Enum" String
"succ"
tagToEnumHashValName :: Name
tagToEnumHashValName :: Name
tagToEnumHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"tagToEnum#"
timesValName :: Name
timesValName :: Name
timesValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Num" String
"*"
toEnumValName :: Name
toEnumValName :: Name
toEnumValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Enum" String
"toEnum"
traverseValName :: Name
traverseValName :: Name
traverseValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Data.Traversable" String
"traverse"
unsafeIndexValName :: Name
unsafeIndexValName :: Name
unsafeIndexValName = String -> String -> String -> Name
mkNameG_v String
"base" String
gHC_IX String
"unsafeIndex"
unsafeRangeSizeValName :: Name
unsafeRangeSizeValName :: Name
unsafeRangeSizeValName = String -> String -> String -> Name
mkNameG_v String
"base" String
gHC_IX String
"unsafeRangeSize"
unwrapMonadValName :: Name
unwrapMonadValName :: Name
unwrapMonadValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Control.Applicative" String
"unwrapMonad"
#if MIN_VERSION_base(4,4,0)
boolTypeName :: Name
boolTypeName :: Name
boolTypeName = String -> String -> String -> Name
mkNameG_tc String
"ghc-prim" String
"GHC.Types" String
"Bool"
falseDataName :: Name
falseDataName :: Name
falseDataName = String -> String -> String -> Name
mkNameG_d String
"ghc-prim" String
"GHC.Types" String
"False"
trueDataName :: Name
trueDataName :: Name
trueDataName = String -> String -> String -> Name
mkNameG_d String
"ghc-prim" String
"GHC.Types" String
"True"
#else
boolTypeName :: Name
boolTypeName = mkNameG_tc "ghc-prim" "GHC.Bool" "Bool"
falseDataName :: Name
falseDataName = mkNameG_d "ghc-prim" "GHC.Bool" "False"
trueDataName :: Name
trueDataName = mkNameG_d "ghc-prim" "GHC.Bool" "True"
#endif
#if MIN_VERSION_base(4,5,0)
eqDataName :: Name
eqDataName :: Name
eqDataName = String -> String -> String -> Name
mkNameG_d String
"ghc-prim" String
"GHC.Types" String
"EQ"
gtDataName :: Name
gtDataName :: Name
gtDataName = String -> String -> String -> Name
mkNameG_d String
"ghc-prim" String
"GHC.Types" String
"GT"
ltDataName :: Name
ltDataName :: Name
ltDataName = String -> String -> String -> Name
mkNameG_d String
"ghc-prim" String
"GHC.Types" String
"LT"
eqTypeName :: Name
eqTypeName :: Name
eqTypeName = String -> String -> String -> Name
mkNameG_tc String
"ghc-prim" String
"GHC.Classes" String
"Eq"
ordTypeName :: Name
ordTypeName :: Name
ordTypeName = String -> String -> String -> Name
mkNameG_tc String
"ghc-prim" String
"GHC.Classes" String
"Ord"
andValName :: Name
andValName :: Name
andValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Classes" String
"&&"
compareValName :: Name
compareValName :: Name
compareValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Classes" String
"compare"
eqValName :: Name
eqValName :: Name
eqValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Classes" String
"=="
geValName :: Name
geValName :: Name
geValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Classes" String
">="
gtValName :: Name
gtValName :: Name
gtValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Classes" String
">"
leValName :: Name
leValName :: Name
leValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Classes" String
"<="
ltValName :: Name
ltValName :: Name
ltValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Classes" String
"<"
notValName :: Name
notValName :: Name
notValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Classes" String
"not"
#else
eqDataName :: Name
eqDataName = mkNameG_d "ghc-prim" "GHC.Ordering" "EQ"
gtDataName :: Name
gtDataName = mkNameG_d "ghc-prim" "GHC.Ordering" "GT"
ltDataName :: Name
ltDataName = mkNameG_d "ghc-prim" "GHC.Ordering" "LT"
eqTypeName :: Name
eqTypeName = mkNameG_tc "base" "GHC.Classes" "Eq"
ordTypeName :: Name
ordTypeName = mkNameG_tc "base" "GHC.Classes" "Ord"
andValName :: Name
andValName = mkNameG_v "base" "GHC.Classes" "&&"
compareValName :: Name
compareValName = mkNameG_v "base" "GHC.Classes" "compare"
eqValName :: Name
eqValName = mkNameG_v "base" "GHC.Classes" "=="
geValName :: Name
geValName = mkNameG_v "base" "GHC.Classes" ">="
gtValName :: Name
gtValName = mkNameG_v "base" "GHC.Classes" ">"
leValName :: Name
leValName = mkNameG_v "base" "GHC.Classes" "<="
ltValName :: Name
ltValName = mkNameG_v "base" "GHC.Classes" "<"
notValName :: Name
notValName = mkNameG_v "base" "GHC.Classes" "not"
#endif
#if MIN_VERSION_base(4,6,0)
wHashDataName :: Name
wHashDataName :: Name
wHashDataName = String -> String -> String -> Name
mkNameG_d String
"ghc-prim" String
"GHC.Types" String
"W#"
#else
wHashDataName :: Name
wHashDataName = mkNameG_d "base" "GHC.Word" "W#"
#endif
#if MIN_VERSION_base(4,7,0)
expectPValName :: Name
expectPValName :: Name
expectPValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Read" String
"expectP"
#else
expectP :: Lexeme -> ReadPrec ()
expectP lexeme = do
thing <- lexP
if thing == lexeme then return () else pfail
expectPValName :: Name
expectPValName = mkDerivingCompatName_v "expectP"
#endif
#if MIN_VERSION_base(4,8,0)
allValName :: Name
allValName :: Name
allValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Data.Foldable" String
"all"
apValName :: Name
apValName :: Name
apValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Base" String
"<*>"
pureValName :: Name
pureValName :: Name
pureValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Base" String
"pure"
liftA2ValName :: Name
liftA2ValName :: Name
liftA2ValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Base" String
"liftA2"
mappendValName :: Name
mappendValName :: Name
mappendValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Base" String
"mappend"
memptyValName :: Name
memptyValName :: Name
memptyValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Base" String
"mempty"
nullValName :: Name
nullValName :: Name
nullValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Data.Foldable" String
"null"
#else
allValName :: Name
allValName = mkNameG_v "base" "GHC.List" "all"
apValName :: Name
apValName = mkNameG_v "base" "Control.Applicative" "<*>"
pureValName :: Name
pureValName = mkNameG_v "base" "Control.Applicative" "pure"
liftA2ValName :: Name
liftA2ValName = mkNameG_v "base" "Control.Applicative" "liftA2"
mappendValName :: Name
mappendValName = mkNameG_v "base" "Data.Monoid" "mappend"
memptyValName :: Name
memptyValName = mkNameG_v "base" "Data.Monoid" "mempty"
nullValName :: Name
nullValName = mkNameG_v "base" "GHC.List" "null"
#endif
#if MIN_VERSION_base(4,9,0)
eq1TypeName :: Name
eq1TypeName :: Name
eq1TypeName = String -> String -> String -> Name
mkNameG_tc String
"base" String
"Data.Functor.Classes" String
"Eq1"
eq2TypeName :: Name
eq2TypeName :: Name
eq2TypeName = String -> String -> String -> Name
mkNameG_tc String
"base" String
"Data.Functor.Classes" String
"Eq2"
liftEqValName :: Name
liftEqValName :: Name
liftEqValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Data.Functor.Classes" String
"liftEq"
liftEq2ValName :: Name
liftEq2ValName :: Name
liftEq2ValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Data.Functor.Classes" String
"liftEq2"
ord1TypeName :: Name
ord1TypeName :: Name
ord1TypeName = String -> String -> String -> Name
mkNameG_tc String
"base" String
"Data.Functor.Classes" String
"Ord1"
ord2TypeName :: Name
ord2TypeName :: Name
ord2TypeName = String -> String -> String -> Name
mkNameG_tc String
"base" String
"Data.Functor.Classes" String
"Ord2"
liftCompareValName :: Name
liftCompareValName :: Name
liftCompareValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Data.Functor.Classes" String
"liftCompare"
liftCompare2ValName :: Name
liftCompare2ValName :: Name
liftCompare2ValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Data.Functor.Classes" String
"liftCompare2"
read1TypeName :: Name
read1TypeName :: Name
read1TypeName = String -> String -> String -> Name
mkNameG_tc String
"base" String
"Data.Functor.Classes" String
"Read1"
read2TypeName :: Name
read2TypeName :: Name
read2TypeName = String -> String -> String -> Name
mkNameG_tc String
"base" String
"Data.Functor.Classes" String
"Read2"
liftReadsPrecValName :: Name
liftReadsPrecValName :: Name
liftReadsPrecValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Data.Functor.Classes" String
"liftReadsPrec"
liftReadListValName :: Name
liftReadListValName :: Name
liftReadListValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Data.Functor.Classes" String
"liftReadList"
liftReadsPrec2ValName :: Name
liftReadsPrec2ValName :: Name
liftReadsPrec2ValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Data.Functor.Classes" String
"liftReadsPrec2"
liftReadList2ValName :: Name
liftReadList2ValName :: Name
liftReadList2ValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Data.Functor.Classes" String
"liftReadList2"
show1TypeName :: Name
show1TypeName :: Name
show1TypeName = String -> String -> String -> Name
mkNameG_tc String
"base" String
"Data.Functor.Classes" String
"Show1"
show2TypeName :: Name
show2TypeName :: Name
show2TypeName = String -> String -> String -> Name
mkNameG_tc String
"base" String
"Data.Functor.Classes" String
"Show2"
liftShowListValName :: Name
liftShowListValName :: Name
liftShowListValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Data.Functor.Classes" String
"liftShowList"
liftShowsPrecValName :: Name
liftShowsPrecValName :: Name
liftShowsPrecValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Data.Functor.Classes" String
"liftShowsPrec"
liftShowList2ValName :: Name
liftShowList2ValName :: Name
liftShowList2ValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Data.Functor.Classes" String
"liftShowList2"
liftShowsPrec2ValName :: Name
liftShowsPrec2ValName :: Name
liftShowsPrec2ValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Data.Functor.Classes" String
"liftShowsPrec2"
#else
# if !(MIN_VERSION_transformers(0,4,0)) || MIN_VERSION_transformers(0,5,0)
eq1TypeName :: Name
eq1TypeName = ''Eq1
eq2TypeName :: Name
eq2TypeName = ''Eq2
liftEqValName :: Name
liftEqValName = 'liftEq
liftEq2ValName :: Name
liftEq2ValName = 'liftEq2
ord1TypeName :: Name
ord1TypeName = ''Ord1
ord2TypeName :: Name
ord2TypeName = ''Ord2
liftCompareValName :: Name
liftCompareValName = 'liftCompare
liftCompare2ValName :: Name
liftCompare2ValName = 'liftCompare2
read1TypeName :: Name
read1TypeName = ''Read1
read2TypeName :: Name
read2TypeName = ''Read2
liftReadsPrecValName :: Name
liftReadsPrecValName = 'liftReadsPrec
liftReadListValName :: Name
liftReadListValName = 'liftReadList
liftReadsPrec2ValName :: Name
liftReadsPrec2ValName = 'liftReadsPrec2
liftReadList2ValName :: Name
liftReadList2ValName = 'liftReadList2
show1TypeName :: Name
show1TypeName = ''Show1
show2TypeName :: Name
show2TypeName = ''Show2
liftShowListValName :: Name
liftShowListValName = 'liftShowList
liftShowsPrecValName :: Name
liftShowsPrecValName = 'liftShowsPrec
liftShowList2ValName :: Name
liftShowList2ValName = 'liftShowList2
liftShowsPrec2ValName :: Name
liftShowsPrec2ValName = 'liftShowsPrec2
# else
eq1TypeName :: Name
eq1TypeName = ''Eq1
eq1ValName :: Name
eq1ValName = 'eq1
ord1TypeName :: Name
ord1TypeName = ''Ord1
compare1ValName :: Name
compare1ValName = 'compare1
read1TypeName :: Name
read1TypeName = ''Read1
readsPrec1ValName :: Name
readsPrec1ValName = 'readsPrec1
show1TypeName :: Name
show1TypeName = ''Show1
showsPrec1ValName :: Name
showsPrec1ValName = 'showsPrec1
newtype Apply f a = Apply { unApply :: f a }
instance (Eq1 f, Eq a) => Eq (Apply f a) where
Apply x == Apply y = eq1 x y
instance (Ord1 g, Ord a) => Ord (Apply g a) where
compare (Apply x) (Apply y) = compare1 x y
instance (Read1 f, Read a) => Read (Apply f a) where
readsPrec d s = [(Apply a, t) | (a, t) <- readsPrec1 d s]
instance (Show1 f, Show a) => Show (Apply f a) where
showsPrec p (Apply x) = showsPrec1 p x
makeFmapApplyNeg :: ClassRep a => a -> Name -> Type -> Name -> Q Exp
makeFmapApplyNeg = makeFmapApply False
makeFmapApplyPos :: ClassRep a => a -> Name -> Type -> Name -> Q Exp
makeFmapApplyPos = makeFmapApply True
makeFmapApply :: ClassRep a => Bool -> a -> Name -> Type -> Name -> Q Exp
makeFmapApply pos cRep conName (SigT ty _) name = makeFmapApply pos cRep conName ty name
makeFmapApply pos cRep conName t name = do
let tyCon :: Type
tyArgs :: [Type]
(tyCon, tyArgs) = unapplyTy t
numLastArgs :: Int
numLastArgs = min (arity cRep) (length tyArgs)
lhsArgs, rhsArgs :: [Type]
(lhsArgs, rhsArgs) = splitAt (length tyArgs - numLastArgs) tyArgs
inspectTy :: Type -> Q Exp
inspectTy (SigT ty _) = inspectTy ty
inspectTy (VarT a) | a == name = varE idValName
inspectTy beta = varE fmapValName `appE`
infixApp (if pos then makeFmapApply pos cRep conName beta name
else conE applyDataName)
(varE composeValName)
(if pos then varE unApplyValName
else makeFmapApply pos cRep conName beta name)
itf <- isInTypeFamilyApp [name] tyCon tyArgs
if any (`mentionsName` [name]) lhsArgs || itf
then outOfPlaceTyVarError cRep conName
else inspectTy (head rhsArgs)
applyDataName :: Name
applyDataName = mkNameG_d derivingCompatPackageKey "Data.Deriving.Internal" "Apply"
unApplyValName :: Name
unApplyValName = mkNameG_v derivingCompatPackageKey "Data.Deriving.Internal" "unApply"
# endif
#endif
#if MIN_VERSION_base(4,10,0)
showCommaSpaceValName :: Name
showCommaSpaceValName :: Name
showCommaSpaceValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Show" String
"showCommaSpace"
#else
showCommaSpace :: ShowS
showCommaSpace = showString ", "
showCommaSpaceValName :: Name
showCommaSpaceValName = mkNameG_v derivingCompatPackageKey "Data.Deriving.Internal" "showCommaSpace"
#endif
#if MIN_VERSION_base(4,11,0)
appEndoValName :: Name
appEndoValName :: Name
appEndoValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Data.Semigroup.Internal" String
"appEndo"
dualDataName :: Name
dualDataName :: Name
dualDataName = String -> String -> String -> Name
mkNameG_d String
"base" String
"Data.Semigroup.Internal" String
"Dual"
endoDataName :: Name
endoDataName :: Name
endoDataName = String -> String -> String -> Name
mkNameG_d String
"base" String
"Data.Semigroup.Internal" String
"Endo"
getDualValName :: Name
getDualValName :: Name
getDualValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"Data.Semigroup.Internal" String
"getDual"
readFieldValName :: Name
readFieldValName :: Name
readFieldValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Read" String
"readField"
readSymFieldValName :: Name
readSymFieldValName :: Name
readSymFieldValName = String -> String -> String -> Name
mkNameG_v String
"base" String
"GHC.Read" String
"readSymField"
#else
appEndoValName :: Name
appEndoValName = mkNameG_v "base" "Data.Monoid" "appEndo"
dualDataName :: Name
dualDataName = mkNameG_d "base" "Data.Monoid" "Dual"
endoDataName :: Name
endoDataName = mkNameG_d "base" "Data.Monoid" "Endo"
getDualValName :: Name
getDualValName = mkNameG_v "base" "Data.Monoid" "getDual"
readField :: String -> ReadPrec a -> ReadPrec a
readField fieldName readVal = do
expectP (L.Ident fieldName)
expectP (L.Punc "=")
readVal
{-# NOINLINE readField #-}
readFieldValName :: Name
readFieldValName = mkNameG_v derivingCompatPackageKey "Data.Deriving.Internal" "readField"
readSymField :: String -> ReadPrec a -> ReadPrec a
readSymField fieldName readVal = do
expectP (L.Punc "(")
expectP (L.Symbol fieldName)
expectP (L.Punc ")")
expectP (L.Punc "=")
readVal
{-# NOINLINE readSymField #-}
readSymFieldValName :: Name
readSymFieldValName = mkNameG_v derivingCompatPackageKey "Data.Deriving.Internal" "readSymField"
#endif
#if MIN_VERSION_base(4,13,0)
eqInt8HashValName :: Name
eqInt8HashValName :: Name
eqInt8HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"eqInt8#"
eqInt16HashValName :: Name
eqInt16HashValName :: Name
eqInt16HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"eqInt16#"
eqWord8HashValName :: Name
eqWord8HashValName :: Name
eqWord8HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"eqWord8#"
eqWord16HashValName :: Name
eqWord16HashValName :: Name
eqWord16HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"eqWord16#"
geInt8HashValName :: Name
geInt8HashValName :: Name
geInt8HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"geInt8#"
geInt16HashValName :: Name
geInt16HashValName :: Name
geInt16HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"geInt16#"
geWord8HashValName :: Name
geWord8HashValName :: Name
geWord8HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"geWord8#"
geWord16HashValName :: Name
geWord16HashValName :: Name
geWord16HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"geWord16#"
gtInt8HashValName :: Name
gtInt8HashValName :: Name
gtInt8HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"gtInt8#"
gtInt16HashValName :: Name
gtInt16HashValName :: Name
gtInt16HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"gtInt16#"
gtWord8HashValName :: Name
gtWord8HashValName :: Name
gtWord8HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"gtWord8#"
gtWord16HashValName :: Name
gtWord16HashValName :: Name
gtWord16HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"gtWord16#"
int8HashTypeName :: Name
int8HashTypeName :: Name
int8HashTypeName = String -> String -> String -> Name
mkNameG_tc String
"ghc-prim" String
"GHC.Prim" String
"Int8#"
int8ToIntHashValName :: Name
int8ToIntHashValName :: Name
int8ToIntHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim"
# if MIN_VERSION_base(4,16,0)
String
"int8ToInt#"
# else
"extendInt8#"
# endif
int16HashTypeName :: Name
int16HashTypeName :: Name
int16HashTypeName = String -> String -> String -> Name
mkNameG_tc String
"ghc-prim" String
"GHC.Prim" String
"Int16#"
int16ToIntHashValName :: Name
int16ToIntHashValName :: Name
int16ToIntHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim"
# if MIN_VERSION_base(4,16,0)
String
"int16ToInt#"
# else
"extendInt16#"
# endif
intToInt8HashValName :: Name
intToInt8HashValName :: Name
intToInt8HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim"
# if MIN_VERSION_base(4,16,0)
String
"intToInt8#"
# else
"narrowInt8#"
# endif
intToInt16HashValName :: Name
intToInt16HashValName :: Name
intToInt16HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim"
# if MIN_VERSION_base(4,16,0)
String
"intToInt16#"
# else
"narrowInt16#"
# endif
leInt8HashValName :: Name
leInt8HashValName :: Name
leInt8HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"leInt8#"
leInt16HashValName :: Name
leInt16HashValName :: Name
leInt16HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"leInt16#"
leWord8HashValName :: Name
leWord8HashValName :: Name
leWord8HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"leWord8#"
leWord16HashValName :: Name
leWord16HashValName :: Name
leWord16HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"leWord16#"
ltInt8HashValName :: Name
ltInt8HashValName :: Name
ltInt8HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"ltInt8#"
ltInt16HashValName :: Name
ltInt16HashValName :: Name
ltInt16HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"ltInt16#"
ltWord8HashValName :: Name
ltWord8HashValName :: Name
ltWord8HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"ltWord8#"
ltWord16HashValName :: Name
ltWord16HashValName :: Name
ltWord16HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"ltWord16#"
word8HashTypeName :: Name
word8HashTypeName :: Name
word8HashTypeName = String -> String -> String -> Name
mkNameG_tc String
"ghc-prim" String
"GHC.Prim" String
"Word8#"
word8ToWordHashValName :: Name
word8ToWordHashValName :: Name
word8ToWordHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim"
# if MIN_VERSION_base(4,16,0)
String
"word8ToWord#"
# else
"extendWord8#"
# endif
word16HashTypeName :: Name
word16HashTypeName :: Name
word16HashTypeName = String -> String -> String -> Name
mkNameG_tc String
"ghc-prim" String
"GHC.Prim" String
"Word16#"
word16ToWordHashValName :: Name
word16ToWordHashValName :: Name
word16ToWordHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim"
# if MIN_VERSION_base(4,16,0)
String
"word16ToWord#"
# else
"extendWord16#"
# endif
wordToWord8HashValName :: Name
wordToWord8HashValName :: Name
wordToWord8HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim"
# if MIN_VERSION_base(4,16,0)
String
"wordToWord8#"
# else
"narrowWord8#"
# endif
wordToWord16HashValName :: Name
wordToWord16HashValName :: Name
wordToWord16HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim"
# if MIN_VERSION_base(4,16,0)
String
"wordToWord16#"
# else
"narrowWord16#"
# endif
#endif
#if MIN_VERSION_base(4,16,0)
eqInt32HashValName :: Name
eqInt32HashValName :: Name
eqInt32HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"eqInt32#"
eqWord32HashValName :: Name
eqWord32HashValName :: Name
eqWord32HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"eqWord32#"
geInt32HashValName :: Name
geInt32HashValName :: Name
geInt32HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"geInt32#"
geWord32HashValName :: Name
geWord32HashValName :: Name
geWord32HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"geWord32#"
gtInt32HashValName :: Name
gtInt32HashValName :: Name
gtInt32HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"gtInt32#"
gtWord32HashValName :: Name
gtWord32HashValName :: Name
gtWord32HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"gtWord32#"
int32HashTypeName :: Name
int32HashTypeName :: Name
int32HashTypeName = String -> String -> String -> Name
mkNameG_tc String
"ghc-prim" String
"GHC.Prim" String
"Int32#"
int32ToIntHashValName :: Name
int32ToIntHashValName :: Name
int32ToIntHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"int32ToInt#"
intToInt32HashValName :: Name
intToInt32HashValName :: Name
intToInt32HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"intToInt32#"
leInt32HashValName :: Name
leInt32HashValName :: Name
leInt32HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"leInt32#"
leWord32HashValName :: Name
leWord32HashValName :: Name
leWord32HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"leWord32#"
ltInt32HashValName :: Name
ltInt32HashValName :: Name
ltInt32HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"ltInt32#"
ltWord32HashValName :: Name
ltWord32HashValName :: Name
ltWord32HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"ltWord32#"
word32HashTypeName :: Name
word32HashTypeName :: Name
word32HashTypeName = String -> String -> String -> Name
mkNameG_tc String
"ghc-prim" String
"GHC.Prim" String
"Word32#"
word32ToWordHashValName :: Name
word32ToWordHashValName :: Name
word32ToWordHashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"word32ToWord#"
wordToWord32HashValName :: Name
wordToWord32HashValName :: Name
wordToWord32HashValName = String -> String -> String -> Name
mkNameG_v String
"ghc-prim" String
"GHC.Prim" String
"wordToWord32#"
#endif