{-
(c) The GRASP/AQUA Project, Glasgow University, 1992-1998

\section[PrelNames]{Definitions of prelude modules and names}


Nota Bene: all Names defined in here should come from the base package

 - ModuleNames for prelude modules,
        e.g.    pREL_BASE_Name :: ModuleName

 - Modules for prelude modules
        e.g.    pREL_Base :: Module

 - Uniques for Ids, DataCons, TyCons and Classes that the compiler
   "knows about" in some way
        e.g.    intTyConKey :: Unique
                minusClassOpKey :: Unique

 - Names for Ids, DataCons, TyCons and Classes that the compiler
   "knows about" in some way
        e.g.    intTyConName :: Name
                minusName    :: Name
   One of these Names contains
        (a) the module and occurrence name of the thing
        (b) its Unique
   The way the compiler "knows about" one of these things is
   where the type checker or desugarer needs to look it up. For
   example, when desugaring list comprehensions the desugarer
   needs to conjure up 'foldr'.  It does this by looking up
   foldrName in the environment.

 - RdrNames for Ids, DataCons etc that the compiler may emit into
   generated code (e.g. for deriving).  It's not necessary to know
   the uniques for these guys, only their names


Note [Known-key names]
~~~~~~~~~~~~~~~~~~~~~~
It is *very* important that the compiler gives wired-in things and
things with "known-key" names the correct Uniques wherever they
occur. We have to be careful about this in exactly two places:

  1. When we parse some source code, renaming the AST better yield an
     AST whose Names have the correct uniques

  2. When we read an interface file, the read-in gubbins better have
     the right uniques

This is accomplished through a combination of mechanisms:

  1. When parsing source code, the RdrName-decorated AST has some
     RdrNames which are Exact. These are wired-in RdrNames where the
     we could directly tell from the parsed syntax what Name to
     use. For example, when we parse a [] in a type we can just insert
     an Exact RdrName Name with the listTyConKey.

     Currently, I believe this is just an optimisation: it would be
     equally valid to just output Orig RdrNames that correctly record
     the module etc we expect the final Name to come from. However,
     were we to eliminate isBuiltInOcc_maybe it would become essential
     (see point 3).

  2. The knownKeyNames (which consist of the basicKnownKeyNames from
     the module, and those names reachable via the wired-in stuff from
     TysWiredIn) are used to initialise the "OrigNameCache" in
     IfaceEnv.  This initialization ensures that when the type checker
     or renamer (both of which use IfaceEnv) look up an original name
     (i.e. a pair of a Module and an OccName) for a known-key name
     they get the correct Unique.

     This is the most important mechanism for ensuring that known-key
     stuff gets the right Unique, and is why it is so important to
     place your known-key names in the appropriate lists.

  3. For "infinite families" of known-key names (i.e. tuples and sums), we
     have to be extra careful. Because there are an infinite number of
     these things, we cannot add them to the list of known-key names
     used to initialise the OrigNameCache. Instead, we have to
     rely on never having to look them up in that cache. See
     Note [Infinite families of known-key names] for details.


Note [Infinite families of known-key names]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Infinite families of known-key things (e.g. tuples and sums) pose a tricky
problem: we can't add them to the knownKeyNames finite map which we use to
ensure that, e.g., a reference to (,) gets assigned the right unique (if this
doesn't sound familiar see Note [Known-key names] above).

We instead handle tuples and sums separately from the "vanilla" known-key
things,

  a) The parser recognises them specially and generates an Exact Name (hence not
     looked up in the orig-name cache)

  b) The known infinite families of names are specially serialised by
     BinIface.putName, with that special treatment detected when we read back to
     ensure that we get back to the correct uniques. See Note [Symbol table
     representation of names] in BinIface and Note [How tuples work] in
     TysWiredIn.

Most of the infinite families cannot occur in source code, so mechanisms (a) and (b)
suffice to ensure that they always have the right Unique. In particular,
implicit param TyCon names, constraint tuples and Any TyCons cannot be mentioned
by the user. For those things that *can* appear in source programs,

  c) IfaceEnv.lookupOrigNameCache uses isBuiltInOcc_maybe to map built-in syntax
     directly onto the corresponding name, rather than trying to find it in the
     original-name cache.

     See also Note [Built-in syntax and the OrigNameCache]


Note [The integer library]
~~~~~~~~~~~~~~~~~~~~~~~~~~

Clearly, we need to know the names of various definitions of the integer
library, e.g. the type itself, `mkInteger` etc. But there are two possible
implementations of the integer library:

 * integer-gmp (fast, but uses libgmp, which may not be available on all
   targets and is GPL licensed)
 * integer-simple (slow, but pure Haskell and BSD-licensed)

We want the compiler to work with either one. The way we achieve this is:

 * When compiling the integer-{gmp,simple} library, we pass
     -this-unit-id  integer-wired-in
   to GHC (see the cabal file libraries/integer-{gmp,simple}.
 * This way, GHC can use just this UnitID (see Module.integerUnitId) when
   generating code, and the linker will succeed.

Unfortuately, the abstraction is not complete: When using integer-gmp, we
really want to use the S# constructor directly. This is controlled by
the `integerLibrary` field of `DynFlags`: If it is IntegerGMP, we use
this constructor directly (see  CorePrep.lookupIntegerSDataConName)

When GHC reads the package data base, it (internally only) pretends it has UnitId
`integer-wired-in` instead of the actual UnitId (which includes the version
number); just like for `base` and other packages, as described in
Note [Wired-in packages] in Module. This is done in Packages.findWiredInPackages.
-}

{-# LANGUAGE CPP #-}

module PrelNames (
        Unique, Uniquable(..), hasKey,  -- Re-exported for convenience

        -----------------------------------------------------------
        module PrelNames,       -- A huge bunch of (a) Names,  e.g. intTyConName
                                --                 (b) Uniques e.g. intTyConKey
                                --                 (c) Groups of classes and types
                                --                 (d) miscellaneous things
                                -- So many that we export them all
    ) where

#include "HsVersions.h"

import GhcPrelude

import Module
import OccName
import RdrName
import Unique
import Name
import SrcLoc
import FastString

{-
************************************************************************
*                                                                      *
     allNameStrings
*                                                                      *
************************************************************************
-}

allNameStrings :: [String]
-- Infinite list of a,b,c...z, aa, ab, ac, ... etc
allNameStrings :: [String]
allNameStrings = [ Char
cChar -> String -> String
forall a. a -> [a] -> [a]
:String
cs | String
cs <- "" String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String]
allNameStrings, Char
c <- ['a'..'z'] ]

{-
************************************************************************
*                                                                      *
\subsection{Local Names}
*                                                                      *
************************************************************************

This *local* name is used by the interactive stuff
-}

itName :: Unique -> SrcSpan -> Name
itName :: Unique -> SrcSpan -> Name
itName uniq :: Unique
uniq loc :: SrcSpan
loc = Unique -> OccName -> SrcSpan -> Name
mkInternalName Unique
uniq (NameSpace -> FastString -> OccName
mkOccNameFS NameSpace
varName (String -> FastString
fsLit "it")) SrcSpan
loc

-- mkUnboundName makes a place-holder Name; it shouldn't be looked at except possibly
-- during compiler debugging.
mkUnboundName :: OccName -> Name
mkUnboundName :: OccName -> Name
mkUnboundName occ :: OccName
occ = Unique -> OccName -> SrcSpan -> Name
mkInternalName Unique
unboundKey OccName
occ SrcSpan
noSrcSpan

isUnboundName :: Name -> Bool
isUnboundName :: Name -> Bool
isUnboundName name :: Name
name = Name
name Name -> Unique -> Bool
forall a. Uniquable a => a -> Unique -> Bool
`hasKey` Unique
unboundKey

{-
************************************************************************
*                                                                      *
\subsection{Known key Names}
*                                                                      *
************************************************************************

This section tells what the compiler knows about the association of
names with uniques.  These ones are the *non* wired-in ones.  The
wired in ones are defined in TysWiredIn etc.
-}

basicKnownKeyNames :: [Name]  -- See Note [Known-key names]
basicKnownKeyNames :: [Name]
basicKnownKeyNames
 = [Name]
genericTyConNames
 [Name] -> [Name] -> [Name]
forall a. [a] -> [a] -> [a]
++ [   --  Classes.  *Must* include:
        --      classes that are grabbed by key (e.g., eqClassKey)
        --      classes in "Class.standardClassKeys" (quite a few)
        Name
eqClassName,                    -- mentioned, derivable
        Name
ordClassName,                   -- derivable
        Name
boundedClassName,               -- derivable
        Name
numClassName,                   -- mentioned, numeric
        Name
enumClassName,                  -- derivable
        Name
monadClassName,
        Name
functorClassName,
        Name
realClassName,                  -- numeric
        Name
integralClassName,              -- numeric
        Name
fractionalClassName,            -- numeric
        Name
floatingClassName,              -- numeric
        Name
realFracClassName,              -- numeric
        Name
realFloatClassName,             -- numeric
        Name
dataClassName,
        Name
isStringClassName,
        Name
applicativeClassName,
        Name
alternativeClassName,
        Name
foldableClassName,
        Name
traversableClassName,
        Name
semigroupClassName, Name
sappendName,
        Name
monoidClassName, Name
memptyName, Name
mappendName, Name
mconcatName,

        -- The IO type
        -- See Note [TyConRepNames for non-wired-in TyCons]
        Name
ioTyConName, Name
ioDataConName,
        Name
runMainIOName,
        Name
runRWName,

        -- Type representation types
        Name
trModuleTyConName, Name
trModuleDataConName,
        Name
trNameTyConName, Name
trNameSDataConName, Name
trNameDDataConName,
        Name
trTyConTyConName, Name
trTyConDataConName,

        -- Typeable
        Name
typeableClassName,
        Name
typeRepTyConName,
        Name
someTypeRepTyConName,
        Name
someTypeRepDataConName,
        Name
kindRepTyConName,
        Name
kindRepTyConAppDataConName,
        Name
kindRepVarDataConName,
        Name
kindRepAppDataConName,
        Name
kindRepFunDataConName,
        Name
kindRepTYPEDataConName,
        Name
kindRepTypeLitSDataConName,
        Name
kindRepTypeLitDDataConName,
        Name
typeLitSortTyConName,
        Name
typeLitSymbolDataConName,
        Name
typeLitNatDataConName,
        Name
typeRepIdName,
        Name
mkTrTypeName,
        Name
mkTrConName,
        Name
mkTrAppName,
        Name
mkTrFunName,
        Name
typeSymbolTypeRepName, Name
typeNatTypeRepName,
        Name
trGhcPrimModuleName,

        -- KindReps for common cases
        Name
starKindRepName,
        Name
starArrStarKindRepName,
        Name
starArrStarArrStarKindRepName,

        -- Dynamic
        Name
toDynName,

        -- Numeric stuff
        Name
negateName, Name
minusName, Name
geName, Name
eqName,

        -- Conversion functions
        Name
rationalTyConName,
        Name
ratioTyConName, Name
ratioDataConName,
        Name
fromRationalName, Name
fromIntegerName,
        Name
toIntegerName, Name
toRationalName,
        Name
fromIntegralName, Name
realToFracName,

        -- Int# stuff
        Name
divIntName, Name
modIntName,

        -- String stuff
        Name
fromStringName,

        -- Enum stuff
        Name
enumFromName, Name
enumFromThenName,
        Name
enumFromThenToName, Name
enumFromToName,

        -- Applicative stuff
        Name
pureAName, Name
apAName, Name
thenAName,

        -- Functor stuff
        Name
fmapName,

        -- Monad stuff
        Name
thenIOName, Name
bindIOName, Name
returnIOName, Name
failIOName, Name
bindMName, Name
thenMName,
        Name
returnMName, Name
joinMName,

        -- MonadFail
        Name
monadFailClassName, Name
failMName,

        -- MonadFix
        Name
monadFixClassName, Name
mfixName,

        -- Arrow stuff
        Name
arrAName, Name
composeAName, Name
firstAName,
        Name
appAName, Name
choiceAName, Name
loopAName,

        -- Ix stuff
        Name
ixClassName,

        -- Show stuff
        Name
showClassName,

        -- Read stuff
        Name
readClassName,

        -- Stable pointers
        Name
newStablePtrName,

        -- GHC Extensions
        Name
groupWithName,

        -- Strings and lists
        Name
unpackCStringName,
        Name
unpackCStringFoldrName, Name
unpackCStringUtf8Name,

        -- Overloaded lists
        Name
isListClassName,
        Name
fromListName,
        Name
fromListNName,
        Name
toListName,

        -- List operations
        Name
concatName, Name
filterName, Name
mapName,
        Name
zipName, Name
foldrName, Name
buildName, Name
augmentName, Name
appendName,

        -- FFI primitive types that are not wired-in.
        Name
stablePtrTyConName, Name
ptrTyConName, Name
funPtrTyConName,
        Name
int8TyConName, Name
int16TyConName, Name
int32TyConName, Name
int64TyConName,
        Name
word16TyConName, Name
word32TyConName, Name
word64TyConName,

        -- Others
        Name
otherwiseIdName, Name
inlineIdName,
        Name
eqStringName, Name
assertName, Name
breakpointName, Name
breakpointCondName,
        Name
breakpointAutoName,  Name
opaqueTyConName,
        Name
assertErrorName, Name
traceName,
        Name
printName, Name
fstName, Name
sndName,
        Name
dollarName,

        -- Integer
        Name
integerTyConName, Name
mkIntegerName,
        Name
integerToWord64Name, Name
integerToInt64Name,
        Name
word64ToIntegerName, Name
int64ToIntegerName,
        Name
plusIntegerName, Name
timesIntegerName, Name
smallIntegerName,
        Name
wordToIntegerName,
        Name
integerToWordName, Name
integerToIntName, Name
minusIntegerName,
        Name
negateIntegerName, Name
eqIntegerPrimName, Name
neqIntegerPrimName,
        Name
absIntegerName, Name
signumIntegerName,
        Name
leIntegerPrimName, Name
gtIntegerPrimName, Name
ltIntegerPrimName, Name
geIntegerPrimName,
        Name
compareIntegerName, Name
quotRemIntegerName, Name
divModIntegerName,
        Name
quotIntegerName, Name
remIntegerName, Name
divIntegerName, Name
modIntegerName,
        Name
floatFromIntegerName, Name
doubleFromIntegerName,
        Name
encodeFloatIntegerName, Name
encodeDoubleIntegerName,
        Name
decodeDoubleIntegerName,
        Name
gcdIntegerName, Name
lcmIntegerName,
        Name
andIntegerName, Name
orIntegerName, Name
xorIntegerName, Name
complementIntegerName,
        Name
shiftLIntegerName, Name
shiftRIntegerName, Name
bitIntegerName,
        Name
integerSDataConName,Name
naturalSDataConName,

        -- Natural
        Name
naturalTyConName,
        Name
naturalFromIntegerName, Name
naturalToIntegerName,
        Name
plusNaturalName, Name
minusNaturalName, Name
timesNaturalName, Name
mkNaturalName,
        Name
wordToNaturalName,

        -- Float/Double
        Name
rationalToFloatName,
        Name
rationalToDoubleName,

        -- Other classes
        Name
randomClassName, Name
randomGenClassName, Name
monadPlusClassName,

        -- Type-level naturals
        Name
knownNatClassName, Name
knownSymbolClassName,

        -- Overloaded labels
        Name
isLabelClassName,

        -- Implicit Parameters
        Name
ipClassName,

        -- Overloaded record fields
        Name
hasFieldClassName,

        -- Call Stacks
        Name
callStackTyConName,
        Name
emptyCallStackName, Name
pushCallStackName,

        -- Source Locations
        Name
srcLocDataConName,

        -- Annotation type checking
        Name
toAnnotationWrapperName

        -- The Ordering type
        , Name
orderingTyConName
        , Name
ordLTDataConName, Name
ordEQDataConName, Name
ordGTDataConName

        -- The SPEC type for SpecConstr
        , Name
specTyConName

        -- The Either type
        , Name
eitherTyConName, Name
leftDataConName, Name
rightDataConName

        -- Plugins
        , Name
pluginTyConName
        , Name
frontendPluginTyConName

        -- Generics
        , Name
genClassName, Name
gen1ClassName
        , Name
datatypeClassName, Name
constructorClassName, Name
selectorClassName

        -- Monad comprehensions
        , Name
guardMName
        , Name
liftMName
        , Name
mzipName

        -- GHCi Sandbox
        , Name
ghciIoClassName, Name
ghciStepIoMName

        -- StaticPtr
        , Name
makeStaticName
        , Name
staticPtrTyConName
        , Name
staticPtrDataConName, Name
staticPtrInfoDataConName
        , Name
fromStaticPtrName

        -- Fingerprint
        , Name
fingerprintDataConName

        -- Custom type errors
        , Name
errorMessageTypeErrorFamName
        , Name
typeErrorTextDataConName
        , Name
typeErrorAppendDataConName
        , Name
typeErrorVAppendDataConName
        , Name
typeErrorShowTypeDataConName

    ]

genericTyConNames :: [Name]
genericTyConNames :: [Name]
genericTyConNames = [
    Name
v1TyConName, Name
u1TyConName, Name
par1TyConName, Name
rec1TyConName,
    Name
k1TyConName, Name
m1TyConName, Name
sumTyConName, Name
prodTyConName,
    Name
compTyConName, Name
rTyConName, Name
dTyConName,
    Name
cTyConName, Name
sTyConName, Name
rec0TyConName,
    Name
d1TyConName, Name
c1TyConName, Name
s1TyConName, Name
noSelTyConName,
    Name
repTyConName, Name
rep1TyConName, Name
uRecTyConName,
    Name
uAddrTyConName, Name
uCharTyConName, Name
uDoubleTyConName,
    Name
uFloatTyConName, Name
uIntTyConName, Name
uWordTyConName,
    Name
prefixIDataConName, Name
infixIDataConName, Name
leftAssociativeDataConName,
    Name
rightAssociativeDataConName, Name
notAssociativeDataConName,
    Name
sourceUnpackDataConName, Name
sourceNoUnpackDataConName,
    Name
noSourceUnpackednessDataConName, Name
sourceLazyDataConName,
    Name
sourceStrictDataConName, Name
noSourceStrictnessDataConName,
    Name
decidedLazyDataConName, Name
decidedStrictDataConName, Name
decidedUnpackDataConName,
    Name
metaDataDataConName, Name
metaConsDataConName, Name
metaSelDataConName
  ]

{-
************************************************************************
*                                                                      *
\subsection{Module names}
*                                                                      *
************************************************************************


--MetaHaskell Extension Add a new module here
-}

pRELUDE :: Module
pRELUDE :: Module
pRELUDE         = ModuleName -> Module
mkBaseModule_ ModuleName
pRELUDE_NAME

gHC_PRIM, gHC_TYPES, gHC_GENERICS, gHC_MAGIC,
    gHC_CLASSES, gHC_PRIMOPWRAPPERS, gHC_BASE, gHC_ENUM,
    gHC_GHCI, gHC_GHCI_HELPERS, gHC_CSTRING,
    gHC_SHOW, gHC_READ, gHC_NUM, gHC_MAYBE, gHC_INTEGER_TYPE, gHC_NATURAL,
    gHC_LIST, gHC_TUPLE, dATA_TUPLE, dATA_EITHER, dATA_STRING,
    dATA_FOLDABLE, dATA_TRAVERSABLE,
    gHC_CONC, gHC_IO, gHC_IO_Exception,
    gHC_ST, gHC_ARR, gHC_STABLE, gHC_PTR, gHC_ERR, gHC_REAL,
    gHC_FLOAT, gHC_TOP_HANDLER, sYSTEM_IO, dYNAMIC,
    tYPEABLE, tYPEABLE_INTERNAL, gENERICS,
    rEAD_PREC, lEX, gHC_INT, gHC_WORD, mONAD, mONAD_FIX, mONAD_ZIP, mONAD_FAIL,
    aRROW, cONTROL_APPLICATIVE, gHC_DESUGAR, rANDOM, gHC_EXTS,
    cONTROL_EXCEPTION_BASE, gHC_TYPELITS, gHC_TYPENATS, dATA_TYPE_EQUALITY,
    dATA_COERCE, dEBUG_TRACE :: Module

gHC_PRIM :: Module
gHC_PRIM        = FastString -> Module
mkPrimModule (String -> FastString
fsLit "GHC.Prim")   -- Primitive types and values
gHC_TYPES :: Module
gHC_TYPES       = FastString -> Module
mkPrimModule (String -> FastString
fsLit "GHC.Types")
gHC_MAGIC :: Module
gHC_MAGIC       = FastString -> Module
mkPrimModule (String -> FastString
fsLit "GHC.Magic")
gHC_CSTRING :: Module
gHC_CSTRING     = FastString -> Module
mkPrimModule (String -> FastString
fsLit "GHC.CString")
gHC_CLASSES :: Module
gHC_CLASSES     = FastString -> Module
mkPrimModule (String -> FastString
fsLit "GHC.Classes")
gHC_PRIMOPWRAPPERS :: Module
gHC_PRIMOPWRAPPERS = FastString -> Module
mkPrimModule (String -> FastString
fsLit "GHC.PrimopWrappers")

gHC_BASE :: Module
gHC_BASE        = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.Base")
gHC_ENUM :: Module
gHC_ENUM        = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.Enum")
gHC_GHCI :: Module
gHC_GHCI        = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.GHCi")
gHC_GHCI_HELPERS :: Module
gHC_GHCI_HELPERS= FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.GHCi.Helpers")
gHC_SHOW :: Module
gHC_SHOW        = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.Show")
gHC_READ :: Module
gHC_READ        = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.Read")
gHC_NUM :: Module
gHC_NUM         = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.Num")
gHC_MAYBE :: Module
gHC_MAYBE       = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.Maybe")
gHC_INTEGER_TYPE :: Module
gHC_INTEGER_TYPE= FastString -> Module
mkIntegerModule (String -> FastString
fsLit "GHC.Integer.Type")
gHC_NATURAL :: Module
gHC_NATURAL     = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.Natural")
gHC_LIST :: Module
gHC_LIST        = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.List")
gHC_TUPLE :: Module
gHC_TUPLE       = FastString -> Module
mkPrimModule (String -> FastString
fsLit "GHC.Tuple")
dATA_TUPLE :: Module
dATA_TUPLE      = FastString -> Module
mkBaseModule (String -> FastString
fsLit "Data.Tuple")
dATA_EITHER :: Module
dATA_EITHER     = FastString -> Module
mkBaseModule (String -> FastString
fsLit "Data.Either")
dATA_STRING :: Module
dATA_STRING     = FastString -> Module
mkBaseModule (String -> FastString
fsLit "Data.String")
dATA_FOLDABLE :: Module
dATA_FOLDABLE   = FastString -> Module
mkBaseModule (String -> FastString
fsLit "Data.Foldable")
dATA_TRAVERSABLE :: Module
dATA_TRAVERSABLE= FastString -> Module
mkBaseModule (String -> FastString
fsLit "Data.Traversable")
gHC_CONC :: Module
gHC_CONC        = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.Conc")
gHC_IO :: Module
gHC_IO          = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.IO")
gHC_IO_Exception :: Module
gHC_IO_Exception = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.IO.Exception")
gHC_ST :: Module
gHC_ST          = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.ST")
gHC_ARR :: Module
gHC_ARR         = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.Arr")
gHC_STABLE :: Module
gHC_STABLE      = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.Stable")
gHC_PTR :: Module
gHC_PTR         = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.Ptr")
gHC_ERR :: Module
gHC_ERR         = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.Err")
gHC_REAL :: Module
gHC_REAL        = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.Real")
gHC_FLOAT :: Module
gHC_FLOAT       = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.Float")
gHC_TOP_HANDLER :: Module
gHC_TOP_HANDLER = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.TopHandler")
sYSTEM_IO :: Module
sYSTEM_IO       = FastString -> Module
mkBaseModule (String -> FastString
fsLit "System.IO")
dYNAMIC :: Module
dYNAMIC         = FastString -> Module
mkBaseModule (String -> FastString
fsLit "Data.Dynamic")
tYPEABLE :: Module
tYPEABLE        = FastString -> Module
mkBaseModule (String -> FastString
fsLit "Data.Typeable")
tYPEABLE_INTERNAL :: Module
tYPEABLE_INTERNAL = FastString -> Module
mkBaseModule (String -> FastString
fsLit "Data.Typeable.Internal")
gENERICS :: Module
gENERICS        = FastString -> Module
mkBaseModule (String -> FastString
fsLit "Data.Data")
rEAD_PREC :: Module
rEAD_PREC       = FastString -> Module
mkBaseModule (String -> FastString
fsLit "Text.ParserCombinators.ReadPrec")
lEX :: Module
lEX             = FastString -> Module
mkBaseModule (String -> FastString
fsLit "Text.Read.Lex")
gHC_INT :: Module
gHC_INT         = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.Int")
gHC_WORD :: Module
gHC_WORD        = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.Word")
mONAD :: Module
mONAD           = FastString -> Module
mkBaseModule (String -> FastString
fsLit "Control.Monad")
mONAD_FIX :: Module
mONAD_FIX       = FastString -> Module
mkBaseModule (String -> FastString
fsLit "Control.Monad.Fix")
mONAD_ZIP :: Module
mONAD_ZIP       = FastString -> Module
mkBaseModule (String -> FastString
fsLit "Control.Monad.Zip")
mONAD_FAIL :: Module
mONAD_FAIL      = FastString -> Module
mkBaseModule (String -> FastString
fsLit "Control.Monad.Fail")
aRROW :: Module
aRROW           = FastString -> Module
mkBaseModule (String -> FastString
fsLit "Control.Arrow")
cONTROL_APPLICATIVE :: Module
cONTROL_APPLICATIVE = FastString -> Module
mkBaseModule (String -> FastString
fsLit "Control.Applicative")
gHC_DESUGAR :: Module
gHC_DESUGAR = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.Desugar")
rANDOM :: Module
rANDOM          = FastString -> Module
mkBaseModule (String -> FastString
fsLit "System.Random")
gHC_EXTS :: Module
gHC_EXTS        = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.Exts")
cONTROL_EXCEPTION_BASE :: Module
cONTROL_EXCEPTION_BASE = FastString -> Module
mkBaseModule (String -> FastString
fsLit "Control.Exception.Base")
gHC_GENERICS :: Module
gHC_GENERICS    = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.Generics")
gHC_TYPELITS :: Module
gHC_TYPELITS    = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.TypeLits")
gHC_TYPENATS :: Module
gHC_TYPENATS    = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.TypeNats")
dATA_TYPE_EQUALITY :: Module
dATA_TYPE_EQUALITY = FastString -> Module
mkBaseModule (String -> FastString
fsLit "Data.Type.Equality")
dATA_COERCE :: Module
dATA_COERCE     = FastString -> Module
mkBaseModule (String -> FastString
fsLit "Data.Coerce")
dEBUG_TRACE :: Module
dEBUG_TRACE     = FastString -> Module
mkBaseModule (String -> FastString
fsLit "Debug.Trace")

gHC_SRCLOC :: Module
gHC_SRCLOC :: Module
gHC_SRCLOC = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.SrcLoc")

gHC_STACK, gHC_STACK_TYPES :: Module
gHC_STACK :: Module
gHC_STACK = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.Stack")
gHC_STACK_TYPES :: Module
gHC_STACK_TYPES = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.Stack.Types")

gHC_STATICPTR :: Module
gHC_STATICPTR :: Module
gHC_STATICPTR = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.StaticPtr")

gHC_STATICPTR_INTERNAL :: Module
gHC_STATICPTR_INTERNAL :: Module
gHC_STATICPTR_INTERNAL = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.StaticPtr.Internal")

gHC_FINGERPRINT_TYPE :: Module
gHC_FINGERPRINT_TYPE :: Module
gHC_FINGERPRINT_TYPE = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.Fingerprint.Type")

gHC_OVER_LABELS :: Module
gHC_OVER_LABELS :: Module
gHC_OVER_LABELS = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.OverloadedLabels")

gHC_RECORDS :: Module
gHC_RECORDS :: Module
gHC_RECORDS = FastString -> Module
mkBaseModule (String -> FastString
fsLit "GHC.Records")

mAIN, rOOT_MAIN :: Module
mAIN :: Module
mAIN            = ModuleName -> Module
mkMainModule_ ModuleName
mAIN_NAME
rOOT_MAIN :: Module
rOOT_MAIN       = FastString -> Module
mkMainModule (String -> FastString
fsLit ":Main") -- Root module for initialisation

mkInteractiveModule :: Int -> Module
-- (mkInteractiveMoudule 9) makes module 'interactive:M9'
mkInteractiveModule :: Int -> Module
mkInteractiveModule n :: Int
n = UnitId -> ModuleName -> Module
mkModule UnitId
interactiveUnitId (String -> ModuleName
mkModuleName ("Ghci" String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
n))

pRELUDE_NAME, mAIN_NAME :: ModuleName
pRELUDE_NAME :: ModuleName
pRELUDE_NAME   = FastString -> ModuleName
mkModuleNameFS (String -> FastString
fsLit "Prelude")
mAIN_NAME :: ModuleName
mAIN_NAME      = FastString -> ModuleName
mkModuleNameFS (String -> FastString
fsLit "Main")

dATA_ARRAY_PARALLEL_NAME, dATA_ARRAY_PARALLEL_PRIM_NAME :: ModuleName
dATA_ARRAY_PARALLEL_NAME :: ModuleName
dATA_ARRAY_PARALLEL_NAME      = FastString -> ModuleName
mkModuleNameFS (String -> FastString
fsLit "Data.Array.Parallel")
dATA_ARRAY_PARALLEL_PRIM_NAME :: ModuleName
dATA_ARRAY_PARALLEL_PRIM_NAME = FastString -> ModuleName
mkModuleNameFS (String -> FastString
fsLit "Data.Array.Parallel.Prim")

mkPrimModule :: FastString -> Module
mkPrimModule :: FastString -> Module
mkPrimModule m :: FastString
m = UnitId -> ModuleName -> Module
mkModule UnitId
primUnitId (FastString -> ModuleName
mkModuleNameFS FastString
m)

mkIntegerModule :: FastString -> Module
mkIntegerModule :: FastString -> Module
mkIntegerModule m :: FastString
m = UnitId -> ModuleName -> Module
mkModule UnitId
integerUnitId (FastString -> ModuleName
mkModuleNameFS FastString
m)

mkBaseModule :: FastString -> Module
mkBaseModule :: FastString -> Module
mkBaseModule m :: FastString
m = UnitId -> ModuleName -> Module
mkModule UnitId
baseUnitId (FastString -> ModuleName
mkModuleNameFS FastString
m)

mkBaseModule_ :: ModuleName -> Module
mkBaseModule_ :: ModuleName -> Module
mkBaseModule_ m :: ModuleName
m = UnitId -> ModuleName -> Module
mkModule UnitId
baseUnitId ModuleName
m

mkThisGhcModule :: FastString -> Module
mkThisGhcModule :: FastString -> Module
mkThisGhcModule m :: FastString
m = UnitId -> ModuleName -> Module
mkModule UnitId
thisGhcUnitId (FastString -> ModuleName
mkModuleNameFS FastString
m)

mkThisGhcModule_ :: ModuleName -> Module
mkThisGhcModule_ :: ModuleName -> Module
mkThisGhcModule_ m :: ModuleName
m = UnitId -> ModuleName -> Module
mkModule UnitId
thisGhcUnitId ModuleName
m

mkMainModule :: FastString -> Module
mkMainModule :: FastString -> Module
mkMainModule m :: FastString
m = UnitId -> ModuleName -> Module
mkModule UnitId
mainUnitId (FastString -> ModuleName
mkModuleNameFS FastString
m)

mkMainModule_ :: ModuleName -> Module
mkMainModule_ :: ModuleName -> Module
mkMainModule_ m :: ModuleName
m = UnitId -> ModuleName -> Module
mkModule UnitId
mainUnitId ModuleName
m

{-
************************************************************************
*                                                                      *
                        RdrNames
*                                                                      *
************************************************************************
-}

main_RDR_Unqual    :: RdrName
main_RDR_Unqual :: RdrName
main_RDR_Unqual = NameSpace -> FastString -> RdrName
mkUnqual NameSpace
varName (String -> FastString
fsLit "main")
        -- We definitely don't want an Orig RdrName, because
        -- main might, in principle, be imported into module Main

eq_RDR, ge_RDR, le_RDR, lt_RDR, gt_RDR, compare_RDR,
    ltTag_RDR, eqTag_RDR, gtTag_RDR :: RdrName
eq_RDR :: RdrName
eq_RDR                  = Name -> RdrName
nameRdrName Name
eqName
ge_RDR :: RdrName
ge_RDR                  = Name -> RdrName
nameRdrName Name
geName
le_RDR :: RdrName
le_RDR                  = Module -> FastString -> RdrName
varQual_RDR  Module
gHC_CLASSES (String -> FastString
fsLit "<=")
lt_RDR :: RdrName
lt_RDR                  = Module -> FastString -> RdrName
varQual_RDR  Module
gHC_CLASSES (String -> FastString
fsLit "<")
gt_RDR :: RdrName
gt_RDR                  = Module -> FastString -> RdrName
varQual_RDR  Module
gHC_CLASSES (String -> FastString
fsLit ">")
compare_RDR :: RdrName
compare_RDR             = Module -> FastString -> RdrName
varQual_RDR  Module
gHC_CLASSES (String -> FastString
fsLit "compare")
ltTag_RDR :: RdrName
ltTag_RDR               = Name -> RdrName
nameRdrName  Name
ordLTDataConName
eqTag_RDR :: RdrName
eqTag_RDR               = Name -> RdrName
nameRdrName  Name
ordEQDataConName
gtTag_RDR :: RdrName
gtTag_RDR               = Name -> RdrName
nameRdrName  Name
ordGTDataConName

eqClass_RDR, numClass_RDR, ordClass_RDR, enumClass_RDR, monadClass_RDR
    :: RdrName
eqClass_RDR :: RdrName
eqClass_RDR             = Name -> RdrName
nameRdrName Name
eqClassName
numClass_RDR :: RdrName
numClass_RDR            = Name -> RdrName
nameRdrName Name
numClassName
ordClass_RDR :: RdrName
ordClass_RDR            = Name -> RdrName
nameRdrName Name
ordClassName
enumClass_RDR :: RdrName
enumClass_RDR           = Name -> RdrName
nameRdrName Name
enumClassName
monadClass_RDR :: RdrName
monadClass_RDR          = Name -> RdrName
nameRdrName Name
monadClassName

map_RDR, append_RDR :: RdrName
map_RDR :: RdrName
map_RDR                 = Name -> RdrName
nameRdrName Name
mapName
append_RDR :: RdrName
append_RDR              = Name -> RdrName
nameRdrName Name
appendName

foldr_RDR, build_RDR, returnM_RDR, bindM_RDR, failM_RDR
    :: RdrName
foldr_RDR :: RdrName
foldr_RDR               = Name -> RdrName
nameRdrName Name
foldrName
build_RDR :: RdrName
build_RDR               = Name -> RdrName
nameRdrName Name
buildName
returnM_RDR :: RdrName
returnM_RDR             = Name -> RdrName
nameRdrName Name
returnMName
bindM_RDR :: RdrName
bindM_RDR               = Name -> RdrName
nameRdrName Name
bindMName
failM_RDR :: RdrName
failM_RDR               = Name -> RdrName
nameRdrName Name
failMName

left_RDR, right_RDR :: RdrName
left_RDR :: RdrName
left_RDR                = Name -> RdrName
nameRdrName Name
leftDataConName
right_RDR :: RdrName
right_RDR               = Name -> RdrName
nameRdrName Name
rightDataConName

fromEnum_RDR, toEnum_RDR :: RdrName
fromEnum_RDR :: RdrName
fromEnum_RDR            = Module -> FastString -> RdrName
varQual_RDR Module
gHC_ENUM (String -> FastString
fsLit "fromEnum")
toEnum_RDR :: RdrName
toEnum_RDR              = Module -> FastString -> RdrName
varQual_RDR Module
gHC_ENUM (String -> FastString
fsLit "toEnum")

enumFrom_RDR, enumFromTo_RDR, enumFromThen_RDR, enumFromThenTo_RDR :: RdrName
enumFrom_RDR :: RdrName
enumFrom_RDR            = Name -> RdrName
nameRdrName Name
enumFromName
enumFromTo_RDR :: RdrName
enumFromTo_RDR          = Name -> RdrName
nameRdrName Name
enumFromToName
enumFromThen_RDR :: RdrName
enumFromThen_RDR        = Name -> RdrName
nameRdrName Name
enumFromThenName
enumFromThenTo_RDR :: RdrName
enumFromThenTo_RDR      = Name -> RdrName
nameRdrName Name
enumFromThenToName

ratioDataCon_RDR, plusInteger_RDR, timesInteger_RDR :: RdrName
ratioDataCon_RDR :: RdrName
ratioDataCon_RDR        = Name -> RdrName
nameRdrName Name
ratioDataConName
plusInteger_RDR :: RdrName
plusInteger_RDR         = Name -> RdrName
nameRdrName Name
plusIntegerName
timesInteger_RDR :: RdrName
timesInteger_RDR        = Name -> RdrName
nameRdrName Name
timesIntegerName

ioDataCon_RDR :: RdrName
ioDataCon_RDR :: RdrName
ioDataCon_RDR           = Name -> RdrName
nameRdrName Name
ioDataConName

eqString_RDR, unpackCString_RDR, unpackCStringFoldr_RDR,
    unpackCStringUtf8_RDR :: RdrName
eqString_RDR :: RdrName
eqString_RDR            = Name -> RdrName
nameRdrName Name
eqStringName
unpackCString_RDR :: RdrName
unpackCString_RDR       = Name -> RdrName
nameRdrName Name
unpackCStringName
unpackCStringFoldr_RDR :: RdrName
unpackCStringFoldr_RDR  = Name -> RdrName
nameRdrName Name
unpackCStringFoldrName
unpackCStringUtf8_RDR :: RdrName
unpackCStringUtf8_RDR   = Name -> RdrName
nameRdrName Name
unpackCStringUtf8Name

newStablePtr_RDR :: RdrName
newStablePtr_RDR :: RdrName
newStablePtr_RDR        = Name -> RdrName
nameRdrName Name
newStablePtrName

bindIO_RDR, returnIO_RDR :: RdrName
bindIO_RDR :: RdrName
bindIO_RDR              = Name -> RdrName
nameRdrName Name
bindIOName
returnIO_RDR :: RdrName
returnIO_RDR            = Name -> RdrName
nameRdrName Name
returnIOName

fromInteger_RDR, fromRational_RDR, minus_RDR, times_RDR, plus_RDR :: RdrName
fromInteger_RDR :: RdrName
fromInteger_RDR         = Name -> RdrName
nameRdrName Name
fromIntegerName
fromRational_RDR :: RdrName
fromRational_RDR        = Name -> RdrName
nameRdrName Name
fromRationalName
minus_RDR :: RdrName
minus_RDR               = Name -> RdrName
nameRdrName Name
minusName
times_RDR :: RdrName
times_RDR               = Module -> FastString -> RdrName
varQual_RDR  Module
gHC_NUM (String -> FastString
fsLit "*")
plus_RDR :: RdrName
plus_RDR                = Module -> FastString -> RdrName
varQual_RDR Module
gHC_NUM (String -> FastString
fsLit "+")

toInteger_RDR, toRational_RDR, fromIntegral_RDR :: RdrName
toInteger_RDR :: RdrName
toInteger_RDR           = Name -> RdrName
nameRdrName Name
toIntegerName
toRational_RDR :: RdrName
toRational_RDR          = Name -> RdrName
nameRdrName Name
toRationalName
fromIntegral_RDR :: RdrName
fromIntegral_RDR        = Name -> RdrName
nameRdrName Name
fromIntegralName

stringTy_RDR, fromString_RDR :: RdrName
stringTy_RDR :: RdrName
stringTy_RDR            = Module -> FastString -> RdrName
tcQual_RDR Module
gHC_BASE (String -> FastString
fsLit "String")
fromString_RDR :: RdrName
fromString_RDR          = Name -> RdrName
nameRdrName Name
fromStringName

fromList_RDR, fromListN_RDR, toList_RDR :: RdrName
fromList_RDR :: RdrName
fromList_RDR = Name -> RdrName
nameRdrName Name
fromListName
fromListN_RDR :: RdrName
fromListN_RDR = Name -> RdrName
nameRdrName Name
fromListNName
toList_RDR :: RdrName
toList_RDR = Name -> RdrName
nameRdrName Name
toListName

compose_RDR :: RdrName
compose_RDR :: RdrName
compose_RDR             = Module -> FastString -> RdrName
varQual_RDR Module
gHC_BASE (String -> FastString
fsLit ".")

not_RDR, getTag_RDR, succ_RDR, pred_RDR, minBound_RDR, maxBound_RDR,
    and_RDR, range_RDR, inRange_RDR, index_RDR,
    unsafeIndex_RDR, unsafeRangeSize_RDR :: RdrName
and_RDR :: RdrName
and_RDR                 = Module -> FastString -> RdrName
varQual_RDR Module
gHC_CLASSES (String -> FastString
fsLit "&&")
not_RDR :: RdrName
not_RDR                 = Module -> FastString -> RdrName
varQual_RDR Module
gHC_CLASSES (String -> FastString
fsLit "not")
getTag_RDR :: RdrName
getTag_RDR              = Module -> FastString -> RdrName
varQual_RDR Module
gHC_BASE (String -> FastString
fsLit "getTag")
succ_RDR :: RdrName
succ_RDR                = Module -> FastString -> RdrName
varQual_RDR Module
gHC_ENUM (String -> FastString
fsLit "succ")
pred_RDR :: RdrName
pred_RDR                = Module -> FastString -> RdrName
varQual_RDR Module
gHC_ENUM (String -> FastString
fsLit "pred")
minBound_RDR :: RdrName
minBound_RDR            = Module -> FastString -> RdrName
varQual_RDR Module
gHC_ENUM (String -> FastString
fsLit "minBound")
maxBound_RDR :: RdrName
maxBound_RDR            = Module -> FastString -> RdrName
varQual_RDR Module
gHC_ENUM (String -> FastString
fsLit "maxBound")
range_RDR :: RdrName
range_RDR               = Module -> FastString -> RdrName
varQual_RDR Module
gHC_ARR (String -> FastString
fsLit "range")
inRange_RDR :: RdrName
inRange_RDR             = Module -> FastString -> RdrName
varQual_RDR Module
gHC_ARR (String -> FastString
fsLit "inRange")
index_RDR :: RdrName
index_RDR               = Module -> FastString -> RdrName
varQual_RDR Module
gHC_ARR (String -> FastString
fsLit "index")
unsafeIndex_RDR :: RdrName
unsafeIndex_RDR         = Module -> FastString -> RdrName
varQual_RDR Module
gHC_ARR (String -> FastString
fsLit "unsafeIndex")
unsafeRangeSize_RDR :: RdrName
unsafeRangeSize_RDR     = Module -> FastString -> RdrName
varQual_RDR Module
gHC_ARR (String -> FastString
fsLit "unsafeRangeSize")

readList_RDR, readListDefault_RDR, readListPrec_RDR, readListPrecDefault_RDR,
    readPrec_RDR, parens_RDR, choose_RDR, lexP_RDR, expectP_RDR :: RdrName
readList_RDR :: RdrName
readList_RDR            = Module -> FastString -> RdrName
varQual_RDR Module
gHC_READ (String -> FastString
fsLit "readList")
readListDefault_RDR :: RdrName
readListDefault_RDR     = Module -> FastString -> RdrName
varQual_RDR Module
gHC_READ (String -> FastString
fsLit "readListDefault")
readListPrec_RDR :: RdrName
readListPrec_RDR        = Module -> FastString -> RdrName
varQual_RDR Module
gHC_READ (String -> FastString
fsLit "readListPrec")
readListPrecDefault_RDR :: RdrName
readListPrecDefault_RDR = Module -> FastString -> RdrName
varQual_RDR Module
gHC_READ (String -> FastString
fsLit "readListPrecDefault")
readPrec_RDR :: RdrName
readPrec_RDR            = Module -> FastString -> RdrName
varQual_RDR Module
gHC_READ (String -> FastString
fsLit "readPrec")
parens_RDR :: RdrName
parens_RDR              = Module -> FastString -> RdrName
varQual_RDR Module
gHC_READ (String -> FastString
fsLit "parens")
choose_RDR :: RdrName
choose_RDR              = Module -> FastString -> RdrName
varQual_RDR Module
gHC_READ (String -> FastString
fsLit "choose")
lexP_RDR :: RdrName
lexP_RDR                = Module -> FastString -> RdrName
varQual_RDR Module
gHC_READ (String -> FastString
fsLit "lexP")
expectP_RDR :: RdrName
expectP_RDR             = Module -> FastString -> RdrName
varQual_RDR Module
gHC_READ (String -> FastString
fsLit "expectP")

readField_RDR, readFieldHash_RDR, readSymField_RDR :: RdrName
readField_RDR :: RdrName
readField_RDR           = Module -> FastString -> RdrName
varQual_RDR Module
gHC_READ (String -> FastString
fsLit "readField")
readFieldHash_RDR :: RdrName
readFieldHash_RDR       = Module -> FastString -> RdrName
varQual_RDR Module
gHC_READ (String -> FastString
fsLit "readFieldHash")
readSymField_RDR :: RdrName
readSymField_RDR        = Module -> FastString -> RdrName
varQual_RDR Module
gHC_READ (String -> FastString
fsLit "readSymField")

punc_RDR, ident_RDR, symbol_RDR :: RdrName
punc_RDR :: RdrName
punc_RDR                = Module -> FastString -> RdrName
dataQual_RDR Module
lEX (String -> FastString
fsLit "Punc")
ident_RDR :: RdrName
ident_RDR               = Module -> FastString -> RdrName
dataQual_RDR Module
lEX (String -> FastString
fsLit "Ident")
symbol_RDR :: RdrName
symbol_RDR              = Module -> FastString -> RdrName
dataQual_RDR Module
lEX (String -> FastString
fsLit "Symbol")

step_RDR, alt_RDR, reset_RDR, prec_RDR, pfail_RDR :: RdrName
step_RDR :: RdrName
step_RDR                = Module -> FastString -> RdrName
varQual_RDR  Module
rEAD_PREC (String -> FastString
fsLit "step")
alt_RDR :: RdrName
alt_RDR                 = Module -> FastString -> RdrName
varQual_RDR  Module
rEAD_PREC (String -> FastString
fsLit "+++")
reset_RDR :: RdrName
reset_RDR               = Module -> FastString -> RdrName
varQual_RDR  Module
rEAD_PREC (String -> FastString
fsLit "reset")
prec_RDR :: RdrName
prec_RDR                = Module -> FastString -> RdrName
varQual_RDR  Module
rEAD_PREC (String -> FastString
fsLit "prec")
pfail_RDR :: RdrName
pfail_RDR               = Module -> FastString -> RdrName
varQual_RDR  Module
rEAD_PREC (String -> FastString
fsLit "pfail")

showsPrec_RDR, shows_RDR, showString_RDR,
    showSpace_RDR, showCommaSpace_RDR, showParen_RDR :: RdrName
showsPrec_RDR :: RdrName
showsPrec_RDR           = Module -> FastString -> RdrName
varQual_RDR Module
gHC_SHOW (String -> FastString
fsLit "showsPrec")
shows_RDR :: RdrName
shows_RDR               = Module -> FastString -> RdrName
varQual_RDR Module
gHC_SHOW (String -> FastString
fsLit "shows")
showString_RDR :: RdrName
showString_RDR          = Module -> FastString -> RdrName
varQual_RDR Module
gHC_SHOW (String -> FastString
fsLit "showString")
showSpace_RDR :: RdrName
showSpace_RDR           = Module -> FastString -> RdrName
varQual_RDR Module
gHC_SHOW (String -> FastString
fsLit "showSpace")
showCommaSpace_RDR :: RdrName
showCommaSpace_RDR      = Module -> FastString -> RdrName
varQual_RDR Module
gHC_SHOW (String -> FastString
fsLit "showCommaSpace")
showParen_RDR :: RdrName
showParen_RDR           = Module -> FastString -> RdrName
varQual_RDR Module
gHC_SHOW (String -> FastString
fsLit "showParen")

undefined_RDR :: RdrName
undefined_RDR :: RdrName
undefined_RDR = Module -> FastString -> RdrName
varQual_RDR Module
gHC_ERR (String -> FastString
fsLit "undefined")

error_RDR :: RdrName
error_RDR :: RdrName
error_RDR = Module -> FastString -> RdrName
varQual_RDR Module
gHC_ERR (String -> FastString
fsLit "error")

-- Generics (constructors and functions)
u1DataCon_RDR, par1DataCon_RDR, rec1DataCon_RDR,
  k1DataCon_RDR, m1DataCon_RDR, l1DataCon_RDR, r1DataCon_RDR,
  prodDataCon_RDR, comp1DataCon_RDR,
  unPar1_RDR, unRec1_RDR, unK1_RDR, unComp1_RDR,
  from_RDR, from1_RDR, to_RDR, to1_RDR,
  datatypeName_RDR, moduleName_RDR, packageName_RDR, isNewtypeName_RDR,
  conName_RDR, conFixity_RDR, conIsRecord_RDR, selName_RDR,
  prefixDataCon_RDR, infixDataCon_RDR, leftAssocDataCon_RDR,
  rightAssocDataCon_RDR, notAssocDataCon_RDR,
  uAddrDataCon_RDR, uCharDataCon_RDR, uDoubleDataCon_RDR,
  uFloatDataCon_RDR, uIntDataCon_RDR, uWordDataCon_RDR,
  uAddrHash_RDR, uCharHash_RDR, uDoubleHash_RDR,
  uFloatHash_RDR, uIntHash_RDR, uWordHash_RDR :: RdrName

u1DataCon_RDR :: RdrName
u1DataCon_RDR    = Module -> FastString -> RdrName
dataQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "U1")
par1DataCon_RDR :: RdrName
par1DataCon_RDR  = Module -> FastString -> RdrName
dataQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "Par1")
rec1DataCon_RDR :: RdrName
rec1DataCon_RDR  = Module -> FastString -> RdrName
dataQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "Rec1")
k1DataCon_RDR :: RdrName
k1DataCon_RDR    = Module -> FastString -> RdrName
dataQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "K1")
m1DataCon_RDR :: RdrName
m1DataCon_RDR    = Module -> FastString -> RdrName
dataQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "M1")

l1DataCon_RDR :: RdrName
l1DataCon_RDR     = Module -> FastString -> RdrName
dataQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "L1")
r1DataCon_RDR :: RdrName
r1DataCon_RDR     = Module -> FastString -> RdrName
dataQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "R1")

prodDataCon_RDR :: RdrName
prodDataCon_RDR   = Module -> FastString -> RdrName
dataQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit ":*:")
comp1DataCon_RDR :: RdrName
comp1DataCon_RDR  = Module -> FastString -> RdrName
dataQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "Comp1")

unPar1_RDR :: RdrName
unPar1_RDR  = Module -> FastString -> RdrName
varQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "unPar1")
unRec1_RDR :: RdrName
unRec1_RDR  = Module -> FastString -> RdrName
varQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "unRec1")
unK1_RDR :: RdrName
unK1_RDR    = Module -> FastString -> RdrName
varQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "unK1")
unComp1_RDR :: RdrName
unComp1_RDR = Module -> FastString -> RdrName
varQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "unComp1")

from_RDR :: RdrName
from_RDR  = Module -> FastString -> RdrName
varQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "from")
from1_RDR :: RdrName
from1_RDR = Module -> FastString -> RdrName
varQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "from1")
to_RDR :: RdrName
to_RDR    = Module -> FastString -> RdrName
varQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "to")
to1_RDR :: RdrName
to1_RDR   = Module -> FastString -> RdrName
varQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "to1")

datatypeName_RDR :: RdrName
datatypeName_RDR  = Module -> FastString -> RdrName
varQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "datatypeName")
moduleName_RDR :: RdrName
moduleName_RDR    = Module -> FastString -> RdrName
varQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "moduleName")
packageName_RDR :: RdrName
packageName_RDR   = Module -> FastString -> RdrName
varQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "packageName")
isNewtypeName_RDR :: RdrName
isNewtypeName_RDR = Module -> FastString -> RdrName
varQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "isNewtype")
selName_RDR :: RdrName
selName_RDR       = Module -> FastString -> RdrName
varQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "selName")
conName_RDR :: RdrName
conName_RDR       = Module -> FastString -> RdrName
varQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "conName")
conFixity_RDR :: RdrName
conFixity_RDR     = Module -> FastString -> RdrName
varQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "conFixity")
conIsRecord_RDR :: RdrName
conIsRecord_RDR   = Module -> FastString -> RdrName
varQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "conIsRecord")

prefixDataCon_RDR :: RdrName
prefixDataCon_RDR     = Module -> FastString -> RdrName
dataQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "Prefix")
infixDataCon_RDR :: RdrName
infixDataCon_RDR      = Module -> FastString -> RdrName
dataQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "Infix")
leftAssocDataCon_RDR :: RdrName
leftAssocDataCon_RDR  = Name -> RdrName
nameRdrName Name
leftAssociativeDataConName
rightAssocDataCon_RDR :: RdrName
rightAssocDataCon_RDR = Name -> RdrName
nameRdrName Name
rightAssociativeDataConName
notAssocDataCon_RDR :: RdrName
notAssocDataCon_RDR   = Name -> RdrName
nameRdrName Name
notAssociativeDataConName

uAddrDataCon_RDR :: RdrName
uAddrDataCon_RDR   = Module -> FastString -> RdrName
dataQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "UAddr")
uCharDataCon_RDR :: RdrName
uCharDataCon_RDR   = Module -> FastString -> RdrName
dataQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "UChar")
uDoubleDataCon_RDR :: RdrName
uDoubleDataCon_RDR = Module -> FastString -> RdrName
dataQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "UDouble")
uFloatDataCon_RDR :: RdrName
uFloatDataCon_RDR  = Module -> FastString -> RdrName
dataQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "UFloat")
uIntDataCon_RDR :: RdrName
uIntDataCon_RDR    = Module -> FastString -> RdrName
dataQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "UInt")
uWordDataCon_RDR :: RdrName
uWordDataCon_RDR   = Module -> FastString -> RdrName
dataQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "UWord")

uAddrHash_RDR :: RdrName
uAddrHash_RDR   = Module -> FastString -> RdrName
varQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "uAddr#")
uCharHash_RDR :: RdrName
uCharHash_RDR   = Module -> FastString -> RdrName
varQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "uChar#")
uDoubleHash_RDR :: RdrName
uDoubleHash_RDR = Module -> FastString -> RdrName
varQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "uDouble#")
uFloatHash_RDR :: RdrName
uFloatHash_RDR  = Module -> FastString -> RdrName
varQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "uFloat#")
uIntHash_RDR :: RdrName
uIntHash_RDR    = Module -> FastString -> RdrName
varQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "uInt#")
uWordHash_RDR :: RdrName
uWordHash_RDR   = Module -> FastString -> RdrName
varQual_RDR Module
gHC_GENERICS (String -> FastString
fsLit "uWord#")

fmap_RDR, replace_RDR, pure_RDR, ap_RDR, liftA2_RDR, foldable_foldr_RDR,
    foldMap_RDR, null_RDR, all_RDR, traverse_RDR, mempty_RDR,
    mappend_RDR :: RdrName
fmap_RDR :: RdrName
fmap_RDR                = Name -> RdrName
nameRdrName Name
fmapName
replace_RDR :: RdrName
replace_RDR             = Module -> FastString -> RdrName
varQual_RDR Module
gHC_BASE (String -> FastString
fsLit "<$")
pure_RDR :: RdrName
pure_RDR                = Name -> RdrName
nameRdrName Name
pureAName
ap_RDR :: RdrName
ap_RDR                  = Name -> RdrName
nameRdrName Name
apAName
liftA2_RDR :: RdrName
liftA2_RDR              = Module -> FastString -> RdrName
varQual_RDR Module
gHC_BASE (String -> FastString
fsLit "liftA2")
foldable_foldr_RDR :: RdrName
foldable_foldr_RDR      = Module -> FastString -> RdrName
varQual_RDR Module
dATA_FOLDABLE       (String -> FastString
fsLit "foldr")
foldMap_RDR :: RdrName
foldMap_RDR             = Module -> FastString -> RdrName
varQual_RDR Module
dATA_FOLDABLE       (String -> FastString
fsLit "foldMap")
null_RDR :: RdrName
null_RDR                = Module -> FastString -> RdrName
varQual_RDR Module
dATA_FOLDABLE       (String -> FastString
fsLit "null")
all_RDR :: RdrName
all_RDR                 = Module -> FastString -> RdrName
varQual_RDR Module
dATA_FOLDABLE       (String -> FastString
fsLit "all")
traverse_RDR :: RdrName
traverse_RDR            = Module -> FastString -> RdrName
varQual_RDR Module
dATA_TRAVERSABLE    (String -> FastString
fsLit "traverse")
mempty_RDR :: RdrName
mempty_RDR              = Name -> RdrName
nameRdrName Name
memptyName
mappend_RDR :: RdrName
mappend_RDR             = Name -> RdrName
nameRdrName Name
mappendName

----------------------
varQual_RDR, tcQual_RDR, clsQual_RDR, dataQual_RDR
    :: Module -> FastString -> RdrName
varQual_RDR :: Module -> FastString -> RdrName
varQual_RDR  mod :: Module
mod str :: FastString
str = Module -> OccName -> RdrName
mkOrig Module
mod (NameSpace -> FastString -> OccName
mkOccNameFS NameSpace
varName FastString
str)
tcQual_RDR :: Module -> FastString -> RdrName
tcQual_RDR   mod :: Module
mod str :: FastString
str = Module -> OccName -> RdrName
mkOrig Module
mod (NameSpace -> FastString -> OccName
mkOccNameFS NameSpace
tcName FastString
str)
clsQual_RDR :: Module -> FastString -> RdrName
clsQual_RDR  mod :: Module
mod str :: FastString
str = Module -> OccName -> RdrName
mkOrig Module
mod (NameSpace -> FastString -> OccName
mkOccNameFS NameSpace
clsName FastString
str)
dataQual_RDR :: Module -> FastString -> RdrName
dataQual_RDR mod :: Module
mod str :: FastString
str = Module -> OccName -> RdrName
mkOrig Module
mod (NameSpace -> FastString -> OccName
mkOccNameFS NameSpace
dataName FastString
str)

{-
************************************************************************
*                                                                      *
\subsection{Known-key names}
*                                                                      *
************************************************************************

Many of these Names are not really "built in", but some parts of the
compiler (notably the deriving mechanism) need to mention their names,
and it's convenient to write them all down in one place.
-}

wildCardName :: Name
wildCardName :: Name
wildCardName = Unique -> FastString -> Name
mkSystemVarName Unique
wildCardKey (String -> FastString
fsLit "wild")

runMainIOName, runRWName :: Name
runMainIOName :: Name
runMainIOName = Module -> FastString -> Unique -> Name
varQual Module
gHC_TOP_HANDLER (String -> FastString
fsLit "runMainIO") Unique
runMainKey
runRWName :: Name
runRWName     = Module -> FastString -> Unique -> Name
varQual Module
gHC_MAGIC       (String -> FastString
fsLit "runRW#")    Unique
runRWKey

orderingTyConName, ordLTDataConName, ordEQDataConName, ordGTDataConName :: Name
orderingTyConName :: Name
orderingTyConName = Module -> FastString -> Unique -> Name
tcQual  Module
gHC_TYPES (String -> FastString
fsLit "Ordering") Unique
orderingTyConKey
ordLTDataConName :: Name
ordLTDataConName     = Module -> FastString -> Unique -> Name
dcQual Module
gHC_TYPES (String -> FastString
fsLit "LT") Unique
ordLTDataConKey
ordEQDataConName :: Name
ordEQDataConName     = Module -> FastString -> Unique -> Name
dcQual Module
gHC_TYPES (String -> FastString
fsLit "EQ") Unique
ordEQDataConKey
ordGTDataConName :: Name
ordGTDataConName     = Module -> FastString -> Unique -> Name
dcQual Module
gHC_TYPES (String -> FastString
fsLit "GT") Unique
ordGTDataConKey

specTyConName :: Name
specTyConName :: Name
specTyConName     = Module -> FastString -> Unique -> Name
tcQual Module
gHC_TYPES (String -> FastString
fsLit "SPEC") Unique
specTyConKey

eitherTyConName, leftDataConName, rightDataConName :: Name
eitherTyConName :: Name
eitherTyConName   = Module -> FastString -> Unique -> Name
tcQual  Module
dATA_EITHER (String -> FastString
fsLit "Either") Unique
eitherTyConKey
leftDataConName :: Name
leftDataConName   = Module -> FastString -> Unique -> Name
dcQual Module
dATA_EITHER (String -> FastString
fsLit "Left")   Unique
leftDataConKey
rightDataConName :: Name
rightDataConName  = Module -> FastString -> Unique -> Name
dcQual Module
dATA_EITHER (String -> FastString
fsLit "Right")  Unique
rightDataConKey

-- Generics (types)
v1TyConName, u1TyConName, par1TyConName, rec1TyConName,
  k1TyConName, m1TyConName, sumTyConName, prodTyConName,
  compTyConName, rTyConName, dTyConName,
  cTyConName, sTyConName, rec0TyConName,
  d1TyConName, c1TyConName, s1TyConName, noSelTyConName,
  repTyConName, rep1TyConName, uRecTyConName,
  uAddrTyConName, uCharTyConName, uDoubleTyConName,
  uFloatTyConName, uIntTyConName, uWordTyConName,
  prefixIDataConName, infixIDataConName, leftAssociativeDataConName,
  rightAssociativeDataConName, notAssociativeDataConName,
  sourceUnpackDataConName, sourceNoUnpackDataConName,
  noSourceUnpackednessDataConName, sourceLazyDataConName,
  sourceStrictDataConName, noSourceStrictnessDataConName,
  decidedLazyDataConName, decidedStrictDataConName, decidedUnpackDataConName,
  metaDataDataConName, metaConsDataConName, metaSelDataConName :: Name

v1TyConName :: Name
v1TyConName  = Module -> FastString -> Unique -> Name
tcQual Module
gHC_GENERICS (String -> FastString
fsLit "V1") Unique
v1TyConKey
u1TyConName :: Name
u1TyConName  = Module -> FastString -> Unique -> Name
tcQual Module
gHC_GENERICS (String -> FastString
fsLit "U1") Unique
u1TyConKey
par1TyConName :: Name
par1TyConName  = Module -> FastString -> Unique -> Name
tcQual Module
gHC_GENERICS (String -> FastString
fsLit "Par1") Unique
par1TyConKey
rec1TyConName :: Name
rec1TyConName  = Module -> FastString -> Unique -> Name
tcQual Module
gHC_GENERICS (String -> FastString
fsLit "Rec1") Unique
rec1TyConKey
k1TyConName :: Name
k1TyConName  = Module -> FastString -> Unique -> Name
tcQual Module
gHC_GENERICS (String -> FastString
fsLit "K1") Unique
k1TyConKey
m1TyConName :: Name
m1TyConName  = Module -> FastString -> Unique -> Name
tcQual Module
gHC_GENERICS (String -> FastString
fsLit "M1") Unique
m1TyConKey

sumTyConName :: Name
sumTyConName    = Module -> FastString -> Unique -> Name
tcQual Module
gHC_GENERICS (String -> FastString
fsLit ":+:") Unique
sumTyConKey
prodTyConName :: Name
prodTyConName   = Module -> FastString -> Unique -> Name
tcQual Module
gHC_GENERICS (String -> FastString
fsLit ":*:") Unique
prodTyConKey
compTyConName :: Name
compTyConName   = Module -> FastString -> Unique -> Name
tcQual Module
gHC_GENERICS (String -> FastString
fsLit ":.:") Unique
compTyConKey

rTyConName :: Name
rTyConName  = Module -> FastString -> Unique -> Name
tcQual Module
gHC_GENERICS (String -> FastString
fsLit "R") Unique
rTyConKey
dTyConName :: Name
dTyConName  = Module -> FastString -> Unique -> Name
tcQual Module
gHC_GENERICS (String -> FastString
fsLit "D") Unique
dTyConKey
cTyConName :: Name
cTyConName  = Module -> FastString -> Unique -> Name
tcQual Module
gHC_GENERICS (String -> FastString
fsLit "C") Unique
cTyConKey
sTyConName :: Name
sTyConName  = Module -> FastString -> Unique -> Name
tcQual Module
gHC_GENERICS (String -> FastString
fsLit "S") Unique
sTyConKey

rec0TyConName :: Name
rec0TyConName  = Module -> FastString -> Unique -> Name
tcQual Module
gHC_GENERICS (String -> FastString
fsLit "Rec0") Unique
rec0TyConKey
d1TyConName :: Name
d1TyConName  = Module -> FastString -> Unique -> Name
tcQual Module
gHC_GENERICS (String -> FastString
fsLit "D1") Unique
d1TyConKey
c1TyConName :: Name
c1TyConName  = Module -> FastString -> Unique -> Name
tcQual Module
gHC_GENERICS (String -> FastString
fsLit "C1") Unique
c1TyConKey
s1TyConName :: Name
s1TyConName  = Module -> FastString -> Unique -> Name
tcQual Module
gHC_GENERICS (String -> FastString
fsLit "S1") Unique
s1TyConKey
noSelTyConName :: Name
noSelTyConName = Module -> FastString -> Unique -> Name
tcQual Module
gHC_GENERICS (String -> FastString
fsLit "NoSelector") Unique
noSelTyConKey

repTyConName :: Name
repTyConName  = Module -> FastString -> Unique -> Name
tcQual Module
gHC_GENERICS (String -> FastString
fsLit "Rep")  Unique
repTyConKey
rep1TyConName :: Name
rep1TyConName = Module -> FastString -> Unique -> Name
tcQual Module
gHC_GENERICS (String -> FastString
fsLit "Rep1") Unique
rep1TyConKey

uRecTyConName :: Name
uRecTyConName      = Module -> FastString -> Unique -> Name
tcQual Module
gHC_GENERICS (String -> FastString
fsLit "URec") Unique
uRecTyConKey
uAddrTyConName :: Name
uAddrTyConName     = Module -> FastString -> Unique -> Name
tcQual Module
gHC_GENERICS (String -> FastString
fsLit "UAddr") Unique
uAddrTyConKey
uCharTyConName :: Name
uCharTyConName     = Module -> FastString -> Unique -> Name
tcQual Module
gHC_GENERICS (String -> FastString
fsLit "UChar") Unique
uCharTyConKey
uDoubleTyConName :: Name
uDoubleTyConName   = Module -> FastString -> Unique -> Name
tcQual Module
gHC_GENERICS (String -> FastString
fsLit "UDouble") Unique
uDoubleTyConKey
uFloatTyConName :: Name
uFloatTyConName    = Module -> FastString -> Unique -> Name
tcQual Module
gHC_GENERICS (String -> FastString
fsLit "UFloat") Unique
uFloatTyConKey
uIntTyConName :: Name
uIntTyConName      = Module -> FastString -> Unique -> Name
tcQual Module
gHC_GENERICS (String -> FastString
fsLit "UInt") Unique
uIntTyConKey
uWordTyConName :: Name
uWordTyConName     = Module -> FastString -> Unique -> Name
tcQual Module
gHC_GENERICS (String -> FastString
fsLit "UWord") Unique
uWordTyConKey

prefixIDataConName :: Name
prefixIDataConName = Module -> FastString -> Unique -> Name
dcQual Module
gHC_GENERICS (String -> FastString
fsLit "PrefixI")  Unique
prefixIDataConKey
infixIDataConName :: Name
infixIDataConName  = Module -> FastString -> Unique -> Name
dcQual Module
gHC_GENERICS (String -> FastString
fsLit "InfixI")   Unique
infixIDataConKey
leftAssociativeDataConName :: Name
leftAssociativeDataConName  = Module -> FastString -> Unique -> Name
dcQual Module
gHC_GENERICS (String -> FastString
fsLit "LeftAssociative")   Unique
leftAssociativeDataConKey
rightAssociativeDataConName :: Name
rightAssociativeDataConName = Module -> FastString -> Unique -> Name
dcQual Module
gHC_GENERICS (String -> FastString
fsLit "RightAssociative")  Unique
rightAssociativeDataConKey
notAssociativeDataConName :: Name
notAssociativeDataConName   = Module -> FastString -> Unique -> Name
dcQual Module
gHC_GENERICS (String -> FastString
fsLit "NotAssociative")    Unique
notAssociativeDataConKey

sourceUnpackDataConName :: Name
sourceUnpackDataConName         = Module -> FastString -> Unique -> Name
dcQual Module
gHC_GENERICS (String -> FastString
fsLit "SourceUnpack")         Unique
sourceUnpackDataConKey
sourceNoUnpackDataConName :: Name
sourceNoUnpackDataConName       = Module -> FastString -> Unique -> Name
dcQual Module
gHC_GENERICS (String -> FastString
fsLit "SourceNoUnpack")       Unique
sourceNoUnpackDataConKey
noSourceUnpackednessDataConName :: Name
noSourceUnpackednessDataConName = Module -> FastString -> Unique -> Name
dcQual Module
gHC_GENERICS (String -> FastString
fsLit "NoSourceUnpackedness") Unique
noSourceUnpackednessDataConKey
sourceLazyDataConName :: Name
sourceLazyDataConName           = Module -> FastString -> Unique -> Name
dcQual Module
gHC_GENERICS (String -> FastString
fsLit "SourceLazy")           Unique
sourceLazyDataConKey
sourceStrictDataConName :: Name
sourceStrictDataConName         = Module -> FastString -> Unique -> Name
dcQual Module
gHC_GENERICS (String -> FastString
fsLit "SourceStrict")         Unique
sourceStrictDataConKey
noSourceStrictnessDataConName :: Name
noSourceStrictnessDataConName   = Module -> FastString -> Unique -> Name
dcQual Module
gHC_GENERICS (String -> FastString
fsLit "NoSourceStrictness")   Unique
noSourceStrictnessDataConKey
decidedLazyDataConName :: Name
decidedLazyDataConName          = Module -> FastString -> Unique -> Name
dcQual Module
gHC_GENERICS (String -> FastString
fsLit "DecidedLazy")          Unique
decidedLazyDataConKey
decidedStrictDataConName :: Name
decidedStrictDataConName        = Module -> FastString -> Unique -> Name
dcQual Module
gHC_GENERICS (String -> FastString
fsLit "DecidedStrict")        Unique
decidedStrictDataConKey
decidedUnpackDataConName :: Name
decidedUnpackDataConName        = Module -> FastString -> Unique -> Name
dcQual Module
gHC_GENERICS (String -> FastString
fsLit "DecidedUnpack")        Unique
decidedUnpackDataConKey

metaDataDataConName :: Name
metaDataDataConName  = Module -> FastString -> Unique -> Name
dcQual Module
gHC_GENERICS (String -> FastString
fsLit "MetaData")  Unique
metaDataDataConKey
metaConsDataConName :: Name
metaConsDataConName  = Module -> FastString -> Unique -> Name
dcQual Module
gHC_GENERICS (String -> FastString
fsLit "MetaCons")  Unique
metaConsDataConKey
metaSelDataConName :: Name
metaSelDataConName   = Module -> FastString -> Unique -> Name
dcQual Module
gHC_GENERICS (String -> FastString
fsLit "MetaSel")   Unique
metaSelDataConKey

-- Primitive Int
divIntName, modIntName :: Name
divIntName :: Name
divIntName = Module -> FastString -> Unique -> Name
varQual Module
gHC_CLASSES (String -> FastString
fsLit "divInt#") Unique
divIntIdKey
modIntName :: Name
modIntName = Module -> FastString -> Unique -> Name
varQual Module
gHC_CLASSES (String -> FastString
fsLit "modInt#") Unique
modIntIdKey

-- Base strings Strings
unpackCStringName, unpackCStringFoldrName,
    unpackCStringUtf8Name, eqStringName :: Name
unpackCStringName :: Name
unpackCStringName       = Module -> FastString -> Unique -> Name
varQual Module
gHC_CSTRING (String -> FastString
fsLit "unpackCString#") Unique
unpackCStringIdKey
unpackCStringFoldrName :: Name
unpackCStringFoldrName  = Module -> FastString -> Unique -> Name
varQual Module
gHC_CSTRING (String -> FastString
fsLit "unpackFoldrCString#") Unique
unpackCStringFoldrIdKey
unpackCStringUtf8Name :: Name
unpackCStringUtf8Name   = Module -> FastString -> Unique -> Name
varQual Module
gHC_CSTRING (String -> FastString
fsLit "unpackCStringUtf8#") Unique
unpackCStringUtf8IdKey
eqStringName :: Name
eqStringName            = Module -> FastString -> Unique -> Name
varQual Module
gHC_BASE (String -> FastString
fsLit "eqString")  Unique
eqStringIdKey

-- The 'inline' function
inlineIdName :: Name
inlineIdName :: Name
inlineIdName            = Module -> FastString -> Unique -> Name
varQual Module
gHC_MAGIC (String -> FastString
fsLit "inline") Unique
inlineIdKey

-- Base classes (Eq, Ord, Functor)
fmapName, eqClassName, eqName, ordClassName, geName, functorClassName :: Name
eqClassName :: Name
eqClassName       = Module -> FastString -> Unique -> Name
clsQual Module
gHC_CLASSES (String -> FastString
fsLit "Eq")      Unique
eqClassKey
eqName :: Name
eqName            = Module -> FastString -> Unique -> Name
varQual Module
gHC_CLASSES (String -> FastString
fsLit "==")      Unique
eqClassOpKey
ordClassName :: Name
ordClassName      = Module -> FastString -> Unique -> Name
clsQual Module
gHC_CLASSES (String -> FastString
fsLit "Ord")     Unique
ordClassKey
geName :: Name
geName            = Module -> FastString -> Unique -> Name
varQual Module
gHC_CLASSES (String -> FastString
fsLit ">=")      Unique
geClassOpKey
functorClassName :: Name
functorClassName  = Module -> FastString -> Unique -> Name
clsQual Module
gHC_BASE    (String -> FastString
fsLit "Functor") Unique
functorClassKey
fmapName :: Name
fmapName          = Module -> FastString -> Unique -> Name
varQual Module
gHC_BASE    (String -> FastString
fsLit "fmap")    Unique
fmapClassOpKey

-- Class Monad
monadClassName, thenMName, bindMName, returnMName :: Name
monadClassName :: Name
monadClassName     = Module -> FastString -> Unique -> Name
clsQual Module
gHC_BASE (String -> FastString
fsLit "Monad")  Unique
monadClassKey
thenMName :: Name
thenMName          = Module -> FastString -> Unique -> Name
varQual Module
gHC_BASE (String -> FastString
fsLit ">>")     Unique
thenMClassOpKey
bindMName :: Name
bindMName          = Module -> FastString -> Unique -> Name
varQual Module
gHC_BASE (String -> FastString
fsLit ">>=")    Unique
bindMClassOpKey
returnMName :: Name
returnMName        = Module -> FastString -> Unique -> Name
varQual Module
gHC_BASE (String -> FastString
fsLit "return") Unique
returnMClassOpKey

-- Class MonadFail
monadFailClassName, failMName :: Name
monadFailClassName :: Name
monadFailClassName = Module -> FastString -> Unique -> Name
clsQual Module
mONAD_FAIL (String -> FastString
fsLit "MonadFail") Unique
monadFailClassKey
failMName :: Name
failMName          = Module -> FastString -> Unique -> Name
varQual Module
mONAD_FAIL (String -> FastString
fsLit "fail")      Unique
failMClassOpKey

-- Class Applicative
applicativeClassName, pureAName, apAName, thenAName :: Name
applicativeClassName :: Name
applicativeClassName = Module -> FastString -> Unique -> Name
clsQual Module
gHC_BASE (String -> FastString
fsLit "Applicative") Unique
applicativeClassKey
apAName :: Name
apAName              = Module -> FastString -> Unique -> Name
varQual Module
gHC_BASE (String -> FastString
fsLit "<*>")         Unique
apAClassOpKey
pureAName :: Name
pureAName            = Module -> FastString -> Unique -> Name
varQual Module
gHC_BASE (String -> FastString
fsLit "pure")        Unique
pureAClassOpKey
thenAName :: Name
thenAName            = Module -> FastString -> Unique -> Name
varQual Module
gHC_BASE (String -> FastString
fsLit "*>")          Unique
thenAClassOpKey

-- Classes (Foldable, Traversable)
foldableClassName, traversableClassName :: Name
foldableClassName :: Name
foldableClassName     = Module -> FastString -> Unique -> Name
clsQual  Module
dATA_FOLDABLE       (String -> FastString
fsLit "Foldable")    Unique
foldableClassKey
traversableClassName :: Name
traversableClassName  = Module -> FastString -> Unique -> Name
clsQual  Module
dATA_TRAVERSABLE    (String -> FastString
fsLit "Traversable") Unique
traversableClassKey

-- Classes (Semigroup, Monoid)
semigroupClassName, sappendName :: Name
semigroupClassName :: Name
semigroupClassName = Module -> FastString -> Unique -> Name
clsQual Module
gHC_BASE       (String -> FastString
fsLit "Semigroup") Unique
semigroupClassKey
sappendName :: Name
sappendName        = Module -> FastString -> Unique -> Name
varQual Module
gHC_BASE       (String -> FastString
fsLit "<>")        Unique
sappendClassOpKey
monoidClassName, memptyName, mappendName, mconcatName :: Name
monoidClassName :: Name
monoidClassName    = Module -> FastString -> Unique -> Name
clsQual Module
gHC_BASE       (String -> FastString
fsLit "Monoid")    Unique
monoidClassKey
memptyName :: Name
memptyName         = Module -> FastString -> Unique -> Name
varQual Module
gHC_BASE       (String -> FastString
fsLit "mempty")    Unique
memptyClassOpKey
mappendName :: Name
mappendName        = Module -> FastString -> Unique -> Name
varQual Module
gHC_BASE       (String -> FastString
fsLit "mappend")   Unique
mappendClassOpKey
mconcatName :: Name
mconcatName        = Module -> FastString -> Unique -> Name
varQual Module
gHC_BASE       (String -> FastString
fsLit "mconcat")   Unique
mconcatClassOpKey



-- AMP additions

joinMName, alternativeClassName :: Name
joinMName :: Name
joinMName            = Module -> FastString -> Unique -> Name
varQual Module
gHC_BASE (String -> FastString
fsLit "join")        Unique
joinMIdKey
alternativeClassName :: Name
alternativeClassName = Module -> FastString -> Unique -> Name
clsQual Module
mONAD (String -> FastString
fsLit "Alternative") Unique
alternativeClassKey

--
joinMIdKey, apAClassOpKey, pureAClassOpKey, thenAClassOpKey,
    alternativeClassKey :: Unique
joinMIdKey :: Unique
joinMIdKey          = Int -> Unique
mkPreludeMiscIdUnique 750
apAClassOpKey :: Unique
apAClassOpKey       = Int -> Unique
mkPreludeMiscIdUnique 751 -- <*>
pureAClassOpKey :: Unique
pureAClassOpKey     = Int -> Unique
mkPreludeMiscIdUnique 752
thenAClassOpKey :: Unique
thenAClassOpKey     = Int -> Unique
mkPreludeMiscIdUnique 753
alternativeClassKey :: Unique
alternativeClassKey = Int -> Unique
mkPreludeMiscIdUnique 754


-- Functions for GHC extensions
groupWithName :: Name
groupWithName :: Name
groupWithName = Module -> FastString -> Unique -> Name
varQual Module
gHC_EXTS (String -> FastString
fsLit "groupWith") Unique
groupWithIdKey

-- Random PrelBase functions
fromStringName, otherwiseIdName, foldrName, buildName, augmentName,
    mapName, appendName, assertName,
    breakpointName, breakpointCondName, breakpointAutoName,
    opaqueTyConName, dollarName :: Name
dollarName :: Name
dollarName        = Module -> FastString -> Unique -> Name
varQual Module
gHC_BASE (String -> FastString
fsLit "$")          Unique
dollarIdKey
otherwiseIdName :: Name
otherwiseIdName   = Module -> FastString -> Unique -> Name
varQual Module
gHC_BASE (String -> FastString
fsLit "otherwise")  Unique
otherwiseIdKey
foldrName :: Name
foldrName         = Module -> FastString -> Unique -> Name
varQual Module
gHC_BASE (String -> FastString
fsLit "foldr")      Unique
foldrIdKey
buildName :: Name
buildName         = Module -> FastString -> Unique -> Name
varQual Module
gHC_BASE (String -> FastString
fsLit "build")      Unique
buildIdKey
augmentName :: Name
augmentName       = Module -> FastString -> Unique -> Name
varQual Module
gHC_BASE (String -> FastString
fsLit "augment")    Unique
augmentIdKey
mapName :: Name
mapName           = Module -> FastString -> Unique -> Name
varQual Module
gHC_BASE (String -> FastString
fsLit "map")        Unique
mapIdKey
appendName :: Name
appendName        = Module -> FastString -> Unique -> Name
varQual Module
gHC_BASE (String -> FastString
fsLit "++")         Unique
appendIdKey
assertName :: Name
assertName        = Module -> FastString -> Unique -> Name
varQual Module
gHC_BASE (String -> FastString
fsLit "assert")     Unique
assertIdKey
breakpointName :: Name
breakpointName    = Module -> FastString -> Unique -> Name
varQual Module
gHC_BASE (String -> FastString
fsLit "breakpoint") Unique
breakpointIdKey
breakpointCondName :: Name
breakpointCondName= Module -> FastString -> Unique -> Name
varQual Module
gHC_BASE (String -> FastString
fsLit "breakpointCond") Unique
breakpointCondIdKey
breakpointAutoName :: Name
breakpointAutoName= Module -> FastString -> Unique -> Name
varQual Module
gHC_BASE (String -> FastString
fsLit "breakpointAuto") Unique
breakpointAutoIdKey
opaqueTyConName :: Name
opaqueTyConName   = Module -> FastString -> Unique -> Name
tcQual  Module
gHC_BASE (String -> FastString
fsLit "Opaque")     Unique
opaqueTyConKey
fromStringName :: Name
fromStringName = Module -> FastString -> Unique -> Name
varQual Module
dATA_STRING (String -> FastString
fsLit "fromString") Unique
fromStringClassOpKey

breakpointJumpName :: Name
breakpointJumpName :: Name
breakpointJumpName
    = Unique -> OccName -> SrcSpan -> Name
mkInternalName
        Unique
breakpointJumpIdKey
        (NameSpace -> FastString -> OccName
mkOccNameFS NameSpace
varName (String -> FastString
fsLit "breakpointJump"))
        SrcSpan
noSrcSpan
breakpointCondJumpName :: Name
breakpointCondJumpName :: Name
breakpointCondJumpName
    = Unique -> OccName -> SrcSpan -> Name
mkInternalName
        Unique
breakpointCondJumpIdKey
        (NameSpace -> FastString -> OccName
mkOccNameFS NameSpace
varName (String -> FastString
fsLit "breakpointCondJump"))
        SrcSpan
noSrcSpan
breakpointAutoJumpName :: Name
breakpointAutoJumpName :: Name
breakpointAutoJumpName
    = Unique -> OccName -> SrcSpan -> Name
mkInternalName
        Unique
breakpointAutoJumpIdKey
        (NameSpace -> FastString -> OccName
mkOccNameFS NameSpace
varName (String -> FastString
fsLit "breakpointAutoJump"))
        SrcSpan
noSrcSpan

-- PrelTup
fstName, sndName :: Name
fstName :: Name
fstName           = Module -> FastString -> Unique -> Name
varQual Module
dATA_TUPLE (String -> FastString
fsLit "fst") Unique
fstIdKey
sndName :: Name
sndName           = Module -> FastString -> Unique -> Name
varQual Module
dATA_TUPLE (String -> FastString
fsLit "snd") Unique
sndIdKey

-- Module GHC.Num
numClassName, fromIntegerName, minusName, negateName :: Name
numClassName :: Name
numClassName      = Module -> FastString -> Unique -> Name
clsQual Module
gHC_NUM (String -> FastString
fsLit "Num")         Unique
numClassKey
fromIntegerName :: Name
fromIntegerName   = Module -> FastString -> Unique -> Name
varQual Module
gHC_NUM (String -> FastString
fsLit "fromInteger") Unique
fromIntegerClassOpKey
minusName :: Name
minusName         = Module -> FastString -> Unique -> Name
varQual Module
gHC_NUM (String -> FastString
fsLit "-")           Unique
minusClassOpKey
negateName :: Name
negateName        = Module -> FastString -> Unique -> Name
varQual Module
gHC_NUM (String -> FastString
fsLit "negate")      Unique
negateClassOpKey

integerTyConName, mkIntegerName, integerSDataConName,
    integerToWord64Name, integerToInt64Name,
    word64ToIntegerName, int64ToIntegerName,
    plusIntegerName, timesIntegerName, smallIntegerName,
    wordToIntegerName,
    integerToWordName, integerToIntName, minusIntegerName,
    negateIntegerName, eqIntegerPrimName, neqIntegerPrimName,
    absIntegerName, signumIntegerName,
    leIntegerPrimName, gtIntegerPrimName, ltIntegerPrimName, geIntegerPrimName,
    compareIntegerName, quotRemIntegerName, divModIntegerName,
    quotIntegerName, remIntegerName, divIntegerName, modIntegerName,
    floatFromIntegerName, doubleFromIntegerName,
    encodeFloatIntegerName, encodeDoubleIntegerName,
    decodeDoubleIntegerName,
    gcdIntegerName, lcmIntegerName,
    andIntegerName, orIntegerName, xorIntegerName, complementIntegerName,
    shiftLIntegerName, shiftRIntegerName, bitIntegerName :: Name
integerTyConName :: Name
integerTyConName      = Module -> FastString -> Unique -> Name
tcQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "Integer")           Unique
integerTyConKey
integerSDataConName :: Name
integerSDataConName   = Module -> FastString -> Unique -> Name
dcQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "S#")                Unique
integerSDataConKey
mkIntegerName :: Name
mkIntegerName         = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "mkInteger")         Unique
mkIntegerIdKey
integerToWord64Name :: Name
integerToWord64Name   = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "integerToWord64")   Unique
integerToWord64IdKey
integerToInt64Name :: Name
integerToInt64Name    = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "integerToInt64")    Unique
integerToInt64IdKey
word64ToIntegerName :: Name
word64ToIntegerName   = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "word64ToInteger")   Unique
word64ToIntegerIdKey
int64ToIntegerName :: Name
int64ToIntegerName    = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "int64ToInteger")    Unique
int64ToIntegerIdKey
plusIntegerName :: Name
plusIntegerName       = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "plusInteger")       Unique
plusIntegerIdKey
timesIntegerName :: Name
timesIntegerName      = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "timesInteger")      Unique
timesIntegerIdKey
smallIntegerName :: Name
smallIntegerName      = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "smallInteger")      Unique
smallIntegerIdKey
wordToIntegerName :: Name
wordToIntegerName     = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "wordToInteger")     Unique
wordToIntegerIdKey
integerToWordName :: Name
integerToWordName     = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "integerToWord")     Unique
integerToWordIdKey
integerToIntName :: Name
integerToIntName      = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "integerToInt")      Unique
integerToIntIdKey
minusIntegerName :: Name
minusIntegerName      = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "minusInteger")      Unique
minusIntegerIdKey
negateIntegerName :: Name
negateIntegerName     = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "negateInteger")     Unique
negateIntegerIdKey
eqIntegerPrimName :: Name
eqIntegerPrimName     = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "eqInteger#")        Unique
eqIntegerPrimIdKey
neqIntegerPrimName :: Name
neqIntegerPrimName    = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "neqInteger#")       Unique
neqIntegerPrimIdKey
absIntegerName :: Name
absIntegerName        = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "absInteger")        Unique
absIntegerIdKey
signumIntegerName :: Name
signumIntegerName     = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "signumInteger")     Unique
signumIntegerIdKey
leIntegerPrimName :: Name
leIntegerPrimName     = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "leInteger#")        Unique
leIntegerPrimIdKey
gtIntegerPrimName :: Name
gtIntegerPrimName     = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "gtInteger#")        Unique
gtIntegerPrimIdKey
ltIntegerPrimName :: Name
ltIntegerPrimName     = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "ltInteger#")        Unique
ltIntegerPrimIdKey
geIntegerPrimName :: Name
geIntegerPrimName     = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "geInteger#")        Unique
geIntegerPrimIdKey
compareIntegerName :: Name
compareIntegerName    = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "compareInteger")    Unique
compareIntegerIdKey
quotRemIntegerName :: Name
quotRemIntegerName    = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "quotRemInteger")    Unique
quotRemIntegerIdKey
divModIntegerName :: Name
divModIntegerName     = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "divModInteger")     Unique
divModIntegerIdKey
quotIntegerName :: Name
quotIntegerName       = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "quotInteger")       Unique
quotIntegerIdKey
remIntegerName :: Name
remIntegerName        = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "remInteger")        Unique
remIntegerIdKey
divIntegerName :: Name
divIntegerName        = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "divInteger")        Unique
divIntegerIdKey
modIntegerName :: Name
modIntegerName        = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "modInteger")        Unique
modIntegerIdKey
floatFromIntegerName :: Name
floatFromIntegerName  = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "floatFromInteger")      Unique
floatFromIntegerIdKey
doubleFromIntegerName :: Name
doubleFromIntegerName = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "doubleFromInteger")     Unique
doubleFromIntegerIdKey
encodeFloatIntegerName :: Name
encodeFloatIntegerName  = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "encodeFloatInteger")  Unique
encodeFloatIntegerIdKey
encodeDoubleIntegerName :: Name
encodeDoubleIntegerName = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "encodeDoubleInteger") Unique
encodeDoubleIntegerIdKey
decodeDoubleIntegerName :: Name
decodeDoubleIntegerName = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "decodeDoubleInteger") Unique
decodeDoubleIntegerIdKey
gcdIntegerName :: Name
gcdIntegerName        = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "gcdInteger")        Unique
gcdIntegerIdKey
lcmIntegerName :: Name
lcmIntegerName        = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "lcmInteger")        Unique
lcmIntegerIdKey
andIntegerName :: Name
andIntegerName        = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "andInteger")        Unique
andIntegerIdKey
orIntegerName :: Name
orIntegerName         = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "orInteger")         Unique
orIntegerIdKey
xorIntegerName :: Name
xorIntegerName        = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "xorInteger")        Unique
xorIntegerIdKey
complementIntegerName :: Name
complementIntegerName = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "complementInteger") Unique
complementIntegerIdKey
shiftLIntegerName :: Name
shiftLIntegerName     = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "shiftLInteger")     Unique
shiftLIntegerIdKey
shiftRIntegerName :: Name
shiftRIntegerName     = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "shiftRInteger")     Unique
shiftRIntegerIdKey
bitIntegerName :: Name
bitIntegerName        = Module -> FastString -> Unique -> Name
varQual Module
gHC_INTEGER_TYPE (String -> FastString
fsLit "bitInteger")        Unique
bitIntegerIdKey

-- GHC.Natural types
naturalTyConName, naturalSDataConName :: Name
naturalTyConName :: Name
naturalTyConName     = Module -> FastString -> Unique -> Name
tcQual Module
gHC_NATURAL (String -> FastString
fsLit "Natural") Unique
naturalTyConKey
naturalSDataConName :: Name
naturalSDataConName  = Module -> FastString -> Unique -> Name
dcQual Module
gHC_NATURAL (String -> FastString
fsLit "NatS#")   Unique
naturalSDataConKey

naturalFromIntegerName :: Name
naturalFromIntegerName :: Name
naturalFromIntegerName = Module -> FastString -> Unique -> Name
varQual Module
gHC_NATURAL (String -> FastString
fsLit "naturalFromInteger") Unique
naturalFromIntegerIdKey

naturalToIntegerName, plusNaturalName, minusNaturalName, timesNaturalName,
   mkNaturalName, wordToNaturalName :: Name
naturalToIntegerName :: Name
naturalToIntegerName  = Module -> FastString -> Unique -> Name
varQual Module
gHC_NATURAL (String -> FastString
fsLit "naturalToInteger")  Unique
naturalToIntegerIdKey
plusNaturalName :: Name
plusNaturalName       = Module -> FastString -> Unique -> Name
varQual Module
gHC_NATURAL (String -> FastString
fsLit "plusNatural")       Unique
plusNaturalIdKey
minusNaturalName :: Name
minusNaturalName      = Module -> FastString -> Unique -> Name
varQual Module
gHC_NATURAL (String -> FastString
fsLit "minusNatural")      Unique
minusNaturalIdKey
timesNaturalName :: Name
timesNaturalName      = Module -> FastString -> Unique -> Name
varQual Module
gHC_NATURAL (String -> FastString
fsLit "timesNatural")      Unique
timesNaturalIdKey
mkNaturalName :: Name
mkNaturalName         = Module -> FastString -> Unique -> Name
varQual Module
gHC_NATURAL (String -> FastString
fsLit "mkNatural")         Unique
mkNaturalIdKey
wordToNaturalName :: Name
wordToNaturalName     = Module -> FastString -> Unique -> Name
varQual Module
gHC_NATURAL (String -> FastString
fsLit "wordToNatural#")    Unique
wordToNaturalIdKey

-- GHC.Real types and classes
rationalTyConName, ratioTyConName, ratioDataConName, realClassName,
    integralClassName, realFracClassName, fractionalClassName,
    fromRationalName, toIntegerName, toRationalName, fromIntegralName,
    realToFracName :: Name
rationalTyConName :: Name
rationalTyConName   = Module -> FastString -> Unique -> Name
tcQual  Module
gHC_REAL (String -> FastString
fsLit "Rational")     Unique
rationalTyConKey
ratioTyConName :: Name
ratioTyConName      = Module -> FastString -> Unique -> Name
tcQual  Module
gHC_REAL (String -> FastString
fsLit "Ratio")        Unique
ratioTyConKey
ratioDataConName :: Name
ratioDataConName    = Module -> FastString -> Unique -> Name
dcQual  Module
gHC_REAL (String -> FastString
fsLit ":%")           Unique
ratioDataConKey
realClassName :: Name
realClassName       = Module -> FastString -> Unique -> Name
clsQual Module
gHC_REAL (String -> FastString
fsLit "Real")         Unique
realClassKey
integralClassName :: Name
integralClassName   = Module -> FastString -> Unique -> Name
clsQual Module
gHC_REAL (String -> FastString
fsLit "Integral")     Unique
integralClassKey
realFracClassName :: Name
realFracClassName   = Module -> FastString -> Unique -> Name
clsQual Module
gHC_REAL (String -> FastString
fsLit "RealFrac")     Unique
realFracClassKey
fractionalClassName :: Name
fractionalClassName = Module -> FastString -> Unique -> Name
clsQual Module
gHC_REAL (String -> FastString
fsLit "Fractional")   Unique
fractionalClassKey
fromRationalName :: Name
fromRationalName    = Module -> FastString -> Unique -> Name
varQual Module
gHC_REAL (String -> FastString
fsLit "fromRational") Unique
fromRationalClassOpKey
toIntegerName :: Name
toIntegerName       = Module -> FastString -> Unique -> Name
varQual Module
gHC_REAL (String -> FastString
fsLit "toInteger")    Unique
toIntegerClassOpKey
toRationalName :: Name
toRationalName      = Module -> FastString -> Unique -> Name
varQual Module
gHC_REAL (String -> FastString
fsLit "toRational")   Unique
toRationalClassOpKey
fromIntegralName :: Name
fromIntegralName    = Module -> FastString -> Unique -> Name
varQual  Module
gHC_REAL (String -> FastString
fsLit "fromIntegral")Unique
fromIntegralIdKey
realToFracName :: Name
realToFracName      = Module -> FastString -> Unique -> Name
varQual  Module
gHC_REAL (String -> FastString
fsLit "realToFrac")  Unique
realToFracIdKey

-- PrelFloat classes
floatingClassName, realFloatClassName :: Name
floatingClassName :: Name
floatingClassName  = Module -> FastString -> Unique -> Name
clsQual Module
gHC_FLOAT (String -> FastString
fsLit "Floating")  Unique
floatingClassKey
realFloatClassName :: Name
realFloatClassName = Module -> FastString -> Unique -> Name
clsQual Module
gHC_FLOAT (String -> FastString
fsLit "RealFloat") Unique
realFloatClassKey

-- other GHC.Float functions
rationalToFloatName, rationalToDoubleName :: Name
rationalToFloatName :: Name
rationalToFloatName  = Module -> FastString -> Unique -> Name
varQual Module
gHC_FLOAT (String -> FastString
fsLit "rationalToFloat") Unique
rationalToFloatIdKey
rationalToDoubleName :: Name
rationalToDoubleName = Module -> FastString -> Unique -> Name
varQual Module
gHC_FLOAT (String -> FastString
fsLit "rationalToDouble") Unique
rationalToDoubleIdKey

-- Class Ix
ixClassName :: Name
ixClassName :: Name
ixClassName = Module -> FastString -> Unique -> Name
clsQual Module
gHC_ARR (String -> FastString
fsLit "Ix") Unique
ixClassKey

-- Typeable representation types
trModuleTyConName
  , trModuleDataConName
  , trNameTyConName
  , trNameSDataConName
  , trNameDDataConName
  , trTyConTyConName
  , trTyConDataConName
  :: Name
trModuleTyConName :: Name
trModuleTyConName     = Module -> FastString -> Unique -> Name
tcQual Module
gHC_TYPES          (String -> FastString
fsLit "Module")         Unique
trModuleTyConKey
trModuleDataConName :: Name
trModuleDataConName   = Module -> FastString -> Unique -> Name
dcQual Module
gHC_TYPES          (String -> FastString
fsLit "Module")         Unique
trModuleDataConKey
trNameTyConName :: Name
trNameTyConName       = Module -> FastString -> Unique -> Name
tcQual Module
gHC_TYPES          (String -> FastString
fsLit "TrName")         Unique
trNameTyConKey
trNameSDataConName :: Name
trNameSDataConName    = Module -> FastString -> Unique -> Name
dcQual Module
gHC_TYPES          (String -> FastString
fsLit "TrNameS")        Unique
trNameSDataConKey
trNameDDataConName :: Name
trNameDDataConName    = Module -> FastString -> Unique -> Name
dcQual Module
gHC_TYPES          (String -> FastString
fsLit "TrNameD")        Unique
trNameDDataConKey
trTyConTyConName :: Name
trTyConTyConName      = Module -> FastString -> Unique -> Name
tcQual Module
gHC_TYPES          (String -> FastString
fsLit "TyCon")          Unique
trTyConTyConKey
trTyConDataConName :: Name
trTyConDataConName    = Module -> FastString -> Unique -> Name
dcQual Module
gHC_TYPES          (String -> FastString
fsLit "TyCon")          Unique
trTyConDataConKey

kindRepTyConName
  , kindRepTyConAppDataConName
  , kindRepVarDataConName
  , kindRepAppDataConName
  , kindRepFunDataConName
  , kindRepTYPEDataConName
  , kindRepTypeLitSDataConName
  , kindRepTypeLitDDataConName
  :: Name
kindRepTyConName :: Name
kindRepTyConName      = Module -> FastString -> Unique -> Name
tcQual Module
gHC_TYPES          (String -> FastString
fsLit "KindRep")        Unique
kindRepTyConKey
kindRepTyConAppDataConName :: Name
kindRepTyConAppDataConName = Module -> FastString -> Unique -> Name
dcQual Module
gHC_TYPES     (String -> FastString
fsLit "KindRepTyConApp") Unique
kindRepTyConAppDataConKey
kindRepVarDataConName :: Name
kindRepVarDataConName = Module -> FastString -> Unique -> Name
dcQual Module
gHC_TYPES          (String -> FastString
fsLit "KindRepVar")     Unique
kindRepVarDataConKey
kindRepAppDataConName :: Name
kindRepAppDataConName = Module -> FastString -> Unique -> Name
dcQual Module
gHC_TYPES          (String -> FastString
fsLit "KindRepApp")     Unique
kindRepAppDataConKey
kindRepFunDataConName :: Name
kindRepFunDataConName = Module -> FastString -> Unique -> Name
dcQual Module
gHC_TYPES          (String -> FastString
fsLit "KindRepFun")     Unique
kindRepFunDataConKey
kindRepTYPEDataConName :: Name
kindRepTYPEDataConName = Module -> FastString -> Unique -> Name
dcQual Module
gHC_TYPES         (String -> FastString
fsLit "KindRepTYPE")    Unique
kindRepTYPEDataConKey
kindRepTypeLitSDataConName :: Name
kindRepTypeLitSDataConName = Module -> FastString -> Unique -> Name
dcQual Module
gHC_TYPES     (String -> FastString
fsLit "KindRepTypeLitS") Unique
kindRepTypeLitSDataConKey
kindRepTypeLitDDataConName :: Name
kindRepTypeLitDDataConName = Module -> FastString -> Unique -> Name
dcQual Module
gHC_TYPES     (String -> FastString
fsLit "KindRepTypeLitD") Unique
kindRepTypeLitDDataConKey

typeLitSortTyConName
  , typeLitSymbolDataConName
  , typeLitNatDataConName
  :: Name
typeLitSortTyConName :: Name
typeLitSortTyConName     = Module -> FastString -> Unique -> Name
tcQual Module
gHC_TYPES       (String -> FastString
fsLit "TypeLitSort")    Unique
typeLitSortTyConKey
typeLitSymbolDataConName :: Name
typeLitSymbolDataConName = Module -> FastString -> Unique -> Name
dcQual Module
gHC_TYPES       (String -> FastString
fsLit "TypeLitSymbol")  Unique
typeLitSymbolDataConKey
typeLitNatDataConName :: Name
typeLitNatDataConName    = Module -> FastString -> Unique -> Name
dcQual Module
gHC_TYPES       (String -> FastString
fsLit "TypeLitNat")     Unique
typeLitNatDataConKey

-- Class Typeable, and functions for constructing `Typeable` dictionaries
typeableClassName
  , typeRepTyConName
  , someTypeRepTyConName
  , someTypeRepDataConName
  , mkTrTypeName
  , mkTrConName
  , mkTrAppName
  , mkTrFunName
  , typeRepIdName
  , typeNatTypeRepName
  , typeSymbolTypeRepName
  , trGhcPrimModuleName
  :: Name
typeableClassName :: Name
typeableClassName     = Module -> FastString -> Unique -> Name
clsQual Module
tYPEABLE_INTERNAL (String -> FastString
fsLit "Typeable")       Unique
typeableClassKey
typeRepTyConName :: Name
typeRepTyConName      = Module -> FastString -> Unique -> Name
tcQual  Module
tYPEABLE_INTERNAL (String -> FastString
fsLit "TypeRep")        Unique
typeRepTyConKey
someTypeRepTyConName :: Name
someTypeRepTyConName   = Module -> FastString -> Unique -> Name
tcQual Module
tYPEABLE_INTERNAL (String -> FastString
fsLit "SomeTypeRep")    Unique
someTypeRepTyConKey
someTypeRepDataConName :: Name
someTypeRepDataConName = Module -> FastString -> Unique -> Name
dcQual Module
tYPEABLE_INTERNAL (String -> FastString
fsLit "SomeTypeRep")    Unique
someTypeRepDataConKey
typeRepIdName :: Name
typeRepIdName         = Module -> FastString -> Unique -> Name
varQual Module
tYPEABLE_INTERNAL (String -> FastString
fsLit "typeRep#")       Unique
typeRepIdKey
mkTrTypeName :: Name
mkTrTypeName          = Module -> FastString -> Unique -> Name
varQual Module
tYPEABLE_INTERNAL (String -> FastString
fsLit "mkTrType")       Unique
mkTrTypeKey
mkTrConName :: Name
mkTrConName           = Module -> FastString -> Unique -> Name
varQual Module
tYPEABLE_INTERNAL (String -> FastString
fsLit "mkTrCon")        Unique
mkTrConKey
mkTrAppName :: Name
mkTrAppName           = Module -> FastString -> Unique -> Name
varQual Module
tYPEABLE_INTERNAL (String -> FastString
fsLit "mkTrApp")        Unique
mkTrAppKey
mkTrFunName :: Name
mkTrFunName           = Module -> FastString -> Unique -> Name
varQual Module
tYPEABLE_INTERNAL (String -> FastString
fsLit "mkTrFun")        Unique
mkTrFunKey
typeNatTypeRepName :: Name
typeNatTypeRepName    = Module -> FastString -> Unique -> Name
varQual Module
tYPEABLE_INTERNAL (String -> FastString
fsLit "typeNatTypeRep") Unique
typeNatTypeRepKey
typeSymbolTypeRepName :: Name
typeSymbolTypeRepName = Module -> FastString -> Unique -> Name
varQual Module
tYPEABLE_INTERNAL (String -> FastString
fsLit "typeSymbolTypeRep") Unique
typeSymbolTypeRepKey
-- this is the Typeable 'Module' for GHC.Prim (which has no code, so we place in GHC.Types)
-- See Note [Grand plan for Typeable] in TcTypeable.
trGhcPrimModuleName :: Name
trGhcPrimModuleName   = Module -> FastString -> Unique -> Name
varQual Module
gHC_TYPES         (String -> FastString
fsLit "tr$ModuleGHCPrim")  Unique
trGhcPrimModuleKey

-- Typeable KindReps for some common cases
starKindRepName, starArrStarKindRepName, starArrStarArrStarKindRepName :: Name
starKindRepName :: Name
starKindRepName        = Module -> FastString -> Unique -> Name
varQual Module
gHC_TYPES         (String -> FastString
fsLit "krep$*")         Unique
starKindRepKey
starArrStarKindRepName :: Name
starArrStarKindRepName = Module -> FastString -> Unique -> Name
varQual Module
gHC_TYPES         (String -> FastString
fsLit "krep$*Arr*")     Unique
starArrStarKindRepKey
starArrStarArrStarKindRepName :: Name
starArrStarArrStarKindRepName = Module -> FastString -> Unique -> Name
varQual Module
gHC_TYPES  (String -> FastString
fsLit "krep$*->*->*")   Unique
starArrStarArrStarKindRepKey

-- Custom type errors
errorMessageTypeErrorFamName
  , typeErrorTextDataConName
  , typeErrorAppendDataConName
  , typeErrorVAppendDataConName
  , typeErrorShowTypeDataConName
  :: Name

errorMessageTypeErrorFamName :: Name
errorMessageTypeErrorFamName =
  Module -> FastString -> Unique -> Name
tcQual Module
gHC_TYPELITS (String -> FastString
fsLit "TypeError") Unique
errorMessageTypeErrorFamKey

typeErrorTextDataConName :: Name
typeErrorTextDataConName =
  Module -> FastString -> Unique -> Name
dcQual Module
gHC_TYPELITS (String -> FastString
fsLit "Text") Unique
typeErrorTextDataConKey

typeErrorAppendDataConName :: Name
typeErrorAppendDataConName =
  Module -> FastString -> Unique -> Name
dcQual Module
gHC_TYPELITS (String -> FastString
fsLit ":<>:") Unique
typeErrorAppendDataConKey

typeErrorVAppendDataConName :: Name
typeErrorVAppendDataConName =
  Module -> FastString -> Unique -> Name
dcQual Module
gHC_TYPELITS (String -> FastString
fsLit ":$$:") Unique
typeErrorVAppendDataConKey

typeErrorShowTypeDataConName :: Name
typeErrorShowTypeDataConName =
  Module -> FastString -> Unique -> Name
dcQual Module
gHC_TYPELITS (String -> FastString
fsLit "ShowType") Unique
typeErrorShowTypeDataConKey



-- Dynamic
toDynName :: Name
toDynName :: Name
toDynName = Module -> FastString -> Unique -> Name
varQual Module
dYNAMIC (String -> FastString
fsLit "toDyn") Unique
toDynIdKey

-- Class Data
dataClassName :: Name
dataClassName :: Name
dataClassName = Module -> FastString -> Unique -> Name
clsQual Module
gENERICS (String -> FastString
fsLit "Data") Unique
dataClassKey

-- Error module
assertErrorName    :: Name
assertErrorName :: Name
assertErrorName   = Module -> FastString -> Unique -> Name
varQual Module
gHC_IO_Exception (String -> FastString
fsLit "assertError") Unique
assertErrorIdKey

-- Debug.Trace
traceName          :: Name
traceName :: Name
traceName         = Module -> FastString -> Unique -> Name
varQual Module
dEBUG_TRACE (String -> FastString
fsLit "trace") Unique
traceKey

-- Enum module (Enum, Bounded)
enumClassName, enumFromName, enumFromToName, enumFromThenName,
    enumFromThenToName, boundedClassName :: Name
enumClassName :: Name
enumClassName      = Module -> FastString -> Unique -> Name
clsQual Module
gHC_ENUM (String -> FastString
fsLit "Enum")           Unique
enumClassKey
enumFromName :: Name
enumFromName       = Module -> FastString -> Unique -> Name
varQual Module
gHC_ENUM (String -> FastString
fsLit "enumFrom")       Unique
enumFromClassOpKey
enumFromToName :: Name
enumFromToName     = Module -> FastString -> Unique -> Name
varQual Module
gHC_ENUM (String -> FastString
fsLit "enumFromTo")     Unique
enumFromToClassOpKey
enumFromThenName :: Name
enumFromThenName   = Module -> FastString -> Unique -> Name
varQual Module
gHC_ENUM (String -> FastString
fsLit "enumFromThen")   Unique
enumFromThenClassOpKey
enumFromThenToName :: Name
enumFromThenToName = Module -> FastString -> Unique -> Name
varQual Module
gHC_ENUM (String -> FastString
fsLit "enumFromThenTo") Unique
enumFromThenToClassOpKey
boundedClassName :: Name
boundedClassName   = Module -> FastString -> Unique -> Name
clsQual Module
gHC_ENUM (String -> FastString
fsLit "Bounded")        Unique
boundedClassKey

-- List functions
concatName, filterName, zipName :: Name
concatName :: Name
concatName        = Module -> FastString -> Unique -> Name
varQual Module
gHC_LIST (String -> FastString
fsLit "concat") Unique
concatIdKey
filterName :: Name
filterName        = Module -> FastString -> Unique -> Name
varQual Module
gHC_LIST (String -> FastString
fsLit "filter") Unique
filterIdKey
zipName :: Name
zipName           = Module -> FastString -> Unique -> Name
varQual Module
gHC_LIST (String -> FastString
fsLit "zip")    Unique
zipIdKey

-- Overloaded lists
isListClassName, fromListName, fromListNName, toListName :: Name
isListClassName :: Name
isListClassName = Module -> FastString -> Unique -> Name
clsQual Module
gHC_EXTS (String -> FastString
fsLit "IsList")    Unique
isListClassKey
fromListName :: Name
fromListName    = Module -> FastString -> Unique -> Name
varQual Module
gHC_EXTS (String -> FastString
fsLit "fromList")  Unique
fromListClassOpKey
fromListNName :: Name
fromListNName   = Module -> FastString -> Unique -> Name
varQual Module
gHC_EXTS (String -> FastString
fsLit "fromListN") Unique
fromListNClassOpKey
toListName :: Name
toListName      = Module -> FastString -> Unique -> Name
varQual Module
gHC_EXTS (String -> FastString
fsLit "toList")    Unique
toListClassOpKey

-- Class Show
showClassName :: Name
showClassName :: Name
showClassName   = Module -> FastString -> Unique -> Name
clsQual Module
gHC_SHOW (String -> FastString
fsLit "Show")      Unique
showClassKey

-- Class Read
readClassName :: Name
readClassName :: Name
readClassName   = Module -> FastString -> Unique -> Name
clsQual Module
gHC_READ (String -> FastString
fsLit "Read")      Unique
readClassKey

-- Classes Generic and Generic1, Datatype, Constructor and Selector
genClassName, gen1ClassName, datatypeClassName, constructorClassName,
  selectorClassName :: Name
genClassName :: Name
genClassName  = Module -> FastString -> Unique -> Name
clsQual Module
gHC_GENERICS (String -> FastString
fsLit "Generic")  Unique
genClassKey
gen1ClassName :: Name
gen1ClassName = Module -> FastString -> Unique -> Name
clsQual Module
gHC_GENERICS (String -> FastString
fsLit "Generic1") Unique
gen1ClassKey

datatypeClassName :: Name
datatypeClassName    = Module -> FastString -> Unique -> Name
clsQual Module
gHC_GENERICS (String -> FastString
fsLit "Datatype")    Unique
datatypeClassKey
constructorClassName :: Name
constructorClassName = Module -> FastString -> Unique -> Name
clsQual Module
gHC_GENERICS (String -> FastString
fsLit "Constructor") Unique
constructorClassKey
selectorClassName :: Name
selectorClassName    = Module -> FastString -> Unique -> Name
clsQual Module
gHC_GENERICS (String -> FastString
fsLit "Selector")    Unique
selectorClassKey

genericClassNames :: [Name]
genericClassNames :: [Name]
genericClassNames = [Name
genClassName, Name
gen1ClassName]

-- GHCi things
ghciIoClassName, ghciStepIoMName :: Name
ghciIoClassName :: Name
ghciIoClassName = Module -> FastString -> Unique -> Name
clsQual Module
gHC_GHCI (String -> FastString
fsLit "GHCiSandboxIO") Unique
ghciIoClassKey
ghciStepIoMName :: Name
ghciStepIoMName = Module -> FastString -> Unique -> Name
varQual Module
gHC_GHCI (String -> FastString
fsLit "ghciStepIO") Unique
ghciStepIoMClassOpKey

-- IO things
ioTyConName, ioDataConName,
  thenIOName, bindIOName, returnIOName, failIOName :: Name
ioTyConName :: Name
ioTyConName       = Module -> FastString -> Unique -> Name
tcQual  Module
gHC_TYPES (String -> FastString
fsLit "IO")       Unique
ioTyConKey
ioDataConName :: Name
ioDataConName     = Module -> FastString -> Unique -> Name
dcQual  Module
gHC_TYPES (String -> FastString
fsLit "IO")       Unique
ioDataConKey
thenIOName :: Name
thenIOName        = Module -> FastString -> Unique -> Name
varQual Module
gHC_BASE  (String -> FastString
fsLit "thenIO")   Unique
thenIOIdKey
bindIOName :: Name
bindIOName        = Module -> FastString -> Unique -> Name
varQual Module
gHC_BASE  (String -> FastString
fsLit "bindIO")   Unique
bindIOIdKey
returnIOName :: Name
returnIOName      = Module -> FastString -> Unique -> Name
varQual Module
gHC_BASE  (String -> FastString
fsLit "returnIO") Unique
returnIOIdKey
failIOName :: Name
failIOName        = Module -> FastString -> Unique -> Name
varQual Module
gHC_IO    (String -> FastString
fsLit "failIO")   Unique
failIOIdKey

-- IO things
printName :: Name
printName :: Name
printName         = Module -> FastString -> Unique -> Name
varQual Module
sYSTEM_IO (String -> FastString
fsLit "print") Unique
printIdKey

-- Int, Word, and Addr things
int8TyConName, int16TyConName, int32TyConName, int64TyConName :: Name
int8TyConName :: Name
int8TyConName     = Module -> FastString -> Unique -> Name
tcQual Module
gHC_INT  (String -> FastString
fsLit "Int8")  Unique
int8TyConKey
int16TyConName :: Name
int16TyConName    = Module -> FastString -> Unique -> Name
tcQual Module
gHC_INT  (String -> FastString
fsLit "Int16") Unique
int16TyConKey
int32TyConName :: Name
int32TyConName    = Module -> FastString -> Unique -> Name
tcQual Module
gHC_INT  (String -> FastString
fsLit "Int32") Unique
int32TyConKey
int64TyConName :: Name
int64TyConName    = Module -> FastString -> Unique -> Name
tcQual Module
gHC_INT  (String -> FastString
fsLit "Int64") Unique
int64TyConKey

-- Word module
word16TyConName, word32TyConName, word64TyConName :: Name
word16TyConName :: Name
word16TyConName   = Module -> FastString -> Unique -> Name
tcQual  Module
gHC_WORD (String -> FastString
fsLit "Word16") Unique
word16TyConKey
word32TyConName :: Name
word32TyConName   = Module -> FastString -> Unique -> Name
tcQual  Module
gHC_WORD (String -> FastString
fsLit "Word32") Unique
word32TyConKey
word64TyConName :: Name
word64TyConName   = Module -> FastString -> Unique -> Name
tcQual  Module
gHC_WORD (String -> FastString
fsLit "Word64") Unique
word64TyConKey

-- PrelPtr module
ptrTyConName, funPtrTyConName :: Name
ptrTyConName :: Name
ptrTyConName      = Module -> FastString -> Unique -> Name
tcQual   Module
gHC_PTR (String -> FastString
fsLit "Ptr")    Unique
ptrTyConKey
funPtrTyConName :: Name
funPtrTyConName   = Module -> FastString -> Unique -> Name
tcQual   Module
gHC_PTR (String -> FastString
fsLit "FunPtr") Unique
funPtrTyConKey

-- Foreign objects and weak pointers
stablePtrTyConName, newStablePtrName :: Name
stablePtrTyConName :: Name
stablePtrTyConName    = Module -> FastString -> Unique -> Name
tcQual   Module
gHC_STABLE (String -> FastString
fsLit "StablePtr")    Unique
stablePtrTyConKey
newStablePtrName :: Name
newStablePtrName      = Module -> FastString -> Unique -> Name
varQual  Module
gHC_STABLE (String -> FastString
fsLit "newStablePtr") Unique
newStablePtrIdKey

-- Recursive-do notation
monadFixClassName, mfixName :: Name
monadFixClassName :: Name
monadFixClassName  = Module -> FastString -> Unique -> Name
clsQual Module
mONAD_FIX (String -> FastString
fsLit "MonadFix") Unique
monadFixClassKey
mfixName :: Name
mfixName           = Module -> FastString -> Unique -> Name
varQual Module
mONAD_FIX (String -> FastString
fsLit "mfix")     Unique
mfixIdKey

-- Arrow notation
arrAName, composeAName, firstAName, appAName, choiceAName, loopAName :: Name
arrAName :: Name
arrAName           = Module -> FastString -> Unique -> Name
varQual Module
aRROW (String -> FastString
fsLit "arr")       Unique
arrAIdKey
composeAName :: Name
composeAName       = Module -> FastString -> Unique -> Name
varQual Module
gHC_DESUGAR (String -> FastString
fsLit ">>>") Unique
composeAIdKey
firstAName :: Name
firstAName         = Module -> FastString -> Unique -> Name
varQual Module
aRROW (String -> FastString
fsLit "first")     Unique
firstAIdKey
appAName :: Name
appAName           = Module -> FastString -> Unique -> Name
varQual Module
aRROW (String -> FastString
fsLit "app")       Unique
appAIdKey
choiceAName :: Name
choiceAName        = Module -> FastString -> Unique -> Name
varQual Module
aRROW (String -> FastString
fsLit "|||")       Unique
choiceAIdKey
loopAName :: Name
loopAName          = Module -> FastString -> Unique -> Name
varQual Module
aRROW (String -> FastString
fsLit "loop")      Unique
loopAIdKey

-- Monad comprehensions
guardMName, liftMName, mzipName :: Name
guardMName :: Name
guardMName         = Module -> FastString -> Unique -> Name
varQual Module
mONAD (String -> FastString
fsLit "guard")    Unique
guardMIdKey
liftMName :: Name
liftMName          = Module -> FastString -> Unique -> Name
varQual Module
mONAD (String -> FastString
fsLit "liftM")    Unique
liftMIdKey
mzipName :: Name
mzipName           = Module -> FastString -> Unique -> Name
varQual Module
mONAD_ZIP (String -> FastString
fsLit "mzip") Unique
mzipIdKey


-- Annotation type checking
toAnnotationWrapperName :: Name
toAnnotationWrapperName :: Name
toAnnotationWrapperName = Module -> FastString -> Unique -> Name
varQual Module
gHC_DESUGAR (String -> FastString
fsLit "toAnnotationWrapper") Unique
toAnnotationWrapperIdKey

-- Other classes, needed for type defaulting
monadPlusClassName, randomClassName, randomGenClassName,
    isStringClassName :: Name
monadPlusClassName :: Name
monadPlusClassName  = Module -> FastString -> Unique -> Name
clsQual Module
mONAD (String -> FastString
fsLit "MonadPlus")      Unique
monadPlusClassKey
randomClassName :: Name
randomClassName     = Module -> FastString -> Unique -> Name
clsQual Module
rANDOM (String -> FastString
fsLit "Random")        Unique
randomClassKey
randomGenClassName :: Name
randomGenClassName  = Module -> FastString -> Unique -> Name
clsQual Module
rANDOM (String -> FastString
fsLit "RandomGen")     Unique
randomGenClassKey
isStringClassName :: Name
isStringClassName   = Module -> FastString -> Unique -> Name
clsQual Module
dATA_STRING (String -> FastString
fsLit "IsString") Unique
isStringClassKey

-- Type-level naturals
knownNatClassName :: Name
knownNatClassName :: Name
knownNatClassName     = Module -> FastString -> Unique -> Name
clsQual Module
gHC_TYPENATS (String -> FastString
fsLit "KnownNat") Unique
knownNatClassNameKey
knownSymbolClassName :: Name
knownSymbolClassName :: Name
knownSymbolClassName  = Module -> FastString -> Unique -> Name
clsQual Module
gHC_TYPELITS (String -> FastString
fsLit "KnownSymbol") Unique
knownSymbolClassNameKey

-- Overloaded labels
isLabelClassName :: Name
isLabelClassName :: Name
isLabelClassName
 = Module -> FastString -> Unique -> Name
clsQual Module
gHC_OVER_LABELS (String -> FastString
fsLit "IsLabel") Unique
isLabelClassNameKey

-- Implicit Parameters
ipClassName :: Name
ipClassName :: Name
ipClassName
  = Module -> FastString -> Unique -> Name
clsQual Module
gHC_CLASSES (String -> FastString
fsLit "IP") Unique
ipClassKey

-- Overloaded record fields
hasFieldClassName :: Name
hasFieldClassName :: Name
hasFieldClassName
 = Module -> FastString -> Unique -> Name
clsQual Module
gHC_RECORDS (String -> FastString
fsLit "HasField") Unique
hasFieldClassNameKey

-- Source Locations
callStackTyConName, emptyCallStackName, pushCallStackName,
  srcLocDataConName :: Name
callStackTyConName :: Name
callStackTyConName
  = Module -> FastString -> Unique -> Name
tcQual Module
gHC_STACK_TYPES  (String -> FastString
fsLit "CallStack") Unique
callStackTyConKey
emptyCallStackName :: Name
emptyCallStackName
  = Module -> FastString -> Unique -> Name
varQual Module
gHC_STACK_TYPES (String -> FastString
fsLit "emptyCallStack") Unique
emptyCallStackKey
pushCallStackName :: Name
pushCallStackName
  = Module -> FastString -> Unique -> Name
varQual Module
gHC_STACK_TYPES (String -> FastString
fsLit "pushCallStack") Unique
pushCallStackKey
srcLocDataConName :: Name
srcLocDataConName
  = Module -> FastString -> Unique -> Name
dcQual Module
gHC_STACK_TYPES  (String -> FastString
fsLit "SrcLoc")    Unique
srcLocDataConKey

-- plugins
pLUGINS :: Module
pLUGINS :: Module
pLUGINS = FastString -> Module
mkThisGhcModule (String -> FastString
fsLit "Plugins")
pluginTyConName :: Name
pluginTyConName :: Name
pluginTyConName = Module -> FastString -> Unique -> Name
tcQual Module
pLUGINS (String -> FastString
fsLit "Plugin") Unique
pluginTyConKey
frontendPluginTyConName :: Name
frontendPluginTyConName :: Name
frontendPluginTyConName = Module -> FastString -> Unique -> Name
tcQual Module
pLUGINS (String -> FastString
fsLit "FrontendPlugin") Unique
frontendPluginTyConKey

-- Static pointers
makeStaticName :: Name
makeStaticName :: Name
makeStaticName =
    Module -> FastString -> Unique -> Name
varQual Module
gHC_STATICPTR_INTERNAL (String -> FastString
fsLit "makeStatic") Unique
makeStaticKey

staticPtrInfoTyConName :: Name
staticPtrInfoTyConName :: Name
staticPtrInfoTyConName =
    Module -> FastString -> Unique -> Name
tcQual Module
gHC_STATICPTR (String -> FastString
fsLit "StaticPtrInfo") Unique
staticPtrInfoTyConKey

staticPtrInfoDataConName :: Name
staticPtrInfoDataConName :: Name
staticPtrInfoDataConName =
    Module -> FastString -> Unique -> Name
dcQual Module
gHC_STATICPTR (String -> FastString
fsLit "StaticPtrInfo") Unique
staticPtrInfoDataConKey

staticPtrTyConName :: Name
staticPtrTyConName :: Name
staticPtrTyConName =
    Module -> FastString -> Unique -> Name
tcQual Module
gHC_STATICPTR (String -> FastString
fsLit "StaticPtr") Unique
staticPtrTyConKey

staticPtrDataConName :: Name
staticPtrDataConName :: Name
staticPtrDataConName =
    Module -> FastString -> Unique -> Name
dcQual Module
gHC_STATICPTR (String -> FastString
fsLit "StaticPtr") Unique
staticPtrDataConKey

fromStaticPtrName :: Name
fromStaticPtrName :: Name
fromStaticPtrName =
    Module -> FastString -> Unique -> Name
varQual Module
gHC_STATICPTR (String -> FastString
fsLit "fromStaticPtr") Unique
fromStaticPtrClassOpKey

fingerprintDataConName :: Name
fingerprintDataConName :: Name
fingerprintDataConName =
    Module -> FastString -> Unique -> Name
dcQual Module
gHC_FINGERPRINT_TYPE (String -> FastString
fsLit "Fingerprint") Unique
fingerprintDataConKey

{-
************************************************************************
*                                                                      *
\subsection{Local helpers}
*                                                                      *
************************************************************************

All these are original names; hence mkOrig
-}

varQual, tcQual, clsQual, dcQual :: Module -> FastString -> Unique -> Name
varQual :: Module -> FastString -> Unique -> Name
varQual  = NameSpace -> Module -> FastString -> Unique -> Name
mk_known_key_name NameSpace
varName
tcQual :: Module -> FastString -> Unique -> Name
tcQual   = NameSpace -> Module -> FastString -> Unique -> Name
mk_known_key_name NameSpace
tcName
clsQual :: Module -> FastString -> Unique -> Name
clsQual  = NameSpace -> Module -> FastString -> Unique -> Name
mk_known_key_name NameSpace
clsName
dcQual :: Module -> FastString -> Unique -> Name
dcQual   = NameSpace -> Module -> FastString -> Unique -> Name
mk_known_key_name NameSpace
dataName

mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name
mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name
mk_known_key_name space :: NameSpace
space modu :: Module
modu str :: FastString
str unique :: Unique
unique
  = Unique -> Module -> OccName -> SrcSpan -> Name
mkExternalName Unique
unique Module
modu (NameSpace -> FastString -> OccName
mkOccNameFS NameSpace
space FastString
str) SrcSpan
noSrcSpan


{-
************************************************************************
*                                                                      *
\subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
*                                                                      *
************************************************************************
--MetaHaskell extension hand allocate keys here
-}

boundedClassKey, enumClassKey, eqClassKey, floatingClassKey,
    fractionalClassKey, integralClassKey, monadClassKey, dataClassKey,
    functorClassKey, numClassKey, ordClassKey, readClassKey, realClassKey,
    realFloatClassKey, realFracClassKey, showClassKey, ixClassKey :: Unique
boundedClassKey :: Unique
boundedClassKey         = Int -> Unique
mkPreludeClassUnique 1
enumClassKey :: Unique
enumClassKey            = Int -> Unique
mkPreludeClassUnique 2
eqClassKey :: Unique
eqClassKey              = Int -> Unique
mkPreludeClassUnique 3
floatingClassKey :: Unique
floatingClassKey        = Int -> Unique
mkPreludeClassUnique 5
fractionalClassKey :: Unique
fractionalClassKey      = Int -> Unique
mkPreludeClassUnique 6
integralClassKey :: Unique
integralClassKey        = Int -> Unique
mkPreludeClassUnique 7
monadClassKey :: Unique
monadClassKey           = Int -> Unique
mkPreludeClassUnique 8
dataClassKey :: Unique
dataClassKey            = Int -> Unique
mkPreludeClassUnique 9
functorClassKey :: Unique
functorClassKey         = Int -> Unique
mkPreludeClassUnique 10
numClassKey :: Unique
numClassKey             = Int -> Unique
mkPreludeClassUnique 11
ordClassKey :: Unique
ordClassKey             = Int -> Unique
mkPreludeClassUnique 12
readClassKey :: Unique
readClassKey            = Int -> Unique
mkPreludeClassUnique 13
realClassKey :: Unique
realClassKey            = Int -> Unique
mkPreludeClassUnique 14
realFloatClassKey :: Unique
realFloatClassKey       = Int -> Unique
mkPreludeClassUnique 15
realFracClassKey :: Unique
realFracClassKey        = Int -> Unique
mkPreludeClassUnique 16
showClassKey :: Unique
showClassKey            = Int -> Unique
mkPreludeClassUnique 17
ixClassKey :: Unique
ixClassKey              = Int -> Unique
mkPreludeClassUnique 18

typeableClassKey, typeable1ClassKey, typeable2ClassKey, typeable3ClassKey,
    typeable4ClassKey, typeable5ClassKey, typeable6ClassKey, typeable7ClassKey
    :: Unique
typeableClassKey :: Unique
typeableClassKey        = Int -> Unique
mkPreludeClassUnique 20
typeable1ClassKey :: Unique
typeable1ClassKey       = Int -> Unique
mkPreludeClassUnique 21
typeable2ClassKey :: Unique
typeable2ClassKey       = Int -> Unique
mkPreludeClassUnique 22
typeable3ClassKey :: Unique
typeable3ClassKey       = Int -> Unique
mkPreludeClassUnique 23
typeable4ClassKey :: Unique
typeable4ClassKey       = Int -> Unique
mkPreludeClassUnique 24
typeable5ClassKey :: Unique
typeable5ClassKey       = Int -> Unique
mkPreludeClassUnique 25
typeable6ClassKey :: Unique
typeable6ClassKey       = Int -> Unique
mkPreludeClassUnique 26
typeable7ClassKey :: Unique
typeable7ClassKey       = Int -> Unique
mkPreludeClassUnique 27

monadFixClassKey :: Unique
monadFixClassKey :: Unique
monadFixClassKey        = Int -> Unique
mkPreludeClassUnique 28

monadFailClassKey :: Unique
monadFailClassKey :: Unique
monadFailClassKey       = Int -> Unique
mkPreludeClassUnique 29

monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique
monadPlusClassKey :: Unique
monadPlusClassKey       = Int -> Unique
mkPreludeClassUnique 30
randomClassKey :: Unique
randomClassKey          = Int -> Unique
mkPreludeClassUnique 31
randomGenClassKey :: Unique
randomGenClassKey       = Int -> Unique
mkPreludeClassUnique 32

isStringClassKey :: Unique
isStringClassKey :: Unique
isStringClassKey        = Int -> Unique
mkPreludeClassUnique 33

applicativeClassKey, foldableClassKey, traversableClassKey :: Unique
applicativeClassKey :: Unique
applicativeClassKey     = Int -> Unique
mkPreludeClassUnique 34
foldableClassKey :: Unique
foldableClassKey        = Int -> Unique
mkPreludeClassUnique 35
traversableClassKey :: Unique
traversableClassKey     = Int -> Unique
mkPreludeClassUnique 36

genClassKey, gen1ClassKey, datatypeClassKey, constructorClassKey,
  selectorClassKey :: Unique
genClassKey :: Unique
genClassKey   = Int -> Unique
mkPreludeClassUnique 37
gen1ClassKey :: Unique
gen1ClassKey  = Int -> Unique
mkPreludeClassUnique 38

datatypeClassKey :: Unique
datatypeClassKey    = Int -> Unique
mkPreludeClassUnique 39
constructorClassKey :: Unique
constructorClassKey = Int -> Unique
mkPreludeClassUnique 40
selectorClassKey :: Unique
selectorClassKey    = Int -> Unique
mkPreludeClassUnique 41

-- KnownNat: see Note [KnowNat & KnownSymbol and EvLit] in TcEvidence
knownNatClassNameKey :: Unique
knownNatClassNameKey :: Unique
knownNatClassNameKey = Int -> Unique
mkPreludeClassUnique 42

-- KnownSymbol: see Note [KnownNat & KnownSymbol and EvLit] in TcEvidence
knownSymbolClassNameKey :: Unique
knownSymbolClassNameKey :: Unique
knownSymbolClassNameKey = Int -> Unique
mkPreludeClassUnique 43

ghciIoClassKey :: Unique
ghciIoClassKey :: Unique
ghciIoClassKey = Int -> Unique
mkPreludeClassUnique 44

isLabelClassNameKey :: Unique
isLabelClassNameKey :: Unique
isLabelClassNameKey = Int -> Unique
mkPreludeClassUnique 45

semigroupClassKey, monoidClassKey :: Unique
semigroupClassKey :: Unique
semigroupClassKey = Int -> Unique
mkPreludeClassUnique 46
monoidClassKey :: Unique
monoidClassKey    = Int -> Unique
mkPreludeClassUnique 47

-- Implicit Parameters
ipClassKey :: Unique
ipClassKey :: Unique
ipClassKey = Int -> Unique
mkPreludeClassUnique 48

-- Overloaded record fields
hasFieldClassNameKey :: Unique
hasFieldClassNameKey :: Unique
hasFieldClassNameKey = Int -> Unique
mkPreludeClassUnique 49


---------------- Template Haskell -------------------
--      THNames.hs: USES ClassUniques 200-299
-----------------------------------------------------

{-
************************************************************************
*                                                                      *
\subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
*                                                                      *
************************************************************************
-}

addrPrimTyConKey, arrayPrimTyConKey, arrayArrayPrimTyConKey, boolTyConKey,
    byteArrayPrimTyConKey, charPrimTyConKey, charTyConKey, doublePrimTyConKey,
    doubleTyConKey, floatPrimTyConKey, floatTyConKey, funTyConKey,
    intPrimTyConKey, intTyConKey, int8TyConKey, int16TyConKey,
    int8PrimTyConKey, int16PrimTyConKey, int32PrimTyConKey, int32TyConKey,
    int64PrimTyConKey, int64TyConKey,
    integerTyConKey, naturalTyConKey,
    listTyConKey, foreignObjPrimTyConKey, maybeTyConKey,
    weakPrimTyConKey, mutableArrayPrimTyConKey, mutableArrayArrayPrimTyConKey,
    mutableByteArrayPrimTyConKey, orderingTyConKey, mVarPrimTyConKey,
    ratioTyConKey, rationalTyConKey, realWorldTyConKey, stablePtrPrimTyConKey,
    stablePtrTyConKey, eqTyConKey, heqTyConKey,
    smallArrayPrimTyConKey, smallMutableArrayPrimTyConKey :: Unique
addrPrimTyConKey :: Unique
addrPrimTyConKey                        = Int -> Unique
mkPreludeTyConUnique  1
arrayPrimTyConKey :: Unique
arrayPrimTyConKey                       = Int -> Unique
mkPreludeTyConUnique  3
boolTyConKey :: Unique
boolTyConKey                            = Int -> Unique
mkPreludeTyConUnique  4
byteArrayPrimTyConKey :: Unique
byteArrayPrimTyConKey                   = Int -> Unique
mkPreludeTyConUnique  5
charPrimTyConKey :: Unique
charPrimTyConKey                        = Int -> Unique
mkPreludeTyConUnique  7
charTyConKey :: Unique
charTyConKey                            = Int -> Unique
mkPreludeTyConUnique  8
doublePrimTyConKey :: Unique
doublePrimTyConKey                      = Int -> Unique
mkPreludeTyConUnique  9
doubleTyConKey :: Unique
doubleTyConKey                          = Int -> Unique
mkPreludeTyConUnique 10
floatPrimTyConKey :: Unique
floatPrimTyConKey                       = Int -> Unique
mkPreludeTyConUnique 11
floatTyConKey :: Unique
floatTyConKey                           = Int -> Unique
mkPreludeTyConUnique 12
funTyConKey :: Unique
funTyConKey                             = Int -> Unique
mkPreludeTyConUnique 13
intPrimTyConKey :: Unique
intPrimTyConKey                         = Int -> Unique
mkPreludeTyConUnique 14
intTyConKey :: Unique
intTyConKey                             = Int -> Unique
mkPreludeTyConUnique 15
int8PrimTyConKey :: Unique
int8PrimTyConKey                        = Int -> Unique
mkPreludeTyConUnique 16
int8TyConKey :: Unique
int8TyConKey                            = Int -> Unique
mkPreludeTyConUnique 17
int16PrimTyConKey :: Unique
int16PrimTyConKey                       = Int -> Unique
mkPreludeTyConUnique 18
int16TyConKey :: Unique
int16TyConKey                           = Int -> Unique
mkPreludeTyConUnique 19
int32PrimTyConKey :: Unique
int32PrimTyConKey                       = Int -> Unique
mkPreludeTyConUnique 20
int32TyConKey :: Unique
int32TyConKey                           = Int -> Unique
mkPreludeTyConUnique 21
int64PrimTyConKey :: Unique
int64PrimTyConKey                       = Int -> Unique
mkPreludeTyConUnique 22
int64TyConKey :: Unique
int64TyConKey                           = Int -> Unique
mkPreludeTyConUnique 23
integerTyConKey :: Unique
integerTyConKey                         = Int -> Unique
mkPreludeTyConUnique 24
naturalTyConKey :: Unique
naturalTyConKey                         = Int -> Unique
mkPreludeTyConUnique 25

listTyConKey :: Unique
listTyConKey                            = Int -> Unique
mkPreludeTyConUnique 26
foreignObjPrimTyConKey :: Unique
foreignObjPrimTyConKey                  = Int -> Unique
mkPreludeTyConUnique 27
maybeTyConKey :: Unique
maybeTyConKey                           = Int -> Unique
mkPreludeTyConUnique 28
weakPrimTyConKey :: Unique
weakPrimTyConKey                        = Int -> Unique
mkPreludeTyConUnique 29
mutableArrayPrimTyConKey :: Unique
mutableArrayPrimTyConKey                = Int -> Unique
mkPreludeTyConUnique 30
mutableByteArrayPrimTyConKey :: Unique
mutableByteArrayPrimTyConKey            = Int -> Unique
mkPreludeTyConUnique 31
orderingTyConKey :: Unique
orderingTyConKey                        = Int -> Unique
mkPreludeTyConUnique 32
mVarPrimTyConKey :: Unique
mVarPrimTyConKey                        = Int -> Unique
mkPreludeTyConUnique 33
ratioTyConKey :: Unique
ratioTyConKey                           = Int -> Unique
mkPreludeTyConUnique 34
rationalTyConKey :: Unique
rationalTyConKey                        = Int -> Unique
mkPreludeTyConUnique 35
realWorldTyConKey :: Unique
realWorldTyConKey                       = Int -> Unique
mkPreludeTyConUnique 36
stablePtrPrimTyConKey :: Unique
stablePtrPrimTyConKey                   = Int -> Unique
mkPreludeTyConUnique 37
stablePtrTyConKey :: Unique
stablePtrTyConKey                       = Int -> Unique
mkPreludeTyConUnique 38
eqTyConKey :: Unique
eqTyConKey                              = Int -> Unique
mkPreludeTyConUnique 40
heqTyConKey :: Unique
heqTyConKey                             = Int -> Unique
mkPreludeTyConUnique 41
arrayArrayPrimTyConKey :: Unique
arrayArrayPrimTyConKey                  = Int -> Unique
mkPreludeTyConUnique 42
mutableArrayArrayPrimTyConKey :: Unique
mutableArrayArrayPrimTyConKey           = Int -> Unique
mkPreludeTyConUnique 43

statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey,
    mutVarPrimTyConKey, ioTyConKey,
    wordPrimTyConKey, wordTyConKey, word8PrimTyConKey, word8TyConKey,
    word16PrimTyConKey, word16TyConKey, word32PrimTyConKey, word32TyConKey,
    word64PrimTyConKey, word64TyConKey,
    liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey,
    typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey,
    funPtrTyConKey, tVarPrimTyConKey, eqPrimTyConKey,
    eqReprPrimTyConKey, eqPhantPrimTyConKey, voidPrimTyConKey,
    compactPrimTyConKey :: Unique
statePrimTyConKey :: Unique
statePrimTyConKey                       = Int -> Unique
mkPreludeTyConUnique 50
stableNamePrimTyConKey :: Unique
stableNamePrimTyConKey                  = Int -> Unique
mkPreludeTyConUnique 51
stableNameTyConKey :: Unique
stableNameTyConKey                      = Int -> Unique
mkPreludeTyConUnique 52
eqPrimTyConKey :: Unique
eqPrimTyConKey                          = Int -> Unique
mkPreludeTyConUnique 53
eqReprPrimTyConKey :: Unique
eqReprPrimTyConKey                      = Int -> Unique
mkPreludeTyConUnique 54
eqPhantPrimTyConKey :: Unique
eqPhantPrimTyConKey                     = Int -> Unique
mkPreludeTyConUnique 55
mutVarPrimTyConKey :: Unique
mutVarPrimTyConKey                      = Int -> Unique
mkPreludeTyConUnique 56
ioTyConKey :: Unique
ioTyConKey                              = Int -> Unique
mkPreludeTyConUnique 57
voidPrimTyConKey :: Unique
voidPrimTyConKey                        = Int -> Unique
mkPreludeTyConUnique 58
wordPrimTyConKey :: Unique
wordPrimTyConKey                        = Int -> Unique
mkPreludeTyConUnique 59
wordTyConKey :: Unique
wordTyConKey                            = Int -> Unique
mkPreludeTyConUnique 60
word8PrimTyConKey :: Unique
word8PrimTyConKey                       = Int -> Unique
mkPreludeTyConUnique 61
word8TyConKey :: Unique
word8TyConKey                           = Int -> Unique
mkPreludeTyConUnique 62
word16PrimTyConKey :: Unique
word16PrimTyConKey                      = Int -> Unique
mkPreludeTyConUnique 63
word16TyConKey :: Unique
word16TyConKey                          = Int -> Unique
mkPreludeTyConUnique 64
word32PrimTyConKey :: Unique
word32PrimTyConKey                      = Int -> Unique
mkPreludeTyConUnique 65
word32TyConKey :: Unique
word32TyConKey                          = Int -> Unique
mkPreludeTyConUnique 66
word64PrimTyConKey :: Unique
word64PrimTyConKey                      = Int -> Unique
mkPreludeTyConUnique 67
word64TyConKey :: Unique
word64TyConKey                          = Int -> Unique
mkPreludeTyConUnique 68
liftedConKey :: Unique
liftedConKey                            = Int -> Unique
mkPreludeTyConUnique 69
unliftedConKey :: Unique
unliftedConKey                          = Int -> Unique
mkPreludeTyConUnique 70
anyBoxConKey :: Unique
anyBoxConKey                            = Int -> Unique
mkPreludeTyConUnique 71
kindConKey :: Unique
kindConKey                              = Int -> Unique
mkPreludeTyConUnique 72
boxityConKey :: Unique
boxityConKey                            = Int -> Unique
mkPreludeTyConUnique 73
typeConKey :: Unique
typeConKey                              = Int -> Unique
mkPreludeTyConUnique 74
threadIdPrimTyConKey :: Unique
threadIdPrimTyConKey                    = Int -> Unique
mkPreludeTyConUnique 75
bcoPrimTyConKey :: Unique
bcoPrimTyConKey                         = Int -> Unique
mkPreludeTyConUnique 76
ptrTyConKey :: Unique
ptrTyConKey                             = Int -> Unique
mkPreludeTyConUnique 77
funPtrTyConKey :: Unique
funPtrTyConKey                          = Int -> Unique
mkPreludeTyConUnique 78
tVarPrimTyConKey :: Unique
tVarPrimTyConKey                        = Int -> Unique
mkPreludeTyConUnique 79
compactPrimTyConKey :: Unique
compactPrimTyConKey                     = Int -> Unique
mkPreludeTyConUnique 80

-- dotnet interop
objectTyConKey :: Unique
objectTyConKey :: Unique
objectTyConKey                          = Int -> Unique
mkPreludeTyConUnique 83

eitherTyConKey :: Unique
eitherTyConKey :: Unique
eitherTyConKey                          = Int -> Unique
mkPreludeTyConUnique 84

-- Kind constructors
liftedTypeKindTyConKey, tYPETyConKey,
  constraintKindTyConKey, runtimeRepTyConKey,
  vecCountTyConKey, vecElemTyConKey :: Unique
liftedTypeKindTyConKey :: Unique
liftedTypeKindTyConKey                  = Int -> Unique
mkPreludeTyConUnique 87
tYPETyConKey :: Unique
tYPETyConKey                            = Int -> Unique
mkPreludeTyConUnique 88
constraintKindTyConKey :: Unique
constraintKindTyConKey                  = Int -> Unique
mkPreludeTyConUnique 92
runtimeRepTyConKey :: Unique
runtimeRepTyConKey                      = Int -> Unique
mkPreludeTyConUnique 95
vecCountTyConKey :: Unique
vecCountTyConKey                        = Int -> Unique
mkPreludeTyConUnique 96
vecElemTyConKey :: Unique
vecElemTyConKey                         = Int -> Unique
mkPreludeTyConUnique 97

pluginTyConKey, frontendPluginTyConKey :: Unique
pluginTyConKey :: Unique
pluginTyConKey                          = Int -> Unique
mkPreludeTyConUnique 102
frontendPluginTyConKey :: Unique
frontendPluginTyConKey                  = Int -> Unique
mkPreludeTyConUnique 103

unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey,
    opaqueTyConKey :: Unique
unknownTyConKey :: Unique
unknownTyConKey                         = Int -> Unique
mkPreludeTyConUnique 129
unknown1TyConKey :: Unique
unknown1TyConKey                        = Int -> Unique
mkPreludeTyConUnique 130
unknown2TyConKey :: Unique
unknown2TyConKey                        = Int -> Unique
mkPreludeTyConUnique 131
unknown3TyConKey :: Unique
unknown3TyConKey                        = Int -> Unique
mkPreludeTyConUnique 132
opaqueTyConKey :: Unique
opaqueTyConKey                          = Int -> Unique
mkPreludeTyConUnique 133

-- Generics (Unique keys)
v1TyConKey, u1TyConKey, par1TyConKey, rec1TyConKey,
  k1TyConKey, m1TyConKey, sumTyConKey, prodTyConKey,
  compTyConKey, rTyConKey, dTyConKey,
  cTyConKey, sTyConKey, rec0TyConKey,
  d1TyConKey, c1TyConKey, s1TyConKey, noSelTyConKey,
  repTyConKey, rep1TyConKey, uRecTyConKey,
  uAddrTyConKey, uCharTyConKey, uDoubleTyConKey,
  uFloatTyConKey, uIntTyConKey, uWordTyConKey :: Unique

v1TyConKey :: Unique
v1TyConKey    = Int -> Unique
mkPreludeTyConUnique 135
u1TyConKey :: Unique
u1TyConKey    = Int -> Unique
mkPreludeTyConUnique 136
par1TyConKey :: Unique
par1TyConKey  = Int -> Unique
mkPreludeTyConUnique 137
rec1TyConKey :: Unique
rec1TyConKey  = Int -> Unique
mkPreludeTyConUnique 138
k1TyConKey :: Unique
k1TyConKey    = Int -> Unique
mkPreludeTyConUnique 139
m1TyConKey :: Unique
m1TyConKey    = Int -> Unique
mkPreludeTyConUnique 140

sumTyConKey :: Unique
sumTyConKey   = Int -> Unique
mkPreludeTyConUnique 141
prodTyConKey :: Unique
prodTyConKey  = Int -> Unique
mkPreludeTyConUnique 142
compTyConKey :: Unique
compTyConKey  = Int -> Unique
mkPreludeTyConUnique 143

rTyConKey :: Unique
rTyConKey = Int -> Unique
mkPreludeTyConUnique 144
dTyConKey :: Unique
dTyConKey = Int -> Unique
mkPreludeTyConUnique 146
cTyConKey :: Unique
cTyConKey = Int -> Unique
mkPreludeTyConUnique 147
sTyConKey :: Unique
sTyConKey = Int -> Unique
mkPreludeTyConUnique 148

rec0TyConKey :: Unique
rec0TyConKey  = Int -> Unique
mkPreludeTyConUnique 149
d1TyConKey :: Unique
d1TyConKey    = Int -> Unique
mkPreludeTyConUnique 151
c1TyConKey :: Unique
c1TyConKey    = Int -> Unique
mkPreludeTyConUnique 152
s1TyConKey :: Unique
s1TyConKey    = Int -> Unique
mkPreludeTyConUnique 153
noSelTyConKey :: Unique
noSelTyConKey = Int -> Unique
mkPreludeTyConUnique 154

repTyConKey :: Unique
repTyConKey  = Int -> Unique
mkPreludeTyConUnique 155
rep1TyConKey :: Unique
rep1TyConKey = Int -> Unique
mkPreludeTyConUnique 156

uRecTyConKey :: Unique
uRecTyConKey    = Int -> Unique
mkPreludeTyConUnique 157
uAddrTyConKey :: Unique
uAddrTyConKey   = Int -> Unique
mkPreludeTyConUnique 158
uCharTyConKey :: Unique
uCharTyConKey   = Int -> Unique
mkPreludeTyConUnique 159
uDoubleTyConKey :: Unique
uDoubleTyConKey = Int -> Unique
mkPreludeTyConUnique 160
uFloatTyConKey :: Unique
uFloatTyConKey  = Int -> Unique
mkPreludeTyConUnique 161
uIntTyConKey :: Unique
uIntTyConKey    = Int -> Unique
mkPreludeTyConUnique 162
uWordTyConKey :: Unique
uWordTyConKey   = Int -> Unique
mkPreludeTyConUnique 163

-- Type-level naturals
typeNatKindConNameKey, typeSymbolKindConNameKey,
  typeNatAddTyFamNameKey, typeNatMulTyFamNameKey, typeNatExpTyFamNameKey,
  typeNatLeqTyFamNameKey, typeNatSubTyFamNameKey
  , typeSymbolCmpTyFamNameKey, typeNatCmpTyFamNameKey
  , typeNatDivTyFamNameKey
  , typeNatModTyFamNameKey
  , typeNatLogTyFamNameKey
  :: Unique
typeNatKindConNameKey :: Unique
typeNatKindConNameKey     = Int -> Unique
mkPreludeTyConUnique 164
typeSymbolKindConNameKey :: Unique
typeSymbolKindConNameKey  = Int -> Unique
mkPreludeTyConUnique 165
typeNatAddTyFamNameKey :: Unique
typeNatAddTyFamNameKey    = Int -> Unique
mkPreludeTyConUnique 166
typeNatMulTyFamNameKey :: Unique
typeNatMulTyFamNameKey    = Int -> Unique
mkPreludeTyConUnique 167
typeNatExpTyFamNameKey :: Unique
typeNatExpTyFamNameKey    = Int -> Unique
mkPreludeTyConUnique 168
typeNatLeqTyFamNameKey :: Unique
typeNatLeqTyFamNameKey    = Int -> Unique
mkPreludeTyConUnique 169
typeNatSubTyFamNameKey :: Unique
typeNatSubTyFamNameKey    = Int -> Unique
mkPreludeTyConUnique 170
typeSymbolCmpTyFamNameKey :: Unique
typeSymbolCmpTyFamNameKey = Int -> Unique
mkPreludeTyConUnique 171
typeNatCmpTyFamNameKey :: Unique
typeNatCmpTyFamNameKey    = Int -> Unique
mkPreludeTyConUnique 172
typeNatDivTyFamNameKey :: Unique
typeNatDivTyFamNameKey  = Int -> Unique
mkPreludeTyConUnique 173
typeNatModTyFamNameKey :: Unique
typeNatModTyFamNameKey  = Int -> Unique
mkPreludeTyConUnique 174
typeNatLogTyFamNameKey :: Unique
typeNatLogTyFamNameKey  = Int -> Unique
mkPreludeTyConUnique 175

-- Custom user type-errors
errorMessageTypeErrorFamKey :: Unique
errorMessageTypeErrorFamKey :: Unique
errorMessageTypeErrorFamKey =  Int -> Unique
mkPreludeTyConUnique 176



ntTyConKey:: Unique
ntTyConKey :: Unique
ntTyConKey = Int -> Unique
mkPreludeTyConUnique 177
coercibleTyConKey :: Unique
coercibleTyConKey :: Unique
coercibleTyConKey = Int -> Unique
mkPreludeTyConUnique 178

proxyPrimTyConKey :: Unique
proxyPrimTyConKey :: Unique
proxyPrimTyConKey = Int -> Unique
mkPreludeTyConUnique 179

specTyConKey :: Unique
specTyConKey :: Unique
specTyConKey = Int -> Unique
mkPreludeTyConUnique 180

anyTyConKey :: Unique
anyTyConKey :: Unique
anyTyConKey = Int -> Unique
mkPreludeTyConUnique 181

smallArrayPrimTyConKey :: Unique
smallArrayPrimTyConKey        = Int -> Unique
mkPreludeTyConUnique  182
smallMutableArrayPrimTyConKey :: Unique
smallMutableArrayPrimTyConKey = Int -> Unique
mkPreludeTyConUnique  183

staticPtrTyConKey  :: Unique
staticPtrTyConKey :: Unique
staticPtrTyConKey  = Int -> Unique
mkPreludeTyConUnique 184

staticPtrInfoTyConKey :: Unique
staticPtrInfoTyConKey :: Unique
staticPtrInfoTyConKey = Int -> Unique
mkPreludeTyConUnique 185

callStackTyConKey :: Unique
callStackTyConKey :: Unique
callStackTyConKey = Int -> Unique
mkPreludeTyConUnique 186

-- Typeables
typeRepTyConKey, someTypeRepTyConKey, someTypeRepDataConKey :: Unique
typeRepTyConKey :: Unique
typeRepTyConKey       = Int -> Unique
mkPreludeTyConUnique 187
someTypeRepTyConKey :: Unique
someTypeRepTyConKey   = Int -> Unique
mkPreludeTyConUnique 188
someTypeRepDataConKey :: Unique
someTypeRepDataConKey = Int -> Unique
mkPreludeTyConUnique 189


typeSymbolAppendFamNameKey :: Unique
typeSymbolAppendFamNameKey :: Unique
typeSymbolAppendFamNameKey = Int -> Unique
mkPreludeTyConUnique 190

---------------- Template Haskell -------------------
--      THNames.hs: USES TyConUniques 200-299
-----------------------------------------------------

----------------------- SIMD ------------------------
--      USES TyConUniques 300-399
-----------------------------------------------------

#include "primop-vector-uniques.hs-incl"

{-
************************************************************************
*                                                                      *
\subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
*                                                                      *
************************************************************************
-}

charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey,
    floatDataConKey, intDataConKey, integerSDataConKey, nilDataConKey,
    ratioDataConKey, stableNameDataConKey, trueDataConKey, wordDataConKey,
    word8DataConKey, ioDataConKey, integerDataConKey, heqDataConKey,
    coercibleDataConKey, eqDataConKey, nothingDataConKey, justDataConKey :: Unique

charDataConKey :: Unique
charDataConKey                          = Int -> Unique
mkPreludeDataConUnique  1
consDataConKey :: Unique
consDataConKey                          = Int -> Unique
mkPreludeDataConUnique  2
doubleDataConKey :: Unique
doubleDataConKey                        = Int -> Unique
mkPreludeDataConUnique  3
falseDataConKey :: Unique
falseDataConKey                         = Int -> Unique
mkPreludeDataConUnique  4
floatDataConKey :: Unique
floatDataConKey                         = Int -> Unique
mkPreludeDataConUnique  5
intDataConKey :: Unique
intDataConKey                           = Int -> Unique
mkPreludeDataConUnique  6
integerSDataConKey :: Unique
integerSDataConKey                      = Int -> Unique
mkPreludeDataConUnique  7
nothingDataConKey :: Unique
nothingDataConKey                       = Int -> Unique
mkPreludeDataConUnique  8
justDataConKey :: Unique
justDataConKey                          = Int -> Unique
mkPreludeDataConUnique  9
eqDataConKey :: Unique
eqDataConKey                            = Int -> Unique
mkPreludeDataConUnique 10
nilDataConKey :: Unique
nilDataConKey                           = Int -> Unique
mkPreludeDataConUnique 11
ratioDataConKey :: Unique
ratioDataConKey                         = Int -> Unique
mkPreludeDataConUnique 12
word8DataConKey :: Unique
word8DataConKey                         = Int -> Unique
mkPreludeDataConUnique 13
stableNameDataConKey :: Unique
stableNameDataConKey                    = Int -> Unique
mkPreludeDataConUnique 14
trueDataConKey :: Unique
trueDataConKey                          = Int -> Unique
mkPreludeDataConUnique 15
wordDataConKey :: Unique
wordDataConKey                          = Int -> Unique
mkPreludeDataConUnique 16
ioDataConKey :: Unique
ioDataConKey                            = Int -> Unique
mkPreludeDataConUnique 17
integerDataConKey :: Unique
integerDataConKey                       = Int -> Unique
mkPreludeDataConUnique 18
heqDataConKey :: Unique
heqDataConKey                           = Int -> Unique
mkPreludeDataConUnique 19

-- Generic data constructors
crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique
crossDataConKey :: Unique
crossDataConKey                         = Int -> Unique
mkPreludeDataConUnique 20
inlDataConKey :: Unique
inlDataConKey                           = Int -> Unique
mkPreludeDataConUnique 21
inrDataConKey :: Unique
inrDataConKey                           = Int -> Unique
mkPreludeDataConUnique 22
genUnitDataConKey :: Unique
genUnitDataConKey                       = Int -> Unique
mkPreludeDataConUnique 23

leftDataConKey, rightDataConKey :: Unique
leftDataConKey :: Unique
leftDataConKey                          = Int -> Unique
mkPreludeDataConUnique 25
rightDataConKey :: Unique
rightDataConKey                         = Int -> Unique
mkPreludeDataConUnique 26

ordLTDataConKey, ordEQDataConKey, ordGTDataConKey :: Unique
ordLTDataConKey :: Unique
ordLTDataConKey                         = Int -> Unique
mkPreludeDataConUnique 27
ordEQDataConKey :: Unique
ordEQDataConKey                         = Int -> Unique
mkPreludeDataConUnique 28
ordGTDataConKey :: Unique
ordGTDataConKey                         = Int -> Unique
mkPreludeDataConUnique 29


coercibleDataConKey :: Unique
coercibleDataConKey                     = Int -> Unique
mkPreludeDataConUnique 32

staticPtrDataConKey :: Unique
staticPtrDataConKey :: Unique
staticPtrDataConKey                     = Int -> Unique
mkPreludeDataConUnique 33

staticPtrInfoDataConKey :: Unique
staticPtrInfoDataConKey :: Unique
staticPtrInfoDataConKey                 = Int -> Unique
mkPreludeDataConUnique 34

fingerprintDataConKey :: Unique
fingerprintDataConKey :: Unique
fingerprintDataConKey                   = Int -> Unique
mkPreludeDataConUnique 35

srcLocDataConKey :: Unique
srcLocDataConKey :: Unique
srcLocDataConKey                        = Int -> Unique
mkPreludeDataConUnique 37

trTyConTyConKey, trTyConDataConKey,
  trModuleTyConKey, trModuleDataConKey,
  trNameTyConKey, trNameSDataConKey, trNameDDataConKey,
  trGhcPrimModuleKey, kindRepTyConKey,
  typeLitSortTyConKey :: Unique
trTyConTyConKey :: Unique
trTyConTyConKey                         = Int -> Unique
mkPreludeDataConUnique 40
trTyConDataConKey :: Unique
trTyConDataConKey                       = Int -> Unique
mkPreludeDataConUnique 41
trModuleTyConKey :: Unique
trModuleTyConKey                        = Int -> Unique
mkPreludeDataConUnique 42
trModuleDataConKey :: Unique
trModuleDataConKey                      = Int -> Unique
mkPreludeDataConUnique 43
trNameTyConKey :: Unique
trNameTyConKey                          = Int -> Unique
mkPreludeDataConUnique 44
trNameSDataConKey :: Unique
trNameSDataConKey                       = Int -> Unique
mkPreludeDataConUnique 45
trNameDDataConKey :: Unique
trNameDDataConKey                       = Int -> Unique
mkPreludeDataConUnique 46
trGhcPrimModuleKey :: Unique
trGhcPrimModuleKey                      = Int -> Unique
mkPreludeDataConUnique 47
kindRepTyConKey :: Unique
kindRepTyConKey                         = Int -> Unique
mkPreludeDataConUnique 48
typeLitSortTyConKey :: Unique
typeLitSortTyConKey                     = Int -> Unique
mkPreludeDataConUnique 49

typeErrorTextDataConKey,
  typeErrorAppendDataConKey,
  typeErrorVAppendDataConKey,
  typeErrorShowTypeDataConKey
  :: Unique
typeErrorTextDataConKey :: Unique
typeErrorTextDataConKey                 = Int -> Unique
mkPreludeDataConUnique 50
typeErrorAppendDataConKey :: Unique
typeErrorAppendDataConKey               = Int -> Unique
mkPreludeDataConUnique 51
typeErrorVAppendDataConKey :: Unique
typeErrorVAppendDataConKey              = Int -> Unique
mkPreludeDataConUnique 52
typeErrorShowTypeDataConKey :: Unique
typeErrorShowTypeDataConKey             = Int -> Unique
mkPreludeDataConUnique 53

prefixIDataConKey, infixIDataConKey, leftAssociativeDataConKey,
    rightAssociativeDataConKey, notAssociativeDataConKey,
    sourceUnpackDataConKey, sourceNoUnpackDataConKey,
    noSourceUnpackednessDataConKey, sourceLazyDataConKey,
    sourceStrictDataConKey, noSourceStrictnessDataConKey,
    decidedLazyDataConKey, decidedStrictDataConKey, decidedUnpackDataConKey,
    metaDataDataConKey, metaConsDataConKey, metaSelDataConKey :: Unique
prefixIDataConKey :: Unique
prefixIDataConKey                       = Int -> Unique
mkPreludeDataConUnique 54
infixIDataConKey :: Unique
infixIDataConKey                        = Int -> Unique
mkPreludeDataConUnique 55
leftAssociativeDataConKey :: Unique
leftAssociativeDataConKey               = Int -> Unique
mkPreludeDataConUnique 56
rightAssociativeDataConKey :: Unique
rightAssociativeDataConKey              = Int -> Unique
mkPreludeDataConUnique 57
notAssociativeDataConKey :: Unique
notAssociativeDataConKey                = Int -> Unique
mkPreludeDataConUnique 58
sourceUnpackDataConKey :: Unique
sourceUnpackDataConKey                  = Int -> Unique
mkPreludeDataConUnique 59
sourceNoUnpackDataConKey :: Unique
sourceNoUnpackDataConKey                = Int -> Unique
mkPreludeDataConUnique 60
noSourceUnpackednessDataConKey :: Unique
noSourceUnpackednessDataConKey          = Int -> Unique
mkPreludeDataConUnique 61
sourceLazyDataConKey :: Unique
sourceLazyDataConKey                    = Int -> Unique
mkPreludeDataConUnique 62
sourceStrictDataConKey :: Unique
sourceStrictDataConKey                  = Int -> Unique
mkPreludeDataConUnique 63
noSourceStrictnessDataConKey :: Unique
noSourceStrictnessDataConKey            = Int -> Unique
mkPreludeDataConUnique 64
decidedLazyDataConKey :: Unique
decidedLazyDataConKey                   = Int -> Unique
mkPreludeDataConUnique 65
decidedStrictDataConKey :: Unique
decidedStrictDataConKey                 = Int -> Unique
mkPreludeDataConUnique 66
decidedUnpackDataConKey :: Unique
decidedUnpackDataConKey                 = Int -> Unique
mkPreludeDataConUnique 67
metaDataDataConKey :: Unique
metaDataDataConKey                      = Int -> Unique
mkPreludeDataConUnique 68
metaConsDataConKey :: Unique
metaConsDataConKey                      = Int -> Unique
mkPreludeDataConUnique 69
metaSelDataConKey :: Unique
metaSelDataConKey                       = Int -> Unique
mkPreludeDataConUnique 70

vecRepDataConKey, tupleRepDataConKey, sumRepDataConKey :: Unique
vecRepDataConKey :: Unique
vecRepDataConKey                        = Int -> Unique
mkPreludeDataConUnique 71
tupleRepDataConKey :: Unique
tupleRepDataConKey                      = Int -> Unique
mkPreludeDataConUnique 72
sumRepDataConKey :: Unique
sumRepDataConKey                        = Int -> Unique
mkPreludeDataConUnique 73

-- See Note [Wiring in RuntimeRep] in TysWiredIn
runtimeRepSimpleDataConKeys, unliftedSimpleRepDataConKeys, unliftedRepDataConKeys :: [Unique]
liftedRepDataConKey :: Unique
runtimeRepSimpleDataConKeys :: [Unique]
runtimeRepSimpleDataConKeys@(liftedRepDataConKey :: Unique
liftedRepDataConKey : unliftedSimpleRepDataConKeys :: [Unique]
unliftedSimpleRepDataConKeys)
  = (Int -> Unique) -> [Int] -> [Unique]
forall a b. (a -> b) -> [a] -> [b]
map Int -> Unique
mkPreludeDataConUnique [74..86]

unliftedRepDataConKeys :: [Unique]
unliftedRepDataConKeys = Unique
vecRepDataConKey Unique -> [Unique] -> [Unique]
forall a. a -> [a] -> [a]
:
                         Unique
tupleRepDataConKey Unique -> [Unique] -> [Unique]
forall a. a -> [a] -> [a]
:
                         Unique
sumRepDataConKey Unique -> [Unique] -> [Unique]
forall a. a -> [a] -> [a]
:
                         [Unique]
unliftedSimpleRepDataConKeys

-- See Note [Wiring in RuntimeRep] in TysWiredIn
-- VecCount
vecCountDataConKeys :: [Unique]
vecCountDataConKeys :: [Unique]
vecCountDataConKeys = (Int -> Unique) -> [Int] -> [Unique]
forall a b. (a -> b) -> [a] -> [b]
map Int -> Unique
mkPreludeDataConUnique [87..92]

-- See Note [Wiring in RuntimeRep] in TysWiredIn
-- VecElem
vecElemDataConKeys :: [Unique]
vecElemDataConKeys :: [Unique]
vecElemDataConKeys = (Int -> Unique) -> [Int] -> [Unique]
forall a b. (a -> b) -> [a] -> [b]
map Int -> Unique
mkPreludeDataConUnique [93..102]

-- Typeable things
kindRepTyConAppDataConKey, kindRepVarDataConKey, kindRepAppDataConKey,
    kindRepFunDataConKey, kindRepTYPEDataConKey,
    kindRepTypeLitSDataConKey, kindRepTypeLitDDataConKey
    :: Unique
kindRepTyConAppDataConKey :: Unique
kindRepTyConAppDataConKey = Int -> Unique
mkPreludeDataConUnique 103
kindRepVarDataConKey :: Unique
kindRepVarDataConKey      = Int -> Unique
mkPreludeDataConUnique 104
kindRepAppDataConKey :: Unique
kindRepAppDataConKey      = Int -> Unique
mkPreludeDataConUnique 105
kindRepFunDataConKey :: Unique
kindRepFunDataConKey      = Int -> Unique
mkPreludeDataConUnique 106
kindRepTYPEDataConKey :: Unique
kindRepTYPEDataConKey     = Int -> Unique
mkPreludeDataConUnique 107
kindRepTypeLitSDataConKey :: Unique
kindRepTypeLitSDataConKey = Int -> Unique
mkPreludeDataConUnique 108
kindRepTypeLitDDataConKey :: Unique
kindRepTypeLitDDataConKey = Int -> Unique
mkPreludeDataConUnique 109

typeLitSymbolDataConKey, typeLitNatDataConKey :: Unique
typeLitSymbolDataConKey :: Unique
typeLitSymbolDataConKey   = Int -> Unique
mkPreludeDataConUnique 110
typeLitNatDataConKey :: Unique
typeLitNatDataConKey      = Int -> Unique
mkPreludeDataConUnique 111


---------------- Template Haskell -------------------
--      THNames.hs: USES DataUniques 200-250
-----------------------------------------------------


{-
************************************************************************
*                                                                      *
\subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
*                                                                      *
************************************************************************
-}

wildCardKey, absentErrorIdKey, augmentIdKey, appendIdKey,
    buildIdKey, errorIdKey, foldrIdKey, recSelErrorIdKey,
    seqIdKey, eqStringIdKey,
    noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey,
    runtimeErrorIdKey, patErrorIdKey, voidPrimIdKey,
    realWorldPrimIdKey, recConErrorIdKey,
    unpackCStringUtf8IdKey, unpackCStringAppendIdKey,
    unpackCStringFoldrIdKey, unpackCStringIdKey,
    typeErrorIdKey, divIntIdKey, modIntIdKey,
    absentSumFieldErrorIdKey :: Unique

wildCardKey :: Unique
wildCardKey                   = Int -> Unique
mkPreludeMiscIdUnique  0  -- See Note [WildCard binders]
absentErrorIdKey :: Unique
absentErrorIdKey              = Int -> Unique
mkPreludeMiscIdUnique  1
augmentIdKey :: Unique
augmentIdKey                  = Int -> Unique
mkPreludeMiscIdUnique  2
appendIdKey :: Unique
appendIdKey                   = Int -> Unique
mkPreludeMiscIdUnique  3
buildIdKey :: Unique
buildIdKey                    = Int -> Unique
mkPreludeMiscIdUnique  4
errorIdKey :: Unique
errorIdKey                    = Int -> Unique
mkPreludeMiscIdUnique  5
foldrIdKey :: Unique
foldrIdKey                    = Int -> Unique
mkPreludeMiscIdUnique  6
recSelErrorIdKey :: Unique
recSelErrorIdKey              = Int -> Unique
mkPreludeMiscIdUnique  7
seqIdKey :: Unique
seqIdKey                      = Int -> Unique
mkPreludeMiscIdUnique  8
eqStringIdKey :: Unique
eqStringIdKey                 = Int -> Unique
mkPreludeMiscIdUnique 10
noMethodBindingErrorIdKey :: Unique
noMethodBindingErrorIdKey     = Int -> Unique
mkPreludeMiscIdUnique 11
nonExhaustiveGuardsErrorIdKey :: Unique
nonExhaustiveGuardsErrorIdKey = Int -> Unique
mkPreludeMiscIdUnique 12
runtimeErrorIdKey :: Unique
runtimeErrorIdKey             = Int -> Unique
mkPreludeMiscIdUnique 13
patErrorIdKey :: Unique
patErrorIdKey                 = Int -> Unique
mkPreludeMiscIdUnique 14
realWorldPrimIdKey :: Unique
realWorldPrimIdKey            = Int -> Unique
mkPreludeMiscIdUnique 15
recConErrorIdKey :: Unique
recConErrorIdKey              = Int -> Unique
mkPreludeMiscIdUnique 16
unpackCStringUtf8IdKey :: Unique
unpackCStringUtf8IdKey        = Int -> Unique
mkPreludeMiscIdUnique 17
unpackCStringAppendIdKey :: Unique
unpackCStringAppendIdKey      = Int -> Unique
mkPreludeMiscIdUnique 18
unpackCStringFoldrIdKey :: Unique
unpackCStringFoldrIdKey       = Int -> Unique
mkPreludeMiscIdUnique 19
unpackCStringIdKey :: Unique
unpackCStringIdKey            = Int -> Unique
mkPreludeMiscIdUnique 20
voidPrimIdKey :: Unique
voidPrimIdKey                 = Int -> Unique
mkPreludeMiscIdUnique 21
typeErrorIdKey :: Unique
typeErrorIdKey                = Int -> Unique
mkPreludeMiscIdUnique 22
divIntIdKey :: Unique
divIntIdKey                   = Int -> Unique
mkPreludeMiscIdUnique 23
modIntIdKey :: Unique
modIntIdKey                   = Int -> Unique
mkPreludeMiscIdUnique 24
absentSumFieldErrorIdKey :: Unique
absentSumFieldErrorIdKey      = Int -> Unique
mkPreludeMiscIdUnique 9

unsafeCoerceIdKey, concatIdKey, filterIdKey, zipIdKey, bindIOIdKey,
    returnIOIdKey, newStablePtrIdKey,
    printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey,
    fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey :: Unique
unsafeCoerceIdKey :: Unique
unsafeCoerceIdKey             = Int -> Unique
mkPreludeMiscIdUnique 30
concatIdKey :: Unique
concatIdKey                   = Int -> Unique
mkPreludeMiscIdUnique 31
filterIdKey :: Unique
filterIdKey                   = Int -> Unique
mkPreludeMiscIdUnique 32
zipIdKey :: Unique
zipIdKey                      = Int -> Unique
mkPreludeMiscIdUnique 33
bindIOIdKey :: Unique
bindIOIdKey                   = Int -> Unique
mkPreludeMiscIdUnique 34
returnIOIdKey :: Unique
returnIOIdKey                 = Int -> Unique
mkPreludeMiscIdUnique 35
newStablePtrIdKey :: Unique
newStablePtrIdKey             = Int -> Unique
mkPreludeMiscIdUnique 36
printIdKey :: Unique
printIdKey                    = Int -> Unique
mkPreludeMiscIdUnique 37
failIOIdKey :: Unique
failIOIdKey                   = Int -> Unique
mkPreludeMiscIdUnique 38
nullAddrIdKey :: Unique
nullAddrIdKey                 = Int -> Unique
mkPreludeMiscIdUnique 39
voidArgIdKey :: Unique
voidArgIdKey                  = Int -> Unique
mkPreludeMiscIdUnique 40
fstIdKey :: Unique
fstIdKey                      = Int -> Unique
mkPreludeMiscIdUnique 41
sndIdKey :: Unique
sndIdKey                      = Int -> Unique
mkPreludeMiscIdUnique 42
otherwiseIdKey :: Unique
otherwiseIdKey                = Int -> Unique
mkPreludeMiscIdUnique 43
assertIdKey :: Unique
assertIdKey                   = Int -> Unique
mkPreludeMiscIdUnique 44

mkIntegerIdKey, smallIntegerIdKey, wordToIntegerIdKey,
    integerToWordIdKey, integerToIntIdKey,
    integerToWord64IdKey, integerToInt64IdKey,
    word64ToIntegerIdKey, int64ToIntegerIdKey,
    plusIntegerIdKey, timesIntegerIdKey, minusIntegerIdKey,
    negateIntegerIdKey,
    eqIntegerPrimIdKey, neqIntegerPrimIdKey, absIntegerIdKey, signumIntegerIdKey,
    leIntegerPrimIdKey, gtIntegerPrimIdKey, ltIntegerPrimIdKey, geIntegerPrimIdKey,
    compareIntegerIdKey, quotRemIntegerIdKey, divModIntegerIdKey,
    quotIntegerIdKey, remIntegerIdKey, divIntegerIdKey, modIntegerIdKey,
    floatFromIntegerIdKey, doubleFromIntegerIdKey,
    encodeFloatIntegerIdKey, encodeDoubleIntegerIdKey,
    decodeDoubleIntegerIdKey,
    gcdIntegerIdKey, lcmIntegerIdKey,
    andIntegerIdKey, orIntegerIdKey, xorIntegerIdKey, complementIntegerIdKey,
    shiftLIntegerIdKey, shiftRIntegerIdKey :: Unique
mkIntegerIdKey :: Unique
mkIntegerIdKey                = Int -> Unique
mkPreludeMiscIdUnique 60
smallIntegerIdKey :: Unique
smallIntegerIdKey             = Int -> Unique
mkPreludeMiscIdUnique 61
integerToWordIdKey :: Unique
integerToWordIdKey            = Int -> Unique
mkPreludeMiscIdUnique 62
integerToIntIdKey :: Unique
integerToIntIdKey             = Int -> Unique
mkPreludeMiscIdUnique 63
integerToWord64IdKey :: Unique
integerToWord64IdKey          = Int -> Unique
mkPreludeMiscIdUnique 64
integerToInt64IdKey :: Unique
integerToInt64IdKey           = Int -> Unique
mkPreludeMiscIdUnique 65
plusIntegerIdKey :: Unique
plusIntegerIdKey              = Int -> Unique
mkPreludeMiscIdUnique 66
timesIntegerIdKey :: Unique
timesIntegerIdKey             = Int -> Unique
mkPreludeMiscIdUnique 67
minusIntegerIdKey :: Unique
minusIntegerIdKey             = Int -> Unique
mkPreludeMiscIdUnique 68
negateIntegerIdKey :: Unique
negateIntegerIdKey            = Int -> Unique
mkPreludeMiscIdUnique 69
eqIntegerPrimIdKey :: Unique
eqIntegerPrimIdKey            = Int -> Unique
mkPreludeMiscIdUnique 70
neqIntegerPrimIdKey :: Unique
neqIntegerPrimIdKey           = Int -> Unique
mkPreludeMiscIdUnique 71
absIntegerIdKey :: Unique
absIntegerIdKey               = Int -> Unique
mkPreludeMiscIdUnique 72
signumIntegerIdKey :: Unique
signumIntegerIdKey            = Int -> Unique
mkPreludeMiscIdUnique 73
leIntegerPrimIdKey :: Unique
leIntegerPrimIdKey            = Int -> Unique
mkPreludeMiscIdUnique 74
gtIntegerPrimIdKey :: Unique
gtIntegerPrimIdKey            = Int -> Unique
mkPreludeMiscIdUnique 75
ltIntegerPrimIdKey :: Unique
ltIntegerPrimIdKey            = Int -> Unique
mkPreludeMiscIdUnique 76
geIntegerPrimIdKey :: Unique
geIntegerPrimIdKey            = Int -> Unique
mkPreludeMiscIdUnique 77
compareIntegerIdKey :: Unique
compareIntegerIdKey           = Int -> Unique
mkPreludeMiscIdUnique 78
quotIntegerIdKey :: Unique
quotIntegerIdKey              = Int -> Unique
mkPreludeMiscIdUnique 79
remIntegerIdKey :: Unique
remIntegerIdKey               = Int -> Unique
mkPreludeMiscIdUnique 80
divIntegerIdKey :: Unique
divIntegerIdKey               = Int -> Unique
mkPreludeMiscIdUnique 81
modIntegerIdKey :: Unique
modIntegerIdKey               = Int -> Unique
mkPreludeMiscIdUnique 82
divModIntegerIdKey :: Unique
divModIntegerIdKey            = Int -> Unique
mkPreludeMiscIdUnique 83
quotRemIntegerIdKey :: Unique
quotRemIntegerIdKey           = Int -> Unique
mkPreludeMiscIdUnique 84
floatFromIntegerIdKey :: Unique
floatFromIntegerIdKey         = Int -> Unique
mkPreludeMiscIdUnique 85
doubleFromIntegerIdKey :: Unique
doubleFromIntegerIdKey        = Int -> Unique
mkPreludeMiscIdUnique 86
encodeFloatIntegerIdKey :: Unique
encodeFloatIntegerIdKey       = Int -> Unique
mkPreludeMiscIdUnique 87
encodeDoubleIntegerIdKey :: Unique
encodeDoubleIntegerIdKey      = Int -> Unique
mkPreludeMiscIdUnique 88
gcdIntegerIdKey :: Unique
gcdIntegerIdKey               = Int -> Unique
mkPreludeMiscIdUnique 89
lcmIntegerIdKey :: Unique
lcmIntegerIdKey               = Int -> Unique
mkPreludeMiscIdUnique 90
andIntegerIdKey :: Unique
andIntegerIdKey               = Int -> Unique
mkPreludeMiscIdUnique 91
orIntegerIdKey :: Unique
orIntegerIdKey                = Int -> Unique
mkPreludeMiscIdUnique 92
xorIntegerIdKey :: Unique
xorIntegerIdKey               = Int -> Unique
mkPreludeMiscIdUnique 93
complementIntegerIdKey :: Unique
complementIntegerIdKey        = Int -> Unique
mkPreludeMiscIdUnique 94
shiftLIntegerIdKey :: Unique
shiftLIntegerIdKey            = Int -> Unique
mkPreludeMiscIdUnique 95
shiftRIntegerIdKey :: Unique
shiftRIntegerIdKey            = Int -> Unique
mkPreludeMiscIdUnique 96
wordToIntegerIdKey :: Unique
wordToIntegerIdKey            = Int -> Unique
mkPreludeMiscIdUnique 97
word64ToIntegerIdKey :: Unique
word64ToIntegerIdKey          = Int -> Unique
mkPreludeMiscIdUnique 98
int64ToIntegerIdKey :: Unique
int64ToIntegerIdKey           = Int -> Unique
mkPreludeMiscIdUnique 99
decodeDoubleIntegerIdKey :: Unique
decodeDoubleIntegerIdKey      = Int -> Unique
mkPreludeMiscIdUnique 100

rootMainKey, runMainKey :: Unique
rootMainKey :: Unique
rootMainKey                   = Int -> Unique
mkPreludeMiscIdUnique 101
runMainKey :: Unique
runMainKey                    = Int -> Unique
mkPreludeMiscIdUnique 102

thenIOIdKey, lazyIdKey, assertErrorIdKey, oneShotKey, runRWKey :: Unique
thenIOIdKey :: Unique
thenIOIdKey                   = Int -> Unique
mkPreludeMiscIdUnique 103
lazyIdKey :: Unique
lazyIdKey                     = Int -> Unique
mkPreludeMiscIdUnique 104
assertErrorIdKey :: Unique
assertErrorIdKey              = Int -> Unique
mkPreludeMiscIdUnique 105
oneShotKey :: Unique
oneShotKey                    = Int -> Unique
mkPreludeMiscIdUnique 106
runRWKey :: Unique
runRWKey                      = Int -> Unique
mkPreludeMiscIdUnique 107

traceKey :: Unique
traceKey :: Unique
traceKey                      = Int -> Unique
mkPreludeMiscIdUnique 108

breakpointIdKey, breakpointCondIdKey, breakpointAutoIdKey,
    breakpointJumpIdKey, breakpointCondJumpIdKey,
    breakpointAutoJumpIdKey :: Unique
breakpointIdKey :: Unique
breakpointIdKey               = Int -> Unique
mkPreludeMiscIdUnique 110
breakpointCondIdKey :: Unique
breakpointCondIdKey           = Int -> Unique
mkPreludeMiscIdUnique 111
breakpointAutoIdKey :: Unique
breakpointAutoIdKey           = Int -> Unique
mkPreludeMiscIdUnique 112
breakpointJumpIdKey :: Unique
breakpointJumpIdKey           = Int -> Unique
mkPreludeMiscIdUnique 113
breakpointCondJumpIdKey :: Unique
breakpointCondJumpIdKey       = Int -> Unique
mkPreludeMiscIdUnique 114
breakpointAutoJumpIdKey :: Unique
breakpointAutoJumpIdKey       = Int -> Unique
mkPreludeMiscIdUnique 115

inlineIdKey, noinlineIdKey :: Unique
inlineIdKey :: Unique
inlineIdKey                   = Int -> Unique
mkPreludeMiscIdUnique 120
-- see below

mapIdKey, groupWithIdKey, dollarIdKey :: Unique
mapIdKey :: Unique
mapIdKey              = Int -> Unique
mkPreludeMiscIdUnique 121
groupWithIdKey :: Unique
groupWithIdKey        = Int -> Unique
mkPreludeMiscIdUnique 122
dollarIdKey :: Unique
dollarIdKey           = Int -> Unique
mkPreludeMiscIdUnique 123

coercionTokenIdKey :: Unique
coercionTokenIdKey :: Unique
coercionTokenIdKey    = Int -> Unique
mkPreludeMiscIdUnique 124

noinlineIdKey :: Unique
noinlineIdKey                 = Int -> Unique
mkPreludeMiscIdUnique 125

rationalToFloatIdKey, rationalToDoubleIdKey :: Unique
rationalToFloatIdKey :: Unique
rationalToFloatIdKey   = Int -> Unique
mkPreludeMiscIdUnique 130
rationalToDoubleIdKey :: Unique
rationalToDoubleIdKey  = Int -> Unique
mkPreludeMiscIdUnique 131

-- dotnet interop
unmarshalObjectIdKey, marshalObjectIdKey, marshalStringIdKey,
    unmarshalStringIdKey, checkDotnetResNameIdKey :: Unique
unmarshalObjectIdKey :: Unique
unmarshalObjectIdKey          = Int -> Unique
mkPreludeMiscIdUnique 150
marshalObjectIdKey :: Unique
marshalObjectIdKey            = Int -> Unique
mkPreludeMiscIdUnique 151
marshalStringIdKey :: Unique
marshalStringIdKey            = Int -> Unique
mkPreludeMiscIdUnique 152
unmarshalStringIdKey :: Unique
unmarshalStringIdKey          = Int -> Unique
mkPreludeMiscIdUnique 153
checkDotnetResNameIdKey :: Unique
checkDotnetResNameIdKey       = Int -> Unique
mkPreludeMiscIdUnique 154

undefinedKey :: Unique
undefinedKey :: Unique
undefinedKey                  = Int -> Unique
mkPreludeMiscIdUnique 155

magicDictKey :: Unique
magicDictKey :: Unique
magicDictKey                  = Int -> Unique
mkPreludeMiscIdUnique 156

coerceKey :: Unique
coerceKey :: Unique
coerceKey                     = Int -> Unique
mkPreludeMiscIdUnique 157

{-
Certain class operations from Prelude classes.  They get their own
uniques so we can look them up easily when we want to conjure them up
during type checking.
-}

-- Just a placeholder for unbound variables produced by the renamer:
unboundKey :: Unique
unboundKey :: Unique
unboundKey                    = Int -> Unique
mkPreludeMiscIdUnique 158

fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey,
    enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey,
    enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey,
    bindMClassOpKey, thenMClassOpKey, returnMClassOpKey, fmapClassOpKey
    :: Unique
fromIntegerClassOpKey :: Unique
fromIntegerClassOpKey         = Int -> Unique
mkPreludeMiscIdUnique 160
minusClassOpKey :: Unique
minusClassOpKey               = Int -> Unique
mkPreludeMiscIdUnique 161
fromRationalClassOpKey :: Unique
fromRationalClassOpKey        = Int -> Unique
mkPreludeMiscIdUnique 162
enumFromClassOpKey :: Unique
enumFromClassOpKey            = Int -> Unique
mkPreludeMiscIdUnique 163
enumFromThenClassOpKey :: Unique
enumFromThenClassOpKey        = Int -> Unique
mkPreludeMiscIdUnique 164
enumFromToClassOpKey :: Unique
enumFromToClassOpKey          = Int -> Unique
mkPreludeMiscIdUnique 165
enumFromThenToClassOpKey :: Unique
enumFromThenToClassOpKey      = Int -> Unique
mkPreludeMiscIdUnique 166
eqClassOpKey :: Unique
eqClassOpKey                  = Int -> Unique
mkPreludeMiscIdUnique 167
geClassOpKey :: Unique
geClassOpKey                  = Int -> Unique
mkPreludeMiscIdUnique 168
negateClassOpKey :: Unique
negateClassOpKey              = Int -> Unique
mkPreludeMiscIdUnique 169
bindMClassOpKey :: Unique
bindMClassOpKey               = Int -> Unique
mkPreludeMiscIdUnique 171 -- (>>=)
thenMClassOpKey :: Unique
thenMClassOpKey               = Int -> Unique
mkPreludeMiscIdUnique 172 -- (>>)
fmapClassOpKey :: Unique
fmapClassOpKey                = Int -> Unique
mkPreludeMiscIdUnique 173
returnMClassOpKey :: Unique
returnMClassOpKey             = Int -> Unique
mkPreludeMiscIdUnique 174

-- Recursive do notation
mfixIdKey :: Unique
mfixIdKey :: Unique
mfixIdKey       = Int -> Unique
mkPreludeMiscIdUnique 175

-- MonadFail operations
failMClassOpKey :: Unique
failMClassOpKey :: Unique
failMClassOpKey = Int -> Unique
mkPreludeMiscIdUnique 176

-- Arrow notation
arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey,
    loopAIdKey :: Unique
arrAIdKey :: Unique
arrAIdKey       = Int -> Unique
mkPreludeMiscIdUnique 180
composeAIdKey :: Unique
composeAIdKey   = Int -> Unique
mkPreludeMiscIdUnique 181 -- >>>
firstAIdKey :: Unique
firstAIdKey     = Int -> Unique
mkPreludeMiscIdUnique 182
appAIdKey :: Unique
appAIdKey       = Int -> Unique
mkPreludeMiscIdUnique 183
choiceAIdKey :: Unique
choiceAIdKey    = Int -> Unique
mkPreludeMiscIdUnique 184 --  |||
loopAIdKey :: Unique
loopAIdKey      = Int -> Unique
mkPreludeMiscIdUnique 185

fromStringClassOpKey :: Unique
fromStringClassOpKey :: Unique
fromStringClassOpKey          = Int -> Unique
mkPreludeMiscIdUnique 186

-- Annotation type checking
toAnnotationWrapperIdKey :: Unique
toAnnotationWrapperIdKey :: Unique
toAnnotationWrapperIdKey      = Int -> Unique
mkPreludeMiscIdUnique 187

-- Conversion functions
fromIntegralIdKey, realToFracIdKey, toIntegerClassOpKey, toRationalClassOpKey :: Unique
fromIntegralIdKey :: Unique
fromIntegralIdKey    = Int -> Unique
mkPreludeMiscIdUnique 190
realToFracIdKey :: Unique
realToFracIdKey      = Int -> Unique
mkPreludeMiscIdUnique 191
toIntegerClassOpKey :: Unique
toIntegerClassOpKey  = Int -> Unique
mkPreludeMiscIdUnique 192
toRationalClassOpKey :: Unique
toRationalClassOpKey = Int -> Unique
mkPreludeMiscIdUnique 193

-- Monad comprehensions
guardMIdKey, liftMIdKey, mzipIdKey :: Unique
guardMIdKey :: Unique
guardMIdKey     = Int -> Unique
mkPreludeMiscIdUnique 194
liftMIdKey :: Unique
liftMIdKey      = Int -> Unique
mkPreludeMiscIdUnique 195
mzipIdKey :: Unique
mzipIdKey       = Int -> Unique
mkPreludeMiscIdUnique 196

-- GHCi
ghciStepIoMClassOpKey :: Unique
ghciStepIoMClassOpKey :: Unique
ghciStepIoMClassOpKey = Int -> Unique
mkPreludeMiscIdUnique 197

-- Overloaded lists
isListClassKey, fromListClassOpKey, fromListNClassOpKey, toListClassOpKey :: Unique
isListClassKey :: Unique
isListClassKey = Int -> Unique
mkPreludeMiscIdUnique 198
fromListClassOpKey :: Unique
fromListClassOpKey = Int -> Unique
mkPreludeMiscIdUnique 199
fromListNClassOpKey :: Unique
fromListNClassOpKey = Int -> Unique
mkPreludeMiscIdUnique 500
toListClassOpKey :: Unique
toListClassOpKey = Int -> Unique
mkPreludeMiscIdUnique 501

proxyHashKey :: Unique
proxyHashKey :: Unique
proxyHashKey = Int -> Unique
mkPreludeMiscIdUnique 502

---------------- Template Haskell -------------------
--      THNames.hs: USES IdUniques 200-499
-----------------------------------------------------

-- Used to make `Typeable` dictionaries
mkTyConKey
  , mkTrTypeKey
  , mkTrConKey
  , mkTrAppKey
  , mkTrFunKey
  , typeNatTypeRepKey
  , typeSymbolTypeRepKey
  , typeRepIdKey
  :: Unique
mkTyConKey :: Unique
mkTyConKey            = Int -> Unique
mkPreludeMiscIdUnique 503
mkTrTypeKey :: Unique
mkTrTypeKey           = Int -> Unique
mkPreludeMiscIdUnique 504
mkTrConKey :: Unique
mkTrConKey            = Int -> Unique
mkPreludeMiscIdUnique 505
mkTrAppKey :: Unique
mkTrAppKey            = Int -> Unique
mkPreludeMiscIdUnique 506
typeNatTypeRepKey :: Unique
typeNatTypeRepKey     = Int -> Unique
mkPreludeMiscIdUnique 507
typeSymbolTypeRepKey :: Unique
typeSymbolTypeRepKey  = Int -> Unique
mkPreludeMiscIdUnique 508
typeRepIdKey :: Unique
typeRepIdKey          = Int -> Unique
mkPreludeMiscIdUnique 509
mkTrFunKey :: Unique
mkTrFunKey            = Int -> Unique
mkPreludeMiscIdUnique 510

-- Representations for primitive types
trTYPEKey
  ,trTYPE'PtrRepLiftedKey
  , trRuntimeRepKey
  , tr'PtrRepLiftedKey
  :: Unique
trTYPEKey :: Unique
trTYPEKey              = Int -> Unique
mkPreludeMiscIdUnique 511
trTYPE'PtrRepLiftedKey :: Unique
trTYPE'PtrRepLiftedKey = Int -> Unique
mkPreludeMiscIdUnique 512
trRuntimeRepKey :: Unique
trRuntimeRepKey        = Int -> Unique
mkPreludeMiscIdUnique 513
tr'PtrRepLiftedKey :: Unique
tr'PtrRepLiftedKey     = Int -> Unique
mkPreludeMiscIdUnique 514

-- KindReps for common cases
starKindRepKey, starArrStarKindRepKey, starArrStarArrStarKindRepKey :: Unique
starKindRepKey :: Unique
starKindRepKey        = Int -> Unique
mkPreludeMiscIdUnique 520
starArrStarKindRepKey :: Unique
starArrStarKindRepKey = Int -> Unique
mkPreludeMiscIdUnique 521
starArrStarArrStarKindRepKey :: Unique
starArrStarArrStarKindRepKey = Int -> Unique
mkPreludeMiscIdUnique 522

-- Dynamic
toDynIdKey :: Unique
toDynIdKey :: Unique
toDynIdKey            = Int -> Unique
mkPreludeMiscIdUnique 523


bitIntegerIdKey :: Unique
bitIntegerIdKey :: Unique
bitIntegerIdKey       = Int -> Unique
mkPreludeMiscIdUnique 550

heqSCSelIdKey, eqSCSelIdKey, coercibleSCSelIdKey :: Unique
eqSCSelIdKey :: Unique
eqSCSelIdKey        = Int -> Unique
mkPreludeMiscIdUnique 551
heqSCSelIdKey :: Unique
heqSCSelIdKey       = Int -> Unique
mkPreludeMiscIdUnique 552
coercibleSCSelIdKey :: Unique
coercibleSCSelIdKey = Int -> Unique
mkPreludeMiscIdUnique 553

sappendClassOpKey :: Unique
sappendClassOpKey :: Unique
sappendClassOpKey = Int -> Unique
mkPreludeMiscIdUnique 554

memptyClassOpKey, mappendClassOpKey, mconcatClassOpKey :: Unique
memptyClassOpKey :: Unique
memptyClassOpKey  = Int -> Unique
mkPreludeMiscIdUnique 555
mappendClassOpKey :: Unique
mappendClassOpKey = Int -> Unique
mkPreludeMiscIdUnique 556
mconcatClassOpKey :: Unique
mconcatClassOpKey = Int -> Unique
mkPreludeMiscIdUnique 557

emptyCallStackKey, pushCallStackKey :: Unique
emptyCallStackKey :: Unique
emptyCallStackKey = Int -> Unique
mkPreludeMiscIdUnique 558
pushCallStackKey :: Unique
pushCallStackKey  = Int -> Unique
mkPreludeMiscIdUnique 559

fromStaticPtrClassOpKey :: Unique
fromStaticPtrClassOpKey :: Unique
fromStaticPtrClassOpKey = Int -> Unique
mkPreludeMiscIdUnique 560

makeStaticKey :: Unique
makeStaticKey :: Unique
makeStaticKey = Int -> Unique
mkPreludeMiscIdUnique 561

-- Natural
naturalFromIntegerIdKey, naturalToIntegerIdKey, plusNaturalIdKey,
   minusNaturalIdKey, timesNaturalIdKey, mkNaturalIdKey,
   naturalSDataConKey, wordToNaturalIdKey :: Unique
naturalFromIntegerIdKey :: Unique
naturalFromIntegerIdKey = Int -> Unique
mkPreludeMiscIdUnique 562
naturalToIntegerIdKey :: Unique
naturalToIntegerIdKey   = Int -> Unique
mkPreludeMiscIdUnique 563
plusNaturalIdKey :: Unique
plusNaturalIdKey        = Int -> Unique
mkPreludeMiscIdUnique 564
minusNaturalIdKey :: Unique
minusNaturalIdKey       = Int -> Unique
mkPreludeMiscIdUnique 565
timesNaturalIdKey :: Unique
timesNaturalIdKey       = Int -> Unique
mkPreludeMiscIdUnique 566
mkNaturalIdKey :: Unique
mkNaturalIdKey          = Int -> Unique
mkPreludeMiscIdUnique 567
naturalSDataConKey :: Unique
naturalSDataConKey      = Int -> Unique
mkPreludeMiscIdUnique 568
wordToNaturalIdKey :: Unique
wordToNaturalIdKey      = Int -> Unique
mkPreludeMiscIdUnique 569

{-
************************************************************************
*                                                                      *
\subsection[Class-std-groups]{Standard groups of Prelude classes}
*                                                                      *
************************************************************************

NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
even though every numeric class has these two as a superclass,
because the list of ambiguous dictionaries hasn't been simplified.
-}

numericClassKeys :: [Unique]
numericClassKeys :: [Unique]
numericClassKeys =
        [ Unique
numClassKey
        , Unique
realClassKey
        , Unique
integralClassKey
        ]
        [Unique] -> [Unique] -> [Unique]
forall a. [a] -> [a] -> [a]
++ [Unique]
fractionalClassKeys

fractionalClassKeys :: [Unique]
fractionalClassKeys :: [Unique]
fractionalClassKeys =
        [ Unique
fractionalClassKey
        , Unique
floatingClassKey
        , Unique
realFracClassKey
        , Unique
realFloatClassKey
        ]

-- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
-- and are: "classes defined in the Prelude or a standard library"
standardClassKeys :: [Unique]
standardClassKeys :: [Unique]
standardClassKeys = [Unique]
derivableClassKeys [Unique] -> [Unique] -> [Unique]
forall a. [a] -> [a] -> [a]
++ [Unique]
numericClassKeys
                  [Unique] -> [Unique] -> [Unique]
forall a. [a] -> [a] -> [a]
++ [Unique
randomClassKey, Unique
randomGenClassKey,
                      Unique
functorClassKey,
                      Unique
monadClassKey, Unique
monadPlusClassKey, Unique
monadFailClassKey,
                      Unique
semigroupClassKey, Unique
monoidClassKey,
                      Unique
isStringClassKey,
                      Unique
applicativeClassKey, Unique
foldableClassKey,
                      Unique
traversableClassKey, Unique
alternativeClassKey
                     ]

{-
@derivableClassKeys@ is also used in checking \tr{deriving} constructs
(@TcDeriv@).
-}

derivableClassKeys :: [Unique]
derivableClassKeys :: [Unique]
derivableClassKeys
  = [ Unique
eqClassKey, Unique
ordClassKey, Unique
enumClassKey, Unique
ixClassKey,
      Unique
boundedClassKey, Unique
showClassKey, Unique
readClassKey ]


-- These are the "interactive classes" that are consulted when doing
-- defaulting. Does not include Num or IsString, which have special
-- handling.
interactiveClassNames :: [Name]
interactiveClassNames :: [Name]
interactiveClassNames
  = [ Name
showClassName, Name
eqClassName, Name
ordClassName, Name
foldableClassName
    , Name
traversableClassName ]

interactiveClassKeys :: [Unique]
interactiveClassKeys :: [Unique]
interactiveClassKeys = (Name -> Unique) -> [Name] -> [Unique]
forall a b. (a -> b) -> [a] -> [b]
map Name -> Unique
forall a. Uniquable a => a -> Unique
getUnique [Name]
interactiveClassNames

{-
************************************************************************
*                                                                      *
   Semi-builtin names
*                                                                      *
************************************************************************

The following names should be considered by GHCi to be in scope always.

-}

pretendNameIsInScope :: Name -> Bool
pretendNameIsInScope :: Name -> Bool
pretendNameIsInScope n :: Name
n
  = (Unique -> Bool) -> [Unique] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (Name
n Name -> Unique -> Bool
forall a. Uniquable a => a -> Unique -> Bool
`hasKey`)
    [ Unique
liftedTypeKindTyConKey, Unique
tYPETyConKey
    , Unique
runtimeRepTyConKey, Unique
liftedRepDataConKey ]