Safe Haskell	None
Language	Haskell98

Liquid.GHC.API

Description

This module re-exports all identifiers that LH needs from the GHC API.

The intended use of this module is to provide a quick look of what GHC API features LH depends upon.

The transitive dependencies of this module shouldn't contain modules from Language.Haskell.Liquid.* or other non-boot libraries. This makes it easy to discover breaking changes in the GHC API.

Synopsis

module Liquid.GHC.API.Compat
module Liquid.GHC.API.Extra
class IsOutput doc => IsLine doc where
- char :: Char -> doc
- text :: String -> doc
- ftext :: FastString -> doc
- ztext :: FastZString -> doc
- (<+>) :: doc -> doc -> doc
- sep :: [doc] -> doc
- fsep :: [doc] -> doc
- hcat :: [doc] -> doc
- hsep :: [doc] -> doc
- dualLine :: SDoc -> HLine -> doc
data Type
- = TyVarTy Var
- | AppTy Type Type
- | TyConApp TyCon [KindOrType]
- | ForAllTy !ForAllTyBinder Type
- | FunTy FunTyFlag Mult Type Type
- | LitTy TyLit
- | CastTy Type KindCoercion
- | CoercionTy Coercion
data Expr b
- = Var Id
- | Lit Literal
- | App (Expr b) (Arg b)
- | Lam b (Expr b)
- | Let (Bind b) (Expr b)
- | Case (Expr b) b Type [Alt b]
- | Cast (Expr b) CoercionR
- | Tick CoreTickish (Expr b)
- | Type Type
- | Coercion Coercion
data Literal
- = LitChar Char
- | LitNumber !LitNumType !Integer
- | LitString !ByteString
- | LitFloat Rational
- | LitDouble Rational
data GhcMode = CompManager
data Name
data ModuleName
class Binary a where
- put_ :: BinHandle -> a -> IO ()
- get :: BinHandle -> IO a
class IsOutput doc where
- empty :: doc
- docWithContext :: (SDocContext -> doc) -> doc
- docWithStyle :: doc -> (PprStyle -> SDoc) -> doc
data UnitId
type Module = GenModule Unit
data SrcLoc
data TyCon
data Var
data GenLocated l e = L l e
space :: IsLine doc => doc
class NamedThing a where
- getOccName :: a -> OccName
- getName :: a -> Name
class (IsOutput doc, IsLine (Line doc)) => IsDoc doc where
- type Line doc = (r :: Type) | r -> doc
- line :: Line doc -> doc
- ($$) :: doc -> doc -> doc
- lines_ :: [Line doc] -> doc
- vcat :: [doc] -> doc
- dualDoc :: SDoc -> HDoc -> doc
data Pair a = Pair a a
comma :: IsLine doc => doc
colon :: IsLine doc => doc
int :: IsLine doc => Int -> doc
word64 :: IsLine doc => Word64 -> doc
word :: Integer -> SDoc
integer :: IsLine doc => Integer -> doc
float :: IsLine doc => Float -> doc
double :: IsLine doc => Double -> doc
quote :: SDoc -> SDoc
type Arity = Int
isTyVar :: Var -> Bool
type Kind = Type
data NamespaceSpecifier = NoNamespaceSpecifier
data ConLike = RealDataCon DataCon
rational :: Rational -> SDoc
lengthAtLeast :: [a] -> Int -> Bool
srcLocFile :: RealSrcLoc -> FastString
parens :: IsLine doc => doc -> doc
data Coercion
- = AxiomInstCo (CoAxiom Branched) BranchIndex [Coercion]
- | SymCo Coercion
data Fixity = Fixity SourceText Int FixityDirection
data LexicalFixity = Prefix
moduleName :: GenModule unit -> ModuleName
moduleUnit :: GenModule unit -> unit
data Alt b = Alt AltCon [b] (Expr b)
mkFunTy :: HasDebugCallStack => FunTyFlag -> Mult -> Type -> Type -> Type
splitTyConApp :: Type -> (TyCon, [Type])
liftIO :: MonadIO m => IO a -> m a
data CostCentre
getEnv :: IOEnv env env
data Unique
newUnique :: TcRnIf gbl lcl Unique
type Arg b = Expr b
isEmpty :: SDocContext -> SDoc -> Bool
type family Line doc = (r :: Type) | r -> doc
data Env gbl lcl
class Outputable a where
- ppr :: a -> SDoc
data GhcException
- = CmdLineError String
- | ProgramError String
data SDoc
data Annotation = Annotation {
- ann_target :: CoreAnnTarget
- ann_value :: AnnPayload
}
data HsExpr p
- = HsVar (XVar p) (LIdP p)
- | HsOverLit (XOverLitE p) (HsOverLit p)
- | ExprWithTySig (XExprWithTySig p) (LHsExpr p) (LHsSigWcType (NoGhcTc p))
data RdrName
type Id = Var
mkCoreApps :: CoreExpr -> [CoreExpr] -> CoreExpr
mkCoreConApps :: DataCon -> [CoreExpr] -> CoreExpr
mkCoreLams :: [CoreBndr] -> CoreExpr -> CoreExpr
mkCoreLets :: [CoreBind] -> CoreExpr -> CoreExpr
data AltCon
- = DataAlt DataCon
- | LitAlt Literal
- | DEFAULT
mkApps :: Expr b -> [Arg b] -> Expr b
data GenTickish (pass :: TickishPass)
- = ProfNote {
  - profNoteCC :: CostCentre
  - profNoteCount :: !Bool
  - profNoteScope :: !Bool
  }
- | HpcTick {
  - tickModule :: Module
  - tickId :: !Int
  }
- | Breakpoint {
  - breakpointExt :: XBreakpoint pass
  - breakpointId :: !Int
  - breakpointFVs :: [XTickishId pass]
  - breakpointModule :: Module
  }
- | SourceNote {
  - sourceSpan :: RealSrcSpan
  - sourceName :: LexicalFastString
  }
expandTypeSynonyms :: Type -> Type
data Session = Session !(IORef HscEnv)
data TcGblEnv
simplifyInfer :: TcLevel -> InferMode -> [TcIdSigInst] -> [(Name, TcTauType)] -> WantedConstraints -> TcM ([TcTyVar], [EvVar], TcEvBinds, Bool)
data DynFlags
data SourceError
data Plugin = Plugin {
- installCoreToDos :: CorePlugin
- tcPlugin :: TcPlugin
- defaultingPlugin :: DefaultingPlugin
- holeFitPlugin :: HoleFitPlugin
- driverPlugin :: [CommandLineOption] -> HscEnv -> IO HscEnv
- latePlugin :: LatePlugin
- pluginRecompile :: [CommandLineOption] -> IO PluginRecompile
- parsedResultAction :: [CommandLineOption] -> ModSummary -> ParsedResult -> Hsc ParsedResult
- renamedResultAction :: [CommandLineOption] -> TcGblEnv -> HsGroup GhcRn -> TcM (TcGblEnv, HsGroup GhcRn)
- typeCheckResultAction :: [CommandLineOption] -> ModSummary -> TcGblEnv -> TcM TcGblEnv
- spliceRunAction :: [CommandLineOption] -> LHsExpr GhcTc -> TcM (LHsExpr GhcTc)
- interfaceLoadAction :: forall lcl. [CommandLineOption] -> ModIface -> IfM lcl ModIface
}
panic :: HasCallStack => String -> a
data FastString
bytesFS :: FastString -> ByteString
lexicalCompareFS :: FastString -> FastString -> Ordering
mkFastStringByteString :: ByteString -> FastString
mkFastString :: String -> FastString
unpackFS :: FastString -> String
concatFS :: [FastString] -> FastString
mkPtrString# :: Addr# -> PtrString
fsLit :: String -> FastString
ptext :: PtrString -> SDoc
semi :: IsLine doc => doc
equals :: IsLine doc => doc
lparen :: IsLine doc => doc
rparen :: IsLine doc => doc
lbrack :: IsLine doc => doc
rbrack :: IsLine doc => doc
lbrace :: IsLine doc => doc
rbrace :: IsLine doc => doc
quotes :: SDoc -> SDoc
doubleQuotes :: IsLine doc => doc -> doc
brackets :: IsLine doc => doc -> doc
braces :: IsLine doc => doc -> doc
nest :: Int -> SDoc -> SDoc
hang :: SDoc -> Int -> SDoc -> SDoc
hangNotEmpty :: SDoc -> Int -> SDoc -> SDoc
punctuate :: IsLine doc => doc -> [doc] -> [doc]
($+$) :: SDoc -> SDoc -> SDoc
cat :: [SDoc] -> SDoc
fcat :: [SDoc] -> SDoc
data Role
data Boxity = Boxed
type family IdP p
noExtField :: NoExtField
moduleNameFS :: ModuleName -> FastString
moduleNameString :: ModuleName -> String
mkModuleName :: String -> ModuleName
mkModuleNameFS :: FastString -> ModuleName
data OccName
mkVarOccFS :: FastString -> OccName
data IsBootInterface
- = NotBoot
- | IsBoot
data HDoc
data HLine
data JoinPointHood
- = JoinPoint !Int
- | NotJoinPoint
data BindingSite
- = LambdaBind
- | CaseBind
- | CasePatBind
- | LetBind
class Outputable a => OutputableBndr a where
- pprBndr :: BindingSite -> a -> SDoc
- pprPrefixOcc :: a -> SDoc
- pprInfixOcc :: a -> SDoc
- bndrIsJoin_maybe :: a -> JoinPointHood
newtype PDoc a = PDoc a
class OutputableP env a where
- pdoc :: env -> a -> SDoc
data SDocContext = SDC {
- sdocStyle :: !PprStyle
- sdocColScheme :: !Scheme
- sdocLastColour :: !PprColour
- sdocShouldUseColor :: !Bool
- sdocDefaultDepth :: !Int
- sdocLineLength :: !Int
- sdocCanUseUnicode :: !Bool
- sdocPrintErrIndexLinks :: !Bool
- sdocHexWordLiterals :: !Bool
- sdocPprDebug :: !Bool
- sdocPrintUnicodeSyntax :: !Bool
- sdocPrintCaseAsLet :: !Bool
- sdocPrintTypecheckerElaboration :: !Bool
- sdocPrintAxiomIncomps :: !Bool
- sdocPrintExplicitKinds :: !Bool
- sdocPrintExplicitCoercions :: !Bool
- sdocPrintExplicitRuntimeReps :: !Bool
- sdocPrintExplicitForalls :: !Bool
- sdocPrintPotentialInstances :: !Bool
- sdocPrintEqualityRelations :: !Bool
- sdocSuppressTicks :: !Bool
- sdocSuppressTypeSignatures :: !Bool
- sdocSuppressTypeApplications :: !Bool
- sdocSuppressIdInfo :: !Bool
- sdocSuppressCoercions :: !Bool
- sdocSuppressCoercionTypes :: !Bool
- sdocSuppressUnfoldings :: !Bool
- sdocSuppressVarKinds :: !Bool
- sdocSuppressUniques :: !Bool
- sdocSuppressModulePrefixes :: !Bool
- sdocSuppressStgExts :: !Bool
- sdocSuppressStgReps :: !Bool
- sdocErrorSpans :: !Bool
- sdocStarIsType :: !Bool
- sdocLinearTypes :: !Bool
- sdocListTuplePuns :: !Bool
- sdocPrintTypeAbbreviations :: !Bool
- sdocUnitIdForUser :: !(FastString -> SDoc)
}
data QualifyName
- = NameUnqual
- | NameQual ModuleName
- | NameNotInScope1
- | NameNotInScope2
newtype IsEmptyOrSingleton = IsEmptyOrSingleton Bool
data PromotedItem
- = PromotedItemListSyntax IsEmptyOrSingleton
- | PromotedItemTupleSyntax
- | PromotedItemDataCon OccName
data PromotionTickContext = PromTickCtx {
- ptcListTuplePuns :: !Bool
- ptcPrintRedundantPromTicks :: !Bool
}
type QueryPromotionTick = PromotedItem -> Bool
type QueryQualifyPackage = Unit -> Bool
type QueryQualifyModule = Module -> Bool
type QueryQualifyName = Module -> OccName -> QualifyName
data NamePprCtx = QueryQualify {
- queryQualifyName :: QueryQualifyName
- queryQualifyModule :: QueryQualifyModule
- queryQualifyPackage :: QueryQualifyPackage
- queryPromotionTick :: QueryPromotionTick
}
data Depth
- = AllTheWay
- | PartWay Int
- | DefaultDepth
data PprStyle
- = PprUser NamePprCtx Depth Coloured
- | PprDump NamePprCtx
- | PprCode
isListEmptyOrSingleton :: [a] -> IsEmptyOrSingleton
reallyAlwaysQualifyNames :: QueryQualifyName
alwaysQualifyNames :: QueryQualifyName
neverQualifyNames :: QueryQualifyName
alwaysQualifyModules :: QueryQualifyModule
neverQualifyModules :: QueryQualifyModule
alwaysQualifyPackages :: QueryQualifyPackage
neverQualifyPackages :: QueryQualifyPackage
alwaysPrintPromTick :: QueryPromotionTick
reallyAlwaysQualify :: NamePprCtx
alwaysQualify :: NamePprCtx
neverQualify :: NamePprCtx
defaultUserStyle :: PprStyle
defaultDumpStyle :: PprStyle
mkDumpStyle :: NamePprCtx -> PprStyle
defaultErrStyle :: PprStyle
mkErrStyle :: NamePprCtx -> PprStyle
cmdlineParserStyle :: PprStyle
mkUserStyle :: NamePprCtx -> Depth -> PprStyle
withUserStyle :: NamePprCtx -> Depth -> SDoc -> SDoc
withErrStyle :: NamePprCtx -> SDoc -> SDoc
setStyleColoured :: Bool -> PprStyle -> PprStyle
runSDoc :: SDoc -> SDocContext -> Doc
defaultSDocContext :: SDocContext
traceSDocContext :: SDocContext
withPprStyle :: PprStyle -> SDoc -> SDoc
pprDeeper :: SDoc -> SDoc
pprDeeperList :: ([SDoc] -> SDoc) -> [SDoc] -> SDoc
pprSetDepth :: Depth -> SDoc -> SDoc
getPprStyle :: (PprStyle -> SDoc) -> SDoc
sdocWithContext :: (SDocContext -> SDoc) -> SDoc
sdocOption :: (SDocContext -> a) -> (a -> SDoc) -> SDoc
updSDocContext :: (SDocContext -> SDocContext) -> SDoc -> SDoc
qualName :: PprStyle -> QueryQualifyName
qualModule :: PprStyle -> QueryQualifyModule
qualPackage :: PprStyle -> QueryQualifyPackage
promTick :: PprStyle -> QueryPromotionTick
queryQual :: PprStyle -> NamePprCtx
codeStyle :: PprStyle -> Bool
dumpStyle :: PprStyle -> Bool
userStyle :: PprStyle -> Bool
getPprDebug :: IsOutput doc => (Bool -> doc) -> doc
ifPprDebug :: IsOutput doc => doc -> doc -> doc
whenPprDebug :: IsOutput doc => doc -> doc
printSDoc :: SDocContext -> Mode -> Handle -> SDoc -> IO ()
printSDocLn :: SDocContext -> Mode -> Handle -> SDoc -> IO ()
bufLeftRenderSDoc :: SDocContext -> BufHandle -> SDoc -> IO ()
pprCode :: SDoc -> SDoc
renderWithContext :: SDocContext -> SDoc -> String
showSDocOneLine :: SDocContext -> SDoc -> String
showSDocUnsafe :: SDoc -> String
showPprUnsafe :: Outputable a => a -> String
pprDebugAndThen :: SDocContext -> (String -> a) -> SDoc -> SDoc -> a
docToSDoc :: Doc -> SDoc
doublePrec :: Int -> Double -> SDoc
angleBrackets :: IsLine doc => doc -> doc
cparen :: Bool -> SDoc -> SDoc
quoteIfPunsEnabled :: SDoc -> SDoc
blankLine :: SDoc
dcolon :: SDoc
arrow :: SDoc
lollipop :: SDoc
larrow :: SDoc
darrow :: SDoc
arrowt :: SDoc
larrowt :: SDoc
arrowtt :: SDoc
larrowtt :: SDoc
lambda :: SDoc
underscore :: IsLine doc => doc
dot :: IsLine doc => doc
vbar :: IsLine doc => doc
forAllLit :: SDoc
bullet :: SDoc
unicodeSyntax :: SDoc -> SDoc -> SDoc
punctuateFinal :: IsLine doc => doc -> doc -> [doc] -> [doc]
ppWhen :: IsOutput doc => Bool -> doc -> doc
ppUnless :: IsOutput doc => Bool -> doc -> doc
ppWhenOption :: (SDocContext -> Bool) -> SDoc -> SDoc
ppUnlessOption :: (SDocContext -> Bool) -> SDoc -> SDoc
coloured :: PprColour -> SDoc -> SDoc
keyword :: SDoc -> SDoc
pprModuleName :: IsLine doc => ModuleName -> doc
isJoinPoint :: JoinPointHood -> Bool
pprHsChar :: Char -> SDoc
pprHsString :: FastString -> SDoc
pprHsBytes :: ByteString -> SDoc
primCharSuffix :: SDoc
primFloatSuffix :: SDoc
primIntSuffix :: SDoc
primDoubleSuffix :: SDoc
primWordSuffix :: SDoc
primInt8Suffix :: SDoc
primWord8Suffix :: SDoc
primInt16Suffix :: SDoc
primWord16Suffix :: SDoc
primInt32Suffix :: SDoc
primWord32Suffix :: SDoc
primInt64Suffix :: SDoc
primWord64Suffix :: SDoc
pprPrimChar :: Char -> SDoc
pprPrimInt :: Integer -> SDoc
pprPrimWord :: Integer -> SDoc
pprPrimInt8 :: Integer -> SDoc
pprPrimInt16 :: Integer -> SDoc
pprPrimInt32 :: Integer -> SDoc
pprPrimInt64 :: Integer -> SDoc
pprPrimWord8 :: Integer -> SDoc
pprPrimWord16 :: Integer -> SDoc
pprPrimWord32 :: Integer -> SDoc
pprPrimWord64 :: Integer -> SDoc
pprPrefixVar :: Bool -> SDoc -> SDoc
pprInfixVar :: Bool -> SDoc -> SDoc
pprFastFilePath :: FastString -> SDoc
pprFilePathString :: IsLine doc => FilePath -> doc
pprWithCommas :: (a -> SDoc) -> [a] -> SDoc
pprWithBars :: (a -> SDoc) -> [a] -> SDoc
spaceIfSingleQuote :: SDoc -> SDoc
interppSP :: Outputable a => [a] -> SDoc
interpp'SP :: Outputable a => [a] -> SDoc
interpp'SP' :: (a -> SDoc) -> [a] -> SDoc
pprQuotedList :: Outputable a => [a] -> SDoc
quotedListWithOr :: [SDoc] -> SDoc
quotedListWithNor :: [SDoc] -> SDoc
quotedListWithAnd :: [SDoc] -> SDoc
intWithCommas :: Integral a => a -> SDoc
speakNth :: Int -> SDoc
speakN :: Int -> SDoc
speakNOf :: Int -> SDoc -> SDoc
plural :: [a] -> SDoc
singular :: [a] -> SDoc
isOrAre :: [a] -> SDoc
doOrDoes :: [a] -> SDoc
itsOrTheir :: [a] -> SDoc
itOrThey :: [a] -> SDoc
thisOrThese :: [a] -> SDoc
hasOrHave :: [a] -> SDoc
bPutHDoc :: BufHandle -> SDocContext -> HDoc -> IO ()
throwGhcException :: GhcException -> a
throwGhcExceptionIO :: GhcException -> IO a
data IdDetails
- = VanillaId
- | RecSelId RecSelParent FieldLabel Bool ([ConLike], [ConLike])
- | DataConWorkId DataCon
- | DataConWrapId DataCon
- | ClassOpId Class Bool
data IdInfo
vanillaIdInfo :: IdInfo
class Uniquable a where
- getUnique :: a -> Unique
getKey :: Unique -> Word64
mkUnique :: Char -> Word64 -> Unique
hasKey :: Uniquable a => a -> Unique -> Bool
nameOccName :: Name -> OccName
nameUnique :: Name -> Unique
type TyVar = Var
data Specificity = SpecifiedSpec
data VarBndr var argf = Bndr var argf
data FunTyFlag
- = FTF_T_T
- | FTF_C_T
data ForAllTyFlag = Required
type CoreExpr = Expr CoreBndr
type CoreBndr = Var
isTupleTyCon :: TyCon -> Bool
data TyThing
- = AnId Id
- | AConLike ConLike
- | ATyCon TyCon
type PredType = Type
data TyLit
- = NumTyLit Integer
- | StrTyLit FastString
- | CharTyLit Char
data UnivCoProvenance
- = PhantomProv KindCoercion
- | ProofIrrelProv KindCoercion
class Monad m => MonadUnique (m :: Type -> Type) where
- getUniqueM :: m Unique
type Located = GenLocated SrcSpan
data UnhelpfulSpanReason
- = UnhelpfulNoLocationInfo
- | UnhelpfulWiredIn
- | UnhelpfulInteractive
- | UnhelpfulGenerated
- | UnhelpfulOther !FastString
data SrcSpan
- = RealSrcSpan !RealSrcSpan !(Maybe BufSpan)
- | UnhelpfulSpan !UnhelpfulSpanReason
data RealSrcSpan
data RealSrcLoc
mkSrcLoc :: FastString -> Int -> Int -> SrcLoc
mkRealSrcLoc :: FastString -> Int -> Int -> RealSrcLoc
srcLocLine :: RealSrcLoc -> Int
srcLocCol :: RealSrcLoc -> Int
noSrcSpan :: SrcSpan
mkGeneralSrcSpan :: FastString -> SrcSpan
mkRealSrcSpan :: RealSrcLoc -> RealSrcLoc -> RealSrcSpan
mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan
combineSrcSpans :: SrcSpan -> SrcSpan -> SrcSpan
isGoodSrcSpan :: SrcSpan -> Bool
srcSpanStartLine :: RealSrcSpan -> Int
srcSpanEndLine :: RealSrcSpan -> Int
srcSpanStartCol :: RealSrcSpan -> Int
srcSpanEndCol :: RealSrcSpan -> Int
realSrcSpanStart :: RealSrcSpan -> RealSrcLoc
srcSpanFileName_maybe :: SrcSpan -> Maybe FastString
srcSpanToRealSrcSpan :: SrcSpan -> Maybe RealSrcSpan
unLoc :: GenLocated l e -> e
withBinBuffer :: BinHandle -> (ByteString -> IO a) -> IO a
unsafeUnpackBinBuffer :: ByteString -> IO BinHandle
openBinMem :: Int -> IO BinHandle
putByte :: BinHandle -> Word8 -> IO ()
getByte :: BinHandle -> IO Word8
mkUniqSet :: Uniquable a => [a] -> UniqSet a
data SourceText
- = SourceText FastString
- | NoSourceText
mkIntegralLit :: Integral a => a -> IntegralLit
mkTHFractionalLit :: Rational -> FractionalLit
data FieldLabel
data Bag a
bagToList :: Bag a -> [a]
data FixityDirection
- = InfixR
- | InfixN
data GeneralFlag
- = Opt_DumpToFile
- | Opt_DumpWithWays
- | Opt_D_dump_minimal_imports
- | Opt_DoCoreLinting
- | Opt_DoLinearCoreLinting
- | Opt_DoStgLinting
- | Opt_DoCmmLinting
- | Opt_DoAsmLinting
- | Opt_DoAnnotationLinting
- | Opt_DoBoundsChecking
- | Opt_NoLlvmMangler
- | Opt_FastLlvm
- | Opt_NoTypeableBinds
- | Opt_DistinctConstructorTables
- | Opt_InfoTableMap
- | Opt_InfoTableMapWithFallback
- | Opt_InfoTableMapWithStack
- | Opt_WarnIsError
- | Opt_ShowWarnGroups
- | Opt_HideSourcePaths
- | Opt_PrintExplicitForalls
- | Opt_PrintExplicitKinds
- | Opt_PrintExplicitCoercions
- | Opt_PrintExplicitRuntimeReps
- | Opt_PrintEqualityRelations
- | Opt_PrintAxiomIncomps
- | Opt_PrintUnicodeSyntax
- | Opt_PrintExpandedSynonyms
- | Opt_PrintPotentialInstances
- | Opt_PrintRedundantPromotionTicks
- | Opt_PrintTypecheckerElaboration
- | Opt_CallArity
- | Opt_Exitification
- | Opt_Strictness
- | Opt_LateDmdAnal
- | Opt_KillAbsence
- | Opt_KillOneShot
- | Opt_FullLaziness
- | Opt_FloatIn
- | Opt_LocalFloatOut
- | Opt_LocalFloatOutTopLevel
- | Opt_LateSpecialise
- | Opt_Specialise
- | Opt_SpecialiseAggressively
- | Opt_CrossModuleSpecialise
- | Opt_PolymorphicSpecialisation
- | Opt_InlineGenerics
- | Opt_InlineGenericsAggressively
- | Opt_StaticArgumentTransformation
- | Opt_CSE
- | Opt_StgCSE
- | Opt_StgLiftLams
- | Opt_LiberateCase
- | Opt_SpecConstr
- | Opt_SpecConstrKeen
- | Opt_SpecialiseIncoherents
- | Opt_DoLambdaEtaExpansion
- | Opt_DoCleverArgEtaExpansion
- | Opt_IgnoreAsserts
- | Opt_DoEtaReduction
- | Opt_CaseMerge
- | Opt_CaseFolding
- | Opt_UnboxStrictFields
- | Opt_UnboxSmallStrictFields
- | Opt_DictsCheap
- | Opt_EnableRewriteRules
- | Opt_EnableThSpliceWarnings
- | Opt_RegsGraph
- | Opt_RegsIterative
- | Opt_PedanticBottoms
- | Opt_LlvmFillUndefWithGarbage
- | Opt_IrrefutableTuples
- | Opt_CmmSink
- | Opt_CmmStaticPred
- | Opt_CmmElimCommonBlocks
- | Opt_CmmControlFlow
- | Opt_AsmShortcutting
- | Opt_OmitYields
- | Opt_FunToThunk
- | Opt_DictsStrict
- | Opt_DmdTxDictSel
- | Opt_Loopification
- | Opt_CfgBlocklayout
- | Opt_WeightlessBlocklayout
- | Opt_CprAnal
- | Opt_WorkerWrapper
- | Opt_WorkerWrapperUnlift
- | Opt_SolveConstantDicts
- | Opt_AlignmentSanitisation
- | Opt_CatchNonexhaustiveCases
- | Opt_NumConstantFolding
- | Opt_CoreConstantFolding
- | Opt_FastPAPCalls
- | Opt_DoTagInferenceChecks
- | Opt_SimplPreInlining
- | Opt_IgnoreInterfacePragmas
- | Opt_OmitInterfacePragmas
- | Opt_ExposeAllUnfoldings
- | Opt_KeepAutoRules
- | Opt_WriteInterface
- | Opt_WriteHie
- | Opt_DisableJsMinifier
- | Opt_DisableJsCsources
- | Opt_AutoSccsOnIndividualCafs
- | Opt_ProfCountEntries
- | Opt_ProfLateInlineCcs
- | Opt_ProfLateCcs
- | Opt_ProfLateOverloadedCcs
- | Opt_ProfLateoverloadedCallsCCs
- | Opt_ProfManualCcs
- | Opt_Pp
- | Opt_ForceRecomp
- | Opt_IgnoreOptimChanges
- | Opt_IgnoreHpcChanges
- | Opt_ExcessPrecision
- | Opt_EagerBlackHoling
- | Opt_OrigThunkInfo
- | Opt_NoHsMain
- | Opt_SplitSections
- | Opt_StgStats
- | Opt_HideAllPackages
- | Opt_HideAllPluginPackages
- | Opt_PrintBindResult
- | Opt_Haddock
- | Opt_HaddockOptions
- | Opt_BreakOnException
- | Opt_BreakOnError
- | Opt_PrintEvldWithShow
- | Opt_PrintBindContents
- | Opt_GenManifest
- | Opt_EmbedManifest
- | Opt_SharedImplib
- | Opt_BuildingCabalPackage
- | Opt_IgnoreDotGhci
- | Opt_GhciSandbox
- | Opt_InsertBreakpoints
- | Opt_GhciHistory
- | Opt_GhciLeakCheck
- | Opt_ValidateHie
- | Opt_LocalGhciHistory
- | Opt_NoIt
- | Opt_HelpfulErrors
- | Opt_DeferTypeErrors
- | Opt_DeferTypedHoles
- | Opt_DeferOutOfScopeVariables
- | Opt_PIC
- | Opt_PIE
- | Opt_PICExecutable
- | Opt_ExternalDynamicRefs
- | Opt_Ticky
- | Opt_Ticky_Allocd
- | Opt_Ticky_LNE
- | Opt_Ticky_Dyn_Thunk
- | Opt_Ticky_Tag
- | Opt_Ticky_AP
- | Opt_CmmThreadSanitizer
- | Opt_RPath
- | Opt_RelativeDynlibPaths
- | Opt_CompactUnwind
- | Opt_Hpc
- | Opt_FamAppCache
- | Opt_ExternalInterpreter
- | Opt_OptimalApplicativeDo
- | Opt_VersionMacros
- | Opt_WholeArchiveHsLibs
- | Opt_SingleLibFolder
- | Opt_ExposeInternalSymbols
- | Opt_KeepCAFs
- | Opt_KeepGoing
- | Opt_ByteCode
- | Opt_ByteCodeAndObjectCode
- | Opt_UnoptimizedCoreForInterpreter
- | Opt_LinkRts
- | Opt_ErrorSpans
- | Opt_DeferDiagnostics
- | Opt_DiagnosticsAsJSON
- | Opt_DiagnosticsShowCaret
- | Opt_PprCaseAsLet
- | Opt_PprShowTicks
- | Opt_ShowHoleConstraints
- | Opt_ShowValidHoleFits
- | Opt_SortValidHoleFits
- | Opt_SortBySizeHoleFits
- | Opt_SortBySubsumHoleFits
- | Opt_AbstractRefHoleFits
- | Opt_UnclutterValidHoleFits
- | Opt_ShowTypeAppOfHoleFits
- | Opt_ShowTypeAppVarsOfHoleFits
- | Opt_ShowDocsOfHoleFits
- | Opt_ShowTypeOfHoleFits
- | Opt_ShowProvOfHoleFits
- | Opt_ShowMatchesOfHoleFits
- | Opt_ShowLoadedModules
- | Opt_HexWordLiterals
- | Opt_SuppressCoercions
- | Opt_SuppressCoercionTypes
- | Opt_SuppressVarKinds
- | Opt_SuppressModulePrefixes
- | Opt_SuppressTypeApplications
- | Opt_SuppressIdInfo
- | Opt_SuppressUnfoldings
- | Opt_SuppressTypeSignatures
- | Opt_SuppressUniques
- | Opt_SuppressStgExts
- | Opt_SuppressStgReps
- | Opt_SuppressTicks
- | Opt_SuppressTimestamps
- | Opt_SuppressCoreSizes
- | Opt_ShowErrorContext
- | Opt_AutoLinkPackages
- | Opt_ImplicitImportQualified
- | Opt_KeepHscppFiles
- | Opt_KeepHiDiffs
- | Opt_KeepHcFiles
- | Opt_KeepSFiles
- | Opt_KeepTmpFiles
- | Opt_KeepRawTokenStream
- | Opt_KeepLlvmFiles
- | Opt_KeepHiFiles
- | Opt_KeepOFiles
- | Opt_BuildDynamicToo
- | Opt_WriteIfSimplifiedCore
- | Opt_UseBytecodeRatherThanObjects
- | Opt_DistrustAllPackages
- | Opt_PackageTrust
- | Opt_PluginTrustworthy
- | Opt_G_NoStateHack
- | Opt_G_NoOptCoercion
type ModuleNameWithIsBoot = GenWithIsBoot ModuleName
data GenWithIsBoot mod
moduleUnitId :: Module -> UnitId
fsToUnit :: FastString -> Unit
unitString :: IsUnitId u => u -> String
toUnitId :: Unit -> UnitId
unitIdString :: UnitId -> String
data ModLocation
lookupModuleEnv :: ModuleEnv a -> Module -> Maybe a
moduleEnvKeys :: ModuleEnv a -> [Module]
moduleStableString :: Module -> String
stableModuleCmp :: Module -> Module -> Ordering
data PkgQual = NoPkgQual
type LHsExpr p = XRec p (HsExpr p)
data PromotionFlag = NotPromoted
data InlinePragma
data Phase = StopLn
data DefMethSpec ty = VanillaDM
data TupleSort = BoxedTuple
data PprPrec
data TopLevelFlag = NotTopLevel
topPrec :: PprPrec
funPrec :: PprPrec
noOccInfo :: OccInfo
isStrongLoopBreaker :: OccInfo -> Bool
isDeadOcc :: OccInfo -> Bool
isNoInlinePragma :: InlinePragma -> Bool
data DataCon
promoteDataCon :: DataCon -> TyCon
dataConWrapId :: DataCon -> Id
dataConFullSig :: DataCon -> ([TyVar], [TyCoVar], [EqSpec], ThetaType, [Scaled Type], Type)
dataConFieldLabels :: DataCon -> [FieldLabel]
dataConExTyCoVars :: DataCon -> [TyCoVar]
dataConTyCon :: DataCon -> TyCon
dataConWorkId :: DataCon -> Id
dataConName :: DataCon -> Name
tupleTyCon :: Boxity -> Arity -> TyCon
tupleDataCon :: Boxity -> Arity -> DataCon
naturalTy :: Type
tupleTyConName :: TupleSort -> Arity -> Name
liftedTypeKind :: Type
liftedTypeKindTyConName :: Name
typeSymbolKind :: Kind
listTyCon :: TyCon
data NameSpace
tcName :: NameSpace
dataName :: NameSpace
isFieldNameSpace :: NameSpace -> Bool
mkOccName :: NameSpace -> String -> OccName
mkVarOcc :: String -> OccName
mkTyVarOcc :: String -> OccName
mkTcOcc :: String -> OccName
occNameString :: OccName -> String
nameNameSpace :: Name -> NameSpace
nameSrcLoc :: Name -> SrcLoc
nameSrcSpan :: Name -> SrcSpan
isTupleTyConName :: Name -> Bool
isExternalName :: Name -> Bool
isInternalName :: Name -> Bool
nameModule :: HasDebugCallStack => Name -> Module
nameModule_maybe :: Name -> Maybe Module
isSystemName :: Name -> Bool
mkInternalName :: Unique -> OccName -> SrcSpan -> Name
mkSystemName :: Unique -> OccName -> Name
stableNameCmp :: Name -> Name -> Ordering
nameStableString :: Name -> String
getSrcSpan :: NamedThing a => a -> SrcSpan
getOccString :: NamedThing a => a -> String
type NameSet = UniqSet Name
elemNameSet :: Name -> NameSet -> Bool
nameSetElemsStable :: NameSet -> [Name]
type NameEnv a = UniqFM Name a
lookupNameEnv :: NameEnv a -> Name -> Maybe a
mkNameEnv :: [(Name, a)] -> NameEnv a
mkNameEnvWith :: (a -> Name) -> [a] -> NameEnv a
type TyVarBinder = VarBndr TyVar ForAllTyFlag
type DFunId = Id
varUnique :: Var -> Unique
setVarUnique :: Var -> Unique -> Var
setVarName :: Var -> Name -> Var
setVarType :: Var -> Type -> Var
binderVar :: VarBndr tv argf -> tv
tyVarKind :: TyVar -> Kind
mkTyVar :: Name -> Kind -> TyVar
idInfo :: HasDebugCallStack => Id -> IdInfo
idDetails :: Id -> IdDetails
mkLocalVar :: IdDetails -> Name -> Mult -> Type -> IdInfo -> Id
isId :: Var -> Bool
isCoVar :: Var -> Bool
isLocalId :: Var -> Bool
tyConAppTyCon_maybe :: Type -> Maybe TyCon
splitTyConApp_maybe :: HasDebugCallStack => Type -> Maybe (TyCon, [Type])
mkTyConApp :: TyCon -> [Type] -> Type
type VarSet = UniqSet Var
emptyVarSet :: VarSet
unitVarSet :: Var -> VarSet
extendVarSet :: VarSet -> Var -> VarSet
extendVarSetList :: VarSet -> [Var] -> VarSet
elemVarSet :: Var -> VarSet -> Bool
tyCoVarsOfType :: Type -> TyCoVarSet
emptyInScopeSet :: InScopeSet
mkRnEnv2 :: InScopeSet -> RnEnv2
noAnn :: NoAnn a => a
noAnnSrcSpan :: HasAnnotation e => SrcSpan -> e
type LocatedN = GenLocated SrcSpanAnnN
noLocA :: HasAnnotation e => a -> GenLocated e a
getLocA :: HasLoc a => GenLocated a e -> SrcSpan
data GREInfo
data AvailInfo
- = Avail Name
- | AvailTC Name [Name]
availsToNameSet :: [AvailInfo] -> NameSet
availNames :: AvailInfo -> [Name]
data ImpItemSpec = ImpAll
data WhichGREs info where
- SameNameSpace :: forall info. WhichGREs info
- RelevantGREs :: {..} -> WhichGREs GREInfo
data LookupGRE info where
- LookupRdrName :: forall info. RdrName -> WhichGREs info -> LookupGRE info
data FieldsOrSelectors = WantNormal
type GlobalRdrEnv = GlobalRdrEnvX GREInfo
mkRdrUnqual :: OccName -> RdrName
mkRdrQual :: ModuleName -> OccName -> RdrName
mkUnqual :: NameSpace -> FastString -> RdrName
mkVarUnqual :: FastString -> RdrName
mkQual :: NameSpace -> (FastString, FastString) -> RdrName
getRdrName :: NamedThing thing => thing -> RdrName
nameRdrName :: Name -> RdrName
greName :: GlobalRdrEltX info -> Name
globalRdrEnvElts :: GlobalRdrEnvX info -> [GlobalRdrEltX info]
lookupGRE :: GlobalRdrEnvX info -> LookupGRE info -> [GlobalRdrEltX info]
lookupGRE_Name :: Outputable info => GlobalRdrEnvX info -> Name -> Maybe (GlobalRdrEltX info)
isLocalGRE :: GlobalRdrEltX info -> Bool
type GhcRn = GhcPass 'Renamed
type GhcPs = GhcPass 'Parsed
ideclAs :: ImportDecl pass -> Maybe (XRec pass ModuleName)
ideclName :: ImportDecl pass -> XRec pass ModuleName
type LImportDecl pass = XRec pass (ImportDecl pass)
data ImportedModsVal
type ImportedMods = ModuleEnv [ImportedBy]
importedByUser :: [ImportedBy] -> [ImportedModsVal]
itName :: Unique -> SrcSpan -> Name
ge_RDR :: RdrName
le_RDR :: RdrName
lt_RDR :: RdrName
gt_RDR :: RdrName
times_RDR :: RdrName
plus_RDR :: RdrName
and_RDR :: RdrName
not_RDR :: RdrName
varQual_RDR :: Module -> FastString -> RdrName
eqClassName :: Name
ordClassName :: Name
bindMName :: Name
negateName :: Name
isStringClassName :: Name
eqClassKey :: Unique
fractionalClassKey :: Unique
ordClassKey :: Unique
numericClassKeys :: [Unique]
fractionalClassKeys :: [Unique]
data AnnTarget name = ModuleTarget Module
type AnnPayload = Serialized
findAnns :: Typeable a => ([Word8] -> a) -> AnnEnv -> CoreAnnTarget -> [a]
data Hsc a
coAxiomTyCon :: forall (br :: BranchFlag). CoAxiom br -> TyCon
coercionKind :: Coercion -> Pair Type
data Class
classAllSelIds :: Class -> [Id]
classSCSelIds :: Class -> [Id]
classMethods :: Class -> [Id]
classOpItems :: Class -> [ClassOpItem]
classSCTheta :: Class -> [PredType]
classBigSig :: Class -> ([TyVar], [PredType], [Id], [ClassOpItem])
data TyConBndrVis = AnonTCB
type TyConBinder = VarBndr TyVar TyConBndrVis
mkPrimTyCon :: Name -> [TyConBinder] -> Kind -> [Role] -> TyCon
isPrimTyCon :: TyCon -> Bool
isAlgTyCon :: TyCon -> Bool
isVanillaAlgTyCon :: TyCon -> Bool
isNewTyCon :: TyCon -> Bool
isTypeSynonymTyCon :: TyCon -> Bool
isGadtSyntaxTyCon :: TyCon -> Bool
isFamilyTyCon :: TyCon -> Bool
isBoxedTupleTyCon :: TyCon -> Bool
isPromotedDataCon :: TyCon -> Bool
tyConDataCons :: TyCon -> [DataCon]
tyConDataCons_maybe :: TyCon -> Maybe [DataCon]
tyConSingleDataCon_maybe :: TyCon -> Maybe DataCon
newTyConRhs :: TyCon -> ([TyVar], Type)
newTyConEtadArity :: TyCon -> Int
synTyConDefn_maybe :: TyCon -> Maybe ([TyVar], Type)
synTyConRhs_maybe :: TyCon -> Maybe Type
isClassTyCon :: TyCon -> Bool
tyConClass_maybe :: TyCon -> Maybe Class
isFamInstTyCon :: TyCon -> Bool
tyConFamInst_maybe :: TyCon -> Maybe (TyCon, [Type])
mkTyVarTy :: TyVar -> Type
mkTyVarTys :: [TyVar] -> [Type]
mkForAllTys :: [ForAllTyBinder] -> Type -> Type
primTyCons :: [TyCon]
isArrowTyCon :: TyCon -> Bool
eqPrimTyCon :: TyCon
eqReprPrimTyCon :: TyCon
tyCoVarsOfCo :: Coercion -> TyCoVarSet
emptyTvSubstEnv :: TvSubstEnv
emptySubst :: Subst
extendSubstInScopeSet :: Subst -> VarSet -> Subst
extendCvSubst :: Subst -> CoVar -> Coercion -> Subst
zipTvSubst :: HasDebugCallStack => [TyVar] -> [Type] -> Subst
mkTvSubstPrs :: [(TyVar, Type)] -> Subst
substTyWith :: HasDebugCallStack => [TyVar] -> [Type] -> Type -> Type
substTy :: HasDebugCallStack => Subst -> Type -> Type
substCo :: HasDebugCallStack => Subst -> Coercion -> Coercion
pattern ManyTy :: Mult
isTyVarTy :: Type -> Bool
splitAppTys :: HasDebugCallStack => Type -> (Type, [Type])
splitFunTy_maybe :: Type -> Maybe (FunTyFlag, Mult, Type, Type)
splitFunTys :: Type -> ([Scaled Type], Type)
piResultTys :: HasDebugCallStack => Type -> [Type] -> Type
tyConAppArgs_maybe :: Type -> Maybe [Type]
newTyConInstRhs :: TyCon -> [Type] -> Type
splitForAllTyCoVars :: Type -> ([TyCoVar], Type)
isFunTy :: Type -> Bool
dropForAlls :: Type -> Type
isTYPEorCONSTRAINT :: Kind -> Bool
irrelevantMult :: Scaled a -> a
eqType :: Type -> Type -> Bool
nonDetCmpType :: Type -> Type -> Ordering
type CoreTickish = GenTickish 'TickishPassCore
data LitNumType = LitNumInt
literalType :: Literal -> Type
mkRepReflCo :: Type -> Coercion
ruleMatchTyKiX :: TyCoVarSet -> RnEnv2 -> TvSubstEnv -> Type -> Type -> Maybe TvSubstEnv
tcUnifyTy :: Type -> Type -> Maybe Subst
mkClassPred :: Class -> [Type] -> PredType
getClassPredTys :: HasDebugCallStack => PredType -> (Class, [Type])
getClassPredTys_maybe :: PredType -> Maybe (Class, [Type])
isEvVarType :: Type -> Bool
isClassPred :: PredType -> Bool
isEqPred :: PredType -> Bool
isEqPrimPred :: PredType -> Bool
isDictId :: Id -> Bool
data StrictnessMark
dataConRepType :: DataCon -> Type
dataConUnivTyVars :: DataCon -> [TyVar]
dataConTheta :: DataCon -> ThetaType
dataConWrapId_maybe :: DataCon -> Maybe Id
dataConImplicitTyThings :: DataCon -> [TyThing]
dataConRepStrictness :: DataCon -> [StrictnessMark]
dataConWrapperType :: DataCon -> Type
dataConInstArgTys :: DataCon -> [Type] -> [Scaled Type]
dataConOrigArgTys :: DataCon -> [Scaled Type]
dataConRepArgTys :: DataCon -> [Scaled Type]
isTupleDataCon :: DataCon -> Bool
isVanillaDataCon :: DataCon -> Bool
classDataCon :: Class -> DataCon
data HsArg p tm ty = HsValArg !(XValArg p) tm
data HsType pass
- = HsForAllTy (XForAllTy pass) (HsForAllTelescope pass) (LHsType pass)
- | HsQualTy (XQualTy pass) (LHsContext pass) (LHsType pass)
- | HsTyVar (XTyVar pass) PromotionFlag (LIdP pass)
- | HsAppTy (XAppTy pass) (LHsType pass) (LHsType pass)
- | HsWildCardTy (XWildCardTy pass)
data HsTyVarBndr flag pass = UserTyVar (XUserTyVar pass) flag (LIdP pass)
data HsSigType pass = HsSig (XHsSig pass) (HsOuterSigTyVarBndrs pass) (LHsType pass)
data HsWildCardBndrs pass thing = HsWC (XHsWC pass thing) thing
data HsOuterTyVarBndrs flag pass = HsOuterImplicit (XHsOuterImplicit pass)
type LHsType pass = XRec pass (HsType pass)
data FixitySig pass = FixitySig (XFixitySig pass) [LIdP pass] Fixity
data Sig pass
- = TypeSig (XTypeSig pass) [LIdP pass] (LHsSigWcType pass)
- | FixSig (XFixSig pass) (FixitySig pass)
- | InlineSig (XInlineSig pass) (LIdP pass) InlinePragma
data HsDecl p = SigD (XSigD p) (Sig p)
type LHsDecl p = XRec p (HsDecl p)
data HsModule p
type CoreAlt = Alt CoreBndr
type CoreBind = Bind CoreBndr
type CoreArg = Arg CoreBndr
type CoreProgram = [CoreBind]
data Unfolding
- = DFunUnfolding [Var] DataCon [CoreExpr]
- | CoreUnfolding CoreExpr UnfoldingSource Bool UnfoldingCache UnfoldingGuidance
data Bind b
- = NonRec b (Expr b)
- | Rec [(b, Expr b)]
maybeUnfoldingTemplate :: Unfolding -> Maybe CoreExpr
cmpAlt :: Alt a -> Alt a -> Ordering
mkTyApps :: Expr b -> [Type] -> Expr b
mkTyArg :: Type -> Expr b
mkLams :: [b] -> Expr b -> Expr b
mkLets :: [Bind b] -> Expr b -> Expr b
bindersOf :: Bind b -> [b]
bindersOfBinds :: [Bind b] -> [b]
rhssOfBind :: Bind b -> [Expr b]
rhssOfAlts :: [Alt b] -> [Expr b]
flattenBinds :: [Bind b] -> [(b, Expr b)]
collectBinders :: Expr b -> ([b], Expr b)
collectTyBinders :: CoreExpr -> ([TyVar], CoreExpr)
collectTyAndValBinders :: CoreExpr -> ([TyVar], [Id], CoreExpr)
collectArgs :: Expr b -> (Expr b, [Arg b])
isTypeArg :: Expr b -> Bool
data Reduction = Reduction Coercion !Type
data CafInfo = NoCafRefs
cafInfo :: IdInfo -> CafInfo
setOccInfo :: IdInfo -> OccInfo -> IdInfo
setCafInfo :: IdInfo -> CafInfo -> IdInfo
mayHaveCafRefs :: CafInfo -> Bool
idType :: Id -> Kind
setIdInfo :: Id -> IdInfo -> Id
modifyIdInfo :: HasDebugCallStack => (IdInfo -> IdInfo) -> Id -> Id
mkExportedLocalId :: IdDetails -> Name -> Type -> Id
mkUserLocalOrCoVar :: OccName -> Unique -> Mult -> Type -> SrcSpan -> Id
isRecordSelector :: Id -> Bool
isClassOpId_maybe :: Id -> Maybe Class
isDFunId :: Id -> Bool
idDataCon :: Id -> DataCon
realIdUnfolding :: Id -> Unfolding
idOccInfo :: Id -> OccInfo
idInlinePragma :: Id -> InlinePragma
isConLikeId :: Id -> Bool
intTyConName :: Name
boolTyConName :: Name
listTyConName :: Name
anyTy :: Type
true_RDR :: RdrName
unrestrictedFunTyConName :: Name
charTyCon :: TyCon
charDataCon :: DataCon
stringTy :: Type
intTy :: Type
intTyCon :: TyCon
intDataCon :: DataCon
boolTy :: Type
boolTyCon :: TyCon
falseDataCon :: DataCon
trueDataCon :: DataCon
falseDataConId :: Id
trueDataConId :: Id
nilDataCon :: DataCon
consDataCon :: DataCon
tcSplitDFunTy :: Type -> ([TyVar], [Type], Class, [Type])
tcSplitMethodTy :: Type -> ([TyVar], PredType, Type)
exprFreeVars :: CoreExpr -> VarSet
exprFreeVarsList :: CoreExpr -> [Var]
exprSomeFreeVarsList :: InterestingVarFun -> CoreExpr -> [Var]
exprsOrphNames :: [CoreExpr] -> NameSet
data FamInstEnv
type FamInstEnvs = (FamInstEnv, FamInstEnv)
data FamFlavor = DataFamilyInst TyCon
data FamInst = FamInst (CoAxiom Unbranched) FamFlavor Name [RoughMatchTc] [TyVar] [CoVar] [Type] Type IsOrphan
emptyFamInstEnv :: FamInstEnv
famInstEnvElts :: FamInstEnv -> [FamInst]
topNormaliseType_maybe :: FamInstEnvs -> Type -> Maybe Reduction
exprType :: HasDebugCallStack => CoreExpr -> Type
extendIdSubst :: Subst -> Id -> CoreExpr -> Subst
substExpr :: HasDebugCallStack => Subst -> CoreExpr -> CoreExpr
occurAnalysePgm :: Module -> (Id -> Bool) -> (Activation -> Bool) -> [CoreRule] -> CoreProgram -> CoreProgram
pAT_ERROR_ID :: Id
data IfaceAnnotation
data InstEnvs
data ClsInst
instanceDFunId :: ClsInst -> DFunId
instanceSig :: ClsInst -> ([TyVar], [Type], Class, [Type])
instEnvElts :: InstEnv -> [ClsInst]
lookupInstEnv :: Bool -> InstEnvs -> Class -> [Type] -> ClsInstLookupResult
data TcEvBinds = EvBinds (Bag EvBind)
mkHsForAllInvisTele :: forall (p :: Pass). EpAnnForallTy -> [LHsTyVarBndr Specificity (GhcPass p)] -> HsForAllTelescope (GhcPass p)
mkHsApp :: forall (id :: Pass). LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)
mkHsLam :: forall (p :: Pass). (IsPass p, XMG (GhcPass p) (LHsExpr (GhcPass p)) ~ Origin) => [LPat (GhcPass p)] -> LHsExpr (GhcPass p) -> LHsExpr (GhcPass p)
mkHsIntegral :: IntegralLit -> HsOverLit GhcPs
mkHsFractional :: FractionalLit -> HsOverLit GhcPs
nlHsVar :: forall (p :: Pass) a. IsSrcSpanAnn p a => IdP (GhcPass p) -> LHsExpr (GhcPass p)
nlVarPat :: forall (p :: Pass) a. IsSrcSpanAnn p a => IdP (GhcPass p) -> LPat (GhcPass p)
nlHsIf :: LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs
nlList :: [LHsExpr GhcPs] -> LHsExpr GhcPs
nlHsAppTy :: forall (p :: Pass). LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p)
nlHsTyVar :: forall (p :: Pass) a. IsSrcSpanAnn p a => PromotionFlag -> IdP (GhcPass p) -> LHsType (GhcPass p)
nlHsFunTy :: forall (p :: Pass). IsPass p => LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p)
nlHsTyConApp :: forall (p :: Pass) a. IsSrcSpanAnn p a => PromotionFlag -> LexicalFixity -> IdP (GhcPass p) -> [LHsTypeArg (GhcPass p)] -> LHsType (GhcPass p)
hsTypeToHsSigType :: LHsType GhcPs -> LHsSigType GhcPs
hsTypeToHsSigWcType :: LHsType GhcPs -> LHsSigWcType GhcPs
mkHsDictLet :: TcEvBinds -> LHsExpr GhcTc -> LHsExpr GhcTc
data Severity = SevWarning
data MessageClass = MCDiagnostic Severity ResolvedDiagnosticReason (Maybe DiagnosticCode)
data MsgEnvelope e
newtype ResolvedDiagnosticReason = ResolvedDiagnosticReason DiagnosticReason
data DiagnosticReason = WarningWithoutFlag
class HasDefaultDiagnosticOpts (DiagnosticOpts a) => Diagnostic a
data Messages e
defaultDiagnosticOpts :: HasDefaultDiagnosticOpts (DiagnosticOpts opts) => DiagnosticOpts opts
mkPlainError :: [GhcHint] -> SDoc -> DiagnosticMessage
errorsOrFatalWarningsFound :: Messages e -> Bool
getLogger :: HasLogger m => m Logger
data Logger
putLogMsg :: Logger -> LogAction
pprLocMsgEnvelope :: Diagnostic e => DiagnosticOpts e -> MsgEnvelope e -> SDoc
withTiming :: MonadIO m => Logger -> SDoc -> (a -> ()) -> m a -> m a
interpreterBackend :: Backend
data GhcLink = LinkInMemory
getDynFlags :: HasDynFlags m => m DynFlags
gopt :: GeneralFlag -> DynFlags -> Bool
gopt_set :: DynFlags -> GeneralFlag -> DynFlags
gopt_unset :: DynFlags -> GeneralFlag -> DynFlags
xopt_set :: DynFlags -> Extension -> DynFlags
data ImportAvails
data HsParsedModule = HsParsedModule {
- hpm_module :: Located (HsModule GhcPs)
- hpm_src_files :: [FilePath]
}
lexprCtOrigin :: LHsExpr GhcRn -> CtOrigin
data ModIface_ (phase :: ModIfacePhase)
mkTcRnUnknownMessage :: (Diagnostic a, Typeable a, DiagnosticOpts a ~ NoDiagnosticOpts) => a -> TcRnMessage
data NameCache
type TypeEnv = NameEnv TyThing
mkTypeEnv :: [TyThing] -> TypeEnv
lookupTypeEnv :: TypeEnv -> Name -> Maybe TyThing
plusTypeEnv :: TypeEnv -> TypeEnv -> TypeEnv
isNumericClass :: Class -> Bool
data FindResult
- = Found ModLocation Module
- | NoPackage Unit
- | FoundMultiple [(Module, ModuleOrigin)]
- | NotFound [FilePath] (Maybe Unit) [Unit] [Unit] [UnusableUnit] [ModuleSuggestion]
lookupName :: GhcMonad m => Name -> m (Maybe TyThing)
data ModGuts
type HomePackageTable = DModuleNameEnv HomeModInfo
data HomeModInfo
lookupHpt :: HomePackageTable -> ModuleName -> Maybe HomeModInfo
data ModSummary
ms_mod_name :: ModSummary -> ModuleName
showSDoc :: DynFlags -> SDoc -> String
showPpr :: Outputable a => DynFlags -> a -> String
data ExternalPackageState
data ExternalUnitCache
data UnitEnv
ue_hpt :: HasDebugCallStack => UnitEnv -> HomePackageTable
missingInterfaceErrorDiagnostic :: IfaceMessageOpts -> MissingInterfaceError -> SDoc
srcErrorMessages :: SourceError -> Messages GhcMessage
printMessages :: Diagnostic a => Logger -> DiagnosticOpts a -> DiagOpts -> Messages a -> IO ()
initDiagOpts :: DynFlags -> DiagOpts
initDsMessageOpts :: DynFlags -> DiagnosticOpts DsMessage
initIfaceMessageOpts :: DynFlags -> DiagnosticOpts IfaceMessage
failM :: IOEnv env a
updEnv :: (env -> env') -> IOEnv env' a -> IOEnv env a
emptyPlugins :: Plugins
data HscEnv
hscUpdateFlags :: (DynFlags -> DynFlags) -> HscEnv -> HscEnv
hscSetFlags :: HasDebugCallStack => DynFlags -> HscEnv -> HscEnv
data Ghc a
class (Functor m, ExceptionMonad m, HasDynFlags m, HasLogger m) => GhcMonad (m :: Type -> Type) where
- getSession :: m HscEnv
withSession :: GhcMonad m => (HscEnv -> m a) -> m a
reflectGhc :: Ghc a -> Session -> IO a
type TcM = TcRn
type TcRn = TcRnIf TcGblEnv TcLclEnv
data ParsedResult = ParsedResult {
- parsedResultModule :: HsParsedModule
- parsedResultMessages :: PsMessages
}
type CommandLineOption = String
purePlugin :: [CommandLineOption] -> IO PluginRecompile
defaultPlugin :: Plugin
findImportedModule :: HscEnv -> ModuleName -> PkgQual -> IO FindResult
findExposedPackageModule :: FinderCache -> FinderOpts -> UnitState -> ModuleName -> PkgQual -> IO FindResult
cannotFindModule :: HscEnv -> ModuleName -> FindResult -> MissingInterfaceError
updOptLevel :: Int -> DynFlags -> DynFlags
type DsM = TcRnIf DsGblEnv DsLclEnv
getTopEnv :: TcRnIf gbl lcl HscEnv
updTopEnv :: (HscEnv -> HscEnv) -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a
getGblEnv :: TcRnIf gbl lcl gbl
setGblEnv :: gbl' -> TcRnIf gbl' lcl a -> TcRnIf gbl lcl a
addErrAt :: SrcSpan -> TcRnMessage -> TcRn ()
addErrs :: [(SrcSpan, TcRnMessage)] -> TcRn ()
reportDiagnostics :: [MsgEnvelope TcRnMessage] -> TcM ()
reportDiagnostic :: MsgEnvelope TcRnMessage -> TcRn ()
failIfErrsM :: TcRn ()
captureConstraints :: TcM a -> TcM (a, WantedConstraints)
failWithTc :: TcRnMessage -> TcM a
discardConstraints :: TcM a -> TcM a
pushTcLevelM :: TcM a -> TcM (TcLevel, a)
initIfaceTcRn :: IfG a -> TcRn a
data TraceBinIFace = QuietBinIFace
getWithUserData :: Binary a => NameCache -> BinHandle -> IO a
putWithUserData :: Binary a => TraceBinIFace -> BinHandle -> a -> IO ()
data WhereFrom = ImportBySystem
loadInterface :: SDoc -> Module -> WhereFrom -> IfM lcl (MaybeErr MissingInterfaceError ModIface)
initDsTc :: DsM a -> TcM (Messages DsMessage, Maybe a)
initDsWithModGuts :: HscEnv -> ModGuts -> DsM a -> IO (Messages DsMessage, Maybe a)
dsLExpr :: LHsExpr GhcTc -> DsM CoreExpr
rnLExpr :: LHsExpr GhcPs -> RnM (LHsExpr GhcRn, FreeVars)
tcInferRho :: LHsExpr GhcRn -> TcM (LHsExpr GhcTc, TcRhoType)
tcGetInstEnvs :: TcM InstEnvs
zonkTopLExpr :: LHsExpr GhcTc -> TcM (LHsExpr GhcTc)
renamePkgQual :: UnitEnv -> ModuleName -> Maybe FastString -> PkgQual
data InferMode = NoRestrictions
captureTopConstraints :: TcM a -> TcM (a, WantedConstraints)
simplifyInteractive :: WantedConstraints -> TcM (Bag EvBind)
tcValBinds :: TopLevelFlag -> [(RecFlag, LHsBinds GhcRn)] -> [LSig GhcRn] -> TcM thing -> TcM ([(RecFlag, LHsBinds GhcTc)], HsWrapper, thing)
tcInferSigma :: Bool -> LHsExpr GhcRn -> TcM TcSigmaType
hscDesugar :: HscEnv -> ModSummary -> TcGblEnv -> IO ModGuts
compileFile :: HscEnv -> StopPhase -> (FilePath, Maybe Phase) -> IO (Maybe FilePath)
data DesugaredModule = DesugaredModule {
- dm_typechecked_module :: TypecheckedModule
- dm_core_module :: ModGuts
}
data TypecheckedModule
data ParsedModule = ParsedModule {
- pm_mod_summary :: ModSummary
- pm_parsed_source :: ParsedSource
- pm_extra_src_files :: [FilePath]
}
coreModule :: DesugaredMod m => m -> ModGuts
typecheckModule :: GhcMonad m => ParsedModule -> m TypecheckedModule
desugarModule :: GhcMonad m => TypecheckedModule -> m DesugaredModule
modInfoTopLevelScope :: ModuleInfo -> Maybe [Name]
isDictonaryId :: Id -> Bool
deserializeWithData :: Data a => [Word8] -> a
fromSerialized :: Typeable a => ([Word8] -> a) -> Serialized -> Maybe a
toSerialized :: Typeable a => (a -> [Word8]) -> a -> Serialized
data Serialized = Serialized TypeRep [Word8]

Documentation

module Liquid.GHC.API.Compat

module Liquid.GHC.API.Extra

class IsOutput doc => IsLine doc where #

A class of types that represent a single logical line of text, with support for horizontal composition.

See Note [HLine versus HDoc] and Note [The outputable class hierarchy] for more details.

Minimal complete definition

char, text, ftext, ztext, (<>), (<+>), sep, fsep, dualLine

Methods

char :: Char -> doc #

text :: String -> doc #

ftext :: FastString -> doc #

ztext :: FastZString -> doc #

(<+>) :: doc -> doc -> doc #

Join two docs together horizontally with a gap between them.

sep :: [doc] -> doc #

Separate: is either like hsep or like vcat, depending on what fits.

fsep :: [doc] -> doc #

A paragraph-fill combinator. It's much like sep, only it keeps fitting things on one line until it can't fit any more.

hcat :: [doc] -> doc #

Concatenate docs horizontally without gaps.

hsep :: [doc] -> doc #

Concatenate docs horizontally with a space between each one.

dualLine :: SDoc -> HLine -> doc #

Prints as either the given SDoc or the given HLine, depending on which type the result is instantiated to. This should generally be avoided; see Note [dualLine and dualDoc] for details.

Instances

Instances details

IsLine HLine
Instance details Defined in GHC.Utils.Outputable Methods char :: Char -> HLine # text :: String -> HLine # ftext :: FastString -> HLine # ztext :: FastZString -> HLine # (<>) :: HLine -> HLine -> HLine # (<+>) :: HLine -> HLine -> HLine # sep :: [HLine] -> HLine # fsep :: [HLine] -> HLine # hcat :: [HLine] -> HLine # hsep :: [HLine] -> HLine # dualLine :: SDoc -> HLine -> HLine #
IsLine SDoc
Instance details Defined in GHC.Utils.Outputable Methods char :: Char -> SDoc # text :: String -> SDoc # ftext :: FastString -> SDoc # ztext :: FastZString -> SDoc # (<>) :: SDoc -> SDoc -> SDoc # (<+>) :: SDoc -> SDoc -> SDoc # sep :: [SDoc] -> SDoc # fsep :: [SDoc] -> SDoc # hcat :: [SDoc] -> SDoc # hsep :: [SDoc] -> SDoc # dualLine :: SDoc -> HLine -> SDoc #

data Type #

Constructors

TyVarTy Var	Vanilla type or kind variable (never a coercion variable)
AppTy Type Type	Type application to something other than a `TyCon`. Parameters: 1) Function: must not be a `TyConApp` or `CastTy`, must be another `AppTy`, or `TyVarTy` See Note [Respecting definitional equality] (EQ1) about the no `CastTy` requirement 2) Argument type
TyConApp TyCon [KindOrType]	Application of a `TyCon`, including newtypes and synonyms. Invariant: saturated applications of `FunTyCon` must use `FunTy` and saturated synonyms must use their own constructors. However, unsaturated `FunTyCon`s do appear as `TyConApp`s. Parameters: 1) Type constructor being applied to. 2) Type arguments. Might not have enough type arguments here to saturate the constructor. Even type synonyms are not necessarily saturated; for example unsaturated type synonyms can appear as the right hand side of a type synonym.
ForAllTy !ForAllTyBinder Type	A Π type. See Note [Why ForAllTy can quantify over a coercion variable] INVARIANT: If the binder is a coercion variable, it must be mentioned in the Type. See Note [Unused coercion variable in ForAllTy]
FunTy FunTyFlag Mult Type Type	FUN m t1 t2 Very common, so an important special case See Note [Function types]
LitTy TyLit	Type literals are similar to type constructors.
CastTy Type KindCoercion	A kind cast. The coercion is always nominal. INVARIANT: The cast is never reflexive (EQ2) INVARIANT: The Type is not a CastTy (use TransCo instead) (EQ3) INVARIANT: The Type is not a ForAllTy over a tyvar (EQ4) See Note [Respecting definitional equality]
CoercionTy Coercion	Injection of a Coercion into a type This should only ever be used in the RHS of an AppTy, in the list of a TyConApp, when applying a promoted GADT data constructor

Instances

Instances details

NFData Type Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Misc Methods rnf :: Type -> () #
Outputable Type
Instance details Defined in GHC.Core.TyCo.Rep Methods ppr :: Type -> SDoc #
Data Type
Instance details Defined in GHC.Core.TyCo.Rep Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Type -> c Type # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Type # toConstr :: Type -> Constr # dataTypeOf :: Type -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Type) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type) # gmapT :: (forall b. Data b => b -> b) -> Type -> Type # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r # gmapQ :: (forall d. Data d => d -> u) -> Type -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Type -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Type -> m Type # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Type -> m Type # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Type -> m Type #
Eq Type Source #
Instance details Defined in Language.Haskell.Liquid.GHC.TypeRep Methods (==) :: Type -> Type -> Bool # (/=) :: Type -> Type -> Bool #
Fixpoint Type Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Misc Methods toFix :: Type -> Doc # simplify :: Type -> Type #
PPrint Type Source #
Instance details Defined in Language.Haskell.Liquid.Types.PrettyPrint Methods pprintTidy :: Tidy -> Type -> Doc # pprintPrec :: Int -> Tidy -> Type -> Doc #
Subable Type Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Play Methods sub :: HashMap CoreBndr CoreExpr -> Type -> Type Source # subTy :: HashMap TyVar Type -> Type -> Type Source #
SubsTy TyVar Type SpecType Source #
Instance details Defined in Language.Haskell.Liquid.Types.RefType Methods subt :: (TyVar, Type) -> SpecType -> SpecType Source #
Eq (DeBruijn Type)
Instance details Defined in GHC.Core.Map.Type Methods (==) :: DeBruijn Type -> DeBruijn Type -> Bool # (/=) :: DeBruijn Type -> DeBruijn Type -> Bool #
Show (Axiom Var Type CoreExpr) Source #
Instance details Defined in Language.Haskell.Liquid.Types.Types Methods showsPrec :: Int -> Axiom Var Type CoreExpr -> ShowS # show :: Axiom Var Type CoreExpr -> String # showList :: [Axiom Var Type CoreExpr] -> ShowS #

data Expr b #

This is the data type that represents GHCs core intermediate language. Currently GHC uses System FC https://www.microsoft.com/en-us/research/publication/system-f-with-type-equality-coercions/ for this purpose, which is closely related to the simpler and better known System F http://en.wikipedia.org/wiki/System_F.

We get from Haskell source to this Core language in a number of stages:

The source code is parsed into an abstract syntax tree, which is represented by the data type HsExpr with the names being RdrNames
This syntax tree is renamed, which attaches a Unique to every RdrName (yielding a Name) to disambiguate identifiers which are lexically identical. For example, this program:

     f x = let f x = x + 1
           in f (x - 2)

Would be renamed by having Uniques attached so it looked something like this:

     f_1 x_2 = let f_3 x_4 = x_4 + 1
               in f_3 (x_2 - 2)

But see Note [Shadowing in Core] below.

The resulting syntax tree undergoes type checking (which also deals with instantiating type class arguments) to yield a HsExpr type that has Id as it's names.
Finally the syntax tree is desugared from the expressive HsExpr type into this Expr type, which has far fewer constructors and hence is easier to perform optimization, analysis and code generation on.

The type parameter b is for the type of binders in the expression tree.

The language consists of the following elements:

Variables See Note [Variable occurrences in Core]
Primitive literals
Applications: note that the argument may be a Type. See Note [Representation polymorphism invariants]
Lambda abstraction See Note [Representation polymorphism invariants]
Recursive and non recursive lets. Operationally this corresponds to allocating a thunk for the things bound and then executing the sub-expression.

See Note [Core letrec invariant] See Note [Core let-can-float invariant] See Note [Representation polymorphism invariants] See Note [Core type and coercion invariant]

Case expression. Operationally this corresponds to evaluating the scrutinee (expression examined) to weak head normal form and then examining at most one level of resulting constructor (i.e. you cannot do nested pattern matching directly with this).

The binder gets bound to the value of the scrutinee, and the Type must be that of all the case alternatives

IMPORTANT: see Note [Case expression invariants]

Cast an expression to a particular type. This is used to implement newtypes (a newtype constructor or destructor just becomes a Cast in Core) and GADTs.
Ticks. These are used to represent all the source annotation we support: profiling SCCs, HPC ticks, and GHCi breakpoints.
A type: this should only show up at the top level of an Arg
A coercion

Constructors

Var Id
Lit Literal
App (Expr b) (Arg b) infixl 4
Lam b (Expr b)
Let (Bind b) (Expr b)
Case (Expr b) b Type [Alt b]
Cast (Expr b) CoercionR
Tick CoreTickish (Expr b)
Type Type
Coercion Coercion

Instances

Instances details

Show CoreExpr Source #
Instance details Defined in Language.Haskell.Liquid.Transforms.CoreToLogic Methods showsPrec :: Int -> CoreExpr -> ShowS # show :: CoreExpr -> String # showList :: [CoreExpr] -> ShowS #
Subable CoreExpr Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Play Methods sub :: HashMap CoreBndr CoreExpr -> CoreExpr -> CoreExpr Source # subTy :: HashMap TyVar Type -> CoreExpr -> CoreExpr Source #
Data b => Data (Expr b)
Instance details Defined in GHC.Core Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Expr b -> c (Expr b) # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Expr b) # toConstr :: Expr b -> Constr # dataTypeOf :: Expr b -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Expr b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expr b)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Expr b -> Expr b # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr b -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr b -> r # gmapQ :: (forall d. Data d => d -> u) -> Expr b -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Expr b -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Expr b -> m (Expr b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Expr b -> m (Expr b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Expr b -> m (Expr b) #
PPrint (Expr Var) Source #
Instance details Defined in Language.Haskell.Liquid.Types.PrettyPrint Methods pprintTidy :: Tidy -> Expr Var -> Doc # pprintPrec :: Int -> Tidy -> Expr Var -> Doc #
CBVisitable (Expr Var) Source #
Instance details Defined in Language.Haskell.Liquid.Types.Visitors Methods freeVars :: HashSet Var -> Expr Var -> [Var] Source # readVars :: Expr Var -> [Var] Source # letVars :: Expr Var -> [Var] Source # literals :: Expr Var -> [Literal] Source #
Show (Axiom Var Type CoreExpr) Source #
Instance details Defined in Language.Haskell.Liquid.Types.Types Methods showsPrec :: Int -> Axiom Var Type CoreExpr -> ShowS # show :: Axiom Var Type CoreExpr -> String # showList :: [Axiom Var Type CoreExpr] -> ShowS #

data Literal #

So-called Literals are one of:

An unboxed numeric literal or floating-point literal which is presumed to be surrounded by appropriate constructors (Int#, etc.), so that the overall thing makes sense.

We maintain the invariant that the Integer in the LitNumber constructor is actually in the (possibly target-dependent) range. The mkLit{Int,Word}*Wrap smart constructors ensure this by applying the target machine's wrapping semantics. Use these in situations where you know the wrapping semantics are correct.

The literal derived from the label mentioned in a "foreign label" declaration (LitLabel)
A LitRubbish to be used in place of values that are never used.
A character
A string
The NULL pointer

Constructors

LitChar Char	`Char#` - at least 31 bits. Create with `mkLitChar`
LitNumber !LitNumType !Integer	Any numeric literal that can be internally represented with an Integer.
LitString !ByteString	A string-literal: stored and emitted UTF-8 encoded, we'll arrange to decode it at runtime. Also emitted with a `'\0'` terminator. Create with `mkLitString`
LitFloat Rational	`Float#`. Create with `mkLitFloat`
LitDouble Rational	`Double#`. Create with `mkLitDouble`

Instances

Instances details

Binary Literal
Instance details Defined in GHC.Types.Literal Methods put_ :: BinHandle -> Literal -> IO () # put :: BinHandle -> Literal -> IO (Bin Literal) # get :: BinHandle -> IO Literal #
Outputable Literal
Instance details Defined in GHC.Types.Literal Methods ppr :: Literal -> SDoc #
Data Literal
Instance details Defined in GHC.Types.Literal Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Literal -> c Literal # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Literal # toConstr :: Literal -> Constr # dataTypeOf :: Literal -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Literal) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Literal) # gmapT :: (forall b. Data b => b -> b) -> Literal -> Literal # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Literal -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Literal -> r # gmapQ :: (forall d. Data d => d -> u) -> Literal -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Literal -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Literal -> m Literal # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Literal -> m Literal # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Literal -> m Literal #
Eq Literal
Instance details Defined in GHC.Types.Literal Methods (==) :: Literal -> Literal -> Bool # (/=) :: Literal -> Literal -> Bool #
Ord Literal	Needed for the `Ord` instance of `AltCon`, which in turn is needed in `CoreMap`.
Instance details Defined in GHC.Types.Literal Methods compare :: Literal -> Literal -> Ordering # (<) :: Literal -> Literal -> Bool # (<=) :: Literal -> Literal -> Bool # (>) :: Literal -> Literal -> Bool # (>=) :: Literal -> Literal -> Bool # max :: Literal -> Literal -> Literal # min :: Literal -> Literal -> Literal #

data GhcMode #

The GhcMode tells us whether we're doing multi-module compilation (controlled via the GHC API) or one-shot (single-module) compilation. This makes a difference primarily to the GHC.Unit.Finder: in one-shot mode we look for interface files for imported modules, but in multi-module mode we look for source files in order to check whether they need to be recompiled.

Constructors

CompManager

--make, GHCi, etc.

Instances

Instances details

Outputable GhcMode
Instance details Defined in GHC.Driver.DynFlags Methods ppr :: GhcMode -> SDoc #
Eq GhcMode
Instance details Defined in GHC.Driver.DynFlags Methods (==) :: GhcMode -> GhcMode -> Bool # (/=) :: GhcMode -> GhcMode -> Bool #

data Name #

A unique, unambiguous name for something, containing information about where that thing originated.

Instances

Instances details

NFData Name
Instance details Defined in GHC.Types.Name Methods rnf :: Name -> () #
ModifyState Name
Instance details Defined in GHC.Iface.Ext.Ast Methods addSubstitution :: Name -> Name -> HieState -> HieState
NamedThing Name
Instance details Defined in GHC.Types.Name Methods getOccName :: Name -> OccName # getName :: Name -> Name #
HasOccName Name
Instance details Defined in GHC.Types.Name Methods occName :: Name -> OccName #
Uniquable Name
Instance details Defined in GHC.Types.Name Methods getUnique :: Name -> Unique #
Binary Name	Assumes that the `Name` is a non-binding one. See `putIfaceTopBndr` and `getIfaceTopBndr` for serializing binding `Name`s. See `UserData` for the rationale for this distinction.
Instance details Defined in GHC.Types.Name Methods put_ :: BinHandle -> Name -> IO () # put :: BinHandle -> Name -> IO (Bin Name) # get :: BinHandle -> IO Name #
Outputable Name
Instance details Defined in GHC.Types.Name Methods ppr :: Name -> SDoc #
OutputableBndr Name
Instance details Defined in GHC.Types.Name Methods pprBndr :: BindingSite -> Name -> SDoc # pprPrefixOcc :: Name -> SDoc # pprInfixOcc :: Name -> SDoc # bndrIsJoin_maybe :: Name -> JoinPointHood #
Data Name
Instance details Defined in GHC.Types.Name Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Name -> c Name # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Name # toConstr :: Name -> Constr # dataTypeOf :: Name -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Name) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name) # gmapT :: (forall b. Data b => b -> b) -> Name -> Name # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r # gmapQ :: (forall d. Data d => d -> u) -> Name -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Name -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Name -> m Name # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name #
Show Name Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Misc Methods showsPrec :: Int -> Name -> ShowS # show :: Name -> String # showList :: [Name] -> ShowS #
Eq Name	The same comments as for `Name`'s `Ord` instance apply.
Instance details Defined in GHC.Types.Name Methods (==) :: Name -> Name -> Bool # (/=) :: Name -> Name -> Bool #
Ord Name	Caution: This instance is implemented via `nonDetCmpUnique`, which means that the ordering is not stable across deserialization or rebuilds. See `nonDetCmpUnique` for further information, and #15240 for a bug caused by improper use of this instance.
Instance details Defined in GHC.Types.Name Methods compare :: Name -> Name -> Ordering # (<) :: Name -> Name -> Bool # (<=) :: Name -> Name -> Bool # (>) :: Name -> Name -> Bool # (>=) :: Name -> Name -> Bool # max :: Name -> Name -> Name # min :: Name -> Name -> Name #
Symbolic Name Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Misc Methods symbol :: Name -> Symbol #
Fixpoint Name Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Misc Methods toFix :: Name -> Doc # simplify :: Name -> Name #
PPrint Name Source #
Instance details Defined in Language.Haskell.Liquid.Types.PrettyPrint Methods pprintTidy :: Tidy -> Name -> Doc # pprintPrec :: Int -> Tidy -> Name -> Doc #
Loc Name Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Misc Methods srcSpan :: Name -> SrcSpan #
ToHie (LBooleanFormula (LocatedN Name))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LBooleanFormula (LocatedN Name) -> HieM [HieAST Type]
ToHie (Context (Located Name))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: Context (Located Name) -> HieM [HieAST Type]
type Anno Name
Instance details Defined in GHC.Hs.Extension type Anno Name = SrcSpanAnnN

data ModuleName #

A ModuleName is essentially a simple string, e.g. Data.List.

Instances

Instances details

NFData ModuleName
Instance details Defined in Language.Haskell.Syntax.Module.Name Methods rnf :: ModuleName -> () #
Uniquable ModuleName
Instance details Defined in GHC.Types.Unique Methods getUnique :: ModuleName -> Unique #
Binary ModuleName
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> ModuleName -> IO () # put :: BinHandle -> ModuleName -> IO (Bin ModuleName) # get :: BinHandle -> IO ModuleName #
Outputable ModuleName
Instance details Defined in GHC.Utils.Outputable Methods ppr :: ModuleName -> SDoc #
Data ModuleName
Instance details Defined in Language.Haskell.Syntax.Module.Name Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModuleName -> c ModuleName # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ModuleName # toConstr :: ModuleName -> Constr # dataTypeOf :: ModuleName -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ModuleName) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleName) # gmapT :: (forall b. Data b => b -> b) -> ModuleName -> ModuleName # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModuleName -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModuleName -> r # gmapQ :: (forall d. Data d => d -> u) -> ModuleName -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ModuleName -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModuleName -> m ModuleName # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleName -> m ModuleName # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleName -> m ModuleName #
Show ModuleName
Instance details Defined in Language.Haskell.Syntax.Module.Name Methods showsPrec :: Int -> ModuleName -> ShowS # show :: ModuleName -> String # showList :: [ModuleName] -> ShowS #
Eq ModuleName
Instance details Defined in Language.Haskell.Syntax.Module.Name Methods (==) :: ModuleName -> ModuleName -> Bool # (/=) :: ModuleName -> ModuleName -> Bool #
Ord ModuleName
Instance details Defined in Language.Haskell.Syntax.Module.Name Methods compare :: ModuleName -> ModuleName -> Ordering # (<) :: ModuleName -> ModuleName -> Bool # (<=) :: ModuleName -> ModuleName -> Bool # (>) :: ModuleName -> ModuleName -> Bool # (>=) :: ModuleName -> ModuleName -> Bool # max :: ModuleName -> ModuleName -> ModuleName # min :: ModuleName -> ModuleName -> ModuleName #
Hashable ModuleName Source #
Instance details Defined in Liquid.GHC.API.StableModule Methods hashWithSalt :: Int -> ModuleName -> Int # hash :: ModuleName -> Int #
Symbolic ModuleName Source #
Instance details Defined in Language.Haskell.Liquid.Types.Types Methods symbol :: ModuleName -> Symbol #
ToHie (IEContext (LocatedA ModuleName))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: IEContext (LocatedA ModuleName) -> HieM [HieAST Type]
type Anno ModuleName
Instance details Defined in GHC.Hs type Anno ModuleName = SrcSpanAnnA
type Anno ModuleName
Instance details Defined in GHC.Hs.ImpExp type Anno ModuleName = SrcSpanAnnA

class Binary a where #

Do not rely on instance sizes for general types, we use variable length encoding for many of them.

Minimal complete definition

get

Methods

put_ :: BinHandle -> a -> IO () #

get :: BinHandle -> IO a #

Instances

Instances details

Binary ByteString
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> ByteString -> IO () # put :: BinHandle -> ByteString -> IO (Bin ByteString) # get :: BinHandle -> IO ByteString #
Binary IsOrphan
Instance details Defined in GHC.Core Methods put_ :: BinHandle -> IsOrphan -> IO () # put :: BinHandle -> IsOrphan -> IO (Bin IsOrphan) # get :: BinHandle -> IO IsOrphan #
Binary StrictnessMark
Instance details Defined in GHC.Core.DataCon Methods put_ :: BinHandle -> StrictnessMark -> IO () # put :: BinHandle -> StrictnessMark -> IO (Bin StrictnessMark) # get :: BinHandle -> IO StrictnessMark #
Binary CallerCcFilter
Instance details Defined in GHC.Core.Opt.CallerCC.Types Methods put_ :: BinHandle -> CallerCcFilter -> IO () # put :: BinHandle -> CallerCcFilter -> IO (Bin CallerCcFilter) # get :: BinHandle -> IO CallerCcFilter #
Binary NamePattern
Instance details Defined in GHC.Core.Opt.CallerCC.Types Methods put_ :: BinHandle -> NamePattern -> IO () # put :: BinHandle -> NamePattern -> IO (Bin NamePattern) # get :: BinHandle -> IO NamePattern #
Binary CoSel
Instance details Defined in GHC.Core.TyCo.Rep Methods put_ :: BinHandle -> CoSel -> IO () # put :: BinHandle -> CoSel -> IO (Bin CoSel) # get :: BinHandle -> IO CoSel #
Binary Injectivity
Instance details Defined in GHC.Core.TyCon Methods put_ :: BinHandle -> Injectivity -> IO () # put :: BinHandle -> Injectivity -> IO (Bin Injectivity) # get :: BinHandle -> IO Injectivity #
Binary PrimElemRep
Instance details Defined in GHC.Core.TyCon Methods put_ :: BinHandle -> PrimElemRep -> IO () # put :: BinHandle -> PrimElemRep -> IO (Bin PrimElemRep) # get :: BinHandle -> IO PrimElemRep #
Binary PrimRep
Instance details Defined in GHC.Core.TyCon Methods put_ :: BinHandle -> PrimRep -> IO () # put :: BinHandle -> PrimRep -> IO (Bin PrimRep) # get :: BinHandle -> IO PrimRep #
Binary TyConBndrVis
Instance details Defined in GHC.Core.TyCon Methods put_ :: BinHandle -> TyConBndrVis -> IO () # put :: BinHandle -> TyConBndrVis -> IO (Bin TyConBndrVis) # get :: BinHandle -> IO TyConBndrVis #
Binary FastString
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> FastString -> IO () # put :: BinHandle -> FastString -> IO (Bin FastString) # get :: BinHandle -> IO FastString #
Binary LexicalFastString
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> LexicalFastString -> IO () # put :: BinHandle -> LexicalFastString -> IO (Bin LexicalFastString) # get :: BinHandle -> IO LexicalFastString #
Binary NonDetFastString
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> NonDetFastString -> IO () # put :: BinHandle -> NonDetFastString -> IO (Bin NonDetFastString) # get :: BinHandle -> IO NonDetFastString #
Binary Language
Instance details Defined in GHC.Driver.Flags Methods put_ :: BinHandle -> Language -> IO () # put :: BinHandle -> Language -> IO (Bin Language) # get :: BinHandle -> IO Language #
Binary DocStructureItem
Instance details Defined in GHC.Hs.Doc Methods put_ :: BinHandle -> DocStructureItem -> IO () # put :: BinHandle -> DocStructureItem -> IO (Bin DocStructureItem) # get :: BinHandle -> IO DocStructureItem #
Binary Docs
Instance details Defined in GHC.Hs.Doc Methods put_ :: BinHandle -> Docs -> IO () # put :: BinHandle -> Docs -> IO (Bin Docs) # get :: BinHandle -> IO Docs #
Binary HsDocString
Instance details Defined in GHC.Hs.DocString Methods put_ :: BinHandle -> HsDocString -> IO () # put :: BinHandle -> HsDocString -> IO (Bin HsDocString) # get :: BinHandle -> IO HsDocString #
Binary HsDocStringChunk
Instance details Defined in GHC.Hs.DocString Methods put_ :: BinHandle -> HsDocStringChunk -> IO () # put :: BinHandle -> HsDocStringChunk -> IO (Bin HsDocStringChunk) # get :: BinHandle -> IO HsDocStringChunk #
Binary HsDocStringDecorator
Instance details Defined in GHC.Hs.DocString Methods put_ :: BinHandle -> HsDocStringDecorator -> IO () # put :: BinHandle -> HsDocStringDecorator -> IO (Bin HsDocStringDecorator) # get :: BinHandle -> IO HsDocStringDecorator #
Binary ExtensibleFields
Instance details Defined in GHC.Iface.Ext.Fields Methods put_ :: BinHandle -> ExtensibleFields -> IO () # put :: BinHandle -> ExtensibleFields -> IO (Bin ExtensibleFields) # get :: BinHandle -> IO ExtensibleFields #
Binary BindType
Instance details Defined in GHC.Iface.Ext.Types Methods put_ :: BinHandle -> BindType -> IO () # put :: BinHandle -> BindType -> IO (Bin BindType) # get :: BinHandle -> IO BindType #
Binary ContextInfo
Instance details Defined in GHC.Iface.Ext.Types Methods put_ :: BinHandle -> ContextInfo -> IO () # put :: BinHandle -> ContextInfo -> IO (Bin ContextInfo) # get :: BinHandle -> IO ContextInfo #
Binary DeclType
Instance details Defined in GHC.Iface.Ext.Types Methods put_ :: BinHandle -> DeclType -> IO () # put :: BinHandle -> DeclType -> IO (Bin DeclType) # get :: BinHandle -> IO DeclType #
Binary EvBindDeps
Instance details Defined in GHC.Iface.Ext.Types Methods put_ :: BinHandle -> EvBindDeps -> IO () # put :: BinHandle -> EvBindDeps -> IO (Bin EvBindDeps) # get :: BinHandle -> IO EvBindDeps #
Binary EvVarSource
Instance details Defined in GHC.Iface.Ext.Types Methods put_ :: BinHandle -> EvVarSource -> IO () # put :: BinHandle -> EvVarSource -> IO (Bin EvVarSource) # get :: BinHandle -> IO EvVarSource #
Binary HieFile
Instance details Defined in GHC.Iface.Ext.Types Methods put_ :: BinHandle -> HieFile -> IO () # put :: BinHandle -> HieFile -> IO (Bin HieFile) # get :: BinHandle -> IO HieFile #
Binary IEType
Instance details Defined in GHC.Iface.Ext.Types Methods put_ :: BinHandle -> IEType -> IO () # put :: BinHandle -> IEType -> IO (Bin IEType) # get :: BinHandle -> IO IEType #
Binary NodeAnnotation
Instance details Defined in GHC.Iface.Ext.Types Methods put_ :: BinHandle -> NodeAnnotation -> IO () # put :: BinHandle -> NodeAnnotation -> IO (Bin NodeAnnotation) # get :: BinHandle -> IO NodeAnnotation #
Binary NodeOrigin
Instance details Defined in GHC.Iface.Ext.Types Methods put_ :: BinHandle -> NodeOrigin -> IO () # put :: BinHandle -> NodeOrigin -> IO (Bin NodeOrigin) # get :: BinHandle -> IO NodeOrigin #
Binary RecFieldContext
Instance details Defined in GHC.Iface.Ext.Types Methods put_ :: BinHandle -> RecFieldContext -> IO () # put :: BinHandle -> RecFieldContext -> IO (Bin RecFieldContext) # get :: BinHandle -> IO RecFieldContext #
Binary Scope
Instance details Defined in GHC.Iface.Ext.Types Methods put_ :: BinHandle -> Scope -> IO () # put :: BinHandle -> Scope -> IO (Bin Scope) # get :: BinHandle -> IO Scope #
Binary TyVarScope
Instance details Defined in GHC.Iface.Ext.Types Methods put_ :: BinHandle -> TyVarScope -> IO () # put :: BinHandle -> TyVarScope -> IO (Bin TyVarScope) # get :: BinHandle -> IO TyVarScope #
Binary IfaceDeclExtras
Instance details Defined in GHC.Iface.Recomp Methods put_ :: BinHandle -> IfaceDeclExtras -> IO () # put :: BinHandle -> IfaceDeclExtras -> IO (Bin IfaceDeclExtras) # get :: BinHandle -> IO IfaceDeclExtras #
Binary IfaceIdExtras
Instance details Defined in GHC.Iface.Recomp Methods put_ :: BinHandle -> IfaceIdExtras -> IO () # put :: BinHandle -> IfaceIdExtras -> IO (Bin IfaceIdExtras) # get :: BinHandle -> IO IfaceIdExtras #
Binary IfGuidance
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfGuidance -> IO () # put :: BinHandle -> IfGuidance -> IO (Bin IfGuidance) # get :: BinHandle -> IO IfGuidance #
Binary IfaceAT
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceAT -> IO () # put :: BinHandle -> IfaceAT -> IO (Bin IfaceAT) # get :: BinHandle -> IO IfaceAT #
Binary IfaceAlt
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceAlt -> IO () # put :: BinHandle -> IfaceAlt -> IO (Bin IfaceAlt) # get :: BinHandle -> IO IfaceAlt #
Binary IfaceAnnotation
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceAnnotation -> IO () # put :: BinHandle -> IfaceAnnotation -> IO (Bin IfaceAnnotation) # get :: BinHandle -> IO IfaceAnnotation #
Binary IfaceAxBranch
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceAxBranch -> IO () # put :: BinHandle -> IfaceAxBranch -> IO (Bin IfaceAxBranch) # get :: BinHandle -> IO IfaceAxBranch #
Binary IfaceBang
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceBang -> IO () # put :: BinHandle -> IfaceBang -> IO (Bin IfaceBang) # get :: BinHandle -> IO IfaceBang #
Binary IfaceBooleanFormula
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceBooleanFormula -> IO () # put :: BinHandle -> IfaceBooleanFormula -> IO (Bin IfaceBooleanFormula) # get :: BinHandle -> IO IfaceBooleanFormula #
Binary IfaceClassOp
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceClassOp -> IO () # put :: BinHandle -> IfaceClassOp -> IO (Bin IfaceClassOp) # get :: BinHandle -> IO IfaceClassOp #
Binary IfaceClsInst
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceClsInst -> IO () # put :: BinHandle -> IfaceClsInst -> IO (Bin IfaceClsInst) # get :: BinHandle -> IO IfaceClsInst #
Binary IfaceCompleteMatch
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceCompleteMatch -> IO () # put :: BinHandle -> IfaceCompleteMatch -> IO (Bin IfaceCompleteMatch) # get :: BinHandle -> IO IfaceCompleteMatch #
Binary IfaceConAlt
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceConAlt -> IO () # put :: BinHandle -> IfaceConAlt -> IO (Bin IfaceConAlt) # get :: BinHandle -> IO IfaceConAlt #
Binary IfaceConDecl
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceConDecl -> IO () # put :: BinHandle -> IfaceConDecl -> IO (Bin IfaceConDecl) # get :: BinHandle -> IO IfaceConDecl #
Binary IfaceConDecls
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceConDecls -> IO () # put :: BinHandle -> IfaceConDecls -> IO (Bin IfaceConDecls) # get :: BinHandle -> IO IfaceConDecls #
Binary IfaceDecl
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceDecl -> IO () # put :: BinHandle -> IfaceDecl -> IO (Bin IfaceDecl) # get :: BinHandle -> IO IfaceDecl #
Binary IfaceExpr
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceExpr -> IO () # put :: BinHandle -> IfaceExpr -> IO (Bin IfaceExpr) # get :: BinHandle -> IO IfaceExpr #
Binary IfaceFamInst
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceFamInst -> IO () # put :: BinHandle -> IfaceFamInst -> IO (Bin IfaceFamInst) # get :: BinHandle -> IO IfaceFamInst #
Binary IfaceFamTyConFlav
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceFamTyConFlav -> IO () # put :: BinHandle -> IfaceFamTyConFlav -> IO (Bin IfaceFamTyConFlav) # get :: BinHandle -> IO IfaceFamTyConFlav #
Binary IfaceIdDetails
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceIdDetails -> IO () # put :: BinHandle -> IfaceIdDetails -> IO (Bin IfaceIdDetails) # get :: BinHandle -> IO IfaceIdDetails #
Binary IfaceInfoItem
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceInfoItem -> IO () # put :: BinHandle -> IfaceInfoItem -> IO (Bin IfaceInfoItem) # get :: BinHandle -> IO IfaceInfoItem #
Binary IfaceLFInfo
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceLFInfo -> IO () # put :: BinHandle -> IfaceLFInfo -> IO (Bin IfaceLFInfo) # get :: BinHandle -> IO IfaceLFInfo #
Binary IfaceLetBndr
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceLetBndr -> IO () # put :: BinHandle -> IfaceLetBndr -> IO (Bin IfaceLetBndr) # get :: BinHandle -> IO IfaceLetBndr #
Binary IfaceMaybeRhs
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceMaybeRhs -> IO () # put :: BinHandle -> IfaceMaybeRhs -> IO (Bin IfaceMaybeRhs) # get :: BinHandle -> IO IfaceMaybeRhs #
Binary IfaceRule
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceRule -> IO () # put :: BinHandle -> IfaceRule -> IO (Bin IfaceRule) # get :: BinHandle -> IO IfaceRule #
Binary IfaceSrcBang
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceSrcBang -> IO () # put :: BinHandle -> IfaceSrcBang -> IO (Bin IfaceSrcBang) # get :: BinHandle -> IO IfaceSrcBang #
Binary IfaceStringLiteral
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceStringLiteral -> IO () # put :: BinHandle -> IfaceStringLiteral -> IO (Bin IfaceStringLiteral) # get :: BinHandle -> IO IfaceStringLiteral #
Binary IfaceTickish
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceTickish -> IO () # put :: BinHandle -> IfaceTickish -> IO (Bin IfaceTickish) # get :: BinHandle -> IO IfaceTickish #
Binary IfaceTopBndrInfo
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceTopBndrInfo -> IO () # put :: BinHandle -> IfaceTopBndrInfo -> IO (Bin IfaceTopBndrInfo) # get :: BinHandle -> IO IfaceTopBndrInfo #
Binary IfaceTyConParent
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceTyConParent -> IO () # put :: BinHandle -> IfaceTyConParent -> IO (Bin IfaceTyConParent) # get :: BinHandle -> IO IfaceTyConParent #
Binary IfaceUnfolding
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceUnfolding -> IO () # put :: BinHandle -> IfaceUnfolding -> IO (Bin IfaceUnfolding) # get :: BinHandle -> IO IfaceUnfolding #
Binary IfaceWarningTxt
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceWarningTxt -> IO () # put :: BinHandle -> IfaceWarningTxt -> IO (Bin IfaceWarningTxt) # get :: BinHandle -> IO IfaceWarningTxt #
Binary IfaceWarnings
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceWarnings -> IO () # put :: BinHandle -> IfaceWarnings -> IO (Bin IfaceWarnings) # get :: BinHandle -> IO IfaceWarnings #
Binary IfaceAppArgs
Instance details Defined in GHC.Iface.Type Methods put_ :: BinHandle -> IfaceAppArgs -> IO () # put :: BinHandle -> IfaceAppArgs -> IO (Bin IfaceAppArgs) # get :: BinHandle -> IO IfaceAppArgs #
Binary IfaceBndr
Instance details Defined in GHC.Iface.Type Methods put_ :: BinHandle -> IfaceBndr -> IO () # put :: BinHandle -> IfaceBndr -> IO (Bin IfaceBndr) # get :: BinHandle -> IO IfaceBndr #
Binary IfaceCoercion
Instance details Defined in GHC.Iface.Type Methods put_ :: BinHandle -> IfaceCoercion -> IO () # put :: BinHandle -> IfaceCoercion -> IO (Bin IfaceCoercion) # get :: BinHandle -> IO IfaceCoercion #
Binary IfaceMCoercion
Instance details Defined in GHC.Iface.Type Methods put_ :: BinHandle -> IfaceMCoercion -> IO () # put :: BinHandle -> IfaceMCoercion -> IO (Bin IfaceMCoercion) # get :: BinHandle -> IO IfaceMCoercion #
Binary IfaceOneShot
Instance details Defined in GHC.Iface.Type Methods put_ :: BinHandle -> IfaceOneShot -> IO () # put :: BinHandle -> IfaceOneShot -> IO (Bin IfaceOneShot) # get :: BinHandle -> IO IfaceOneShot #
Binary IfaceTyCon
Instance details Defined in GHC.Iface.Type Methods put_ :: BinHandle -> IfaceTyCon -> IO () # put :: BinHandle -> IfaceTyCon -> IO (Bin IfaceTyCon) # get :: BinHandle -> IO IfaceTyCon #
Binary IfaceTyConInfo
Instance details Defined in GHC.Iface.Type Methods put_ :: BinHandle -> IfaceTyConInfo -> IO () # put :: BinHandle -> IfaceTyConInfo -> IO (Bin IfaceTyConInfo) # get :: BinHandle -> IO IfaceTyConInfo #
Binary IfaceTyConSort
Instance details Defined in GHC.Iface.Type Methods put_ :: BinHandle -> IfaceTyConSort -> IO () # put :: BinHandle -> IfaceTyConSort -> IO (Bin IfaceTyConSort) # get :: BinHandle -> IO IfaceTyConSort #
Binary IfaceTyLit
Instance details Defined in GHC.Iface.Type Methods put_ :: BinHandle -> IfaceTyLit -> IO () # put :: BinHandle -> IfaceTyLit -> IO (Bin IfaceTyLit) # get :: BinHandle -> IO IfaceTyLit #
Binary IfaceType
Instance details Defined in GHC.Iface.Type Methods put_ :: BinHandle -> IfaceType -> IO () # put :: BinHandle -> IfaceType -> IO (Bin IfaceType) # get :: BinHandle -> IO IfaceType #
Binary IfaceUnivCoProv
Instance details Defined in GHC.Iface.Type Methods put_ :: BinHandle -> IfaceUnivCoProv -> IO () # put :: BinHandle -> IfaceUnivCoProv -> IO (Bin IfaceUnivCoProv) # get :: BinHandle -> IO IfaceUnivCoProv #
Binary TagInfo
Instance details Defined in GHC.Stg.InferTags.TagSig Methods put_ :: BinHandle -> TagInfo -> IO () # put :: BinHandle -> TagInfo -> IO (Bin TagInfo) # get :: BinHandle -> IO TagInfo #
Binary TagSig
Instance details Defined in GHC.Stg.InferTags.TagSig Methods put_ :: BinHandle -> TagSig -> IO () # put :: BinHandle -> TagSig -> IO (Bin TagSig) # get :: BinHandle -> IO TagSig #
Binary BlockDeps
Instance details Defined in GHC.StgToJS.Object Methods put_ :: BinHandle -> BlockDeps -> IO () # put :: BinHandle -> BlockDeps -> IO (Bin BlockDeps) # get :: BinHandle -> IO BlockDeps #
Binary BlockInfo
Instance details Defined in GHC.StgToJS.Object Methods put_ :: BinHandle -> BlockInfo -> IO () # put :: BinHandle -> BlockInfo -> IO (Bin BlockInfo) # get :: BinHandle -> IO BlockInfo #
Binary ExportedFun
Instance details Defined in GHC.StgToJS.Object Methods put_ :: BinHandle -> ExportedFun -> IO () # put :: BinHandle -> ExportedFun -> IO (Bin ExportedFun) # get :: BinHandle -> IO ExportedFun #
Binary IndexEntry
Instance details Defined in GHC.StgToJS.Object Methods put_ :: BinHandle -> IndexEntry -> IO () # put :: BinHandle -> IndexEntry -> IO (Bin IndexEntry) # get :: BinHandle -> IO IndexEntry #
Binary JSOptions
Instance details Defined in GHC.StgToJS.Object Methods put_ :: BinHandle -> JSOptions -> IO () # put :: BinHandle -> JSOptions -> IO (Bin JSOptions) # get :: BinHandle -> IO JSOptions #
Binary AvailInfo
Instance details Defined in GHC.Types.Avail Methods put_ :: BinHandle -> AvailInfo -> IO () # put :: BinHandle -> AvailInfo -> IO (Bin AvailInfo) # get :: BinHandle -> IO AvailInfo #
Binary Activation
Instance details Defined in GHC.Types.Basic Methods put_ :: BinHandle -> Activation -> IO () # put :: BinHandle -> Activation -> IO (Bin Activation) # get :: BinHandle -> IO Activation #
Binary CbvMark
Instance details Defined in GHC.Types.Basic Methods put_ :: BinHandle -> CbvMark -> IO () # put :: BinHandle -> CbvMark -> IO (Bin CbvMark) # get :: BinHandle -> IO CbvMark #
Binary FunctionOrData
Instance details Defined in GHC.Types.Basic Methods put_ :: BinHandle -> FunctionOrData -> IO () # put :: BinHandle -> FunctionOrData -> IO (Bin FunctionOrData) # get :: BinHandle -> IO FunctionOrData #
Binary InlinePragma
Instance details Defined in GHC.Types.Basic Methods put_ :: BinHandle -> InlinePragma -> IO () # put :: BinHandle -> InlinePragma -> IO (Bin InlinePragma) # get :: BinHandle -> IO InlinePragma #
Binary InlineSpec
Instance details Defined in GHC.Types.Basic Methods put_ :: BinHandle -> InlineSpec -> IO () # put :: BinHandle -> InlineSpec -> IO (Bin InlineSpec) # get :: BinHandle -> IO InlineSpec #
Binary LeftOrRight
Instance details Defined in GHC.Types.Basic Methods put_ :: BinHandle -> LeftOrRight -> IO () # put :: BinHandle -> LeftOrRight -> IO (Bin LeftOrRight) # get :: BinHandle -> IO LeftOrRight #
Binary Levity
Instance details Defined in GHC.Types.Basic Methods put_ :: BinHandle -> Levity -> IO () # put :: BinHandle -> Levity -> IO (Bin Levity) # get :: BinHandle -> IO Levity #
Binary OverlapFlag
Instance details Defined in GHC.Types.Basic Methods put_ :: BinHandle -> OverlapFlag -> IO () # put :: BinHandle -> OverlapFlag -> IO (Bin OverlapFlag) # get :: BinHandle -> IO OverlapFlag #
Binary OverlapMode
Instance details Defined in GHC.Types.Basic Methods put_ :: BinHandle -> OverlapMode -> IO () # put :: BinHandle -> OverlapMode -> IO (Bin OverlapMode) # get :: BinHandle -> IO OverlapMode #
Binary RecFlag
Instance details Defined in GHC.Types.Basic Methods put_ :: BinHandle -> RecFlag -> IO () # put :: BinHandle -> RecFlag -> IO (Bin RecFlag) # get :: BinHandle -> IO RecFlag #
Binary RuleMatchInfo
Instance details Defined in GHC.Types.Basic Methods put_ :: BinHandle -> RuleMatchInfo -> IO () # put :: BinHandle -> RuleMatchInfo -> IO (Bin RuleMatchInfo) # get :: BinHandle -> IO RuleMatchInfo #
Binary TupleSort
Instance details Defined in GHC.Types.Basic Methods put_ :: BinHandle -> TupleSort -> IO () # put :: BinHandle -> TupleSort -> IO (Bin TupleSort) # get :: BinHandle -> IO TupleSort #
Binary UnfoldingSource
Instance details Defined in GHC.Types.Basic Methods put_ :: BinHandle -> UnfoldingSource -> IO () # put :: BinHandle -> UnfoldingSource -> IO (Bin UnfoldingSource) # get :: BinHandle -> IO UnfoldingSource #
Binary CCFlavour
Instance details Defined in GHC.Types.CostCentre Methods put_ :: BinHandle -> CCFlavour -> IO () # put :: BinHandle -> CCFlavour -> IO (Bin CCFlavour) # get :: BinHandle -> IO CCFlavour #
Binary CostCentre
Instance details Defined in GHC.Types.CostCentre Methods put_ :: BinHandle -> CostCentre -> IO () # put :: BinHandle -> CostCentre -> IO (Bin CostCentre) # get :: BinHandle -> IO CostCentre #
Binary CostCentreIndex
Instance details Defined in GHC.Types.CostCentre.State Methods put_ :: BinHandle -> CostCentreIndex -> IO () # put :: BinHandle -> CostCentreIndex -> IO (Bin CostCentreIndex) # get :: BinHandle -> IO CostCentreIndex #
Binary Cpr
Instance details Defined in GHC.Types.Cpr Methods put_ :: BinHandle -> Cpr -> IO () # put :: BinHandle -> Cpr -> IO (Bin Cpr) # get :: BinHandle -> IO Cpr #
Binary CprSig
Instance details Defined in GHC.Types.Cpr Methods put_ :: BinHandle -> CprSig -> IO () # put :: BinHandle -> CprSig -> IO (Bin CprSig) # get :: BinHandle -> IO CprSig #
Binary CprType
Instance details Defined in GHC.Types.Cpr Methods put_ :: BinHandle -> CprType -> IO () # put :: BinHandle -> CprType -> IO (Bin CprType) # get :: BinHandle -> IO CprType #
Binary Card
Instance details Defined in GHC.Types.Demand Methods put_ :: BinHandle -> Card -> IO () # put :: BinHandle -> Card -> IO (Bin Card) # get :: BinHandle -> IO Card #
Binary Demand
Instance details Defined in GHC.Types.Demand Methods put_ :: BinHandle -> Demand -> IO () # put :: BinHandle -> Demand -> IO (Bin Demand) # get :: BinHandle -> IO Demand #
Binary Divergence
Instance details Defined in GHC.Types.Demand Methods put_ :: BinHandle -> Divergence -> IO () # put :: BinHandle -> Divergence -> IO (Bin Divergence) # get :: BinHandle -> IO Divergence #
Binary DmdEnv
Instance details Defined in GHC.Types.Demand Methods put_ :: BinHandle -> DmdEnv -> IO () # put :: BinHandle -> DmdEnv -> IO (Bin DmdEnv) # get :: BinHandle -> IO DmdEnv #
Binary DmdSig
Instance details Defined in GHC.Types.Demand Methods put_ :: BinHandle -> DmdSig -> IO () # put :: BinHandle -> DmdSig -> IO (Bin DmdSig) # get :: BinHandle -> IO DmdSig #
Binary DmdType
Instance details Defined in GHC.Types.Demand Methods put_ :: BinHandle -> DmdType -> IO () # put :: BinHandle -> DmdType -> IO (Bin DmdType) # get :: BinHandle -> IO DmdType #
Binary SubDemand
Instance details Defined in GHC.Types.Demand Methods put_ :: BinHandle -> SubDemand -> IO () # put :: BinHandle -> SubDemand -> IO (Bin SubDemand) # get :: BinHandle -> IO SubDemand #
Binary DuplicateRecordFields
Instance details Defined in GHC.Types.FieldLabel Methods put_ :: BinHandle -> DuplicateRecordFields -> IO () # put :: BinHandle -> DuplicateRecordFields -> IO (Bin DuplicateRecordFields) # get :: BinHandle -> IO DuplicateRecordFields #
Binary Name => Binary FieldLabel	We need the `Binary Name` constraint here even though there is an instance defined in GHC.Types.Name, because the we have a SOURCE import, so the instance is not in scope. And the instance cannot be added to Name.hs-boot because GHC.Utils.Binary itself depends on GHC.Types.Name.
Instance details Defined in GHC.Types.FieldLabel Methods put_ :: BinHandle -> FieldLabel -> IO () # put :: BinHandle -> FieldLabel -> IO (Bin FieldLabel) # get :: BinHandle -> IO FieldLabel #
Binary FieldSelectors
Instance details Defined in GHC.Types.FieldLabel Methods put_ :: BinHandle -> FieldSelectors -> IO () # put :: BinHandle -> FieldSelectors -> IO (Bin FieldSelectors) # get :: BinHandle -> IO FieldSelectors #
Binary Fixity
Instance details Defined in GHC.Types.Fixity Methods put_ :: BinHandle -> Fixity -> IO () # put :: BinHandle -> Fixity -> IO (Bin Fixity) # get :: BinHandle -> IO Fixity #
Binary FixityDirection
Instance details Defined in GHC.Types.Fixity Methods put_ :: BinHandle -> FixityDirection -> IO () # put :: BinHandle -> FixityDirection -> IO (Bin FixityDirection) # get :: BinHandle -> IO FixityDirection #
Binary CCallConv
Instance details Defined in GHC.Types.ForeignCall Methods put_ :: BinHandle -> CCallConv -> IO () # put :: BinHandle -> CCallConv -> IO (Bin CCallConv) # get :: BinHandle -> IO CCallConv #
Binary CCallSpec
Instance details Defined in GHC.Types.ForeignCall Methods put_ :: BinHandle -> CCallSpec -> IO () # put :: BinHandle -> CCallSpec -> IO (Bin CCallSpec) # get :: BinHandle -> IO CCallSpec #
Binary CCallTarget
Instance details Defined in GHC.Types.ForeignCall Methods put_ :: BinHandle -> CCallTarget -> IO () # put :: BinHandle -> CCallTarget -> IO (Bin CCallTarget) # get :: BinHandle -> IO CCallTarget #
Binary CExportSpec
Instance details Defined in GHC.Types.ForeignCall Methods put_ :: BinHandle -> CExportSpec -> IO () # put :: BinHandle -> CExportSpec -> IO (Bin CExportSpec) # get :: BinHandle -> IO CExportSpec #
Binary CType
Instance details Defined in GHC.Types.ForeignCall Methods put_ :: BinHandle -> CType -> IO () # put :: BinHandle -> CType -> IO (Bin CType) # get :: BinHandle -> IO CType #
Binary ForeignCall
Instance details Defined in GHC.Types.ForeignCall Methods put_ :: BinHandle -> ForeignCall -> IO () # put :: BinHandle -> ForeignCall -> IO (Bin ForeignCall) # get :: BinHandle -> IO ForeignCall #
Binary Header
Instance details Defined in GHC.Types.ForeignCall Methods put_ :: BinHandle -> Header -> IO () # put :: BinHandle -> Header -> IO (Bin Header) # get :: BinHandle -> IO Header #
Binary Safety
Instance details Defined in GHC.Types.ForeignCall Methods put_ :: BinHandle -> Safety -> IO () # put :: BinHandle -> Safety -> IO (Bin Safety) # get :: BinHandle -> IO Safety #
Binary LitNumType
Instance details Defined in GHC.Types.Literal Methods put_ :: BinHandle -> LitNumType -> IO () # put :: BinHandle -> LitNumType -> IO (Bin LitNumType) # get :: BinHandle -> IO LitNumType #
Binary Literal
Instance details Defined in GHC.Types.Literal Methods put_ :: BinHandle -> Literal -> IO () # put :: BinHandle -> Literal -> IO (Bin Literal) # get :: BinHandle -> IO Literal #
Binary Name	Assumes that the `Name` is a non-binding one. See `putIfaceTopBndr` and `getIfaceTopBndr` for serializing binding `Name`s. See `UserData` for the rationale for this distinction.
Instance details Defined in GHC.Types.Name Methods put_ :: BinHandle -> Name -> IO () # put :: BinHandle -> Name -> IO (Bin Name) # get :: BinHandle -> IO Name #
Binary NameSpace
Instance details Defined in GHC.Types.Name.Occurrence Methods put_ :: BinHandle -> NameSpace -> IO () # put :: BinHandle -> NameSpace -> IO (Bin NameSpace) # get :: BinHandle -> IO NameSpace #
Binary OccName
Instance details Defined in GHC.Types.Name.Occurrence Methods put_ :: BinHandle -> OccName -> IO () # put :: BinHandle -> OccName -> IO (Bin OccName) # get :: BinHandle -> IO OccName #
Binary IfaceTrustInfo
Instance details Defined in GHC.Types.SafeHaskell Methods put_ :: BinHandle -> IfaceTrustInfo -> IO () # put :: BinHandle -> IfaceTrustInfo -> IO (Bin IfaceTrustInfo) # get :: BinHandle -> IO IfaceTrustInfo #
Binary SaneDouble
Instance details Defined in GHC.Types.SaneDouble Methods put_ :: BinHandle -> SaneDouble -> IO () # put :: BinHandle -> SaneDouble -> IO (Bin SaneDouble) # get :: BinHandle -> IO SaneDouble #
Binary HscSource
Instance details Defined in GHC.Types.SourceFile Methods put_ :: BinHandle -> HscSource -> IO () # put :: BinHandle -> HscSource -> IO (Bin HscSource) # get :: BinHandle -> IO HscSource #
Binary SourceText
Instance details Defined in GHC.Types.SourceText Methods put_ :: BinHandle -> SourceText -> IO () # put :: BinHandle -> SourceText -> IO (Bin SourceText) # get :: BinHandle -> IO SourceText #
Binary UnhelpfulSpanReason
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> UnhelpfulSpanReason -> IO () # put :: BinHandle -> UnhelpfulSpanReason -> IO (Bin UnhelpfulSpanReason) # get :: BinHandle -> IO UnhelpfulSpanReason #
Binary ForAllTyFlag
Instance details Defined in GHC.Types.Var Methods put_ :: BinHandle -> ForAllTyFlag -> IO () # put :: BinHandle -> ForAllTyFlag -> IO (Bin ForAllTyFlag) # get :: BinHandle -> IO ForAllTyFlag #
Binary FunTyFlag
Instance details Defined in GHC.Types.Var Methods put_ :: BinHandle -> FunTyFlag -> IO () # put :: BinHandle -> FunTyFlag -> IO (Bin FunTyFlag) # get :: BinHandle -> IO FunTyFlag #
Binary Specificity
Instance details Defined in GHC.Types.Var Methods put_ :: BinHandle -> Specificity -> IO () # put :: BinHandle -> Specificity -> IO (Bin Specificity) # get :: BinHandle -> IO Specificity #
Binary Dependencies
Instance details Defined in GHC.Unit.Module.Deps Methods put_ :: BinHandle -> Dependencies -> IO () # put :: BinHandle -> Dependencies -> IO (Bin Dependencies) # get :: BinHandle -> IO Dependencies #
Binary Usage
Instance details Defined in GHC.Unit.Module.Deps Methods put_ :: BinHandle -> Usage -> IO () # put :: BinHandle -> Usage -> IO (Bin Usage) # get :: BinHandle -> IO Usage #
Binary ModIface
Instance details Defined in GHC.Unit.Module.ModIface Methods put_ :: BinHandle -> ModIface -> IO () # put :: BinHandle -> ModIface -> IO (Bin ModIface) # get :: BinHandle -> IO ModIface #
Binary WarningCategory
Instance details Defined in GHC.Unit.Module.Warnings Methods put_ :: BinHandle -> WarningCategory -> IO () # put :: BinHandle -> WarningCategory -> IO (Bin WarningCategory) # get :: BinHandle -> IO WarningCategory #
Binary InstantiatedUnit
Instance details Defined in GHC.Unit.Types Methods put_ :: BinHandle -> InstantiatedUnit -> IO () # put :: BinHandle -> InstantiatedUnit -> IO (Bin InstantiatedUnit) # get :: BinHandle -> IO InstantiatedUnit #
Binary Unit
Instance details Defined in GHC.Unit.Types Methods put_ :: BinHandle -> Unit -> IO () # put :: BinHandle -> Unit -> IO (Bin Unit) # get :: BinHandle -> IO Unit #
Binary UnitId
Instance details Defined in GHC.Unit.Types Methods put_ :: BinHandle -> UnitId -> IO () # put :: BinHandle -> UnitId -> IO (Bin UnitId) # get :: BinHandle -> IO UnitId #
Binary BinData
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> BinData -> IO () # put :: BinHandle -> BinData -> IO (Bin BinData) # get :: BinHandle -> IO BinData #
Binary BinSpan
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> BinSpan -> IO () # put :: BinHandle -> BinSpan -> IO (Bin BinSpan) # get :: BinHandle -> IO BinSpan #
Binary BinSrcSpan
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> BinSrcSpan -> IO () # put :: BinHandle -> BinSrcSpan -> IO (Bin BinSrcSpan) # get :: BinHandle -> IO BinSrcSpan #
Binary JoinPointHood
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> JoinPointHood -> IO () # put :: BinHandle -> JoinPointHood -> IO (Bin JoinPointHood) # get :: BinHandle -> IO JoinPointHood #
Binary ModuleName
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> ModuleName -> IO () # put :: BinHandle -> ModuleName -> IO (Bin ModuleName) # get :: BinHandle -> IO ModuleName #
Binary Fingerprint
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> Fingerprint -> IO () # put :: BinHandle -> Fingerprint -> IO (Bin Fingerprint) # get :: BinHandle -> IO Fingerprint #
Binary Int16
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> Int16 -> IO () # put :: BinHandle -> Int16 -> IO (Bin Int16) # get :: BinHandle -> IO Int16 #
Binary Int32
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> Int32 -> IO () # put :: BinHandle -> Int32 -> IO (Bin Int32) # get :: BinHandle -> IO Int32 #
Binary Int64
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> Int64 -> IO () # put :: BinHandle -> Int64 -> IO (Bin Int64) # get :: BinHandle -> IO Int64 #
Binary Int8
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> Int8 -> IO () # put :: BinHandle -> Int8 -> IO (Bin Int8) # get :: BinHandle -> IO Int8 #
Binary Word16
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> Word16 -> IO () # put :: BinHandle -> Word16 -> IO (Bin Word16) # get :: BinHandle -> IO Word16 #
Binary Word32
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> Word32 -> IO () # put :: BinHandle -> Word32 -> IO (Bin Word32) # get :: BinHandle -> IO Word32 #
Binary Word64
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> Word64 -> IO () # put :: BinHandle -> Word64 -> IO (Bin Word64) # get :: BinHandle -> IO Word64 #
Binary Word8
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> Word8 -> IO () # put :: BinHandle -> Word8 -> IO (Bin Word8) # get :: BinHandle -> IO Word8 #
Binary LHResolvedName Source #
Instance details Defined in Language.Haskell.Liquid.Types.Names Methods put_ :: BinHandle -> LHResolvedName -> IO () # put :: BinHandle -> LHResolvedName -> IO (Bin LHResolvedName) # get :: BinHandle -> IO LHResolvedName #
Binary LogicName Source #
Instance details Defined in Language.Haskell.Liquid.Types.Names Methods put_ :: BinHandle -> LogicName -> IO () # put :: BinHandle -> LogicName -> IO (Bin LogicName) # get :: BinHandle -> IO LogicName #
Binary Day
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> Day -> IO () # put :: BinHandle -> Day -> IO (Bin Day) # get :: BinHandle -> IO Day #
Binary DiffTime
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> DiffTime -> IO () # put :: BinHandle -> DiffTime -> IO (Bin DiffTime) # get :: BinHandle -> IO DiffTime #
Binary UTCTime
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> UTCTime -> IO () # put :: BinHandle -> UTCTime -> IO (Bin UTCTime) # get :: BinHandle -> IO UTCTime #
Binary Integer
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> Integer -> IO () # put :: BinHandle -> Integer -> IO (Bin Integer) # get :: BinHandle -> IO Integer #
Binary ()
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> () -> IO () # put :: BinHandle -> () -> IO (Bin ()) # get :: BinHandle -> IO () #
Binary Bool
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> Bool -> IO () # put :: BinHandle -> Bool -> IO (Bin Bool) # get :: BinHandle -> IO Bool #
Binary Char
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> Char -> IO () # put :: BinHandle -> Char -> IO (Bin Char) # get :: BinHandle -> IO Char #
Binary Int
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> Int -> IO () # put :: BinHandle -> Int -> IO (Bin Int) # get :: BinHandle -> IO Int #
Binary v => Binary (IntMap v)
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> IntMap v -> IO () # put :: BinHandle -> IntMap v -> IO (Bin (IntMap v)) # get :: BinHandle -> IO (IntMap v) #
(Binary a, Ord a) => Binary (Set a)	This instance doesn't rely on the determinism of the keys' `Ord` instance, so it works e.g. for `Name`s too.
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> Set a -> IO () # put :: BinHandle -> Set a -> IO (Bin (Set a)) # get :: BinHandle -> IO (Set a) #
Binary a => Binary (Maybe a)
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> Maybe a -> IO () # put :: BinHandle -> Maybe a -> IO (Bin (Maybe a)) # get :: BinHandle -> IO (Maybe a) #
Binary (HieAST TypeIndex)
Instance details Defined in GHC.Iface.Ext.Types Methods put_ :: BinHandle -> HieAST TypeIndex -> IO () # put :: BinHandle -> HieAST TypeIndex -> IO (Bin (HieAST TypeIndex)) # get :: BinHandle -> IO (HieAST TypeIndex) #
Binary (HieASTs TypeIndex)
Instance details Defined in GHC.Iface.Ext.Types Methods put_ :: BinHandle -> HieASTs TypeIndex -> IO () # put :: BinHandle -> HieASTs TypeIndex -> IO (Bin (HieASTs TypeIndex)) # get :: BinHandle -> IO (HieASTs TypeIndex) #
Binary (HieArgs TypeIndex)
Instance details Defined in GHC.Iface.Ext.Types Methods put_ :: BinHandle -> HieArgs TypeIndex -> IO () # put :: BinHandle -> HieArgs TypeIndex -> IO (Bin (HieArgs TypeIndex)) # get :: BinHandle -> IO (HieArgs TypeIndex) #
Binary (HieType TypeIndex)
Instance details Defined in GHC.Iface.Ext.Types Methods put_ :: BinHandle -> HieType TypeIndex -> IO () # put :: BinHandle -> HieType TypeIndex -> IO (Bin (HieType TypeIndex)) # get :: BinHandle -> IO (HieType TypeIndex) #
Binary (IdentifierDetails TypeIndex)
Instance details Defined in GHC.Iface.Ext.Types Methods put_ :: BinHandle -> IdentifierDetails TypeIndex -> IO () # put :: BinHandle -> IdentifierDetails TypeIndex -> IO (Bin (IdentifierDetails TypeIndex)) # get :: BinHandle -> IO (IdentifierDetails TypeIndex) #
Binary (NodeInfo TypeIndex)
Instance details Defined in GHC.Iface.Ext.Types Methods put_ :: BinHandle -> NodeInfo TypeIndex -> IO () # put :: BinHandle -> NodeInfo TypeIndex -> IO (Bin (NodeInfo TypeIndex)) # get :: BinHandle -> IO (NodeInfo TypeIndex) #
Binary (SourcedNodeInfo TypeIndex)
Instance details Defined in GHC.Iface.Ext.Types Methods put_ :: BinHandle -> SourcedNodeInfo TypeIndex -> IO () # put :: BinHandle -> SourcedNodeInfo TypeIndex -> IO (Bin (SourcedNodeInfo TypeIndex)) # get :: BinHandle -> IO (SourcedNodeInfo TypeIndex) #
Binary name => Binary (AnnTarget name)
Instance details Defined in GHC.Types.Annotations Methods put_ :: BinHandle -> AnnTarget name -> IO () # put :: BinHandle -> AnnTarget name -> IO (Bin (AnnTarget name)) # get :: BinHandle -> IO (AnnTarget name) #
Binary (DefMethSpec IfaceType)
Instance details Defined in GHC.Iface.Type Methods put_ :: BinHandle -> DefMethSpec IfaceType -> IO () # put :: BinHandle -> DefMethSpec IfaceType -> IO (Bin (DefMethSpec IfaceType)) # get :: BinHandle -> IO (DefMethSpec IfaceType) #
Binary unit => Binary (Definite unit)
Instance details Defined in GHC.Unit.Types Methods put_ :: BinHandle -> Definite unit -> IO () # put :: BinHandle -> Definite unit -> IO (Bin (Definite unit)) # get :: BinHandle -> IO (Definite unit) #
Binary a => Binary (GenModule a)
Instance details Defined in GHC.Unit.Types Methods put_ :: BinHandle -> GenModule a -> IO () # put :: BinHandle -> GenModule a -> IO (Bin (GenModule a)) # get :: BinHandle -> IO (GenModule a) #
Binary a => Binary (GenWithIsBoot a)
Instance details Defined in GHC.Unit.Types Methods put_ :: BinHandle -> GenWithIsBoot a -> IO () # put :: BinHandle -> GenWithIsBoot a -> IO (Bin (GenWithIsBoot a)) # get :: BinHandle -> IO (GenWithIsBoot a) #
Binary a => Binary (BinLocated a)
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> BinLocated a -> IO () # put :: BinHandle -> BinLocated a -> IO (Bin (BinLocated a)) # get :: BinHandle -> IO (BinLocated a) #
Binary (FixedLengthEncoding Word16)
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> FixedLengthEncoding Word16 -> IO () # put :: BinHandle -> FixedLengthEncoding Word16 -> IO (Bin (FixedLengthEncoding Word16)) # get :: BinHandle -> IO (FixedLengthEncoding Word16) #
Binary (FixedLengthEncoding Word32)
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> FixedLengthEncoding Word32 -> IO () # put :: BinHandle -> FixedLengthEncoding Word32 -> IO (Bin (FixedLengthEncoding Word32)) # get :: BinHandle -> IO (FixedLengthEncoding Word32) #
Binary (FixedLengthEncoding Word64)
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> FixedLengthEncoding Word64 -> IO () # put :: BinHandle -> FixedLengthEncoding Word64 -> IO (Bin (FixedLengthEncoding Word64)) # get :: BinHandle -> IO (FixedLengthEncoding Word64) #
Binary (FixedLengthEncoding Word8)
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> FixedLengthEncoding Word8 -> IO () # put :: BinHandle -> FixedLengthEncoding Word8 -> IO (Bin (FixedLengthEncoding Word8)) # get :: BinHandle -> IO (FixedLengthEncoding Word8) #
Binary a => Binary (NonEmpty a)
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> NonEmpty a -> IO () # put :: BinHandle -> NonEmpty a -> IO (Bin (NonEmpty a)) # get :: BinHandle -> IO (NonEmpty a) #
Binary a => Binary (Ratio a)
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> Ratio a -> IO () # put :: BinHandle -> Ratio a -> IO (Bin (Ratio a)) # get :: BinHandle -> IO (Ratio a) #
Binary a => Binary (Maybe a)
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> Maybe a -> IO () # put :: BinHandle -> Maybe a -> IO (Bin (Maybe a)) # get :: BinHandle -> IO (Maybe a) #
Binary a => Binary [a]
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> [a] -> IO () # put :: BinHandle -> [a] -> IO (Bin [a]) # get :: BinHandle -> IO [a] #
Binary (EnumSet a)	Represents the `EnumSet` as a bit set. Assumes that all elements are non-negative. This is only efficient for values that are sufficiently small, for example in the lower hundreds.
Instance details Defined in GHC.Data.EnumSet Methods put_ :: BinHandle -> EnumSet a -> IO () # put :: BinHandle -> EnumSet a -> IO (Bin (EnumSet a)) # get :: BinHandle -> IO (EnumSet a) #
Binary a => Binary (WithHsDocIdentifiers a GhcRn)
Instance details Defined in GHC.Hs.Doc Methods put_ :: BinHandle -> WithHsDocIdentifiers a GhcRn -> IO () # put :: BinHandle -> WithHsDocIdentifiers a GhcRn -> IO (Bin (WithHsDocIdentifiers a GhcRn)) # get :: BinHandle -> IO (WithHsDocIdentifiers a GhcRn) #
(Binary r, Binary b) => Binary (IfaceBindingX b r)
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceBindingX b r -> IO () # put :: BinHandle -> IfaceBindingX b r -> IO (Bin (IfaceBindingX b r)) # get :: BinHandle -> IO (IfaceBindingX b r) #
(Binary tv, Binary vis) => Binary (VarBndr tv vis)
Instance details Defined in GHC.Types.Var Methods put_ :: BinHandle -> VarBndr tv vis -> IO () # put :: BinHandle -> VarBndr tv vis -> IO (Bin (VarBndr tv vis)) # get :: BinHandle -> IO (VarBndr tv vis) #
Binary (Bin a)
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> Bin a -> IO () # put :: BinHandle -> Bin a -> IO (Bin (Bin a)) # get :: BinHandle -> IO (Bin a) #
(Ix a, Binary a, Binary b) => Binary (Array a b)
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> Array a b -> IO () # put :: BinHandle -> Array a b -> IO (Bin (Array a b)) # get :: BinHandle -> IO (Array a b) #
(Binary a, Binary b) => Binary (Either a b)
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> Either a b -> IO () # put :: BinHandle -> Either a b -> IO (Bin (Either a b)) # get :: BinHandle -> IO (Either a b) #
(Binary a, Binary b) => Binary (a, b)
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> (a, b) -> IO () # put :: BinHandle -> (a, b) -> IO (Bin (a, b)) # get :: BinHandle -> IO (a, b) #
(Binary a, Binary b, Binary c) => Binary (a, b, c)
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> (a, b, c) -> IO () # put :: BinHandle -> (a, b, c) -> IO (Bin (a, b, c)) # get :: BinHandle -> IO (a, b, c) #
(Binary a, Binary b, Binary c, Binary d) => Binary (a, b, c, d)
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> (a, b, c, d) -> IO () # put :: BinHandle -> (a, b, c, d) -> IO (Bin (a, b, c, d)) # get :: BinHandle -> IO (a, b, c, d) #
(Binary a, Binary b, Binary c, Binary d, Binary e) => Binary (a, b, c, d, e)
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> (a, b, c, d, e) -> IO () # put :: BinHandle -> (a, b, c, d, e) -> IO (Bin (a, b, c, d, e)) # get :: BinHandle -> IO (a, b, c, d, e) #
(Binary a, Binary b, Binary c, Binary d, Binary e, Binary f) => Binary (a, b, c, d, e, f)
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> (a, b, c, d, e, f) -> IO () # put :: BinHandle -> (a, b, c, d, e, f) -> IO (Bin (a, b, c, d, e, f)) # get :: BinHandle -> IO (a, b, c, d, e, f) #
(Binary a, Binary b, Binary c, Binary d, Binary e, Binary f, Binary g) => Binary (a, b, c, d, e, f, g)
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> (a, b, c, d, e, f, g) -> IO () # put :: BinHandle -> (a, b, c, d, e, f, g) -> IO (Bin (a, b, c, d, e, f, g)) # get :: BinHandle -> IO (a, b, c, d, e, f, g) #

class IsOutput doc where #

A superclass for IsLine and IsDoc that provides an identity, empty, as well as access to the shared SDocContext.

See Note [The outputable class hierarchy] for more details.

Methods

empty :: doc #

docWithContext :: (SDocContext -> doc) -> doc #

docWithStyle :: doc -> (PprStyle -> SDoc) -> doc #

Instances

Instances details

IsOutput HDoc
Instance details Defined in GHC.Utils.Outputable Methods empty :: HDoc # docWithContext :: (SDocContext -> HDoc) -> HDoc # docWithStyle :: HDoc -> (PprStyle -> SDoc) -> HDoc #
IsOutput HLine
Instance details Defined in GHC.Utils.Outputable Methods empty :: HLine # docWithContext :: (SDocContext -> HLine) -> HLine # docWithStyle :: HLine -> (PprStyle -> SDoc) -> HLine #
IsOutput SDoc
Instance details Defined in GHC.Utils.Outputable Methods empty :: SDoc # docWithContext :: (SDocContext -> SDoc) -> SDoc # docWithStyle :: SDoc -> (PprStyle -> SDoc) -> SDoc #

data UnitId #

A UnitId identifies a built library in a database and is used to generate unique symbols, etc. It's usually of the form:

pkgname-1.2:libname+hash

These UnitId are provided to us via the -this-unit-id flag.

The library in question may be definite or indefinite; if it is indefinite, none of the holes have been filled (we never install partially instantiated libraries as we can cheaply instantiate them on-the-fly, cf VirtUnit). Put another way, an installed unit id is either fully instantiated, or not instantiated at all.

Instances

Instances details

NFData Unit
Instance details Defined in GHC.Unit.Types Methods rnf :: Unit -> () #
Uniquable Module
Instance details Defined in GHC.Unit.Types Methods getUnique :: Module -> Unique #
Uniquable UnitId
Instance details Defined in GHC.Unit.Types Methods getUnique :: UnitId -> Unique #
IsUnitId UnitId
Instance details Defined in GHC.Unit.Types Methods unitFS :: UnitId -> FastString #
Binary InstantiatedUnit
Instance details Defined in GHC.Unit.Types Methods put_ :: BinHandle -> InstantiatedUnit -> IO () # put :: BinHandle -> InstantiatedUnit -> IO (Bin InstantiatedUnit) # get :: BinHandle -> IO InstantiatedUnit #
Binary Unit
Instance details Defined in GHC.Unit.Types Methods put_ :: BinHandle -> Unit -> IO () # put :: BinHandle -> Unit -> IO (Bin Unit) # get :: BinHandle -> IO Unit #
Binary UnitId
Instance details Defined in GHC.Unit.Types Methods put_ :: BinHandle -> UnitId -> IO () # put :: BinHandle -> UnitId -> IO (Bin UnitId) # get :: BinHandle -> IO UnitId #
Outputable InstalledModule
Instance details Defined in GHC.Unit.Types Methods ppr :: InstalledModule -> SDoc #
Outputable InstantiatedModule
Instance details Defined in GHC.Unit.Types Methods ppr :: InstantiatedModule -> SDoc #
Outputable InstantiatedUnit
Instance details Defined in GHC.Unit.Types Methods ppr :: InstantiatedUnit -> SDoc #
Outputable Module
Instance details Defined in GHC.Unit.Types Methods ppr :: Module -> SDoc #
Outputable Unit
Instance details Defined in GHC.Unit.Types Methods ppr :: Unit -> SDoc #
Outputable UnitId
Instance details Defined in GHC.Unit.Types Methods ppr :: UnitId -> SDoc #
Data Unit
Instance details Defined in GHC.Unit.Types Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Unit -> c Unit # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Unit # toConstr :: Unit -> Constr # dataTypeOf :: Unit -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Unit) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Unit) # gmapT :: (forall b. Data b => b -> b) -> Unit -> Unit # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Unit -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Unit -> r # gmapQ :: (forall d. Data d => d -> u) -> Unit -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Unit -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Unit -> m Unit # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Unit -> m Unit # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Unit -> m Unit #
Data UnitId
Instance details Defined in GHC.Unit.Types Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UnitId -> c UnitId # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UnitId # toConstr :: UnitId -> Constr # dataTypeOf :: UnitId -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UnitId) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnitId) # gmapT :: (forall b. Data b => b -> b) -> UnitId -> UnitId # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UnitId -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UnitId -> r # gmapQ :: (forall d. Data d => d -> u) -> UnitId -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> UnitId -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> UnitId -> m UnitId # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UnitId -> m UnitId # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UnitId -> m UnitId #
Show Unit
Instance details Defined in GHC.Unit.Types Methods showsPrec :: Int -> Unit -> ShowS # show :: Unit -> String # showList :: [Unit] -> ShowS #
Eq UnitId
Instance details Defined in GHC.Unit.Types Methods (==) :: UnitId -> UnitId -> Bool # (/=) :: UnitId -> UnitId -> Bool #
Ord Unit
Instance details Defined in GHC.Unit.Types Methods compare :: Unit -> Unit -> Ordering # (<) :: Unit -> Unit -> Bool # (<=) :: Unit -> Unit -> Bool # (>) :: Unit -> Unit -> Bool # (>=) :: Unit -> Unit -> Bool # max :: Unit -> Unit -> Unit # min :: Unit -> Unit -> Unit #
Ord UnitId
Instance details Defined in GHC.Unit.Types Methods compare :: UnitId -> UnitId -> Ordering # (<) :: UnitId -> UnitId -> Bool # (<=) :: UnitId -> UnitId -> Bool # (>) :: UnitId -> UnitId -> Bool # (>=) :: UnitId -> UnitId -> Bool # max :: UnitId -> UnitId -> UnitId # min :: UnitId -> UnitId -> UnitId #

type Module = GenModule Unit #

A Module is a pair of a Unit and a ModuleName.

data SrcLoc #

Source Location

Instances

Instances details

Outputable SrcLoc
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: SrcLoc -> SDoc #
Show SrcLoc
Instance details Defined in GHC.Types.SrcLoc Methods showsPrec :: Int -> SrcLoc -> ShowS # show :: SrcLoc -> String # showList :: [SrcLoc] -> ShowS #
Eq SrcLoc
Instance details Defined in GHC.Types.SrcLoc Methods (==) :: SrcLoc -> SrcLoc -> Bool # (/=) :: SrcLoc -> SrcLoc -> Bool #

data TyCon #

TyCons represent type constructors. Type constructors are introduced by things such as:

1) Data declarations: data Foo = ... creates the Foo type constructor of kind Type

2) Type synonyms: type Foo = ... creates the Foo type constructor

3) Newtypes: newtype Foo a = MkFoo ... creates the Foo type constructor of kind Type -> Type

4) Class declarations: class Foo where creates the Foo type constructor of kind Constraint

This data type also encodes a number of primitive, built in type constructors such as those for function and tuple types.

If you edit this type, you may need to update the GHC formalism See Note [GHC Formalism] in GHC.Core.Lint

Instances

Instances details

NFData TyCon Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Misc Methods rnf :: TyCon -> () #
NamedThing TyCon
Instance details Defined in GHC.Core.TyCon Methods getOccName :: TyCon -> OccName # getName :: TyCon -> Name #
Uniquable TyCon
Instance details Defined in GHC.Core.TyCon Methods getUnique :: TyCon -> Unique #
Outputable TyCon
Instance details Defined in GHC.Core.TyCon Methods ppr :: TyCon -> SDoc #
Outputable OccurrenceMap Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Play Methods ppr :: OccurrenceMap -> SDoc #
Data TyCon
Instance details Defined in GHC.Core.TyCon Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyCon -> c TyCon # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TyCon # toConstr :: TyCon -> Constr # dataTypeOf :: TyCon -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TyCon) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyCon) # gmapT :: (forall b. Data b => b -> b) -> TyCon -> TyCon # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyCon -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyCon -> r # gmapQ :: (forall d. Data d => d -> u) -> TyCon -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TyCon -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyCon -> m TyCon # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyCon -> m TyCon # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyCon -> m TyCon #
Show TyCon Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Misc Methods showsPrec :: Int -> TyCon -> ShowS # show :: TyCon -> String # showList :: [TyCon] -> ShowS #
Eq TyCon
Instance details Defined in GHC.Core.TyCon Methods (==) :: TyCon -> TyCon -> Bool # (/=) :: TyCon -> TyCon -> Bool #
Ord TyCon Source #
Instance details Defined in Language.Haskell.Liquid.Types.Types Methods compare :: TyCon -> TyCon -> Ordering # (<) :: TyCon -> TyCon -> Bool # (<=) :: TyCon -> TyCon -> Bool # (>) :: TyCon -> TyCon -> Bool # (>=) :: TyCon -> TyCon -> Bool # max :: TyCon -> TyCon -> TyCon # min :: TyCon -> TyCon -> TyCon #
Hashable TyCon Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Misc Methods hashWithSalt :: Int -> TyCon -> Int # hash :: TyCon -> Int #
Symbolic TyCon Source #	Symbol Instances
Instance details Defined in Language.Haskell.Liquid.GHC.Misc Methods symbol :: TyCon -> Symbol #
PPrint TyCon Source #
Instance details Defined in Language.Haskell.Liquid.Types.RType Methods pprintTidy :: Tidy -> TyCon -> Doc # pprintPrec :: Int -> Tidy -> TyCon -> Doc #
TyConable TyCon Source #
Instance details Defined in Language.Haskell.Liquid.Types.RType Methods isFun :: TyCon -> Bool Source # isList :: TyCon -> Bool Source # isTuple :: TyCon -> Bool Source # ppTycon :: TyCon -> Doc Source # isClass :: TyCon -> Bool Source # isEmbeddedDict :: TyCon -> Bool Source # isEqual :: TyCon -> Bool Source # isOrdCls :: TyCon -> Bool Source # isEqCls :: TyCon -> Bool Source # isNumCls :: TyCon -> Bool Source # isFracCls :: TyCon -> Bool Source #

data Var #

Variable

Essentially a typed Name, that may also contain some additional information about the Var and its use sites.

Instances

Instances details

NFData Var Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Misc Methods rnf :: Var -> () #
ModifyState Id
Instance details Defined in GHC.Iface.Ext.Ast Methods addSubstitution :: Id -> Id -> HieState -> HieState
NamedThing Var
Instance details Defined in GHC.Types.Var Methods getOccName :: Var -> OccName # getName :: Var -> Name #
HasOccName Var
Instance details Defined in GHC.Types.Var Methods occName :: Var -> OccName #
Uniquable Var
Instance details Defined in GHC.Types.Var Methods getUnique :: Var -> Unique #
Outputable Var
Instance details Defined in GHC.Types.Var Methods ppr :: Var -> SDoc #
Data Var
Instance details Defined in GHC.Types.Var Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Var -> c Var # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Var # toConstr :: Var -> Constr # dataTypeOf :: Var -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Var) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Var) # gmapT :: (forall b. Data b => b -> b) -> Var -> Var # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r # gmapQ :: (forall d. Data d => d -> u) -> Var -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Var -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Var -> m Var # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Var -> m Var # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Var -> m Var #
Show CoreExpr Source #
Instance details Defined in Language.Haskell.Liquid.Transforms.CoreToLogic Methods showsPrec :: Int -> CoreExpr -> ShowS # show :: CoreExpr -> String # showList :: [CoreExpr] -> ShowS #
Show Var Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Misc Methods showsPrec :: Int -> Var -> ShowS # show :: Var -> String # showList :: [Var] -> ShowS #
Eq Var
Instance details Defined in GHC.Types.Var Methods (==) :: Var -> Var -> Bool # (/=) :: Var -> Var -> Bool #
Ord Var
Instance details Defined in GHC.Types.Var Methods compare :: Var -> Var -> Ordering # (<) :: Var -> Var -> Bool # (<=) :: Var -> Var -> Bool # (>) :: Var -> Var -> Bool # (>=) :: Var -> Var -> Bool # max :: Var -> Var -> Var # min :: Var -> Var -> Var #
Hashable Var Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Misc Methods hashWithSalt :: Int -> Var -> Int # hash :: Var -> Int #
Symbolic Var Source #	NOTE:REFLECT-IMPORTS we eschew the `unique` suffix for exported vars, to make it possible to lookup names from symbols _across_ modules; anyways exported names are top-level and you shouldn't have local binders that shadow them. However, we keep the `unique` suffix for local variables, as otherwise there are spurious, but extremely problematic, name collisions in the fixpoint environment.
Instance details Defined in Language.Haskell.Liquid.GHC.Misc Methods symbol :: Var -> Symbol #
Fixpoint Var Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Misc Methods toFix :: Var -> Doc # simplify :: Var -> Var #
PPrint Var Source #
Instance details Defined in Language.Haskell.Liquid.Types.PrettyPrint Methods pprintTidy :: Tidy -> Var -> Doc # pprintPrec :: Int -> Tidy -> Var -> Doc #
Expression Var Source #	Converting to Fixpoint ----------------------------------------------------
Instance details Defined in Language.Haskell.Liquid.Types.RefType Methods expr :: Var -> Expr #
Loc Var Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Misc Methods srcSpan :: Var -> SrcSpan #
Subable CoreExpr Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Play Methods sub :: HashMap CoreBndr CoreExpr -> CoreExpr -> CoreExpr Source # subTy :: HashMap TyVar Type -> CoreExpr -> CoreExpr Source #
Subable Var Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Play Methods sub :: HashMap CoreBndr CoreExpr -> Var -> Var Source # subTy :: HashMap TyVar Type -> Var -> Var Source #
CBVisitable CoreBind Source #
Instance details Defined in Language.Haskell.Liquid.Types.Visitors Methods freeVars :: HashSet Var -> CoreBind -> [Var] Source # readVars :: CoreBind -> [Var] Source # letVars :: CoreBind -> [Var] Source # literals :: CoreBind -> [Literal] Source #
SubsTy TyVar Type SpecType Source #
Instance details Defined in Language.Haskell.Liquid.Types.RefType Methods subt :: (TyVar, Type) -> SpecType -> SpecType Source #
ToHie (Context (Located Var))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: Context (Located Var) -> HieM [HieAST Type]
Eq (DeBruijn Var)
Instance details Defined in GHC.Core.Map.Type Methods (==) :: DeBruijn Var -> DeBruijn Var -> Bool # (/=) :: DeBruijn Var -> DeBruijn Var -> Bool #
PPrint (Bind Var) Source #
Instance details Defined in Language.Haskell.Liquid.Types.PrettyPrint Methods pprintTidy :: Tidy -> Bind Var -> Doc # pprintPrec :: Int -> Tidy -> Bind Var -> Doc #
PPrint (Expr Var) Source #
Instance details Defined in Language.Haskell.Liquid.Types.PrettyPrint Methods pprintTidy :: Tidy -> Expr Var -> Doc # pprintPrec :: Int -> Tidy -> Expr Var -> Doc #
Subable (Alt Var) Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Play Methods sub :: HashMap CoreBndr CoreExpr -> Alt Var -> Alt Var Source # subTy :: HashMap TyVar Type -> Alt Var -> Alt Var Source #
Subable (Bind Var) Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Play Methods sub :: HashMap CoreBndr CoreExpr -> Bind Var -> Bind Var Source # subTy :: HashMap TyVar Type -> Bind Var -> Bind Var Source #
CBVisitable (Alt Var) Source #
Instance details Defined in Language.Haskell.Liquid.Types.Visitors Methods freeVars :: HashSet Var -> Alt Var -> [Var] Source # readVars :: Alt Var -> [Var] Source # letVars :: Alt Var -> [Var] Source # literals :: Alt Var -> [Literal] Source #
CBVisitable (Expr Var) Source #
Instance details Defined in Language.Haskell.Liquid.Types.Visitors Methods freeVars :: HashSet Var -> Expr Var -> [Var] Source # readVars :: Expr Var -> [Var] Source # letVars :: Expr Var -> [Var] Source # literals :: Expr Var -> [Literal] Source #
CBVisitable [CoreBind] Source #
Instance details Defined in Language.Haskell.Liquid.Types.Visitors Methods freeVars :: HashSet Var -> [CoreBind] -> [Var] Source # readVars :: [CoreBind] -> [Var] Source # letVars :: [CoreBind] -> [Var] Source # literals :: [CoreBind] -> [Literal] Source #
OutputableBndr (Id, TagSig)
Instance details Defined in GHC.Stg.InferTags.TagSig Methods pprBndr :: BindingSite -> (Id, TagSig) -> SDoc # pprPrefixOcc :: (Id, TagSig) -> SDoc # pprInfixOcc :: (Id, TagSig) -> SDoc # bndrIsJoin_maybe :: (Id, TagSig) -> JoinPointHood #
Show (Axiom Var Type CoreExpr) Source #
Instance details Defined in Language.Haskell.Liquid.Types.Types Methods showsPrec :: Int -> Axiom Var Type CoreExpr -> ShowS # show :: Axiom Var Type CoreExpr -> String # showList :: [Axiom Var Type CoreExpr] -> ShowS #
type Anno Id
Instance details Defined in GHC.Hs.Extension type Anno Id = SrcSpanAnnN

data GenLocated l e #

We attach SrcSpans to lots of things, so let's have a datatype for it.

Constructors

L l e

Instances

Instances details

HasAnnotation EpaLocation
Instance details Defined in GHC.Parser.Annotation Methods noAnnSrcSpan :: SrcSpan -> EpaLocation #
HasLoc EpaLocation
Instance details Defined in GHC.Parser.Annotation Methods getHasLoc :: EpaLocation -> SrcSpan #
NoAnn EpaLocation
Instance details Defined in GHC.Parser.Annotation Methods noAnn :: EpaLocation #
Semigroup EpaLocation
Instance details Defined in GHC.Parser.Annotation Methods (<>) :: EpaLocation -> EpaLocation -> EpaLocation # sconcat :: NonEmpty EpaLocation -> EpaLocation # stimes :: Integral b => b -> EpaLocation -> EpaLocation #
HiePass p => HasType (LocatedA (HsBind (GhcPass p)))
Instance details Defined in GHC.Iface.Ext.Ast Methods getTypeNode :: LocatedA (HsBind (GhcPass p)) -> HieM [HieAST Type]
HiePass p => HasType (LocatedA (HsExpr (GhcPass p)))	This instance tries to construct `HieAST` nodes which include the type of the expression. It is not yet possible to do this efficiently for all expression forms, so we skip filling in the type for those inputs. See Note [Computing the type of every node in the tree]
Instance details Defined in GHC.Iface.Ext.Ast Methods getTypeNode :: LocatedA (HsExpr (GhcPass p)) -> HieM [HieAST Type]
HiePass p => HasType (LocatedA (Pat (GhcPass p)))
Instance details Defined in GHC.Iface.Ext.Ast Methods getTypeNode :: LocatedA (Pat (GhcPass p)) -> HieM [HieAST Type]
ToHie (LBooleanFormula (LocatedN Name))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LBooleanFormula (LocatedN Name) -> HieM [HieAST Type]
ToHie (LHsDoc GhcRn)
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LHsDoc GhcRn -> HieM [HieAST Type]
HiePass p => ToHie (BindContext (LocatedA (HsBind (GhcPass p))))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: BindContext (LocatedA (HsBind (GhcPass p))) -> HieM [HieAST Type]
ToHie (Context (Located a)) => ToHie (Context (LocatedA a))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: Context (LocatedA a) -> HieM [HieAST Type]
ToHie (Context (Located a)) => ToHie (Context (LocatedN a))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: Context (LocatedN a) -> HieM [HieAST Type]
ToHie (Context (Located Name))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: Context (Located Name) -> HieM [HieAST Type]
ToHie (Context (Located Var))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: Context (Located Var) -> HieM [HieAST Type]
ToHie (Context (Located NoExtField))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: Context (Located NoExtField) -> HieM [HieAST Type]
ToHie (EvBindContext (LocatedA TcEvBinds))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: EvBindContext (LocatedA TcEvBinds) -> HieM [HieAST Type]
ToHie (IEContext (LocatedA (IE GhcRn)))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: IEContext (LocatedA (IE GhcRn)) -> HieM [HieAST Type]
ToHie (IEContext (LocatedA (IEWrappedName GhcRn)))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: IEContext (LocatedA (IEWrappedName GhcRn)) -> HieM [HieAST Type]
ToHie (IEContext (LocatedA ModuleName))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: IEContext (LocatedA ModuleName) -> HieM [HieAST Type]
ToHie (IEContext (Located RecFieldInfo))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: IEContext (Located RecFieldInfo) -> HieM [HieAST Type]
HiePass p => ToHie (PScoped (LocatedA (Pat (GhcPass p))))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: PScoped (LocatedA (Pat (GhcPass p))) -> HieM [HieAST Type]
(ToHie (RFContext label), ToHie arg, HasLoc arg, Data arg, Data label) => ToHie (RContext (LocatedA (HsFieldBind label arg)))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: RContext (LocatedA (HsFieldBind label arg)) -> HieM [HieAST Type]
HiePass p => ToHie (RFContext (LocatedA (AmbiguousFieldOcc (GhcPass p))))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: RFContext (LocatedA (AmbiguousFieldOcc (GhcPass p))) -> HieM [HieAST Type]
HiePass p => ToHie (RFContext (LocatedA (FieldOcc (GhcPass p))))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: RFContext (LocatedA (FieldOcc (GhcPass p))) -> HieM [HieAST Type]
HiePass p => ToHie (RScoped (LocatedA (IPBind (GhcPass p))))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: RScoped (LocatedA (IPBind (GhcPass p))) -> HieM [HieAST Type]
(ToHie (LocatedA (body (GhcPass p))), AnnoBody p body, HiePass p) => ToHie (RScoped (LocatedA (Stmt (GhcPass p) (LocatedA (body (GhcPass p))))))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: RScoped (LocatedA (Stmt (GhcPass p) (LocatedA (body (GhcPass p))))) -> HieM [HieAST Type]
ToHie (RScoped (LocatedAn NoEpAnns (DerivStrategy GhcRn)))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: RScoped (LocatedAn NoEpAnns (DerivStrategy GhcRn)) -> HieM [HieAST Type]
ToHie (RScoped (LocatedAn NoEpAnns (FamilyResultSig GhcRn)))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: RScoped (LocatedAn NoEpAnns (FamilyResultSig GhcRn)) -> HieM [HieAST Type]
ToHie (RScoped (LocatedAn NoEpAnns (RuleBndr GhcRn)))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: RScoped (LocatedAn NoEpAnns (RuleBndr GhcRn)) -> HieM [HieAST Type]
HiePass p => ToHie (SigContext (LocatedA (Sig (GhcPass p))))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: SigContext (LocatedA (Sig (GhcPass p))) -> HieM [HieAST Type]
ToHie (TScoped (LocatedA (HsSigType GhcRn)))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: TScoped (LocatedA (HsSigType GhcRn)) -> HieM [HieAST Type]
ToHie (TScoped (FamEqn GhcRn (LocatedA (HsType GhcRn))))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: TScoped (FamEqn GhcRn (LocatedA (HsType GhcRn))) -> HieM [HieAST Type]
ToHie (TScoped (HsWildCardBndrs GhcRn (LocatedA (HsSigType GhcRn))))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: TScoped (HsWildCardBndrs GhcRn (LocatedA (HsSigType GhcRn))) -> HieM [HieAST Type]
ToHie (TScoped (HsWildCardBndrs GhcRn (LocatedA (HsType GhcRn))))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: TScoped (HsWildCardBndrs GhcRn (LocatedA (HsType GhcRn))) -> HieM [HieAST Type]
Data flag => ToHie (TVScoped (LocatedA (HsTyVarBndr flag GhcRn)))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: TVScoped (LocatedA (HsTyVarBndr flag GhcRn)) -> HieM [HieAST Type]
ToHie (LocatedA SyntaxExprRn)
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA SyntaxExprRn -> HieM [HieAST Type]
ToHie (LocatedA SyntaxExprTc)
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA SyntaxExprTc -> HieM [HieAST Type]
ToHie (LocatedA HsWrapper)
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA HsWrapper -> HieM [HieAST Type]
ToHie (LocatedA (FixitySig GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (FixitySig GhcRn) -> HieM [HieAST Type]
ToHie (LocatedA (AnnDecl GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (AnnDecl GhcRn) -> HieM [HieAST Type]
ToHie (LocatedA (ClsInstDecl GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (ClsInstDecl GhcRn) -> HieM [HieAST Type]
ToHie (LocatedA (ConDecl GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (ConDecl GhcRn) -> HieM [HieAST Type]
ToHie (LocatedA (DataFamInstDecl GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (DataFamInstDecl GhcRn) -> HieM [HieAST Type]
ToHie (LocatedA (DefaultDecl GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (DefaultDecl GhcRn) -> HieM [HieAST Type]
ToHie (LocatedA (DerivDecl GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (DerivDecl GhcRn) -> HieM [HieAST Type]
ToHie (LocatedA (DocDecl GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (DocDecl GhcRn) -> HieM [HieAST Type]
ToHie (LocatedA (FamilyDecl GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (FamilyDecl GhcRn) -> HieM [HieAST Type]
ToHie (LocatedA (ForeignDecl GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (ForeignDecl GhcRn) -> HieM [HieAST Type]
ToHie (LocatedA (FunDep GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (FunDep GhcRn) -> HieM [HieAST Type]
ToHie (LocatedA (InstDecl GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (InstDecl GhcRn) -> HieM [HieAST Type]
ToHie (LocatedA (RoleAnnotDecl GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (RoleAnnotDecl GhcRn) -> HieM [HieAST Type]
ToHie (LocatedA (RuleDecl GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (RuleDecl GhcRn) -> HieM [HieAST Type]
ToHie (LocatedA (RuleDecls GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (RuleDecls GhcRn) -> HieM [HieAST Type]
ToHie (LocatedA (SpliceDecl GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (SpliceDecl GhcRn) -> HieM [HieAST Type]
ToHie (LocatedA (StandaloneKindSig GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (StandaloneKindSig GhcRn) -> HieM [HieAST Type]
ToHie (LocatedA (TyClDecl GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (TyClDecl GhcRn) -> HieM [HieAST Type]
ToHie (LocatedA (TyFamInstDecl GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (TyFamInstDecl GhcRn) -> HieM [HieAST Type]
ToHie (LocatedA (WarnDecl GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (WarnDecl GhcRn) -> HieM [HieAST Type]
ToHie (LocatedA (WarnDecls GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (WarnDecls GhcRn) -> HieM [HieAST Type]
HiePass p => ToHie (LocatedA (HsCmd (GhcPass p)))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (HsCmd (GhcPass p)) -> HieM [HieAST Type]
HiePass p => ToHie (LocatedA (HsExpr (GhcPass p)))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (HsExpr (GhcPass p)) -> HieM [HieAST Type]
HiePass p => ToHie (LocatedA (HsUntypedSplice (GhcPass p)))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (HsUntypedSplice (GhcPass p)) -> HieM [HieAST Type]
(HiePass p, Data (body (GhcPass p)), AnnoBody p body, ToHie (LocatedA (body (GhcPass p)))) => ToHie (LocatedA (Match (GhcPass p) (LocatedA (body (GhcPass p)))))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (Match (GhcPass p) (LocatedA (body (GhcPass p)))) -> HieM [HieAST Type]
ToHie (LocatedA (ImportDecl GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (ImportDecl GhcRn) -> HieM [HieAST Type]
HiePass p => ToHie (LocatedA (HsOverLit (GhcPass p)))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (HsOverLit (GhcPass p)) -> HieM [HieAST Type]
ToHie (LocatedA (ConDeclField GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (ConDeclField GhcRn) -> HieM [HieAST Type]
ToHie (LocatedA (HsType GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (HsType GhcRn) -> HieM [HieAST Type]
ToHie (LocatedC (DerivClauseTys GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedC (DerivClauseTys GhcRn) -> HieM [HieAST Type]
ToHie (LocatedC [LocatedA (HsType GhcRn)])
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedC [LocatedA (HsType GhcRn)] -> HieM [HieAST Type]
ToHie (LocatedL [LocatedA (ConDeclField GhcRn)])
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedL [LocatedA (ConDeclField GhcRn)] -> HieM [HieAST Type]
ToHie (LocatedP OverlapMode)
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedP OverlapMode -> HieM [HieAST Type]
HiePass p => ToHie (Located (PatSynBind (GhcPass p) (GhcPass p)))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: Located (PatSynBind (GhcPass p) (GhcPass p)) -> HieM [HieAST Type]
ToHie (Located [LocatedAn NoEpAnns (HsDerivingClause GhcRn)])
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: Located [LocatedAn NoEpAnns (HsDerivingClause GhcRn)] -> HieM [HieAST Type]
HasHaddock (LocatedA (ConDecl GhcPs))
Instance details Defined in GHC.Parser.PostProcess.Haddock Methods addHaddock :: LocatedA (ConDecl GhcPs) -> HdkA (LocatedA (ConDecl GhcPs))
HasHaddock (LocatedA (HsDecl GhcPs))
Instance details Defined in GHC.Parser.PostProcess.Haddock Methods addHaddock :: LocatedA (HsDecl GhcPs) -> HdkA (LocatedA (HsDecl GhcPs))
HasHaddock (LocatedA (IE GhcPs))
Instance details Defined in GHC.Parser.PostProcess.Haddock Methods addHaddock :: LocatedA (IE GhcPs) -> HdkA (LocatedA (IE GhcPs))
HasHaddock (LocatedA (HsSigType GhcPs))
Instance details Defined in GHC.Parser.PostProcess.Haddock Methods addHaddock :: LocatedA (HsSigType GhcPs) -> HdkA (LocatedA (HsSigType GhcPs))
HasHaddock (LocatedA (HsType GhcPs))
Instance details Defined in GHC.Parser.PostProcess.Haddock Methods addHaddock :: LocatedA (HsType GhcPs) -> HdkA (LocatedA (HsType GhcPs))
HasHaddock (LocatedC (DerivClauseTys GhcPs))
Instance details Defined in GHC.Parser.PostProcess.Haddock Methods addHaddock :: LocatedC (DerivClauseTys GhcPs) -> HdkA (LocatedC (DerivClauseTys GhcPs))
HasHaddock (LocatedL [LocatedA (IE GhcPs)])	Only for module exports, not module imports. module M (a, b, c) where -- use on this [LIE GhcPs] import I (a, b, c) -- do not use here! Imports cannot have documentation comments anyway.
Instance details Defined in GHC.Parser.PostProcess.Haddock Methods addHaddock :: LocatedL [LocatedA (IE GhcPs)] -> HdkA (LocatedL [LocatedA (IE GhcPs)])
HasHaddock (Located (HsModule GhcPs))
Instance details Defined in GHC.Parser.PostProcess.Haddock Methods addHaddock :: Located (HsModule GhcPs) -> HdkA (Located (HsModule GhcPs))
HasHaddock (Located [LocatedAn NoEpAnns (HsDerivingClause GhcPs)])
Instance details Defined in GHC.Parser.PostProcess.Haddock Methods addHaddock :: Located [LocatedAn NoEpAnns (HsDerivingClause GhcPs)] -> HdkA (Located [LocatedAn NoEpAnns (HsDerivingClause GhcPs)])
NamedThing e => NamedThing (Located e)
Instance details Defined in GHC.Types.Name Methods getOccName :: Located e -> OccName # getName :: Located e -> Name #
Outputable e => Outputable (Located e)
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: Located e -> SDoc #
Functor (GenLocated l)
Instance details Defined in GHC.Types.SrcLoc Methods fmap :: (a -> b) -> GenLocated l a -> GenLocated l b # (<$) :: a -> GenLocated l b -> GenLocated l a #
Foldable (GenLocated l)
Instance details Defined in GHC.Types.SrcLoc Methods fold :: Monoid m => GenLocated l m -> m # foldMap :: Monoid m => (a -> m) -> GenLocated l a -> m # foldMap' :: Monoid m => (a -> m) -> GenLocated l a -> m # foldr :: (a -> b -> b) -> b -> GenLocated l a -> b # foldr' :: (a -> b -> b) -> b -> GenLocated l a -> b # foldl :: (b -> a -> b) -> b -> GenLocated l a -> b # foldl' :: (b -> a -> b) -> b -> GenLocated l a -> b # foldr1 :: (a -> a -> a) -> GenLocated l a -> a # foldl1 :: (a -> a -> a) -> GenLocated l a -> a # toList :: GenLocated l a -> [a] # null :: GenLocated l a -> Bool # length :: GenLocated l a -> Int # elem :: Eq a => a -> GenLocated l a -> Bool # maximum :: Ord a => GenLocated l a -> a # minimum :: Ord a => GenLocated l a -> a # sum :: Num a => GenLocated l a -> a # product :: Num a => GenLocated l a -> a #
Traversable (GenLocated l)
Instance details Defined in GHC.Types.SrcLoc Methods traverse :: Applicative f => (a -> f b) -> GenLocated l a -> f (GenLocated l b) # sequenceA :: Applicative f => GenLocated l (f a) -> f (GenLocated l a) # mapM :: Monad m => (a -> m b) -> GenLocated l a -> m (GenLocated l b) # sequence :: Monad m => GenLocated l (m a) -> m (GenLocated l a) #
(NFData l, NFData e) => NFData (GenLocated l e)
Instance details Defined in GHC.Types.SrcLoc Methods rnf :: GenLocated l e -> () #
ToHie (LocatedAn NoEpAnns (HsDerivingClause GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedAn NoEpAnns (HsDerivingClause GhcRn) -> HieM [HieAST Type]
ToHie (LocatedAn NoEpAnns (InjectivityAnn GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedAn NoEpAnns (InjectivityAnn GhcRn) -> HieM [HieAST Type]
(ToHie (LocatedA (body (GhcPass p))), HiePass p, AnnoBody p body) => ToHie (LocatedAn NoEpAnns (GRHS (GhcPass p) (LocatedA (body (GhcPass p)))))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedAn NoEpAnns (GRHS (GhcPass p) (LocatedA (body (GhcPass p)))) -> HieM [HieAST Type]
HiePass p => ToHie (LocatedAn NoEpAnns (HsCmdTop (GhcPass p)))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedAn NoEpAnns (HsCmdTop (GhcPass p)) -> HieM [HieAST Type]
ToHie (LocatedAn NoEpAnns HsIPName)
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedAn NoEpAnns HsIPName -> HieM [HieAST Type]
(ToHie (LocatedA (body (GhcPass p))), HiePass p, AnnoBody p body) => ToHie (GRHSs (GhcPass p) (LocatedA (body (GhcPass p))))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: GRHSs (GhcPass p) (LocatedA (body (GhcPass p))) -> HieM [HieAST Type]
(HiePass p, AnnoBody p body, ToHie (LocatedA (body (GhcPass p)))) => ToHie (MatchGroup (GhcPass p) (LocatedA (body (GhcPass p))))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: MatchGroup (GhcPass p) (LocatedA (body (GhcPass p))) -> HieM [HieAST Type]
HasLoc l => HasLoc (GenLocated l a)
Instance details Defined in GHC.Parser.Annotation Methods getHasLoc :: GenLocated l a -> SrcSpan #
HasHaddock (LocatedAn NoEpAnns (HsDerivingClause GhcPs))
Instance details Defined in GHC.Parser.PostProcess.Haddock Methods addHaddock :: LocatedAn NoEpAnns (HsDerivingClause GhcPs) -> HdkA (LocatedAn NoEpAnns (HsDerivingClause GhcPs))
NamedThing (Located a) => NamedThing (LocatedAn an a)
Instance details Defined in GHC.Parser.Annotation Methods getOccName :: LocatedAn an a -> OccName # getName :: LocatedAn an a -> Name #
(Outputable a, Outputable e) => Outputable (GenLocated (EpAnn a) e)
Instance details Defined in GHC.Parser.Annotation Methods ppr :: GenLocated (EpAnn a) e -> SDoc #
Outputable e => Outputable (GenLocated EpaLocation e)
Instance details Defined in GHC.Parser.Annotation Methods ppr :: GenLocated EpaLocation e -> SDoc #
Outputable a => Outputable (GenLocated TokenLocation a)
Instance details Defined in GHC.Parser.Annotation Methods ppr :: GenLocated TokenLocation a -> SDoc #
Outputable (GenLocated NoCommentsLocation EpaComment)
Instance details Defined in GHC.Parser.Annotation Methods ppr :: GenLocated NoCommentsLocation EpaComment -> SDoc #
Outputable e => Outputable (GenLocated RealSrcSpan e)
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: GenLocated RealSrcSpan e -> SDoc #
(Outputable a, OutputableBndr e) => OutputableBndr (GenLocated (EpAnn a) e)
Instance details Defined in GHC.Parser.Annotation Methods pprBndr :: BindingSite -> GenLocated (EpAnn a) e -> SDoc # pprPrefixOcc :: GenLocated (EpAnn a) e -> SDoc # pprInfixOcc :: GenLocated (EpAnn a) e -> SDoc # bndrIsJoin_maybe :: GenLocated (EpAnn a) e -> JoinPointHood #
(Data l, Data e) => Data (GenLocated l e)
Instance details Defined in GHC.Types.SrcLoc Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GenLocated l e -> c (GenLocated l e) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GenLocated l e) # toConstr :: GenLocated l e -> Constr # dataTypeOf :: GenLocated l e -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GenLocated l e)) # dataCast2 :: Typeable t => (forall d e0. (Data d, Data e0) => c (t d e0)) -> Maybe (c (GenLocated l e)) # gmapT :: (forall b. Data b => b -> b) -> GenLocated l e -> GenLocated l e # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GenLocated l e -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GenLocated l e -> r # gmapQ :: (forall d. Data d => d -> u) -> GenLocated l e -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> GenLocated l e -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> GenLocated l e -> m (GenLocated l e) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GenLocated l e -> m (GenLocated l e) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GenLocated l e -> m (GenLocated l e) #
(Show l, Show e) => Show (GenLocated l e)
Instance details Defined in GHC.Types.SrcLoc Methods showsPrec :: Int -> GenLocated l e -> ShowS # show :: GenLocated l e -> String # showList :: [GenLocated l e] -> ShowS #
(Eq l, Eq e) => Eq (GenLocated l e)
Instance details Defined in GHC.Types.SrcLoc Methods (==) :: GenLocated l e -> GenLocated l e -> Bool # (/=) :: GenLocated l e -> GenLocated l e -> Bool #
(Ord l, Ord e) => Ord (GenLocated l e)
Instance details Defined in GHC.Types.SrcLoc Methods compare :: GenLocated l e -> GenLocated l e -> Ordering # (<) :: GenLocated l e -> GenLocated l e -> Bool # (<=) :: GenLocated l e -> GenLocated l e -> Bool # (>) :: GenLocated l e -> GenLocated l e -> Bool # (>=) :: GenLocated l e -> GenLocated l e -> Bool # max :: GenLocated l e -> GenLocated l e -> GenLocated l e # min :: GenLocated l e -> GenLocated l e -> GenLocated l e #
type Anno (LocatedA (IE (GhcPass p)))
Instance details Defined in GHC.Hs.ImpExp type Anno (LocatedA (IE (GhcPass p))) = SrcSpanAnnA
type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))] = SrcSpanAnnL
type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))] = SrcSpanAnnL
type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))]
Instance details Defined in GHC.Parser.Types type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))]
Instance details Defined in GHC.Parser.Types type Anno [LocatedA (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL
type Anno [LocatedA (IE (GhcPass p))]
Instance details Defined in GHC.Hs.ImpExp type Anno [LocatedA (IE (GhcPass p))] = SrcSpanAnnL
type Anno [LocatedA (ConDeclField (GhcPass _1))]
Instance details Defined in GHC.Hs.Decls type Anno [LocatedA (ConDeclField (GhcPass _1))] = SrcSpanAnnL
type Anno [LocatedA (HsType (GhcPass p))]
Instance details Defined in GHC.Hs.Type type Anno [LocatedA (HsType (GhcPass p))] = SrcSpanAnnC
type Anno (FamEqn p (LocatedA (HsType p)))
Instance details Defined in GHC.Hs.Decls type Anno (FamEqn p (LocatedA (HsType p))) = SrcSpanAnnA
type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p))))
Instance details Defined in GHC.Hs.Expr type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = EpAnnCO
type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p))))
Instance details Defined in GHC.Hs.Expr type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = EpAnnCO
type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs)))
Instance details Defined in GHC.Parser.Types type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs))) = EpAnnCO
type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))
Instance details Defined in GHC.Hs.Expr type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcSpanAnnA
type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))
Instance details Defined in GHC.Hs.Expr type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpanAnnA
type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs)))
Instance details Defined in GHC.Parser.Types type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA
type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))
Instance details Defined in GHC.Hs.Expr type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr)))) = SrcSpanAnnA
type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))
Instance details Defined in GHC.Parser.Types type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA
type Anno (StmtLR GhcRn GhcRn (LocatedA (body GhcRn)))
Instance details Defined in GHC.Hs.Expr type Anno (StmtLR GhcRn GhcRn (LocatedA (body GhcRn))) = SrcSpanAnnA

space :: IsLine doc => doc #

class NamedThing a where #

A class allowing convenient access to the Name of various datatypes

Minimal complete definition

getName

Methods

getOccName :: a -> OccName #

getName :: a -> Name #

Instances

Instances details

NamedThing Class
Instance details Defined in GHC.Core.Class Methods getOccName :: Class -> OccName # getName :: Class -> Name #
NamedThing ConLike
Instance details Defined in GHC.Core.ConLike Methods getOccName :: ConLike -> OccName # getName :: ConLike -> Name #
NamedThing DataCon
Instance details Defined in GHC.Core.DataCon Methods getOccName :: DataCon -> OccName # getName :: DataCon -> Name #
NamedThing FamInst
Instance details Defined in GHC.Core.FamInstEnv Methods getOccName :: FamInst -> OccName # getName :: FamInst -> Name #
NamedThing ClsInst
Instance details Defined in GHC.Core.InstEnv Methods getOccName :: ClsInst -> OccName # getName :: ClsInst -> Name #
NamedThing PatSyn
Instance details Defined in GHC.Core.PatSyn Methods getOccName :: PatSyn -> OccName # getName :: PatSyn -> Name #
NamedThing TyCon
Instance details Defined in GHC.Core.TyCon Methods getOccName :: TyCon -> OccName # getName :: TyCon -> Name #
NamedThing IfaceClassOp
Instance details Defined in GHC.Iface.Syntax Methods getOccName :: IfaceClassOp -> OccName # getName :: IfaceClassOp -> Name #
NamedThing IfaceConDecl
Instance details Defined in GHC.Iface.Syntax Methods getOccName :: IfaceConDecl -> OccName # getName :: IfaceConDecl -> Name #
NamedThing IfaceDecl
Instance details Defined in GHC.Iface.Syntax Methods getOccName :: IfaceDecl -> OccName # getName :: IfaceDecl -> Name #
NamedThing HoleFitCandidate
Instance details Defined in GHC.Tc.Errors.Hole.FitTypes Methods getOccName :: HoleFitCandidate -> OccName # getName :: HoleFitCandidate -> Name #
NamedThing InvalidFamInstQTv
Instance details Defined in GHC.Tc.Errors.Types Methods getOccName :: InvalidFamInstQTv -> OccName # getName :: InvalidFamInstQTv -> Name #
NamedThing Name
Instance details Defined in GHC.Types.Name Methods getOccName :: Name -> OccName # getName :: Name -> Name #
NamedThing TyThing
Instance details Defined in GHC.Types.TyThing Methods getOccName :: TyThing -> OccName # getName :: TyThing -> Name #
NamedThing Var
Instance details Defined in GHC.Types.Var Methods getOccName :: Var -> OccName # getName :: Var -> Name #
NamedThing (CoAxiom br)
Instance details Defined in GHC.Core.Coercion.Axiom Methods getOccName :: CoAxiom br -> OccName # getName :: CoAxiom br -> Name #
NamedThing e => NamedThing (Located e)
Instance details Defined in GHC.Types.Name Methods getOccName :: Located e -> OccName # getName :: Located e -> Name #
NamedThing (Located a) => NamedThing (LocatedAn an a)
Instance details Defined in GHC.Parser.Annotation Methods getOccName :: LocatedAn an a -> OccName # getName :: LocatedAn an a -> Name #
NamedThing tv => NamedThing (VarBndr tv flag)
Instance details Defined in GHC.Types.Var Methods getOccName :: VarBndr tv flag -> OccName # getName :: VarBndr tv flag -> Name #

class (IsOutput doc, IsLine (Line doc)) => IsDoc doc where #

A class of types that represent a multiline document, with support for vertical composition.

See Note [HLine versus HDoc] and Note [The outputable class hierarchy] for more details.

Minimal complete definition

line, ($$), dualDoc

Associated Types

type Line doc = (r :: Type) | r -> doc #

Methods

line :: Line doc -> doc #

($$) :: doc -> doc -> doc #

Join two docs together vertically. If there is no vertical overlap it "dovetails" the two onto one line.

lines_ :: [Line doc] -> doc #

vcat :: [doc] -> doc #

Concatenate docs vertically with dovetailing.

dualDoc :: SDoc -> HDoc -> doc #

Prints as either the given SDoc or the given HDoc, depending on which type the result is instantiated to. This should generally be avoided; see Note [dualLine and dualDoc] for details.

Instances

Instances details

IsDoc HDoc

Instance details

Defined in GHC.Utils.Outputable

Associated Types

type Line HDoc
Instance details Defined in GHC.Utils.Outputable type Line HDoc = HLine

Methods

line :: Line HDoc -> HDoc #

($$) :: HDoc -> HDoc -> HDoc #

lines_ :: [Line HDoc] -> HDoc #

vcat :: [HDoc] -> HDoc #

dualDoc :: SDoc -> HDoc -> HDoc #

IsDoc SDoc

Instance details

Defined in GHC.Utils.Outputable

Associated Types

type Line SDoc
Instance details Defined in GHC.Utils.Outputable type Line SDoc = SDoc

Methods

line :: Line SDoc -> SDoc #

($$) :: SDoc -> SDoc -> SDoc #

lines_ :: [Line SDoc] -> SDoc #

vcat :: [SDoc] -> SDoc #

dualDoc :: SDoc -> HDoc -> SDoc #

data Pair a #

Constructors

Pair a a

Instances

Instances details

Applicative Pair
Instance details Defined in GHC.Data.Pair Methods pure :: a -> Pair a # (<>) :: Pair (a -> b) -> Pair a -> Pair b # liftA2 :: (a -> b -> c) -> Pair a -> Pair b -> Pair c # (>) :: Pair a -> Pair b -> Pair b # (<*) :: Pair a -> Pair b -> Pair a #
Functor Pair
Instance details Defined in GHC.Data.Pair Methods fmap :: (a -> b) -> Pair a -> Pair b # (<$) :: a -> Pair b -> Pair a #
Foldable Pair
Instance details Defined in GHC.Data.Pair Methods fold :: Monoid m => Pair m -> m # foldMap :: Monoid m => (a -> m) -> Pair a -> m # foldMap' :: Monoid m => (a -> m) -> Pair a -> m # foldr :: (a -> b -> b) -> b -> Pair a -> b # foldr' :: (a -> b -> b) -> b -> Pair a -> b # foldl :: (b -> a -> b) -> b -> Pair a -> b # foldl' :: (b -> a -> b) -> b -> Pair a -> b # foldr1 :: (a -> a -> a) -> Pair a -> a # foldl1 :: (a -> a -> a) -> Pair a -> a # toList :: Pair a -> [a] # null :: Pair a -> Bool # length :: Pair a -> Int # elem :: Eq a => a -> Pair a -> Bool # maximum :: Ord a => Pair a -> a # minimum :: Ord a => Pair a -> a # sum :: Num a => Pair a -> a # product :: Num a => Pair a -> a #
Traversable Pair
Instance details Defined in GHC.Data.Pair Methods traverse :: Applicative f => (a -> f b) -> Pair a -> f (Pair b) # sequenceA :: Applicative f => Pair (f a) -> f (Pair a) # mapM :: Monad m => (a -> m b) -> Pair a -> m (Pair b) # sequence :: Monad m => Pair (m a) -> m (Pair a) #
Outputable a => Outputable (Pair a)
Instance details Defined in GHC.Data.Pair Methods ppr :: Pair a -> SDoc #
(Semigroup a, Monoid a) => Monoid (Pair a)
Instance details Defined in GHC.Data.Pair Methods mempty :: Pair a # mappend :: Pair a -> Pair a -> Pair a # mconcat :: [Pair a] -> Pair a #
Semigroup a => Semigroup (Pair a)
Instance details Defined in GHC.Data.Pair Methods (<>) :: Pair a -> Pair a -> Pair a # sconcat :: NonEmpty (Pair a) -> Pair a # stimes :: Integral b => b -> Pair a -> Pair a #

comma :: IsLine doc => doc #

colon :: IsLine doc => doc #

int :: IsLine doc => Int -> doc #

word64 :: IsLine doc => Word64 -> doc #

word :: Integer -> SDoc #

integer :: IsLine doc => Integer -> doc #

float :: IsLine doc => Float -> doc #

double :: IsLine doc => Double -> doc #

quote :: SDoc -> SDoc #

type Arity = Int #

The number of value arguments that can be applied to a value before it does "real work". So: fib 100 has arity 0 x -> fib x has arity 1 See also Note [Definition of arity] in GHC.Core.Opt.Arity

isTyVar :: Var -> Bool #

Is this a type-level (i.e., computationally irrelevant, thus erasable) variable? Satisfies isTyVar = not . isId.

type Kind = Type #

The key type representing kinds in the compiler.

data NamespaceSpecifier #

Optional namespace specifier for fixity signatures, WARNINIG and DEPRECATED pragmas.

Examples:

{-# WARNING in "x-partial" data Head "don't use this pattern synonym" #-} -- ↑ DataNamespaceSpecifier

{-# DEPRECATED type D "This type was deprecated" #-} -- ↑ TypeNamespaceSpecifier

infixr 6 data $ -- ↑ DataNamespaceSpecifier

Constructors

NoNamespaceSpecifier

Instances

Instances details

Outputable NamespaceSpecifier
Instance details Defined in GHC.Hs.Binds Methods ppr :: NamespaceSpecifier -> SDoc #
Data NamespaceSpecifier
Instance details Defined in GHC.Hs.Binds Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NamespaceSpecifier -> c NamespaceSpecifier # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NamespaceSpecifier # toConstr :: NamespaceSpecifier -> Constr # dataTypeOf :: NamespaceSpecifier -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NamespaceSpecifier) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NamespaceSpecifier) # gmapT :: (forall b. Data b => b -> b) -> NamespaceSpecifier -> NamespaceSpecifier # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NamespaceSpecifier -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NamespaceSpecifier -> r # gmapQ :: (forall d. Data d => d -> u) -> NamespaceSpecifier -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NamespaceSpecifier -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NamespaceSpecifier -> m NamespaceSpecifier # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NamespaceSpecifier -> m NamespaceSpecifier # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NamespaceSpecifier -> m NamespaceSpecifier #
Eq NamespaceSpecifier
Instance details Defined in GHC.Hs.Binds Methods (==) :: NamespaceSpecifier -> NamespaceSpecifier -> Bool # (/=) :: NamespaceSpecifier -> NamespaceSpecifier -> Bool #

data ConLike #

A constructor-like thing

Constructors

RealDataCon DataCon

Instances

Instances details

NamedThing ConLike
Instance details Defined in GHC.Core.ConLike Methods getOccName :: ConLike -> OccName # getName :: ConLike -> Name #
Uniquable ConLike
Instance details Defined in GHC.Core.ConLike Methods getUnique :: ConLike -> Unique #
Outputable ConLike
Instance details Defined in GHC.Core.ConLike Methods ppr :: ConLike -> SDoc #
OutputableBndr ConLike
Instance details Defined in GHC.Core.ConLike Methods pprBndr :: BindingSite -> ConLike -> SDoc # pprPrefixOcc :: ConLike -> SDoc # pprInfixOcc :: ConLike -> SDoc # bndrIsJoin_maybe :: ConLike -> JoinPointHood #
Data ConLike
Instance details Defined in GHC.Core.ConLike Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConLike -> c ConLike # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ConLike # toConstr :: ConLike -> Constr # dataTypeOf :: ConLike -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ConLike) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConLike) # gmapT :: (forall b. Data b => b -> b) -> ConLike -> ConLike # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConLike -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConLike -> r # gmapQ :: (forall d. Data d => d -> u) -> ConLike -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ConLike -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConLike -> m ConLike # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConLike -> m ConLike # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConLike -> m ConLike #
Eq ConLike
Instance details Defined in GHC.Core.ConLike Methods (==) :: ConLike -> ConLike -> Bool # (/=) :: ConLike -> ConLike -> Bool #
type Anno ConLike
Instance details Defined in GHC.Hs.Pat type Anno ConLike = SrcSpanAnnN

rational :: Rational -> SDoc #

lengthAtLeast :: [a] -> Int -> Bool #

(lengthAtLeast xs n) = (length xs >= n)

srcLocFile :: RealSrcLoc -> FastString #

Gives the filename of the RealSrcLoc

parens :: IsLine doc => doc -> doc #

data Coercion #

A Coercion is concrete evidence of the equality/convertibility of two types.

Constructors

AxiomInstCo (CoAxiom Branched) BranchIndex [Coercion]
SymCo Coercion

Instances

Instances details

Outputable Coercion
Instance details Defined in GHC.Core.TyCo.Rep Methods ppr :: Coercion -> SDoc #
Data Coercion
Instance details Defined in GHC.Core.TyCo.Rep Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Coercion -> c Coercion # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Coercion # toConstr :: Coercion -> Constr # dataTypeOf :: Coercion -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Coercion) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Coercion) # gmapT :: (forall b. Data b => b -> b) -> Coercion -> Coercion # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Coercion -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Coercion -> r # gmapQ :: (forall d. Data d => d -> u) -> Coercion -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Coercion -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Coercion -> m Coercion # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Coercion -> m Coercion # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Coercion -> m Coercion #
Eq (DeBruijn Coercion)
Instance details Defined in GHC.Core.Map.Type Methods (==) :: DeBruijn Coercion -> DeBruijn Coercion -> Bool # (/=) :: DeBruijn Coercion -> DeBruijn Coercion -> Bool #

data Fixity #

Constructors

Fixity SourceText Int FixityDirection

Instances

Instances details

Binary Fixity
Instance details Defined in GHC.Types.Fixity Methods put_ :: BinHandle -> Fixity -> IO () # put :: BinHandle -> Fixity -> IO (Bin Fixity) # get :: BinHandle -> IO Fixity #
Outputable Fixity
Instance details Defined in GHC.Types.Fixity Methods ppr :: Fixity -> SDoc #
Data Fixity
Instance details Defined in GHC.Types.Fixity Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Fixity -> c Fixity # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Fixity # toConstr :: Fixity -> Constr # dataTypeOf :: Fixity -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Fixity) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity) # gmapT :: (forall b. Data b => b -> b) -> Fixity -> Fixity # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r # gmapQ :: (forall d. Data d => d -> u) -> Fixity -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Fixity -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity #
Eq Fixity
Instance details Defined in GHC.Types.Fixity Methods (==) :: Fixity -> Fixity -> Bool # (/=) :: Fixity -> Fixity -> Bool #

data LexicalFixity #

Captures the fixity of declarations as they are parsed. This is not necessarily the same as the fixity declaration, as the normal fixity may be overridden using parens or backticks.

Constructors

Prefix

Instances

Instances details

Outputable LexicalFixity
Instance details Defined in GHC.Types.Fixity Methods ppr :: LexicalFixity -> SDoc #
Data LexicalFixity
Instance details Defined in GHC.Types.Fixity Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LexicalFixity -> c LexicalFixity # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LexicalFixity # toConstr :: LexicalFixity -> Constr # dataTypeOf :: LexicalFixity -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c LexicalFixity) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LexicalFixity) # gmapT :: (forall b. Data b => b -> b) -> LexicalFixity -> LexicalFixity # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LexicalFixity -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LexicalFixity -> r # gmapQ :: (forall d. Data d => d -> u) -> LexicalFixity -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> LexicalFixity -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> LexicalFixity -> m LexicalFixity # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LexicalFixity -> m LexicalFixity # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LexicalFixity -> m LexicalFixity #
Eq LexicalFixity
Instance details Defined in GHC.Types.Fixity Methods (==) :: LexicalFixity -> LexicalFixity -> Bool # (/=) :: LexicalFixity -> LexicalFixity -> Bool #

moduleName :: GenModule unit -> ModuleName #

Module name (e.g. A.B.C)

moduleUnit :: GenModule unit -> unit #

Unit the module belongs to

data Alt b #

A case split alternative. Consists of the constructor leading to the alternative, the variables bound from the constructor, and the expression to be executed given that binding. The default alternative is (DEFAULT, [], rhs)

Constructors

Alt AltCon [b] (Expr b)

Instances

Instances details

Data b => Data (Alt b)
Instance details Defined in GHC.Core Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Alt b -> c (Alt b) # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Alt b) # toConstr :: Alt b -> Constr # dataTypeOf :: Alt b -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Alt b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt b)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Alt b -> Alt b # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt b -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt b -> r # gmapQ :: (forall d. Data d => d -> u) -> Alt b -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Alt b -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Alt b -> m (Alt b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt b -> m (Alt b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt b -> m (Alt b) #
Subable (Alt Var) Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Play Methods sub :: HashMap CoreBndr CoreExpr -> Alt Var -> Alt Var Source # subTy :: HashMap TyVar Type -> Alt Var -> Alt Var Source #
CBVisitable (Alt Var) Source #
Instance details Defined in Language.Haskell.Liquid.Types.Visitors Methods freeVars :: HashSet Var -> Alt Var -> [Var] Source # readVars :: Alt Var -> [Var] Source # letVars :: Alt Var -> [Var] Source # literals :: Alt Var -> [Literal] Source #

mkFunTy :: HasDebugCallStack => FunTyFlag -> Mult -> Type -> Type -> Type infixr 3 #

splitTyConApp :: Type -> (TyCon, [Type]) #

Attempts to tease a type apart into a type constructor and the application of a number of arguments to that constructor. Panics if that is not possible. See also splitTyConApp_maybe

liftIO :: MonadIO m => IO a -> m a #

Lift a computation from the IO monad. This allows us to run IO computations in any monadic stack, so long as it supports these kinds of operations (i.e. IO is the base monad for the stack).

Example

Expand

import Control.Monad.Trans.State -- from the "transformers" library

printState :: Show s => StateT s IO ()
printState = do
  state <- get
  liftIO $ print state

Had we omitted liftIO, we would have ended up with this error:

• Couldn't match type ‘IO’ with ‘StateT s IO’
 Expected type: StateT s IO ()
   Actual type: IO ()

The important part here is the mismatch between StateT s IO () and IO ().

Luckily, we know of a function that takes an IO a and returns an (m a): liftIO, enabling us to run the program and see the expected results:

> evalStateT printState "hello"
"hello"

> evalStateT printState 3
3

data CostCentre #

A Cost Centre is a single {-# SCC #-} annotation.

Instances

Instances details

Binary CostCentre
Instance details Defined in GHC.Types.CostCentre Methods put_ :: BinHandle -> CostCentre -> IO () # put :: BinHandle -> CostCentre -> IO (Bin CostCentre) # get :: BinHandle -> IO CostCentre #
Outputable CostCentre
Instance details Defined in GHC.Types.CostCentre Methods ppr :: CostCentre -> SDoc #
Data CostCentre
Instance details Defined in GHC.Types.CostCentre Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CostCentre -> c CostCentre # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CostCentre # toConstr :: CostCentre -> Constr # dataTypeOf :: CostCentre -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c CostCentre) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CostCentre) # gmapT :: (forall b. Data b => b -> b) -> CostCentre -> CostCentre # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CostCentre -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CostCentre -> r # gmapQ :: (forall d. Data d => d -> u) -> CostCentre -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CostCentre -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CostCentre -> m CostCentre # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CostCentre -> m CostCentre # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CostCentre -> m CostCentre #
Eq CostCentre
Instance details Defined in GHC.Types.CostCentre Methods (==) :: CostCentre -> CostCentre -> Bool # (/=) :: CostCentre -> CostCentre -> Bool #
Ord CostCentre
Instance details Defined in GHC.Types.CostCentre Methods compare :: CostCentre -> CostCentre -> Ordering # (<) :: CostCentre -> CostCentre -> Bool # (<=) :: CostCentre -> CostCentre -> Bool # (>) :: CostCentre -> CostCentre -> Bool # (>=) :: CostCentre -> CostCentre -> Bool # max :: CostCentre -> CostCentre -> CostCentre # min :: CostCentre -> CostCentre -> CostCentre #

getEnv :: IOEnv env env #

data Unique #

Unique identifier.

The type of unique identifiers that are used in many places in GHC for fast ordering and equality tests. You should generate these with the functions from the UniqSupply module

These are sometimes also referred to as "keys" in comments in GHC.

Instances

Instances details

Uniquable Unique
Instance details Defined in GHC.Types.Unique Methods getUnique :: Unique -> Unique #
Outputable Unique
Instance details Defined in GHC.Types.Unique Methods ppr :: Unique -> SDoc #
Show Unique
Instance details Defined in GHC.Types.Unique Methods showsPrec :: Int -> Unique -> ShowS # show :: Unique -> String # showList :: [Unique] -> ShowS #
Eq Unique
Instance details Defined in GHC.Types.Unique Methods (==) :: Unique -> Unique -> Bool # (/=) :: Unique -> Unique -> Bool #

newUnique :: TcRnIf gbl lcl Unique #

type Arg b = Expr b #

Type synonym for expressions that occur in function argument positions. Only Arg should contain a Type at top level, general Expr should not

isEmpty :: SDocContext -> SDoc -> Bool #

type family Line doc = (r :: Type) | r -> doc #

Instances

Instances details

type Line HDoc
Instance details Defined in GHC.Utils.Outputable type Line HDoc = HLine
type Line SDoc
Instance details Defined in GHC.Utils.Outputable type Line SDoc = SDoc

data Env gbl lcl #

Instances

Instances details

ContainsDynFlags (Env gbl lcl)
Instance details Defined in GHC.Tc.Types Methods extractDynFlags :: Env gbl lcl -> DynFlags #
ContainsHooks (Env gbl lcl)
Instance details Defined in GHC.Tc.Types Methods extractHooks :: Env gbl lcl -> Hooks #
ContainsModule gbl => ContainsModule (Env gbl lcl)
Instance details Defined in GHC.Tc.Types Methods extractModule :: Env gbl lcl -> Module #
ContainsLogger (Env gbl lcl)
Instance details Defined in GHC.Tc.Types Methods extractLogger :: Env gbl lcl -> Logger #

class Outputable a where #

Class designating that some type has an SDoc representation

Methods

ppr :: a -> SDoc #

Instances

Instances details

Outputable CoreModule
Instance details Defined in GHC Methods ppr :: CoreModule -> SDoc #
Outputable PrimCall
Instance details Defined in GHC.Builtin.PrimOps Methods ppr :: PrimCall -> SDoc #
Outputable PrimOp
Instance details Defined in GHC.Builtin.PrimOps Methods ppr :: PrimOp -> SDoc #
Outputable BCInstr
Instance details Defined in GHC.ByteCode.Instr Methods ppr :: BCInstr -> SDoc #
Outputable LocalLabel
Instance details Defined in GHC.ByteCode.Instr Methods ppr :: LocalLabel -> SDoc #
Outputable ByteOff
Instance details Defined in GHC.ByteCode.Types Methods ppr :: ByteOff -> SDoc #
Outputable CgBreakInfo
Instance details Defined in GHC.ByteCode.Types Methods ppr :: CgBreakInfo -> SDoc #
Outputable CompiledByteCode
Instance details Defined in GHC.ByteCode.Types Methods ppr :: CompiledByteCode -> SDoc #
Outputable HalfWord
Instance details Defined in GHC.ByteCode.Types Methods ppr :: HalfWord -> SDoc #
Outputable NativeCallInfo
Instance details Defined in GHC.ByteCode.Types Methods ppr :: NativeCallInfo -> SDoc #
Outputable RegBitmap
Instance details Defined in GHC.ByteCode.Types Methods ppr :: RegBitmap -> SDoc #
Outputable UnlinkedBCO
Instance details Defined in GHC.ByteCode.Types Methods ppr :: UnlinkedBCO -> SDoc #
Outputable WordOff
Instance details Defined in GHC.ByteCode.Types Methods ppr :: WordOff -> SDoc #
Outputable CmmStackInfo
Instance details Defined in GHC.Cmm Methods ppr :: CmmStackInfo -> SDoc #
Outputable CmmStatic
Instance details Defined in GHC.Cmm Methods ppr :: CmmStatic -> SDoc #
Outputable ConInfoTableLocation
Instance details Defined in GHC.Cmm.CLabel Methods ppr :: ConInfoTableLocation -> SDoc #
Outputable ForeignLabelSource
Instance details Defined in GHC.Cmm.CLabel Methods ppr :: ForeignLabelSource -> SDoc #
Outputable IdLabelInfo
Instance details Defined in GHC.Cmm.CLabel Methods ppr :: IdLabelInfo -> SDoc #
Outputable TickyIdInfo
Instance details Defined in GHC.Cmm.CLabel Methods ppr :: TickyIdInfo -> SDoc #
Outputable ParamLocation
Instance details Defined in GHC.Cmm.CallConv Methods ppr :: ParamLocation -> SDoc #
Outputable Label
Instance details Defined in GHC.Cmm.Dataflow.Label Methods ppr :: Label -> SDoc #
Outputable LabelSet
Instance details Defined in GHC.Cmm.Dataflow.Label Methods ppr :: LabelSet -> SDoc #
Outputable DominatorSet
Instance details Defined in GHC.Cmm.Dominators Methods ppr :: DominatorSet -> SDoc #
Outputable RPNum
Instance details Defined in GHC.Cmm.Dominators Methods ppr :: RPNum -> SDoc #
Outputable Area
Instance details Defined in GHC.Cmm.Expr Methods ppr :: Area -> SDoc #
Outputable CmmLit
Instance details Defined in GHC.Cmm.Expr Methods ppr :: CmmLit -> SDoc #
Outputable StackMap
Instance details Defined in GHC.Cmm.LayoutStack Methods ppr :: StackMap -> SDoc #
Outputable StackSlot
Instance details Defined in GHC.Cmm.LayoutStack Methods ppr :: StackSlot -> SDoc #
Outputable CmmReturnInfo
Instance details Defined in GHC.Cmm.Node Methods ppr :: CmmReturnInfo -> SDoc #
Outputable CmmTickScope
Instance details Defined in GHC.Cmm.Node Methods ppr :: CmmTickScope -> SDoc #
Outputable Convention
Instance details Defined in GHC.Cmm.Node Methods ppr :: Convention -> SDoc #
Outputable ForeignConvention
Instance details Defined in GHC.Cmm.Node Methods ppr :: ForeignConvention -> SDoc #
Outputable Status
Instance details Defined in GHC.Cmm.ProcPoint Methods ppr :: Status -> SDoc #
Outputable CmmReg
Instance details Defined in GHC.Cmm.Reg Methods ppr :: CmmReg -> SDoc #
Outputable GlobalReg
Instance details Defined in GHC.Cmm.Reg Methods ppr :: GlobalReg -> SDoc #
Outputable GlobalRegUse
Instance details Defined in GHC.Cmm.Reg Methods ppr :: GlobalRegUse -> SDoc #
Outputable LocalReg
Instance details Defined in GHC.Cmm.Reg Methods ppr :: LocalReg -> SDoc #
Outputable CmmCat
Instance details Defined in GHC.Cmm.Type Methods ppr :: CmmCat -> SDoc #
Outputable CmmType
Instance details Defined in GHC.Cmm.Type Methods ppr :: CmmType -> SDoc #
Outputable ForeignHint
Instance details Defined in GHC.Cmm.Type Methods ppr :: ForeignHint -> SDoc #
Outputable Width
Instance details Defined in GHC.Cmm.Type Methods ppr :: Width -> SDoc #
Outputable JumpDest
Instance details Defined in GHC.CmmToAsm.AArch64.RegInfo Methods ppr :: JumpDest -> SDoc #
Outputable BlockChain
Instance details Defined in GHC.CmmToAsm.BlockLayout Methods ppr :: BlockChain -> SDoc #
Outputable BranchInfo
Instance details Defined in GHC.CmmToAsm.CFG Methods ppr :: BranchInfo -> SDoc #
Outputable CfgEdge
Instance details Defined in GHC.CmmToAsm.CFG Methods ppr :: CfgEdge -> SDoc #
Outputable EdgeInfo
Instance details Defined in GHC.CmmToAsm.CFG Methods ppr :: EdgeInfo -> SDoc #
Outputable EdgeWeight
Instance details Defined in GHC.CmmToAsm.CFG Methods ppr :: EdgeWeight -> SDoc #
Outputable LoopInfo
Instance details Defined in GHC.CmmToAsm.CFG Methods ppr :: LoopInfo -> SDoc #
Outputable JumpDest
Instance details Defined in GHC.CmmToAsm.PPC.RegInfo Methods ppr :: JumpDest -> SDoc #
Outputable SpillStats
Instance details Defined in GHC.CmmToAsm.Reg.Graph.Spill Methods ppr :: SpillStats -> SDoc #
Outputable Store
Instance details Defined in GHC.CmmToAsm.Reg.Graph.SpillClean Methods ppr :: Store -> SDoc #
Outputable FreeRegs
Instance details Defined in GHC.CmmToAsm.Reg.Linear.AArch64 Methods ppr :: FreeRegs -> SDoc #
Outputable Loc
Instance details Defined in GHC.CmmToAsm.Reg.Linear.Base Methods ppr :: Loc -> SDoc #
Outputable FreeRegs
Instance details Defined in GHC.CmmToAsm.Reg.Linear.PPC Methods ppr :: FreeRegs -> SDoc #
Outputable FreeRegs
Instance details Defined in GHC.CmmToAsm.Reg.Linear.X86 Methods ppr :: FreeRegs -> SDoc #
Outputable FreeRegs
Instance details Defined in GHC.CmmToAsm.Reg.Linear.X86_64 Methods ppr :: FreeRegs -> SDoc #
Outputable BrTableInterval
Instance details Defined in GHC.CmmToAsm.Wasm.Types Methods ppr :: BrTableInterval -> SDoc #
Outputable JumpDest
Instance details Defined in GHC.CmmToAsm.X86.Instr Methods ppr :: JumpDest -> SDoc #
Outputable AltCon
Instance details Defined in GHC.Core Methods ppr :: AltCon -> SDoc #
Outputable Class
Instance details Defined in GHC.Core.Class Methods ppr :: Class -> SDoc #
Outputable LiftingContext
Instance details Defined in GHC.Core.Coercion Methods ppr :: LiftingContext -> SDoc #
Outputable CoAxBranch
Instance details Defined in GHC.Core.Coercion.Axiom Methods ppr :: CoAxBranch -> SDoc #
Outputable CoAxiomRule
Instance details Defined in GHC.Core.Coercion.Axiom Methods ppr :: CoAxiomRule -> SDoc #
Outputable ConLike
Instance details Defined in GHC.Core.ConLike Methods ppr :: ConLike -> SDoc #
Outputable DataCon
Instance details Defined in GHC.Core.DataCon Methods ppr :: DataCon -> SDoc #
Outputable EqSpec
Instance details Defined in GHC.Core.DataCon Methods ppr :: EqSpec -> SDoc #
Outputable HsImplBang
Instance details Defined in GHC.Core.DataCon Methods ppr :: HsImplBang -> SDoc #
Outputable HsSrcBang
Instance details Defined in GHC.Core.DataCon Methods ppr :: HsSrcBang -> SDoc #
Outputable StrictnessMark
Instance details Defined in GHC.Core.DataCon Methods ppr :: StrictnessMark -> SDoc #
Outputable FamInst
Instance details Defined in GHC.Core.FamInstEnv Methods ppr :: FamInst -> SDoc #
Outputable FamInstEnv
Instance details Defined in GHC.Core.FamInstEnv Methods ppr :: FamInstEnv -> SDoc #
Outputable FamInstMatch
Instance details Defined in GHC.Core.FamInstEnv Methods ppr :: FamInstMatch -> SDoc #
Outputable ClsInst
Instance details Defined in GHC.Core.InstEnv Methods ppr :: ClsInst -> SDoc #
Outputable InstEnv
Instance details Defined in GHC.Core.InstEnv Methods ppr :: InstEnv -> SDoc #
Outputable InstMatches
Instance details Defined in GHC.Core.InstEnv Methods ppr :: InstMatches -> SDoc #
Outputable PotentialUnifiers
Instance details Defined in GHC.Core.InstEnv Methods ppr :: PotentialUnifiers -> SDoc #
Outputable FloatBind
Instance details Defined in GHC.Core.Make Methods ppr :: FloatBind -> SDoc #
Outputable IsSubmult
Instance details Defined in GHC.Core.Multiplicity Methods ppr :: IsSubmult -> SDoc #
Outputable ArityEnv
Instance details Defined in GHC.Core.Opt.Arity Methods ppr :: ArityEnv -> SDoc #
Outputable ArityType	This is the BNF of the generated output: @ We format AT [o1,..,on] topDiv `as` o1..on.T`and`AT [o1,..,on] botDiv `as` o1..on.⊥`, respectively. More concretely,`AT [NOI,OS,OS] topDiv `is formatted as` ?11.T`. If the one-shot info is empty, we omit the leading`.@.
Instance details Defined in GHC.Core.Opt.Arity Methods ppr :: ArityType -> SDoc #
Outputable EtaInfo
Instance details Defined in GHC.Core.Opt.Arity Methods ppr :: EtaInfo -> SDoc #
Outputable CallerCcFilter
Instance details Defined in GHC.Core.Opt.CallerCC.Types Methods ppr :: CallerCcFilter -> SDoc #
Outputable NamePattern
Instance details Defined in GHC.Core.Opt.CallerCC.Types Methods ppr :: NamePattern -> SDoc #
Outputable AnalEnv
Instance details Defined in GHC.Core.Opt.CprAnal Methods ppr :: AnalEnv -> SDoc #
Outputable SigEnv
Instance details Defined in GHC.Core.Opt.CprAnal Methods ppr :: SigEnv -> SDoc #
Outputable AnalEnv
Instance details Defined in GHC.Core.Opt.DmdAnal Methods ppr :: AnalEnv -> SDoc #
Outputable FloatInBind
Instance details Defined in GHC.Core.Opt.FloatIn Methods ppr :: FloatInBind -> SDoc #
Outputable FloatBinds
Instance details Defined in GHC.Core.Opt.FloatOut Methods ppr :: FloatBinds -> SDoc #
Outputable FloatOutSwitches
Instance details Defined in GHC.Core.Opt.Monad Methods ppr :: FloatOutSwitches -> SDoc #
Outputable LocalOcc
Instance details Defined in GHC.Core.Opt.OccurAnal Methods ppr :: LocalOcc -> SDoc #
Outputable NodeDetails
Instance details Defined in GHC.Core.Opt.OccurAnal Methods ppr :: NodeDetails -> SDoc #
Outputable OccEncl
Instance details Defined in GHC.Core.Opt.OccurAnal Methods ppr :: OccEncl -> SDoc #
Outputable SimpleNodeDetails
Instance details Defined in GHC.Core.Opt.OccurAnal Methods ppr :: SimpleNodeDetails -> SDoc #
Outputable TailUsageDetails
Instance details Defined in GHC.Core.Opt.OccurAnal Methods ppr :: TailUsageDetails -> SDoc #
Outputable UsageDetails
Instance details Defined in GHC.Core.Opt.OccurAnal Methods ppr :: UsageDetails -> SDoc #
Outputable CoreToDo
Instance details Defined in GHC.Core.Opt.Pipeline.Types Methods ppr :: CoreToDo -> SDoc #
Outputable FloatSpec
Instance details Defined in GHC.Core.Opt.SetLevels Methods ppr :: FloatSpec -> SDoc #
Outputable Level
Instance details Defined in GHC.Core.Opt.SetLevels Methods ppr :: Level -> SDoc #
Outputable FloatFlag
Instance details Defined in GHC.Core.Opt.Simplify.Env Methods ppr :: FloatFlag -> SDoc #
Outputable LetFloats
Instance details Defined in GHC.Core.Opt.Simplify.Env Methods ppr :: LetFloats -> SDoc #
Outputable SimplFloats
Instance details Defined in GHC.Core.Opt.Simplify.Env Methods ppr :: SimplFloats -> SDoc #
Outputable SimplMode
Instance details Defined in GHC.Core.Opt.Simplify.Env Methods ppr :: SimplMode -> SDoc #
Outputable SimplSR
Instance details Defined in GHC.Core.Opt.Simplify.Env Methods ppr :: SimplSR -> SDoc #
Outputable ArgInfo
Instance details Defined in GHC.Core.Opt.Simplify.Utils Methods ppr :: ArgInfo -> SDoc #
Outputable ArgSpec
Instance details Defined in GHC.Core.Opt.Simplify.Utils Methods ppr :: ArgSpec -> SDoc #
Outputable DupFlag
Instance details Defined in GHC.Core.Opt.Simplify.Utils Methods ppr :: DupFlag -> SDoc #
Outputable SimplCont
Instance details Defined in GHC.Core.Opt.Simplify.Utils Methods ppr :: SimplCont -> SDoc #
Outputable ArgOcc
Instance details Defined in GHC.Core.Opt.SpecConstr Methods ppr :: ArgOcc -> SDoc #
Outputable Call
Instance details Defined in GHC.Core.Opt.SpecConstr Methods ppr :: Call -> SDoc #
Outputable CallPat
Instance details Defined in GHC.Core.Opt.SpecConstr Methods ppr :: CallPat -> SDoc #
Outputable HowBound
Instance details Defined in GHC.Core.Opt.SpecConstr Methods ppr :: HowBound -> SDoc #
Outputable ScUsage
Instance details Defined in GHC.Core.Opt.SpecConstr Methods ppr :: ScUsage -> SDoc #
Outputable Value
Instance details Defined in GHC.Core.Opt.SpecConstr Methods ppr :: Value -> SDoc #
Outputable CallInfo
Instance details Defined in GHC.Core.Opt.Specialise Methods ppr :: CallInfo -> SDoc #
Outputable CallInfoSet
Instance details Defined in GHC.Core.Opt.Specialise Methods ppr :: CallInfoSet -> SDoc #
Outputable DictBind
Instance details Defined in GHC.Core.Opt.Specialise Methods ppr :: DictBind -> SDoc #
Outputable FloatedDictBinds
Instance details Defined in GHC.Core.Opt.Specialise Methods ppr :: FloatedDictBinds -> SDoc #
Outputable SpecArg
Instance details Defined in GHC.Core.Opt.Specialise Methods ppr :: SpecArg -> SDoc #
Outputable SpecEnv
Instance details Defined in GHC.Core.Opt.Specialise Methods ppr :: SpecEnv -> SDoc #
Outputable UsageDetails
Instance details Defined in GHC.Core.Opt.Specialise Methods ppr :: UsageDetails -> SDoc #
Outputable Tick
Instance details Defined in GHC.Core.Opt.Stats Methods ppr :: Tick -> SDoc #
Outputable IsRecDataConResult
Instance details Defined in GHC.Core.Opt.WorkWrap.Utils Methods ppr :: IsRecDataConResult -> SDoc #
Outputable PatSyn
Instance details Defined in GHC.Core.PatSyn Methods ppr :: PatSyn -> SDoc #
Outputable EqRel
Instance details Defined in GHC.Core.Predicate Methods ppr :: EqRel -> SDoc #
Outputable Reduction
Instance details Defined in GHC.Core.Reduction Methods ppr :: Reduction -> SDoc #
Outputable RoughMatchLookupTc
Instance details Defined in GHC.Core.RoughMap Methods ppr :: RoughMatchLookupTc -> SDoc #
Outputable RoughMatchTc
Instance details Defined in GHC.Core.RoughMap Methods ppr :: RoughMatchTc -> SDoc #
Outputable SimpleOptEnv
Instance details Defined in GHC.Core.SimpleOpt Methods ppr :: SimpleOptEnv -> SDoc #
Outputable CoreStats
Instance details Defined in GHC.Core.Stats Methods ppr :: CoreStats -> SDoc #
Outputable CoSel
Instance details Defined in GHC.Core.TyCo.Rep Methods ppr :: CoSel -> SDoc #
Outputable Coercion
Instance details Defined in GHC.Core.TyCo.Rep Methods ppr :: Coercion -> SDoc #
Outputable CoercionHole
Instance details Defined in GHC.Core.TyCo.Rep Methods ppr :: CoercionHole -> SDoc #
Outputable FunSel
Instance details Defined in GHC.Core.TyCo.Rep Methods ppr :: FunSel -> SDoc #
Outputable MCoercion
Instance details Defined in GHC.Core.TyCo.Rep Methods ppr :: MCoercion -> SDoc #
Outputable TyLit
Instance details Defined in GHC.Core.TyCo.Rep Methods ppr :: TyLit -> SDoc #
Outputable Type
Instance details Defined in GHC.Core.TyCo.Rep Methods ppr :: Type -> SDoc #
Outputable UnivCoProvenance
Instance details Defined in GHC.Core.TyCo.Rep Methods ppr :: UnivCoProvenance -> SDoc #
Outputable Subst
Instance details Defined in GHC.Core.TyCo.Subst Methods ppr :: Subst -> SDoc #
Outputable AlgTyConFlav
Instance details Defined in GHC.Core.TyCon Methods ppr :: AlgTyConFlav -> SDoc #
Outputable FamTyConFlav
Instance details Defined in GHC.Core.TyCon Methods ppr :: FamTyConFlav -> SDoc #
Outputable PrimElemRep
Instance details Defined in GHC.Core.TyCon Methods ppr :: PrimElemRep -> SDoc #
Outputable PrimRep
Instance details Defined in GHC.Core.TyCon Methods ppr :: PrimRep -> SDoc #
Outputable TyCon
Instance details Defined in GHC.Core.TyCon Methods ppr :: TyCon -> SDoc #
Outputable TyConBndrVis
Instance details Defined in GHC.Core.TyCon Methods ppr :: TyConBndrVis -> SDoc #
Outputable RecTcChecker
Instance details Defined in GHC.Core.TyCon.RecWalk Methods ppr :: RecTcChecker -> SDoc #
Outputable ArgSummary
Instance details Defined in GHC.Core.Unfold Methods ppr :: ArgSummary -> SDoc #
Outputable CallCtxt
Instance details Defined in GHC.Core.Unfold Methods ppr :: CallCtxt -> SDoc #
Outputable ExprSize
Instance details Defined in GHC.Core.Unfold Methods ppr :: ExprSize -> SDoc #
Outputable MaybeApartReason
Instance details Defined in GHC.Core.Unify Methods ppr :: MaybeApartReason -> SDoc #
Outputable Usage
Instance details Defined in GHC.Core.UsageEnv Methods ppr :: Usage -> SDoc #
Outputable UsageEnv
Instance details Defined in GHC.Core.UsageEnv Methods ppr :: UsageEnv -> SDoc #
Outputable ArgInfo
Instance details Defined in GHC.CoreToStg.Prep Methods ppr :: ArgInfo -> SDoc #
Outputable BindInfo
Instance details Defined in GHC.CoreToStg.Prep Methods ppr :: BindInfo -> SDoc #
Outputable FloatInfo
Instance details Defined in GHC.CoreToStg.Prep Methods ppr :: FloatInfo -> SDoc #
Outputable FloatingBind
Instance details Defined in GHC.CoreToStg.Prep Methods ppr :: FloatingBind -> SDoc #
Outputable Floats
Instance details Defined in GHC.CoreToStg.Prep Methods ppr :: Floats -> SDoc #
Outputable FastString
Instance details Defined in GHC.Utils.Outputable Methods ppr :: FastString -> SDoc #
Outputable LexicalFastString
Instance details Defined in GHC.Utils.Outputable Methods ppr :: LexicalFastString -> SDoc #
Outputable NonDetFastString
Instance details Defined in GHC.Utils.Outputable Methods ppr :: NonDetFastString -> SDoc #
Outputable EdgeType
Instance details Defined in GHC.Data.Graph.Directed Methods ppr :: EdgeType -> SDoc #
Outputable Time
Instance details Defined in GHC.Data.Graph.Directed Methods ppr :: Time -> SDoc #
Outputable UnVarGraph
Instance details Defined in GHC.Data.Graph.UnVar Methods ppr :: UnVarGraph -> SDoc #
Outputable UnVarSet
Instance details Defined in GHC.Data.Graph.UnVar Methods ppr :: UnVarSet -> SDoc #
Outputable Word64Set
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Word64Set -> SDoc #
Outputable HsComponentId
Instance details Defined in GHC.Driver.Backpack.Syntax Methods ppr :: HsComponentId -> SDoc #
Outputable GhcMode
Instance details Defined in GHC.Driver.DynFlags Methods ppr :: GhcMode -> SDoc #
Outputable ModRenaming
Instance details Defined in GHC.Driver.DynFlags Methods ppr :: ModRenaming -> SDoc #
Outputable PackageArg
Instance details Defined in GHC.Driver.DynFlags Methods ppr :: PackageArg -> SDoc #
Outputable PackageFlag
Instance details Defined in GHC.Driver.DynFlags Methods ppr :: PackageFlag -> SDoc #
Outputable Language
Instance details Defined in GHC.Driver.Flags Methods ppr :: Language -> SDoc #
Outputable BuildPlan
Instance details Defined in GHC.Driver.Make Methods ppr :: BuildPlan -> SDoc #
Outputable CachedIface
Instance details Defined in GHC.Driver.Make Methods ppr :: CachedIface -> SDoc #
Outputable CodeGenEnable
Instance details Defined in GHC.Driver.Make Methods ppr :: CodeGenEnable -> SDoc #
Outputable ModuleGraphNodeWithBootFile
Instance details Defined in GHC.Driver.Make Methods ppr :: ModuleGraphNodeWithBootFile -> SDoc #
Outputable JobResources
Instance details Defined in GHC.Driver.MakeSem Methods ppr :: JobResources -> SDoc #
Outputable Phase
Instance details Defined in GHC.Driver.Phases Methods ppr :: Phase -> SDoc #
Outputable PluginRecompile
Instance details Defined in GHC.Driver.Plugins Methods ppr :: PluginRecompile -> SDoc #
Outputable ABExport
Instance details Defined in GHC.Hs.Binds Methods ppr :: ABExport -> SDoc #
Outputable NamespaceSpecifier
Instance details Defined in GHC.Hs.Binds Methods ppr :: NamespaceSpecifier -> SDoc #
Outputable TcSpecPrag
Instance details Defined in GHC.Hs.Binds Methods ppr :: TcSpecPrag -> SDoc #
Outputable XViaStrategyPs
Instance details Defined in GHC.Hs.Decls Methods ppr :: XViaStrategyPs -> SDoc #
Outputable DocStructureItem
Instance details Defined in GHC.Hs.Doc Methods ppr :: DocStructureItem -> SDoc #
Outputable Docs
Instance details Defined in GHC.Hs.Doc Methods ppr :: Docs -> SDoc #
Outputable HsDocString
Instance details Defined in GHC.Hs.DocString Methods ppr :: HsDocString -> SDoc #
Outputable HsDocStringChunk
Instance details Defined in GHC.Hs.DocString Methods ppr :: HsDocStringChunk -> SDoc #
Outputable HsDocStringDecorator
Instance details Defined in GHC.Hs.DocString Methods ppr :: HsDocStringDecorator -> SDoc #
Outputable GrhsAnn
Instance details Defined in GHC.Hs.Expr Methods ppr :: GrhsAnn -> SDoc #
Outputable HsThingRn
Instance details Defined in GHC.Hs.Expr Methods ppr :: HsThingRn -> SDoc #
Outputable PendingRnSplice
Instance details Defined in GHC.Hs.Expr Methods ppr :: PendingRnSplice -> SDoc #
Outputable PendingTcSplice
Instance details Defined in GHC.Hs.Expr Methods ppr :: PendingTcSplice -> SDoc #
Outputable SyntaxExprRn
Instance details Defined in GHC.Hs.Expr Methods ppr :: SyntaxExprRn -> SDoc #
Outputable SyntaxExprTc
Instance details Defined in GHC.Hs.Expr Methods ppr :: SyntaxExprTc -> SDoc #
Outputable XXExprGhcRn
Instance details Defined in GHC.Hs.Expr Methods ppr :: XXExprGhcRn -> SDoc #
Outputable XXExprGhcTc
Instance details Defined in GHC.Hs.Expr Methods ppr :: XXExprGhcTc -> SDoc #
Outputable OpName
Instance details Defined in GHC.Hs.Type Methods ppr :: OpName -> SDoc #
Outputable DsMatchContext
Instance details Defined in GHC.HsToCore.Monad Methods ppr :: DsMatchContext -> SDoc #
Outputable EquationInfo
Instance details Defined in GHC.HsToCore.Monad Methods ppr :: EquationInfo -> SDoc #
Outputable GenerateInhabitingPatternsMode
Instance details Defined in GHC.HsToCore.Pmc.Solver Methods ppr :: GenerateInhabitingPatternsMode -> SDoc #
Outputable PhiCt
Instance details Defined in GHC.HsToCore.Pmc.Solver Methods ppr :: PhiCt -> SDoc #
Outputable TopNormaliseTypeResult
Instance details Defined in GHC.HsToCore.Pmc.Solver Methods ppr :: TopNormaliseTypeResult -> SDoc #
Outputable BotInfo
Instance details Defined in GHC.HsToCore.Pmc.Solver.Types Methods ppr :: BotInfo -> SDoc #
Outputable Nabla
Instance details Defined in GHC.HsToCore.Pmc.Solver.Types Methods ppr :: Nabla -> SDoc #
Outputable Nablas
Instance details Defined in GHC.HsToCore.Pmc.Solver.Types Methods ppr :: Nablas -> SDoc #
Outputable PmAltCon
Instance details Defined in GHC.HsToCore.Pmc.Solver.Types Methods ppr :: PmAltCon -> SDoc #
Outputable PmAltConApp
Instance details Defined in GHC.HsToCore.Pmc.Solver.Types Methods ppr :: PmAltConApp -> SDoc #
Outputable PmAltConSet
Instance details Defined in GHC.HsToCore.Pmc.Solver.Types Methods ppr :: PmAltConSet -> SDoc #
Outputable PmEquality
Instance details Defined in GHC.HsToCore.Pmc.Solver.Types Methods ppr :: PmEquality -> SDoc #
Outputable PmLit
Instance details Defined in GHC.HsToCore.Pmc.Solver.Types Methods ppr :: PmLit -> SDoc #
Outputable PmLitValue
Instance details Defined in GHC.HsToCore.Pmc.Solver.Types Methods ppr :: PmLitValue -> SDoc #
Outputable ResidualCompleteMatches
Instance details Defined in GHC.HsToCore.Pmc.Solver.Types Methods ppr :: ResidualCompleteMatches -> SDoc #
Outputable TmState	Not user-facing.
Instance details Defined in GHC.HsToCore.Pmc.Solver.Types Methods ppr :: TmState -> SDoc #
Outputable TyState	Not user-facing.
Instance details Defined in GHC.HsToCore.Pmc.Solver.Types Methods ppr :: TyState -> SDoc #
Outputable VarInfo	Not user-facing.
Instance details Defined in GHC.HsToCore.Pmc.Solver.Types Methods ppr :: VarInfo -> SDoc #
Outputable GrdVec	Format LYG guards as `\| True <- x, let x = 42, !z`
Instance details Defined in GHC.HsToCore.Pmc.Types Methods ppr :: GrdVec -> SDoc #
Outputable PmEmptyCase
Instance details Defined in GHC.HsToCore.Pmc.Types Methods ppr :: PmEmptyCase -> SDoc #
Outputable PmGrd	Should not be user-facing.
Instance details Defined in GHC.HsToCore.Pmc.Types Methods ppr :: PmGrd -> SDoc #
Outputable Precision
Instance details Defined in GHC.HsToCore.Pmc.Types Methods ppr :: Precision -> SDoc #
Outputable RedSets
Instance details Defined in GHC.HsToCore.Pmc.Types Methods ppr :: RedSets -> SDoc #
Outputable SrcInfo
Instance details Defined in GHC.HsToCore.Pmc.Types Methods ppr :: SrcInfo -> SDoc #
Outputable BindType
Instance details Defined in GHC.Iface.Ext.Types Methods ppr :: BindType -> SDoc #
Outputable ContextInfo
Instance details Defined in GHC.Iface.Ext.Types Methods ppr :: ContextInfo -> SDoc #
Outputable DeclType
Instance details Defined in GHC.Iface.Ext.Types Methods ppr :: DeclType -> SDoc #
Outputable EvBindDeps
Instance details Defined in GHC.Iface.Ext.Types Methods ppr :: EvBindDeps -> SDoc #
Outputable EvVarSource
Instance details Defined in GHC.Iface.Ext.Types Methods ppr :: EvVarSource -> SDoc #
Outputable HieName
Instance details Defined in GHC.Iface.Ext.Types Methods ppr :: HieName -> SDoc #
Outputable IEType
Instance details Defined in GHC.Iface.Ext.Types Methods ppr :: IEType -> SDoc #
Outputable NodeAnnotation
Instance details Defined in GHC.Iface.Ext.Types Methods ppr :: NodeAnnotation -> SDoc #
Outputable NodeOrigin
Instance details Defined in GHC.Iface.Ext.Types Methods ppr :: NodeOrigin -> SDoc #
Outputable RecFieldContext
Instance details Defined in GHC.Iface.Ext.Types Methods ppr :: RecFieldContext -> SDoc #
Outputable Scope
Instance details Defined in GHC.Iface.Ext.Types Methods ppr :: Scope -> SDoc #
Outputable TyVarScope
Instance details Defined in GHC.Iface.Ext.Types Methods ppr :: TyVarScope -> SDoc #
Outputable WhereFrom
Instance details Defined in GHC.Iface.Load Methods ppr :: WhereFrom -> SDoc #
Outputable CompileReason
Instance details Defined in GHC.Iface.Recomp Methods ppr :: CompileReason -> SDoc #
Outputable IfaceDeclExtras
Instance details Defined in GHC.Iface.Recomp Methods ppr :: IfaceDeclExtras -> SDoc #
Outputable RecompReason
Instance details Defined in GHC.Iface.Recomp Methods ppr :: RecompReason -> SDoc #
Outputable RecompileRequired
Instance details Defined in GHC.Iface.Recomp Methods ppr :: RecompileRequired -> SDoc #
Outputable IfGuidance
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfGuidance -> SDoc #
Outputable IfaceAT
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceAT -> SDoc #
Outputable IfaceAnnotation
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceAnnotation -> SDoc #
Outputable IfaceClassOp
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceClassOp -> SDoc #
Outputable IfaceClsInst
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceClsInst -> SDoc #
Outputable IfaceCompleteMatch
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceCompleteMatch -> SDoc #
Outputable IfaceConAlt
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceConAlt -> SDoc #
Outputable IfaceDecl
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceDecl -> SDoc #
Outputable IfaceExpr
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceExpr -> SDoc #
Outputable IfaceFamInst
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceFamInst -> SDoc #
Outputable IfaceIdDetails
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceIdDetails -> SDoc #
Outputable IfaceInfoItem
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceInfoItem -> SDoc #
Outputable IfaceLFInfo
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceLFInfo -> SDoc #
Outputable IfaceMaybeRhs
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceMaybeRhs -> SDoc #
Outputable IfaceRule
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceRule -> SDoc #
Outputable IfaceStringLiteral
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceStringLiteral -> SDoc #
Outputable IfaceTopBndrInfo
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceTopBndrInfo -> SDoc #
Outputable IfaceTyConParent
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceTyConParent -> SDoc #
Outputable IfaceUnfolding
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceUnfolding -> SDoc #
Outputable IfaceWarningTxt
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceWarningTxt -> SDoc #
Outputable IfaceWarnings
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceWarnings -> SDoc #
Outputable IfaceAppArgs
Instance details Defined in GHC.Iface.Type Methods ppr :: IfaceAppArgs -> SDoc #
Outputable IfaceBndr
Instance details Defined in GHC.Iface.Type Methods ppr :: IfaceBndr -> SDoc #
Outputable IfaceCoercion
Instance details Defined in GHC.Iface.Type Methods ppr :: IfaceCoercion -> SDoc #
Outputable IfaceOneShot
Instance details Defined in GHC.Iface.Type Methods ppr :: IfaceOneShot -> SDoc #
Outputable IfaceTyCon
Instance details Defined in GHC.Iface.Type Methods ppr :: IfaceTyCon -> SDoc #
Outputable IfaceTyConInfo
Instance details Defined in GHC.Iface.Type Methods ppr :: IfaceTyConInfo -> SDoc #
Outputable IfaceTyConSort
Instance details Defined in GHC.Iface.Type Methods ppr :: IfaceTyConSort -> SDoc #
Outputable IfaceTyLit
Instance details Defined in GHC.Iface.Type Methods ppr :: IfaceTyLit -> SDoc #
Outputable IfaceType
Instance details Defined in GHC.Iface.Type Methods ppr :: IfaceType -> SDoc #
Outputable ShowHowMuch
Instance details Defined in GHC.Iface.Type Methods ppr :: ShowHowMuch -> SDoc #
Outputable JStgExpr
Instance details Defined in GHC.JS.JStg.Syntax Methods ppr :: JStgExpr -> SDoc #
Outputable LibrarySpec
Instance details Defined in GHC.Linker.Types Methods ppr :: LibrarySpec -> SDoc #
Outputable Linkable
Instance details Defined in GHC.Linker.Types Methods ppr :: Linkable -> SDoc #
Outputable LoadedPkgInfo
Instance details Defined in GHC.Linker.Types Methods ppr :: LoadedPkgInfo -> SDoc #
Outputable SptEntry
Instance details Defined in GHC.Linker.Types Methods ppr :: SptEntry -> SDoc #
Outputable Unlinked
Instance details Defined in GHC.Linker.Types Methods ppr :: Unlinked -> SDoc #
Outputable MetaId
Instance details Defined in GHC.Llvm.MetaData Methods ppr :: MetaId -> SDoc #
Outputable LlvmCallConvention
Instance details Defined in GHC.Llvm.Types Methods ppr :: LlvmCallConvention -> SDoc #
Outputable LlvmCastOp
Instance details Defined in GHC.Llvm.Types Methods ppr :: LlvmCastOp -> SDoc #
Outputable LlvmCmpOp
Instance details Defined in GHC.Llvm.Types Methods ppr :: LlvmCmpOp -> SDoc #
Outputable LlvmFuncAttr
Instance details Defined in GHC.Llvm.Types Methods ppr :: LlvmFuncAttr -> SDoc #
Outputable LlvmLinkageType
Instance details Defined in GHC.Llvm.Types Methods ppr :: LlvmLinkageType -> SDoc #
Outputable LlvmMachOp
Instance details Defined in GHC.Llvm.Types Methods ppr :: LlvmMachOp -> SDoc #
Outputable LlvmParamAttr
Instance details Defined in GHC.Llvm.Types Methods ppr :: LlvmParamAttr -> SDoc #
Outputable LlvmType
Instance details Defined in GHC.Llvm.Types Methods ppr :: LlvmType -> SDoc #
Outputable AddEpAnn
Instance details Defined in GHC.Parser.Annotation Methods ppr :: AddEpAnn -> SDoc #
Outputable AnnContext
Instance details Defined in GHC.Parser.Annotation Methods ppr :: AnnContext -> SDoc #
Outputable AnnKeywordId
Instance details Defined in GHC.Parser.Annotation Methods ppr :: AnnKeywordId -> SDoc #
Outputable AnnList
Instance details Defined in GHC.Parser.Annotation Methods ppr :: AnnList -> SDoc #
Outputable AnnListItem
Instance details Defined in GHC.Parser.Annotation Methods ppr :: AnnListItem -> SDoc #
Outputable AnnPragma
Instance details Defined in GHC.Parser.Annotation Methods ppr :: AnnPragma -> SDoc #
Outputable BindTag
Instance details Defined in GHC.Parser.Annotation Methods ppr :: BindTag -> SDoc #
Outputable DeclTag
Instance details Defined in GHC.Parser.Annotation Methods ppr :: DeclTag -> SDoc #
Outputable EpAnnComments
Instance details Defined in GHC.Parser.Annotation Methods ppr :: EpAnnComments -> SDoc #
Outputable EpaComment
Instance details Defined in GHC.Parser.Annotation Methods ppr :: EpaComment -> SDoc #
Outputable IsUnicodeSyntax
Instance details Defined in GHC.Parser.Annotation Methods ppr :: IsUnicodeSyntax -> SDoc #
Outputable NameAdornment
Instance details Defined in GHC.Parser.Annotation Methods ppr :: NameAdornment -> SDoc #
Outputable NameAnn
Instance details Defined in GHC.Parser.Annotation Methods ppr :: NameAnn -> SDoc #
Outputable NoEpAnns
Instance details Defined in GHC.Parser.Annotation Methods ppr :: NoEpAnns -> SDoc #
Outputable ParenType
Instance details Defined in GHC.Parser.Annotation Methods ppr :: ParenType -> SDoc #
Outputable TrailingAnn
Instance details Defined in GHC.Parser.Annotation Methods ppr :: TrailingAnn -> SDoc #
Outputable Token
Instance details Defined in GHC.Parser.Lexer Methods ppr :: Token -> SDoc #
Outputable DataConBuilder
Instance details Defined in GHC.Parser.Types Methods ppr :: DataConBuilder -> SDoc #
Outputable RealReg
Instance details Defined in GHC.Platform.Reg Methods ppr :: RealReg -> SDoc #
Outputable Reg	Print a reg in a generic manner If you want the architecture specific names, then use the pprReg function from the appropriate Ppr module.
Instance details Defined in GHC.Platform.Reg Methods ppr :: Reg -> SDoc #
Outputable VirtualReg
Instance details Defined in GHC.Platform.Reg Methods ppr :: VirtualReg -> SDoc #
Outputable RegClass
Instance details Defined in GHC.Platform.Reg.Class Methods ppr :: RegClass -> SDoc #
Outputable ChildLookupResult
Instance details Defined in GHC.Rename.Env Methods ppr :: ChildLookupResult -> SDoc #
Outputable DisambigInfo
Instance details Defined in GHC.Rename.Env Methods ppr :: DisambigInfo -> SDoc #
Outputable HsSigCtxt
Instance details Defined in GHC.Rename.Env Methods ppr :: HsSigCtxt -> SDoc #
Outputable MonadNames
Instance details Defined in GHC.Rename.Expr Methods ppr :: MonadNames -> SDoc #
Outputable RnTyKiEnv
Instance details Defined in GHC.Rename.HsType Methods ppr :: RnTyKiEnv -> SDoc #
Outputable RnTyKiWhat
Instance details Defined in GHC.Rename.HsType Methods ppr :: RnTyKiWhat -> SDoc #
Outputable WarnUnusedForalls
Instance details Defined in GHC.Rename.HsType Methods ppr :: WarnUnusedForalls -> SDoc #
Outputable ImpOccItem
Instance details Defined in GHC.Rename.Names Methods ppr :: ImpOccItem -> SDoc #
Outputable InteractiveImport
Instance details Defined in GHC.Runtime.Context Methods ppr :: InteractiveImport -> SDoc #
Outputable GetDocsFailure
Instance details Defined in GHC.Runtime.Eval Methods ppr :: GetDocsFailure -> SDoc #
Outputable Term
Instance details Defined in GHC.Runtime.Heap.Inspect Methods ppr :: Term -> SDoc #
Outputable ArgDescr
Instance details Defined in GHC.Runtime.Heap.Layout Methods ppr :: ArgDescr -> SDoc #
Outputable ClosureTypeInfo
Instance details Defined in GHC.Runtime.Heap.Layout Methods ppr :: ClosureTypeInfo -> SDoc #
Outputable SMRep
Instance details Defined in GHC.Runtime.Heap.Layout Methods ppr :: SMRep -> SDoc #
Outputable StgHalfWord
Instance details Defined in GHC.Runtime.Heap.Layout Methods ppr :: StgHalfWord -> SDoc #
Outputable StgWord
Instance details Defined in GHC.Runtime.Heap.Layout Methods ppr :: StgWord -> SDoc #
Outputable TagInfo
Instance details Defined in GHC.Stg.InferTags.TagSig Methods ppr :: TagInfo -> SDoc #
Outputable TagSig
Instance details Defined in GHC.Stg.InferTags.TagSig Methods ppr :: TagSig -> SDoc #
Outputable FloatLang
Instance details Defined in GHC.Stg.Lift.Monad Methods ppr :: FloatLang -> SDoc #
Outputable BinderInfo
Instance details Defined in GHC.Stg.Lift.Types Methods ppr :: BinderInfo -> SDoc #
Outputable Skeleton
Instance details Defined in GHC.Stg.Lift.Types Methods ppr :: Skeleton -> SDoc #
Outputable AltType
Instance details Defined in GHC.Stg.Syntax Methods ppr :: AltType -> SDoc #
Outputable ConstructorNumber
Instance details Defined in GHC.Stg.Syntax Methods ppr :: ConstructorNumber -> SDoc #
Outputable NoExtFieldSilent
Instance details Defined in GHC.Stg.Syntax Methods ppr :: NoExtFieldSilent -> SDoc #
Outputable StgArg
Instance details Defined in GHC.Stg.Syntax Methods ppr :: StgArg -> SDoc #
Outputable StgOp
Instance details Defined in GHC.Stg.Syntax Methods ppr :: StgOp -> SDoc #
Outputable UpdateFlag
Instance details Defined in GHC.Stg.Syntax Methods ppr :: UpdateFlag -> SDoc #
Outputable UnariseVal
Instance details Defined in GHC.Stg.Unarise Methods ppr :: UnariseVal -> SDoc #
Outputable Discr
Instance details Defined in GHC.StgToByteCode Methods ppr :: Discr -> SDoc #
Outputable ArgRep
Instance details Defined in GHC.StgToCmm.ArgRep Methods ppr :: ArgRep -> SDoc #
Outputable CallMethod
Instance details Defined in GHC.StgToCmm.Closure Methods ppr :: CallMethod -> SDoc #
Outputable Sequel
Instance details Defined in GHC.StgToCmm.Sequel Methods ppr :: Sequel -> SDoc #
Outputable LambdaFormInfo
Instance details Defined in GHC.StgToCmm.Types Methods ppr :: LambdaFormInfo -> SDoc #
Outputable StandardFormInfo
Instance details Defined in GHC.StgToCmm.Types Methods ppr :: StandardFormInfo -> SDoc #
Outputable IPEStats
Instance details Defined in GHC.StgToCmm.Utils Methods ppr :: IPEStats -> SDoc #
Outputable LinkSpec
Instance details Defined in GHC.StgToJS.Linker.Linker Methods ppr :: LinkSpec -> SDoc #
Outputable LinkPlan
Instance details Defined in GHC.StgToJS.Linker.Types Methods ppr :: LinkPlan -> SDoc #
Outputable BlockInfo
Instance details Defined in GHC.StgToJS.Object Methods ppr :: BlockInfo -> SDoc #
Outputable BlockLocation
Instance details Defined in GHC.StgToJS.Object Methods ppr :: BlockLocation -> SDoc #
Outputable ExportedFun
Instance details Defined in GHC.StgToJS.Object Methods ppr :: ExportedFun -> SDoc #
Outputable StaticArg
Instance details Defined in GHC.StgToJS.Types Methods ppr :: StaticArg -> SDoc #
Outputable StaticLit
Instance details Defined in GHC.StgToJS.Types Methods ppr :: StaticLit -> SDoc #
Outputable TypedExpr
Instance details Defined in GHC.StgToJS.Types Methods ppr :: TypedExpr -> SDoc #
Outputable SlotCount
Instance details Defined in GHC.StgToJS.Utils Methods ppr :: SlotCount -> SDoc #
Outputable EarlyDerivSpec
Instance details Defined in GHC.Tc.Deriv Methods ppr :: EarlyDerivSpec -> SDoc #
Outputable DerivInstTys
Instance details Defined in GHC.Tc.Deriv.Generate Methods ppr :: DerivInstTys -> SDoc #
Outputable DerivContext
Instance details Defined in GHC.Tc.Deriv.Utils Methods ppr :: DerivContext -> SDoc #
Outputable DerivEnv
Instance details Defined in GHC.Tc.Deriv.Utils Methods ppr :: DerivEnv -> SDoc #
Outputable DerivSpecMechanism
Instance details Defined in GHC.Tc.Deriv.Utils Methods ppr :: DerivSpecMechanism -> SDoc #
Outputable PredSpec
Instance details Defined in GHC.Tc.Deriv.Utils Methods ppr :: PredSpec -> SDoc #
Outputable HoleFit
Instance details Defined in GHC.Tc.Errors.Hole.FitTypes Methods ppr :: HoleFit -> SDoc #
Outputable HoleFitCandidate
Instance details Defined in GHC.Tc.Errors.Hole.FitTypes Methods ppr :: HoleFitCandidate -> SDoc #
Outputable TypedHole
Instance details Defined in GHC.Tc.Errors.Hole.FitTypes Methods ppr :: TypedHole -> SDoc #
Outputable ErrorItem
Instance details Defined in GHC.Tc.Errors.Types Methods ppr :: ErrorItem -> SDoc #
Outputable Exported
Instance details Defined in GHC.Tc.Errors.Types Methods ppr :: Exported -> SDoc #
Outputable HsTyVarBndrExistentialFlag
Instance details Defined in GHC.Tc.Errors.Types Methods ppr :: HsTyVarBndrExistentialFlag -> SDoc #
Outputable TypeDataForbids
Instance details Defined in GHC.Tc.Errors.Types Methods ppr :: TypeDataForbids -> SDoc #
Outputable PromotionErr
Instance details Defined in GHC.Tc.Errors.Types.PromotionErr Methods ppr :: PromotionErr -> SDoc #
Outputable GeneralisationPlan
Instance details Defined in GHC.Tc.Gen.Bind Methods ppr :: GeneralisationPlan -> SDoc #
Outputable AppCtxt
Instance details Defined in GHC.Tc.Gen.Head Methods ppr :: AppCtxt -> SDoc #
Outputable EWrap
Instance details Defined in GHC.Tc.Gen.Head Methods ppr :: EWrap -> SDoc #
Outputable ContextKind
Instance details Defined in GHC.Tc.Gen.HsType Methods ppr :: ContextKind -> SDoc #
Outputable HoleMode
Instance details Defined in GHC.Tc.Gen.HsType Methods ppr :: HoleMode -> SDoc #
Outputable SAKS_or_CUSK
Instance details Defined in GHC.Tc.Gen.HsType Methods ppr :: SAKS_or_CUSK -> SDoc #
Outputable TcTyMode
Instance details Defined in GHC.Tc.Gen.HsType Methods ppr :: TcTyMode -> SDoc #
Outputable LetBndrSpec
Instance details Defined in GHC.Tc.Gen.Pat Methods ppr :: LetBndrSpec -> SDoc #
Outputable ClsInstResult
Instance details Defined in GHC.Tc.Instance.Class Methods ppr :: ClsInstResult -> SDoc #
Outputable InferMode
Instance details Defined in GHC.Tc.Solver Methods ppr :: InferMode -> SDoc #
Outputable InertCans
Instance details Defined in GHC.Tc.Solver.InertSet Methods ppr :: InertCans -> SDoc #
Outputable InertSet
Instance details Defined in GHC.Tc.Solver.InertSet Methods ppr :: InertSet -> SDoc #
Outputable InteractResult
Instance details Defined in GHC.Tc.Solver.InertSet Methods ppr :: InteractResult -> SDoc #
Outputable WorkList
Instance details Defined in GHC.Tc.Solver.InertSet Methods ppr :: WorkList -> SDoc #
Outputable DefaultingProposal
Instance details Defined in GHC.Tc.Types Methods ppr :: DefaultingProposal -> SDoc #
Outputable IdBindingInfo
Instance details Defined in GHC.Tc.Types.BasicTypes Methods ppr :: IdBindingInfo -> SDoc #
Outputable TcBinder
Instance details Defined in GHC.Tc.Types.BasicTypes Methods ppr :: TcBinder -> SDoc #
Outputable TcCompleteSig
Instance details Defined in GHC.Tc.Types.BasicTypes Methods ppr :: TcCompleteSig -> SDoc #
Outputable TcIdSig
Instance details Defined in GHC.Tc.Types.BasicTypes Methods ppr :: TcIdSig -> SDoc #
Outputable TcIdSigInst
Instance details Defined in GHC.Tc.Types.BasicTypes Methods ppr :: TcIdSigInst -> SDoc #
Outputable TcPartialSig
Instance details Defined in GHC.Tc.Types.BasicTypes Methods ppr :: TcPartialSig -> SDoc #
Outputable TcPatSynSig
Instance details Defined in GHC.Tc.Types.BasicTypes Methods ppr :: TcPatSynSig -> SDoc #
Outputable TcSigInfo
Instance details Defined in GHC.Tc.Types.BasicTypes Methods ppr :: TcSigInfo -> SDoc #
Outputable TcTyThing
Instance details Defined in GHC.Tc.Types.BasicTypes Methods ppr :: TcTyThing -> SDoc #
Outputable CanEqLHS
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: CanEqLHS -> SDoc #
Outputable CheckTyEqProblem
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: CheckTyEqProblem -> SDoc #
Outputable CheckTyEqResult
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: CheckTyEqResult -> SDoc #
Outputable Ct
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: Ct -> SDoc #
Outputable CtEvidence
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: CtEvidence -> SDoc #
Outputable CtFlavour
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: CtFlavour -> SDoc #
Outputable CtIrredReason
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: CtIrredReason -> SDoc #
Outputable DelayedError
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: DelayedError -> SDoc #
Outputable DictCt
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: DictCt -> SDoc #
Outputable EqCt
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: EqCt -> SDoc #
Outputable HasGivenEqs
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: HasGivenEqs -> SDoc #
Outputable Hole
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: Hole -> SDoc #
Outputable HoleSort
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: HoleSort -> SDoc #
Outputable ImplicStatus
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: ImplicStatus -> SDoc #
Outputable Implication
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: Implication -> SDoc #
Outputable IrredCt
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: IrredCt -> SDoc #
Outputable NotConcreteError
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: NotConcreteError -> SDoc #
Outputable QCInst
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: QCInst -> SDoc #
Outputable RewriterSet
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: RewriterSet -> SDoc #
Outputable SubGoalDepth
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: SubGoalDepth -> SDoc #
Outputable TcEvDest
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: TcEvDest -> SDoc #
Outputable WantedConstraints
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: WantedConstraints -> SDoc #
Outputable EvBind
Instance details Defined in GHC.Tc.Types.Evidence Methods ppr :: EvBind -> SDoc #
Outputable EvBindMap
Instance details Defined in GHC.Tc.Types.Evidence Methods ppr :: EvBindMap -> SDoc #
Outputable EvBindsVar
Instance details Defined in GHC.Tc.Types.Evidence Methods ppr :: EvBindsVar -> SDoc #
Outputable EvCallStack
Instance details Defined in GHC.Tc.Types.Evidence Methods ppr :: EvCallStack -> SDoc #
Outputable EvTerm
Instance details Defined in GHC.Tc.Types.Evidence Methods ppr :: EvTerm -> SDoc #
Outputable EvTypeable
Instance details Defined in GHC.Tc.Types.Evidence Methods ppr :: EvTypeable -> SDoc #
Outputable HoleExprRef
Instance details Defined in GHC.Tc.Types.Evidence Methods ppr :: HoleExprRef -> SDoc #
Outputable HsWrapper
Instance details Defined in GHC.Tc.Types.Evidence Methods ppr :: HsWrapper -> SDoc #
Outputable TcEvBinds
Instance details Defined in GHC.Tc.Types.Evidence Methods ppr :: TcEvBinds -> SDoc #
Outputable CtOrigin
Instance details Defined in GHC.Tc.Types.Origin Methods ppr :: CtOrigin -> SDoc #
Outputable FRRArrowContext
Instance details Defined in GHC.Tc.Types.Origin Methods ppr :: FRRArrowContext -> SDoc #
Outputable FixedRuntimeRepContext
Instance details Defined in GHC.Tc.Types.Origin Methods ppr :: FixedRuntimeRepContext -> SDoc #
Outputable FixedRuntimeRepOrigin
Instance details Defined in GHC.Tc.Types.Origin Methods ppr :: FixedRuntimeRepOrigin -> SDoc #
Outputable InstanceWhat
Instance details Defined in GHC.Tc.Types.Origin Methods ppr :: InstanceWhat -> SDoc #
Outputable NakedScFlag
Instance details Defined in GHC.Tc.Types.Origin Methods ppr :: NakedScFlag -> SDoc #
Outputable SkolemInfo
Instance details Defined in GHC.Tc.Types.Origin Methods ppr :: SkolemInfo -> SDoc #
Outputable SkolemInfoAnon
Instance details Defined in GHC.Tc.Types.Origin Methods ppr :: SkolemInfoAnon -> SDoc #
Outputable StmtOrigin
Instance details Defined in GHC.Tc.Types.Origin Methods ppr :: StmtOrigin -> SDoc #
Outputable TyVarBndrs
Instance details Defined in GHC.Tc.Types.Origin Methods ppr :: TyVarBndrs -> SDoc #
Outputable TypedThing
Instance details Defined in GHC.Tc.Types.Origin Methods ppr :: TypedThing -> SDoc #
Outputable Rank
Instance details Defined in GHC.Tc.Types.Rank Methods ppr :: Rank -> SDoc #
Outputable ThStage
Instance details Defined in GHC.Tc.Types.TH Methods ppr :: ThStage -> SDoc #
Outputable IsExtraConstraint
Instance details Defined in GHC.Tc.Utils.Monad Methods ppr :: IsExtraConstraint -> SDoc #
Outputable CandidatesQTvs
Instance details Defined in GHC.Tc.Utils.TcMType Methods ppr :: CandidatesQTvs -> SDoc #
Outputable ExpPatType
Instance details Defined in GHC.Tc.Utils.TcType Methods ppr :: ExpPatType -> SDoc #
Outputable ExpType
Instance details Defined in GHC.Tc.Utils.TcType Methods ppr :: ExpType -> SDoc #
Outputable InferResult
Instance details Defined in GHC.Tc.Utils.TcType Methods ppr :: InferResult -> SDoc #
Outputable MetaDetails
Instance details Defined in GHC.Tc.Utils.TcType Methods ppr :: MetaDetails -> SDoc #
Outputable MetaInfo
Instance details Defined in GHC.Tc.Utils.TcType Methods ppr :: MetaInfo -> SDoc #
Outputable PatersonSize
Instance details Defined in GHC.Tc.Utils.TcType Methods ppr :: PatersonSize -> SDoc #
Outputable TcLevel
Instance details Defined in GHC.Tc.Utils.TcType Methods ppr :: TcLevel -> SDoc #
Outputable TcTyVarDetails
Instance details Defined in GHC.Tc.Utils.TcType Methods ppr :: TcTyVarDetails -> SDoc #
Outputable AreUnifying
Instance details Defined in GHC.Tc.Utils.Unify Methods ppr :: AreUnifying -> SDoc #
Outputable LevelCheck
Instance details Defined in GHC.Tc.Utils.Unify Methods ppr :: LevelCheck -> SDoc #
Outputable ExpandMode
Instance details Defined in GHC.Tc.Validity Methods ppr :: ExpandMode -> SDoc #
Outputable TypeOrKindCtxt
Instance details Defined in GHC.Tc.Validity Methods ppr :: TypeOrKindCtxt -> SDoc #
Outputable ValidityEnv
Instance details Defined in GHC.Tc.Validity Methods ppr :: ValidityEnv -> SDoc #
Outputable ZonkEnv
Instance details Defined in GHC.Tc.Zonk.Env Methods ppr :: ZonkEnv -> SDoc #
Outputable Annotation
Instance details Defined in GHC.Types.Annotations Methods ppr :: Annotation -> SDoc #
Outputable AvailInfo
Instance details Defined in GHC.Types.Avail Methods ppr :: AvailInfo -> SDoc #
Outputable Activation
Instance details Defined in GHC.Types.Basic Methods ppr :: Activation -> SDoc #
Outputable Alignment
Instance details Defined in GHC.Types.Basic Methods ppr :: Alignment -> SDoc #
Outputable CbvMark
Instance details Defined in GHC.Types.Basic Methods ppr :: CbvMark -> SDoc #
Outputable CompilerPhase
Instance details Defined in GHC.Types.Basic Methods ppr :: CompilerPhase -> SDoc #
Outputable DefaultingStrategy
Instance details Defined in GHC.Types.Basic Methods ppr :: DefaultingStrategy -> SDoc #
Outputable DoPmc
Instance details Defined in GHC.Types.Basic Methods ppr :: DoPmc -> SDoc #
Outputable FunctionOrData
Instance details Defined in GHC.Types.Basic Methods ppr :: FunctionOrData -> SDoc #
Outputable GenReason
Instance details Defined in GHC.Types.Basic Methods ppr :: GenReason -> SDoc #
Outputable InlinePragma
Instance details Defined in GHC.Types.Basic Methods ppr :: InlinePragma -> SDoc #
Outputable InlineSpec
Instance details Defined in GHC.Types.Basic Methods ppr :: InlineSpec -> SDoc #
Outputable IntWithInf
Instance details Defined in GHC.Types.Basic Methods ppr :: IntWithInf -> SDoc #
Outputable LeftOrRight
Instance details Defined in GHC.Types.Basic Methods ppr :: LeftOrRight -> SDoc #
Outputable Levity
Instance details Defined in GHC.Types.Basic Methods ppr :: Levity -> SDoc #
Outputable NonStandardDefaultingStrategy
Instance details Defined in GHC.Types.Basic Methods ppr :: NonStandardDefaultingStrategy -> SDoc #
Outputable OccInfo
Instance details Defined in GHC.Types.Basic Methods ppr :: OccInfo -> SDoc #
Outputable OneShotInfo
Instance details Defined in GHC.Types.Basic Methods ppr :: OneShotInfo -> SDoc #
Outputable Origin
Instance details Defined in GHC.Types.Basic Methods ppr :: Origin -> SDoc #
Outputable OverlapFlag
Instance details Defined in GHC.Types.Basic Methods ppr :: OverlapFlag -> SDoc #
Outputable OverlapMode
Instance details Defined in GHC.Types.Basic Methods ppr :: OverlapMode -> SDoc #
Outputable RecFlag
Instance details Defined in GHC.Types.Basic Methods ppr :: RecFlag -> SDoc #
Outputable RuleMatchInfo
Instance details Defined in GHC.Types.Basic Methods ppr :: RuleMatchInfo -> SDoc #
Outputable SuccessFlag
Instance details Defined in GHC.Types.Basic Methods ppr :: SuccessFlag -> SDoc #
Outputable SwapFlag
Instance details Defined in GHC.Types.Basic Methods ppr :: SwapFlag -> SDoc #
Outputable TailCallInfo
Instance details Defined in GHC.Types.Basic Methods ppr :: TailCallInfo -> SDoc #
Outputable TopLevelFlag
Instance details Defined in GHC.Types.Basic Methods ppr :: TopLevelFlag -> SDoc #
Outputable TupleSort
Instance details Defined in GHC.Types.Basic Methods ppr :: TupleSort -> SDoc #
Outputable TypeOrData
Instance details Defined in GHC.Types.Basic Methods ppr :: TypeOrData -> SDoc #
Outputable TypeOrKind
Instance details Defined in GHC.Types.Basic Methods ppr :: TypeOrKind -> SDoc #
Outputable UnboxedTupleOrSum
Instance details Defined in GHC.Types.Basic Methods ppr :: UnboxedTupleOrSum -> SDoc #
Outputable UnfoldingSource
Instance details Defined in GHC.Types.Basic Methods ppr :: UnfoldingSource -> SDoc #
Outputable CompleteMatch
Instance details Defined in GHC.Types.CompleteMatch Methods ppr :: CompleteMatch -> SDoc #
Outputable CostCentre
Instance details Defined in GHC.Types.CostCentre Methods ppr :: CostCentre -> SDoc #
Outputable CostCentreStack
Instance details Defined in GHC.Types.CostCentre Methods ppr :: CostCentreStack -> SDoc #
Outputable Cpr	BNF: cpr ::= '' -- TopCpr \| n -- FlatConCpr n \| n '(' cpr1 ',' cpr2 ',' ... ')' -- ConCpr n [cpr1,cpr2,...] \| 'b' -- BotCpr Examples: * `f x = f x` has result CPR `b` * `1(1,)` is a valid (nested) `Cpr` denotation for `(I# 42#, f 42)`.
Instance details Defined in GHC.Types.Cpr Methods ppr :: Cpr -> SDoc #
Outputable CprSig	Only print the CPR result
Instance details Defined in GHC.Types.Cpr Methods ppr :: CprSig -> SDoc #
Outputable CprType	BNF: cpr_ty ::= cpr -- short form if arty == 0 \| '\' arty '.' cpr -- if arty > 0 Examples: * `f x y z = f x y z` has denotation `3.b` * `g !x = (x+1, x+2)` has denotation `1.1(1,1)`.
Instance details Defined in GHC.Types.Cpr Methods ppr :: CprType -> SDoc #
Outputable Card	See Note [Demand notation] Current syntax was discussed in #19016.
Instance details Defined in GHC.Types.Demand Methods ppr :: Card -> SDoc #
Outputable Demand	See Note [Demand notation]
Instance details Defined in GHC.Types.Demand Methods ppr :: Demand -> SDoc #
Outputable Divergence
Instance details Defined in GHC.Types.Demand Methods ppr :: Divergence -> SDoc #
Outputable DmdEnv
Instance details Defined in GHC.Types.Demand Methods ppr :: DmdEnv -> SDoc #
Outputable DmdSig
Instance details Defined in GHC.Types.Demand Methods ppr :: DmdSig -> SDoc #
Outputable DmdType
Instance details Defined in GHC.Types.Demand Methods ppr :: DmdType -> SDoc #
Outputable SubDemand	See Note [Demand notation]
Instance details Defined in GHC.Types.Demand Methods ppr :: SubDemand -> SDoc #
Outputable TypeShape
Instance details Defined in GHC.Types.Demand Methods ppr :: TypeShape -> SDoc #
Outputable DiagnosticCode
Instance details Defined in GHC.Types.Error Methods ppr :: DiagnosticCode -> SDoc #
Outputable DiagnosticHint
Instance details Defined in GHC.Types.Error Methods ppr :: DiagnosticHint -> SDoc #
Outputable DiagnosticReason
Instance details Defined in GHC.Types.Error Methods ppr :: DiagnosticReason -> SDoc #
Outputable LinkedDiagCode
Instance details Defined in GHC.Types.Error Methods ppr :: LinkedDiagCode -> SDoc #
Outputable ResolvedDiagnosticReason
Instance details Defined in GHC.Types.Error Methods ppr :: ResolvedDiagnosticReason -> SDoc #
Outputable Severity
Instance details Defined in GHC.Types.Error Methods ppr :: Severity -> SDoc #
Outputable DuplicateRecordFields
Instance details Defined in GHC.Types.FieldLabel Methods ppr :: DuplicateRecordFields -> SDoc #
Outputable FieldLabel
Instance details Defined in GHC.Types.FieldLabel Methods ppr :: FieldLabel -> SDoc #
Outputable FieldSelectors
Instance details Defined in GHC.Types.FieldLabel Methods ppr :: FieldSelectors -> SDoc #
Outputable Fixity
Instance details Defined in GHC.Types.Fixity Methods ppr :: Fixity -> SDoc #
Outputable FixityDirection
Instance details Defined in GHC.Types.Fixity Methods ppr :: FixityDirection -> SDoc #
Outputable LexicalFixity
Instance details Defined in GHC.Types.Fixity Methods ppr :: LexicalFixity -> SDoc #
Outputable FixItem
Instance details Defined in GHC.Types.Fixity.Env Methods ppr :: FixItem -> SDoc #
Outputable CCallConv
Instance details Defined in GHC.Types.ForeignCall Methods ppr :: CCallConv -> SDoc #
Outputable CCallSpec
Instance details Defined in GHC.Types.ForeignCall Methods ppr :: CCallSpec -> SDoc #
Outputable CExportSpec
Instance details Defined in GHC.Types.ForeignCall Methods ppr :: CExportSpec -> SDoc #
Outputable CType
Instance details Defined in GHC.Types.ForeignCall Methods ppr :: CType -> SDoc #
Outputable ForeignCall
Instance details Defined in GHC.Types.ForeignCall Methods ppr :: ForeignCall -> SDoc #
Outputable Header
Instance details Defined in GHC.Types.ForeignCall Methods ppr :: Header -> SDoc #
Outputable Safety
Instance details Defined in GHC.Types.ForeignCall Methods ppr :: Safety -> SDoc #
Outputable ConInfo
Instance details Defined in GHC.Types.GREInfo Methods ppr :: ConInfo -> SDoc #
Outputable ConLikeName
Instance details Defined in GHC.Types.GREInfo Methods ppr :: ConLikeName -> SDoc #
Outputable GREInfo
Instance details Defined in GHC.Types.GREInfo Methods ppr :: GREInfo -> SDoc #
Outputable RecFieldInfo
Instance details Defined in GHC.Types.GREInfo Methods ppr :: RecFieldInfo -> SDoc #
Outputable CafInfo
Instance details Defined in GHC.Types.Id.Info Methods ppr :: CafInfo -> SDoc #
Outputable IdDetails
Instance details Defined in GHC.Types.Id.Info Methods ppr :: IdDetails -> SDoc #
Outputable RecSelParent
Instance details Defined in GHC.Types.Id.Info Methods ppr :: RecSelParent -> SDoc #
Outputable TickBoxOp
Instance details Defined in GHC.Types.Id.Info Methods ppr :: TickBoxOp -> SDoc #
Outputable Literal
Instance details Defined in GHC.Types.Literal Methods ppr :: Literal -> SDoc #
Outputable Name
Instance details Defined in GHC.Types.Name Methods ppr :: Name -> SDoc #
Outputable NameSort
Instance details Defined in GHC.Types.Name Methods ppr :: NameSort -> SDoc #
Outputable OccName
Instance details Defined in GHC.Types.Name.Occurrence Methods ppr :: OccName -> SDoc #
Outputable ImportSpec
Instance details Defined in GHC.Types.Name.Reader Methods ppr :: ImportSpec -> SDoc #
Outputable LocalRdrEnv
Instance details Defined in GHC.Types.Name.Reader Methods ppr :: LocalRdrEnv -> SDoc #
Outputable LookupChild
Instance details Defined in GHC.Types.Name.Reader Methods ppr :: LookupChild -> SDoc #
Outputable Parent
Instance details Defined in GHC.Types.Name.Reader Methods ppr :: Parent -> SDoc #
Outputable RdrName
Instance details Defined in GHC.Types.Name.Reader Methods ppr :: RdrName -> SDoc #
Outputable PkgQual
Instance details Defined in GHC.Types.PkgQual Methods ppr :: PkgQual -> SDoc #
Outputable RawPkgQual
Instance details Defined in GHC.Types.PkgQual Methods ppr :: RawPkgQual -> SDoc #
Outputable SlotTy
Instance details Defined in GHC.Types.RepType Methods ppr :: SlotTy -> SDoc #
Outputable IfaceTrustInfo
Instance details Defined in GHC.Types.SafeHaskell Methods ppr :: IfaceTrustInfo -> SDoc #
Outputable SafeHaskellMode
Instance details Defined in GHC.Types.SafeHaskell Methods ppr :: SafeHaskellMode -> SDoc #
Outputable FractionalLit
Instance details Defined in GHC.Types.SourceText Methods ppr :: FractionalLit -> SDoc #
Outputable IntegralLit
Instance details Defined in GHC.Types.SourceText Methods ppr :: IntegralLit -> SDoc #
Outputable SourceText
Instance details Defined in GHC.Types.SourceText Methods ppr :: SourceText -> SDoc #
Outputable StringLiteral
Instance details Defined in GHC.Types.SourceText Methods ppr :: StringLiteral -> SDoc #
Outputable DeltaPos
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: DeltaPos -> SDoc #
Outputable NoComments
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: NoComments -> SDoc #
Outputable RealSrcLoc
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: RealSrcLoc -> SDoc #
Outputable RealSrcSpan
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: RealSrcSpan -> SDoc #
Outputable SrcLoc
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: SrcLoc -> SDoc #
Outputable SrcSpan
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: SrcSpan -> SDoc #
Outputable UnhelpfulSpanReason
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: UnhelpfulSpanReason -> SDoc #
Outputable Target
Instance details Defined in GHC.Types.Target Methods ppr :: Target -> SDoc #
Outputable TargetId
Instance details Defined in GHC.Types.Target Methods ppr :: TargetId -> SDoc #
Outputable TickishPlacement
Instance details Defined in GHC.Types.Tickish Methods ppr :: TickishPlacement -> SDoc #
Outputable TyThing
Instance details Defined in GHC.Types.TyThing Methods ppr :: TyThing -> SDoc #
Outputable Unique
Instance details Defined in GHC.Types.Unique Methods ppr :: Unique -> SDoc #
Outputable ForAllTyFlag
Instance details Defined in GHC.Types.Var Methods ppr :: ForAllTyFlag -> SDoc #
Outputable FunTyFlag
Instance details Defined in GHC.Types.Var Methods ppr :: FunTyFlag -> SDoc #
Outputable PiTyBinder
Instance details Defined in GHC.Types.Var Methods ppr :: PiTyBinder -> SDoc #
Outputable Var
Instance details Defined in GHC.Types.Var Methods ppr :: Var -> SDoc #
Outputable InScopeSet
Instance details Defined in GHC.Types.Var.Env Methods ppr :: InScopeSet -> SDoc #
Outputable HomeUnitEnv
Instance details Defined in GHC.Unit.Env Methods ppr :: HomeUnitEnv -> SDoc #
Outputable HomeModLinkable
Instance details Defined in GHC.Unit.Home.ModInfo Methods ppr :: HomeModLinkable -> SDoc #
Outputable PackageId
Instance details Defined in GHC.Unit.Info Methods ppr :: PackageId -> SDoc #
Outputable PackageName
Instance details Defined in GHC.Unit.Info Methods ppr :: PackageName -> SDoc #
Outputable NDModule
Instance details Defined in GHC.Unit.Module.Env Methods ppr :: NDModule -> SDoc #
Outputable ModNodeKeyWithUid
Instance details Defined in GHC.Unit.Module.Graph Methods ppr :: ModNodeKeyWithUid -> SDoc #
Outputable ModuleGraphNode
Instance details Defined in GHC.Unit.Module.Graph Methods ppr :: ModuleGraphNode -> SDoc #
Outputable NodeKey
Instance details Defined in GHC.Unit.Module.Graph Methods ppr :: NodeKey -> SDoc #
Outputable ModLocation
Instance details Defined in GHC.Unit.Module.Location Methods ppr :: ModLocation -> SDoc #
Outputable ModSummary
Instance details Defined in GHC.Unit.Module.ModSummary Methods ppr :: ModSummary -> SDoc #
Outputable HscBackendAction
Instance details Defined in GHC.Unit.Module.Status Methods ppr :: HscBackendAction -> SDoc #
Outputable InWarningCategory
Instance details Defined in GHC.Unit.Module.Warnings Methods ppr :: InWarningCategory -> SDoc #
Outputable WarningCategory
Instance details Defined in GHC.Unit.Module.Warnings Methods ppr :: WarningCategory -> SDoc #
Outputable UnitPprInfo
Instance details Defined in GHC.Unit.Ppr Methods ppr :: UnitPprInfo -> SDoc #
Outputable ModuleOrigin
Instance details Defined in GHC.Unit.State Methods ppr :: ModuleOrigin -> SDoc #
Outputable UnitErr
Instance details Defined in GHC.Unit.State Methods ppr :: UnitErr -> SDoc #
Outputable UnitVisibility
Instance details Defined in GHC.Unit.State Methods ppr :: UnitVisibility -> SDoc #
Outputable UnusableUnitReason
Instance details Defined in GHC.Unit.State Methods ppr :: UnusableUnitReason -> SDoc #
Outputable InstalledModule
Instance details Defined in GHC.Unit.Types Methods ppr :: InstalledModule -> SDoc #
Outputable InstantiatedModule
Instance details Defined in GHC.Unit.Types Methods ppr :: InstantiatedModule -> SDoc #
Outputable InstantiatedUnit
Instance details Defined in GHC.Unit.Types Methods ppr :: InstantiatedUnit -> SDoc #
Outputable Module
Instance details Defined in GHC.Unit.Types Methods ppr :: Module -> SDoc #
Outputable Unit
Instance details Defined in GHC.Unit.Types Methods ppr :: Unit -> SDoc #
Outputable UnitId
Instance details Defined in GHC.Unit.Types Methods ppr :: UnitId -> SDoc #
Outputable JoinPointHood
Instance details Defined in GHC.Utils.Outputable Methods ppr :: JoinPointHood -> SDoc #
Outputable PprStyle
Instance details Defined in GHC.Utils.Outputable Methods ppr :: PprStyle -> SDoc #
Outputable QualifyName
Instance details Defined in GHC.Utils.Outputable Methods ppr :: QualifyName -> SDoc #
Outputable SDoc
Instance details Defined in GHC.Utils.Outputable Methods ppr :: SDoc -> SDoc #
Outputable ContainingSyntax
Instance details Defined in GHC.Wasm.ControlFlow.FromCmm Methods ppr :: ContainingSyntax -> SDoc #
Outputable Context
Instance details Defined in GHC.Wasm.ControlFlow.FromCmm Methods ppr :: Context -> SDoc #
Outputable ModuleName
Instance details Defined in GHC.Utils.Outputable Methods ppr :: ModuleName -> SDoc #
Outputable Serialized
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Serialized -> SDoc #
Outputable Extension
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Extension -> SDoc #
Outputable Void
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Void -> SDoc #
Outputable Fingerprint
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Fingerprint -> SDoc #
Outputable Int16
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Int16 -> SDoc #
Outputable Int32
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Int32 -> SDoc #
Outputable Int64
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Int64 -> SDoc #
Outputable Int8
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Int8 -> SDoc #
Outputable Word16
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Word16 -> SDoc #
Outputable Word32
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Word32 -> SDoc #
Outputable Word64
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Word64 -> SDoc #
Outputable Word8
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Word8 -> SDoc #
Outputable Ordering
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Ordering -> SDoc #
Outputable HashableType Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Misc Methods ppr :: HashableType -> SDoc #
Outputable OccurrenceMap Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Play Methods ppr :: OccurrenceMap -> SDoc #
Outputable TyConOccurrence Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Play Methods ppr :: TyConOccurrence -> SDoc #
Outputable UTCTime
Instance details Defined in GHC.Utils.Outputable Methods ppr :: UTCTime -> SDoc #
Outputable Integer
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Integer -> SDoc #
Outputable ()
Instance details Defined in GHC.Utils.Outputable Methods ppr :: () -> SDoc #
Outputable Bool
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Bool -> SDoc #
Outputable Double
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Double -> SDoc #
Outputable Float
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Float -> SDoc #
Outputable Int
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Int -> SDoc #
Outputable Word
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Word -> SDoc #
Outputable a => Outputable (SCC a)
Instance details Defined in GHC.Utils.Outputable Methods ppr :: SCC a -> SDoc #
Outputable elt => Outputable (IntMap elt)
Instance details Defined in GHC.Utils.Outputable Methods ppr :: IntMap elt -> SDoc #
Outputable a => Outputable (Set a)
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Set a -> SDoc #
Outputable a => Outputable (ProtoBCO a)
Instance details Defined in GHC.ByteCode.Instr Methods ppr :: ProtoBCO a -> SDoc #
Outputable instr => Outputable (GenBasicBlock instr)
Instance details Defined in GHC.Cmm Methods ppr :: GenBasicBlock instr -> SDoc #
Outputable instr => Outputable (ListGraph instr)
Instance details Defined in GHC.Cmm Methods ppr :: ListGraph instr -> SDoc #
Outputable a => Outputable (LabelMap a)
Instance details Defined in GHC.Cmm.Dataflow.Label Methods ppr :: LabelMap a -> SDoc #
Outputable instr => Outputable (InstrSR instr)
Instance details Defined in GHC.CmmToAsm.Reg.Liveness Methods ppr :: InstrSR instr -> SDoc #
Outputable instr => Outputable (LiveInstr instr)
Instance details Defined in GHC.CmmToAsm.Reg.Liveness Methods ppr :: LiveInstr instr -> SDoc #
Outputable b => Outputable (TaggedBndr b)
Instance details Defined in GHC.Core Methods ppr :: TaggedBndr b -> SDoc #
Outputable ev => Outputable (NormaliseStepResult ev)
Instance details Defined in GHC.Core.Coercion Methods ppr :: NormaliseStepResult ev -> SDoc #
Outputable (CoAxiom br)
Instance details Defined in GHC.Core.Coercion.Axiom Methods ppr :: CoAxiom br -> SDoc #
Outputable a => Outputable (CoreMap a)
Instance details Defined in GHC.Core.Map.Expr Methods ppr :: CoreMap a -> SDoc #
Outputable a => Outputable (TypeMapG a)
Instance details Defined in GHC.Core.Map.Type Methods ppr :: TypeMapG a -> SDoc #
Outputable i => Outputable (UnboxingDecision i)
Instance details Defined in GHC.Core.Opt.WorkWrap.Utils Methods ppr :: UnboxingDecision i -> SDoc #
Outputable a => Outputable (RoughMap a)
Instance details Defined in GHC.Core.RoughMap Methods ppr :: RoughMap a -> SDoc #
Outputable a => Outputable (Scaled a)
Instance details Defined in GHC.Core.TyCo.Rep Methods ppr :: Scaled a -> SDoc #
Outputable a => Outputable (UnifyResultM a)
Instance details Defined in GHC.Core.Unify Methods ppr :: UnifyResultM a -> SDoc #
Outputable a => Outputable (Bag a)
Instance details Defined in GHC.Data.Bag Methods ppr :: Bag a -> SDoc #
OutputableBndr a => Outputable (BooleanFormula a)
Instance details Defined in GHC.Data.BooleanFormula Methods ppr :: BooleanFormula a -> SDoc #
Outputable node => Outputable (Edge node)
Instance details Defined in GHC.Data.Graph.Directed Methods ppr :: Edge node -> SDoc #
Outputable node => Outputable (Graph node)
Instance details Defined in GHC.Data.Graph.Directed Methods ppr :: Graph node -> SDoc #
Outputable a => Outputable (OrdList a)
Instance details Defined in GHC.Data.OrdList Methods ppr :: OrdList a -> SDoc #
Outputable a => Outputable (Pair a)
Instance details Defined in GHC.Data.Pair Methods ppr :: Pair a -> SDoc #
Outputable a => Outputable (OnOff a)
Instance details Defined in GHC.Driver.DynFlags Methods ppr :: OnOff a -> SDoc #
Outputable (KnotVars a)
Instance details Defined in GHC.Driver.Env.KnotVars Methods ppr :: KnotVars a -> SDoc #
Outputable a => Outputable (CheckResult a)
Instance details Defined in GHC.HsToCore.Pmc.Types Methods ppr :: CheckResult a -> SDoc #
Outputable p => Outputable (PmGRHS p)
Instance details Defined in GHC.HsToCore.Pmc.Types Methods ppr :: PmGRHS p -> SDoc #
Outputable p => Outputable (PmGRHSs p)
Instance details Defined in GHC.HsToCore.Pmc.Types Methods ppr :: PmGRHSs p -> SDoc #
Outputable p => Outputable (PmMatch p)
Instance details Defined in GHC.HsToCore.Pmc.Types Methods ppr :: PmMatch p -> SDoc #
Outputable p => Outputable (PmMatchGroup p)
Instance details Defined in GHC.HsToCore.Pmc.Types Methods ppr :: PmMatchGroup p -> SDoc #
Outputable p => Outputable (PmPatBind p)
Instance details Defined in GHC.HsToCore.Pmc.Types Methods ppr :: PmPatBind p -> SDoc #
Outputable a => Outputable (HieAST a)
Instance details Defined in GHC.Iface.Ext.Types Methods ppr :: HieAST a -> SDoc #
Outputable a => Outputable (HieASTs a)
Instance details Defined in GHC.Iface.Ext.Types Methods ppr :: HieASTs a -> SDoc #
Outputable a => Outputable (IdentifierDetails a)
Instance details Defined in GHC.Iface.Ext.Types Methods ppr :: IdentifierDetails a -> SDoc #
Outputable a => Outputable (NodeInfo a)
Instance details Defined in GHC.Iface.Ext.Types Methods ppr :: NodeInfo a -> SDoc #
Outputable a => Outputable (SourcedNodeInfo a)
Instance details Defined in GHC.Iface.Ext.Types Methods ppr :: SourcedNodeInfo a -> SDoc #
Outputable a => Outputable (EvidenceInfo a)
Instance details Defined in GHC.Iface.Ext.Utils Methods ppr :: EvidenceInfo a -> SDoc #
Outputable a => Outputable (MaybeValidated a)
Instance details Defined in GHC.Iface.Recomp Methods ppr :: MaybeValidated a -> SDoc #
Outputable tag => Outputable (AnnSortKey tag)
Instance details Defined in GHC.Parser.Annotation Methods ppr :: AnnSortKey tag -> SDoc #
Outputable a => Outputable (EpAnn a)
Instance details Defined in GHC.Parser.Annotation Methods ppr :: EpAnn a -> SDoc #
Outputable (ArgPatBuilder GhcPs)
Instance details Defined in GHC.Parser.PostProcess Methods ppr :: ArgPatBuilder GhcPs -> SDoc #
Outputable (PatBuilder GhcPs)
Instance details Defined in GHC.Parser.Types Methods ppr :: PatBuilder GhcPs -> SDoc #
Outputable a => Outputable (StmtTree a)
Instance details Defined in GHC.Rename.Expr Methods ppr :: StmtTree a -> SDoc #
Outputable (TagEnv p)
Instance details Defined in GHC.Stg.InferTags.Types Methods ppr :: TagEnv p -> SDoc #
OutputablePass pass => Outputable (GenStgBinding pass)
Instance details Defined in GHC.Stg.Syntax Methods ppr :: GenStgBinding pass -> SDoc #
OutputablePass pass => Outputable (GenStgExpr pass)
Instance details Defined in GHC.Stg.Syntax Methods ppr :: GenStgExpr pass -> SDoc #
OutputablePass pass => Outputable (GenStgRhs pass)
Instance details Defined in GHC.Stg.Syntax Methods ppr :: GenStgRhs pass -> SDoc #
Outputable a => Outputable (NonVoid a)
Instance details Defined in GHC.StgToCmm.Closure Methods ppr :: NonVoid a -> SDoc #
Outputable theta => Outputable (DerivSpec theta)
Instance details Defined in GHC.Tc.Deriv.Utils Methods ppr :: DerivSpec theta -> SDoc #
OutputableBndrId p => Outputable (HsTypeOrSigType (GhcPass p))
Instance details Defined in GHC.Tc.Errors.Types Methods ppr :: HsTypeOrSigType (GhcPass p) -> SDoc #
OutputableBndrId (XPass p) => Outputable (EValArg p)
Instance details Defined in GHC.Tc.Gen.Head Methods ppr :: EValArg p -> SDoc #
OutputableBndrId (XPass p) => Outputable (HsExprArg p)
Instance details Defined in GHC.Tc.Gen.Head Methods ppr :: HsExprArg p -> SDoc #
Outputable (FunDepEqn a)
Instance details Defined in GHC.Tc.Instance.FunDeps Methods ppr :: FunDepEqn a -> SDoc #
Outputable a => Outputable (StopOrContinue a)
Instance details Defined in GHC.Tc.Solver.Monad Methods ppr :: StopOrContinue a -> SDoc #
OutputableBndrId a => Outputable (InstInfo (GhcPass a))
Instance details Defined in GHC.Tc.Utils.Env Methods ppr :: InstInfo (GhcPass a) -> SDoc #
Outputable (TyEqFamApp a)
Instance details Defined in GHC.Tc.Utils.Unify Methods ppr :: TyEqFamApp a -> SDoc #
Outputable (TyEqFlags a)
Instance details Defined in GHC.Tc.Utils.Unify Methods ppr :: TyEqFlags a -> SDoc #
Outputable name => Outputable (AnnTarget name)
Instance details Defined in GHC.Types.Annotations Methods ppr :: AnnTarget name -> SDoc #
Outputable (DefMethSpec ty)
Instance details Defined in GHC.Types.Basic Methods ppr :: DefMethSpec ty -> SDoc #
Outputable (TyConFlavour tc)
Instance details Defined in GHC.Types.Basic Methods ppr :: TyConFlavour tc -> SDoc #
Diagnostic e => Outputable (Messages e)
Instance details Defined in GHC.Types.Error Methods ppr :: Messages e -> SDoc #
Outputable a => Outputable (OccEnv a)
Instance details Defined in GHC.Types.Name.Occurrence Methods ppr :: OccEnv a -> SDoc #
Outputable info => Outputable (GlobalRdrEltX info)
Instance details Defined in GHC.Types.Name.Reader Methods ppr :: GlobalRdrEltX info -> SDoc #
Outputable (WhichGREs info)
Instance details Defined in GHC.Types.Name.Reader Methods ppr :: WhichGREs info -> SDoc #
Outputable a => Outputable (EpaLocation' a)
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: EpaLocation' a -> SDoc #
Outputable e => Outputable (Located e)
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: Located e -> SDoc #
Outputable a => Outputable (UniqDSet a)
Instance details Defined in GHC.Types.Unique.DSet Methods ppr :: UniqDSet a -> SDoc #
Outputable a => Outputable (Edit a)
Instance details Defined in GHC.Types.Unique.FM Methods ppr :: Edit a -> SDoc #
Outputable a => Outputable (UniqSet a)
Instance details Defined in GHC.Types.Unique.Set Methods ppr :: UniqSet a -> SDoc #
Outputable (UnitEnvGraph HomeUnitEnv)
Instance details Defined in GHC.Unit.Env Methods ppr :: UnitEnvGraph HomeUnitEnv -> SDoc #
Outputable elt => Outputable (InstalledModuleEnv elt)
Instance details Defined in GHC.Unit.Module.Env Methods ppr :: InstalledModuleEnv elt -> SDoc #
Outputable a => Outputable (ModuleEnv a)
Instance details Defined in GHC.Unit.Module.Env Methods ppr :: ModuleEnv a -> SDoc #
Outputable (WarningTxt pass)
Instance details Defined in GHC.Unit.Module.Warnings Methods ppr :: WarningTxt pass -> SDoc #
Outputable u => Outputable (UnitDatabase u)
Instance details Defined in GHC.Unit.State Methods ppr :: UnitDatabase u -> SDoc #
Outputable unit => Outputable (Definite unit)
Instance details Defined in GHC.Unit.Types Methods ppr :: Definite unit -> SDoc #
Outputable a => Outputable (GenWithIsBoot a)
Instance details Defined in GHC.Unit.Types Methods ppr :: GenWithIsBoot a -> SDoc #
Outputable a => Outputable (NonEmpty a)
Instance details Defined in GHC.Utils.Outputable Methods ppr :: NonEmpty a -> SDoc #
Outputable a => Outputable (HashSet a) Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Misc Methods ppr :: HashSet a -> SDoc #
Outputable a => Outputable (Maybe a)
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Maybe a -> SDoc #
Outputable a => Outputable [a]
Instance details Defined in GHC.Utils.Outputable Methods ppr :: [a] -> SDoc #
(Outputable a, Outputable b) => Outputable (Arg a b)
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Arg a b -> SDoc #
(Outputable key, Outputable elt) => Outputable (Map key elt)
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Map key elt -> SDoc #
(OutputableP Platform statics, OutputableP Platform instr) => Outputable (RegAllocStats statics instr)
Instance details Defined in GHC.CmmToAsm.Reg.Graph.Stats Methods ppr :: RegAllocStats statics instr -> SDoc #
(Outputable a, Outputable b) => Outputable (Node a b)
Instance details Defined in GHC.Data.Graph.Directed Methods ppr :: Node a b -> SDoc #
(Outputable a, Outputable (m a)) => Outputable (GenMap m a)
Instance details Defined in GHC.Data.TrieMap Methods ppr :: GenMap m a -> SDoc #
(TrieMap m, Outputable a) => Outputable (ListMap m a)
Instance details Defined in GHC.Data.TrieMap Methods ppr :: ListMap m a -> SDoc #
Outputable a => Outputable (WithHsDocIdentifiers a pass)	For compatibility with the existing @-ddump-parsed' output, we only show the docstring. Use `pprHsDoc` to show `HsDoc`'s internals.
Instance details Defined in GHC.Hs.Doc Methods ppr :: WithHsDocIdentifiers a pass -> SDoc #
(Outputable a, Outputable b) => Outputable (HsPatExpansion a b)
Instance details Defined in GHC.Hs.Pat Methods ppr :: HsPatExpansion a b -> SDoc #
(Outputable r, Outputable b) => Outputable (IfaceBindingX r b)
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceBindingX r b -> SDoc #
(Outputable a, Outputable b) => Outputable (PuResult a b)
Instance details Defined in GHC.Tc.Utils.Unify Methods ppr :: PuResult a b -> SDoc #
(Outputable a, Outputable e) => Outputable (GenLocated (EpAnn a) e)
Instance details Defined in GHC.Parser.Annotation Methods ppr :: GenLocated (EpAnn a) e -> SDoc #
Outputable e => Outputable (GenLocated EpaLocation e)
Instance details Defined in GHC.Parser.Annotation Methods ppr :: GenLocated EpaLocation e -> SDoc #
Outputable a => Outputable (GenLocated TokenLocation a)
Instance details Defined in GHC.Parser.Annotation Methods ppr :: GenLocated TokenLocation a -> SDoc #
Outputable (GenLocated NoCommentsLocation EpaComment)
Instance details Defined in GHC.Parser.Annotation Methods ppr :: GenLocated NoCommentsLocation EpaComment -> SDoc #
Outputable e => Outputable (GenLocated RealSrcSpan e)
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: GenLocated RealSrcSpan e -> SDoc #
(Outputable k, Outputable a) => Outputable (UniqMap k a)
Instance details Defined in GHC.Types.Unique.Map Methods ppr :: UniqMap k a -> SDoc #
(Outputable key, Outputable ele) => Outputable (Shared key ele)
Instance details Defined in GHC.Types.Unique.SDFM Methods ppr :: Shared key ele -> SDoc #
(Outputable key, Outputable ele) => Outputable (UniqSDFM key ele)
Instance details Defined in GHC.Types.Unique.SDFM Methods ppr :: UniqSDFM key ele -> SDoc #
OutputableBndr tv => Outputable (VarBndr tv TyConBndrVis)
Instance details Defined in GHC.Core.TyCon Methods ppr :: VarBndr tv TyConBndrVis -> SDoc #
Outputable tv => Outputable (VarBndr tv ForAllTyFlag)
Instance details Defined in GHC.Types.Var Methods ppr :: VarBndr tv ForAllTyFlag -> SDoc #
Outputable tv => Outputable (VarBndr tv Specificity)
Instance details Defined in GHC.Types.Var Methods ppr :: VarBndr tv Specificity -> SDoc #
(Outputable a, Outputable b) => Outputable (Either a b)
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Either a b -> SDoc #
(Outputable a, Outputable b) => Outputable (a, b)
Instance details Defined in GHC.Utils.Outputable Methods ppr :: (a, b) -> SDoc #
Outputable a => Outputable (UniqDFM key a)
Instance details Defined in GHC.Types.Unique.DFM Methods ppr :: UniqDFM key a -> SDoc #
Outputable a => Outputable (UniqFM key a)
Instance details Defined in GHC.Types.Unique.FM Methods ppr :: UniqFM key a -> SDoc #
(Outputable a, Outputable b, Outputable c) => Outputable (a, b, c)
Instance details Defined in GHC.Utils.Outputable Methods ppr :: (a, b, c) -> SDoc #
(Outputable a, Outputable b, Outputable c, Outputable d) => Outputable (a, b, c, d)
Instance details Defined in GHC.Utils.Outputable Methods ppr :: (a, b, c, d) -> SDoc #
(Outputable a, Outputable b, Outputable c, Outputable d, Outputable e) => Outputable (a, b, c, d, e)
Instance details Defined in GHC.Utils.Outputable Methods ppr :: (a, b, c, d, e) -> SDoc #
(Outputable a, Outputable b, Outputable c, Outputable d, Outputable e, Outputable f) => Outputable (a, b, c, d, e, f)
Instance details Defined in GHC.Utils.Outputable Methods ppr :: (a, b, c, d, e, f) -> SDoc #
(Outputable a, Outputable b, Outputable c, Outputable d, Outputable e, Outputable f, Outputable g) => Outputable (a, b, c, d, e, f, g)
Instance details Defined in GHC.Utils.Outputable Methods ppr :: (a, b, c, d, e, f, g) -> SDoc #

data GhcException #

GHC's own exception type error messages all take the form:

     <location>: <error>

If the location is on the command line, or in GHC itself, then <location>="ghc". All of the error types below correspond to a <location> of "ghc", except for ProgramError (where the string is assumed to contain a location already, so we don't print one).

Constructors

CmdLineError String	A problem with the command line arguments, but don't print usage.
ProgramError String	An error in the user's code, probably.

Instances

Instances details

Exception GhcException
Instance details Defined in GHC.Utils.Panic Methods toException :: GhcException -> SomeException # fromException :: SomeException -> Maybe GhcException # displayException :: GhcException -> String # backtraceDesired :: GhcException -> Bool #
Show GhcException
Instance details Defined in GHC.Utils.Panic Methods showsPrec :: Int -> GhcException -> ShowS # show :: GhcException -> String # showList :: [GhcException] -> ShowS #

data SDoc #

Represents a pretty-printable document.

To display an SDoc, use printSDoc, printSDocLn, bufLeftRenderSDoc, or renderWithContext. Avoid calling runSDoc directly as it breaks the abstraction layer.

Instances

Instances details

JsRender SDoc

Instance details

Defined in GHC.JS.Ppr

Methods

(<+?>) :: SDoc -> SDoc -> SDoc #

($$$) :: SDoc -> SDoc -> SDoc #

jcat :: [SDoc] -> SDoc #

jnest :: SDoc -> SDoc #

addSemi :: SDoc -> SDoc #

IsDoc SDoc

Instance details

Defined in GHC.Utils.Outputable

Associated Types

type Line SDoc
Instance details Defined in GHC.Utils.Outputable type Line SDoc = SDoc

Methods

line :: Line SDoc -> SDoc #

($$) :: SDoc -> SDoc -> SDoc #

lines_ :: [Line SDoc] -> SDoc #

vcat :: [SDoc] -> SDoc #

dualDoc :: SDoc -> HDoc -> SDoc #

IsLine SDoc

Instance details

Defined in GHC.Utils.Outputable

Methods

char :: Char -> SDoc #

text :: String -> SDoc #

ftext :: FastString -> SDoc #

ztext :: FastZString -> SDoc #

(<>) :: SDoc -> SDoc -> SDoc #

(<+>) :: SDoc -> SDoc -> SDoc #

sep :: [SDoc] -> SDoc #

fsep :: [SDoc] -> SDoc #

hcat :: [SDoc] -> SDoc #

hsep :: [SDoc] -> SDoc #

dualLine :: SDoc -> HLine -> SDoc #

IsOutput SDoc

Instance details

Defined in GHC.Utils.Outputable

Methods

empty :: SDoc #

docWithContext :: (SDocContext -> SDoc) -> SDoc #

docWithStyle :: SDoc -> (PprStyle -> SDoc) -> SDoc #

Outputable SDoc

Instance details

Defined in GHC.Utils.Outputable

Methods

ppr :: SDoc -> SDoc #

IsString SDoc

Instance details

Defined in GHC.Utils.Outputable

Methods

fromString :: String -> SDoc #

OutputableP env SDoc

Instance details

Defined in GHC.Utils.Outputable

Methods

pdoc :: env -> SDoc -> SDoc #

type Line SDoc

Instance details

Defined in GHC.Utils.Outputable

type Line SDoc = SDoc

data Annotation #

Represents an annotation after it has been sufficiently desugared from it's initial form of AnnDecl

Constructors

Annotation
Fields ann_target :: CoreAnnTarget The target of the annotation ann_value :: AnnPayload

Instances

Instances details

Outputable Annotation
Instance details Defined in GHC.Types.Annotations Methods ppr :: Annotation -> SDoc #

data HsExpr p #

A Haskell expression.

Constructors

HsVar (XVar p) (LIdP p)

Variable See Note [Located RdrNames]

HsOverLit (XOverLitE p) (HsOverLit p)

Overloaded literals

ExprWithTySig (XExprWithTySig p) (LHsExpr p) (LHsSigWcType (NoGhcTc p))

Expression with an explicit type signature. e :: type

AnnKeywordId : AnnDcolon

Instances

Instances details

HiePass p => HasType (LocatedA (HsExpr (GhcPass p)))

This instance tries to construct HieAST nodes which include the type of the expression. It is not yet possible to do this efficiently for all expression forms, so we skip filling in the type for those inputs.

See Note [Computing the type of every node in the tree]

Instance details

Defined in GHC.Iface.Ext.Ast

Methods

getTypeNode :: LocatedA (HsExpr (GhcPass p)) -> HieM [HieAST Type]

HiePass p => ToHie (LocatedA (HsExpr (GhcPass p)))

Instance details

Defined in GHC.Iface.Ext.Ast

Methods

toHie :: LocatedA (HsExpr (GhcPass p)) -> HieM [HieAST Type]

DisambECP (HsExpr GhcPs)

Instance details

Defined in GHC.Parser.PostProcess

Associated Types

type Body (HsExpr GhcPs)
Instance details Defined in GHC.Parser.PostProcess type Body (HsExpr GhcPs) = HsExpr
type InfixOp (HsExpr GhcPs)
Instance details Defined in GHC.Parser.PostProcess type InfixOp (HsExpr GhcPs) = HsExpr GhcPs
type FunArg (HsExpr GhcPs)
Instance details Defined in GHC.Parser.PostProcess type FunArg (HsExpr GhcPs) = HsExpr GhcPs

Methods

ecpFromCmd' :: LHsCmd GhcPs -> PV (LocatedA (HsExpr GhcPs)) #

ecpFromExp' :: LHsExpr GhcPs -> PV (LocatedA (HsExpr GhcPs)) #

mkHsProjUpdatePV :: SrcSpan -> Located [LocatedAn NoEpAnns (DotFieldOcc GhcPs)] -> LocatedA (HsExpr GhcPs) -> Bool -> [AddEpAnn] -> PV (LHsRecProj GhcPs (LocatedA (HsExpr GhcPs))) #

mkHsLetPV :: SrcSpan -> EpToken "let" -> HsLocalBinds GhcPs -> EpToken "in" -> LocatedA (HsExpr GhcPs) -> PV (LocatedA (HsExpr GhcPs)) #

superInfixOp :: (DisambInfixOp (InfixOp (HsExpr GhcPs)) => PV (LocatedA (HsExpr GhcPs))) -> PV (LocatedA (HsExpr GhcPs)) #

mkHsOpAppPV :: SrcSpan -> LocatedA (HsExpr GhcPs) -> LocatedN (InfixOp (HsExpr GhcPs)) -> LocatedA (HsExpr GhcPs) -> PV (LocatedA (HsExpr GhcPs)) #

mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> LocatedL [LMatch GhcPs (LocatedA (HsExpr GhcPs))] -> EpAnnHsCase -> PV (LocatedA (HsExpr GhcPs)) #

mkHsLamPV :: SrcSpan -> HsLamVariant -> LocatedL [LMatch GhcPs (LocatedA (HsExpr GhcPs))] -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) #

superFunArg :: (DisambECP (FunArg (HsExpr GhcPs)) => PV (LocatedA (HsExpr GhcPs))) -> PV (LocatedA (HsExpr GhcPs)) #

mkHsAppPV :: SrcSpanAnnA -> LocatedA (HsExpr GhcPs) -> LocatedA (FunArg (HsExpr GhcPs)) -> PV (LocatedA (HsExpr GhcPs)) #

mkHsAppTypePV :: SrcSpanAnnA -> LocatedA (HsExpr GhcPs) -> EpToken "@" -> LHsType GhcPs -> PV (LocatedA (HsExpr GhcPs)) #

mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> LocatedA (HsExpr GhcPs) -> Bool -> LocatedA (HsExpr GhcPs) -> AnnsIf -> PV (LocatedA (HsExpr GhcPs)) #

mkHsDoPV :: SrcSpan -> Maybe ModuleName -> LocatedL [LStmt GhcPs (LocatedA (HsExpr GhcPs))] -> AnnList -> PV (LocatedA (HsExpr GhcPs)) #

mkHsParPV :: SrcSpan -> EpToken "(" -> LocatedA (HsExpr GhcPs) -> EpToken ")" -> PV (LocatedA (HsExpr GhcPs)) #

mkHsVarPV :: LocatedN RdrName -> PV (LocatedA (HsExpr GhcPs)) #

mkHsLitPV :: Located (HsLit GhcPs) -> PV (LocatedA (HsExpr GhcPs)) #

mkHsOverLitPV :: LocatedAn a (HsOverLit GhcPs) -> PV (LocatedAn a (HsExpr GhcPs)) #

mkHsWildCardPV :: NoAnn a => SrcSpan -> PV (LocatedAn a (HsExpr GhcPs)) #

mkHsTySigPV :: SrcSpanAnnA -> LocatedA (HsExpr GhcPs) -> LHsType GhcPs -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) #

mkHsExplicitListPV :: SrcSpan -> [LocatedA (HsExpr GhcPs)] -> AnnList -> PV (LocatedA (HsExpr GhcPs)) #

mkHsSplicePV :: Located (HsUntypedSplice GhcPs) -> PV (LocatedA (HsExpr GhcPs)) #

mkHsRecordPV :: Bool -> SrcSpan -> SrcSpan -> LocatedA (HsExpr GhcPs) -> ([Fbind (HsExpr GhcPs)], Maybe SrcSpan) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) #

mkHsNegAppPV :: SrcSpan -> LocatedA (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) #

mkHsSectionR_PV :: SrcSpan -> LocatedA (InfixOp (HsExpr GhcPs)) -> LocatedA (HsExpr GhcPs) -> PV (LocatedA (HsExpr GhcPs)) #

mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> LocatedA (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) #

mkHsAsPatPV :: SrcSpan -> LocatedN RdrName -> EpToken "@" -> LocatedA (HsExpr GhcPs) -> PV (LocatedA (HsExpr GhcPs)) #

mkHsLazyPatPV :: SrcSpan -> LocatedA (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) #

mkHsBangPatPV :: SrcSpan -> LocatedA (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) #

mkSumOrTuplePV :: SrcSpanAnnA -> Boxity -> SumOrTuple (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) #

mkHsEmbTyPV :: SrcSpan -> EpToken "type" -> LHsType GhcPs -> PV (LocatedA (HsExpr GhcPs)) #

rejectPragmaPV :: LocatedA (HsExpr GhcPs) -> PV () #

DisambInfixOp (HsExpr GhcPs)

Instance details

Defined in GHC.Parser.PostProcess

Methods

mkHsVarOpPV :: LocatedN RdrName -> PV (LocatedN (HsExpr GhcPs)) #

mkHsConOpPV :: LocatedN RdrName -> PV (LocatedN (HsExpr GhcPs)) #

mkHsInfixHolePV :: LocatedN (HsExpr GhcPs) -> PV (LocatedN (HsExpr GhcPs)) #

type Body (HsExpr GhcPs)

Instance details

Defined in GHC.Parser.PostProcess

type Body (HsExpr GhcPs) = HsExpr

type FunArg (HsExpr GhcPs)

Instance details

Defined in GHC.Parser.PostProcess

type FunArg (HsExpr GhcPs) = HsExpr GhcPs

type InfixOp (HsExpr GhcPs)

Instance details

Defined in GHC.Parser.PostProcess

type InfixOp (HsExpr GhcPs) = HsExpr GhcPs

type Anno (HsExpr (GhcPass p))

Instance details

Defined in GHC.Hs.Expr

type Anno (HsExpr (GhcPass p)) = SrcSpanAnnA

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))]

Instance details

Defined in GHC.Hs.Expr

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))]

Instance details

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))] = SrcSpanAnnL

type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p))))

Instance details

Defined in GHC.Hs.Expr

type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = EpAnnCO

type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))

Instance details

Defined in GHC.Hs.Expr

type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpanAnnA

data RdrName #

Reader Name

Do not use the data constructors of RdrName directly: prefer the family of functions that creates them, such as mkRdrUnqual

Note: A Located RdrName will only have API Annotations if it is a compound one, e.g.

`bar`
( ~ )

AnnKeywordId : AnnType, AnnOpen '(' or '[' or '[:', AnnClose ')' or ']' or ':]',, AnnBackquote '`', AnnVal AnnTilde,

Instances

Instances details

DisambInfixOp RdrName
Instance details Defined in GHC.Parser.PostProcess Methods mkHsVarOpPV :: LocatedN RdrName -> PV (LocatedN RdrName) # mkHsConOpPV :: LocatedN RdrName -> PV (LocatedN RdrName) # mkHsInfixHolePV :: LocatedN (HsExpr GhcPs) -> PV (LocatedN RdrName) #
HasOccName RdrName
Instance details Defined in GHC.Types.Name.Reader Methods occName :: RdrName -> OccName #
Outputable RdrName
Instance details Defined in GHC.Types.Name.Reader Methods ppr :: RdrName -> SDoc #
OutputableBndr RdrName
Instance details Defined in GHC.Types.Name.Reader Methods pprBndr :: BindingSite -> RdrName -> SDoc # pprPrefixOcc :: RdrName -> SDoc # pprInfixOcc :: RdrName -> SDoc # bndrIsJoin_maybe :: RdrName -> JoinPointHood #
Data RdrName
Instance details Defined in GHC.Types.Name.Reader Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RdrName -> c RdrName # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RdrName # toConstr :: RdrName -> Constr # dataTypeOf :: RdrName -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RdrName) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RdrName) # gmapT :: (forall b. Data b => b -> b) -> RdrName -> RdrName # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RdrName -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RdrName -> r # gmapQ :: (forall d. Data d => d -> u) -> RdrName -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RdrName -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RdrName -> m RdrName # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RdrName -> m RdrName # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RdrName -> m RdrName #
Eq RdrName
Instance details Defined in GHC.Types.Name.Reader Methods (==) :: RdrName -> RdrName -> Bool # (/=) :: RdrName -> RdrName -> Bool #
Ord RdrName
Instance details Defined in GHC.Types.Name.Reader Methods compare :: RdrName -> RdrName -> Ordering # (<) :: RdrName -> RdrName -> Bool # (<=) :: RdrName -> RdrName -> Bool # (>) :: RdrName -> RdrName -> Bool # (>=) :: RdrName -> RdrName -> Bool # max :: RdrName -> RdrName -> RdrName # min :: RdrName -> RdrName -> RdrName #
type Anno RdrName
Instance details Defined in GHC.Hs.Extension type Anno RdrName = SrcSpanAnnN

type Id = Var #

Identifier

mkCoreApps infixl 4 #

Arguments

:: CoreExpr	function
-> [CoreExpr]	arguments
-> CoreExpr

Construct an expression which represents the application of a number of expressions to another. The leftmost expression in the list is applied first

mkCoreConApps :: DataCon -> [CoreExpr] -> CoreExpr #

Construct an expression which represents the application of a number of expressions to that of a data constructor expression. The leftmost expression in the list is applied first

mkCoreLams :: [CoreBndr] -> CoreExpr -> CoreExpr #

Create a lambda where the given expression has a number of variables bound over it. The leftmost binder is that bound by the outermost lambda in the result

mkCoreLets :: [CoreBind] -> CoreExpr -> CoreExpr #

Bind a list of binding groups over an expression. The leftmost binding group becomes the outermost group in the resulting expression

data AltCon #

A case alternative constructor (i.e. pattern match)

Constructors

DataAlt DataCon
LitAlt Literal	A literal: `case e of { 1 -> ... }` Invariant: always an unlifted literal See Note [Literal alternatives]
DEFAULT	Trivial alternative: `case e of { _ -> ... }`

Instances

Instances details

Outputable AltCon
Instance details Defined in GHC.Core Methods ppr :: AltCon -> SDoc #
Data AltCon
Instance details Defined in GHC.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AltCon -> c AltCon # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AltCon # toConstr :: AltCon -> Constr # dataTypeOf :: AltCon -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AltCon) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AltCon) # gmapT :: (forall b. Data b => b -> b) -> AltCon -> AltCon # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AltCon -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AltCon -> r # gmapQ :: (forall d. Data d => d -> u) -> AltCon -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AltCon -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AltCon -> m AltCon # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AltCon -> m AltCon # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AltCon -> m AltCon #
Eq AltCon
Instance details Defined in GHC.Core Methods (==) :: AltCon -> AltCon -> Bool # (/=) :: AltCon -> AltCon -> Bool #
Ord AltCon
Instance details Defined in GHC.Core Methods compare :: AltCon -> AltCon -> Ordering # (<) :: AltCon -> AltCon -> Bool # (<=) :: AltCon -> AltCon -> Bool # (>) :: AltCon -> AltCon -> Bool # (>=) :: AltCon -> AltCon -> Bool # max :: AltCon -> AltCon -> AltCon # min :: AltCon -> AltCon -> AltCon #
CBVisitable AltCon Source #
Instance details Defined in Language.Haskell.Liquid.Types.Visitors Methods freeVars :: HashSet Var -> AltCon -> [Var] Source # readVars :: AltCon -> [Var] Source # letVars :: AltCon -> [Var] Source # literals :: AltCon -> [Literal] Source #

mkApps :: Expr b -> [Arg b] -> Expr b infixl 4 #

Apply a list of argument expressions to a function expression in a nested fashion. Prefer to use mkCoreApps if possible

data GenTickish (pass :: TickishPass) #

Constructors

ProfNote	An `{-# SCC #-}` profiling annotation, either automatically added by the desugarer as a result of -auto-all, or added by the user.
Fields profNoteCC :: CostCentre the cost centre profNoteCount :: !Bool bump the entry count? profNoteScope :: !Bool scopes over the enclosed expression (i.e. not just a tick)
HpcTick	A "tick" used by HPC to track the execution of each subexpression in the original source code.
Fields tickModule :: Module tickId :: !Int
Breakpoint	A breakpoint for the GHCi debugger. This behaves like an HPC tick, but has a list of free variables which will be available for inspection in GHCi when the program stops at the breakpoint. NB. we must take account of these Ids when (a) counting free variables, and (b) substituting (don't substitute for them)
Fields breakpointExt :: XBreakpoint pass breakpointId :: !Int breakpointFVs :: [XTickishId pass] the order of this list is important: it matches the order of the lists in the appropriate entry in `ModBreaks`. Careful about substitution! See Note [substTickish] in GHC.Core.Subst. breakpointModule :: Module
SourceNote	A source note. Source notes are pure annotations: Their presence should neither influence compilation nor execution. The semantics are given by causality: The presence of a source note means that a local change in the referenced source code span will possibly provoke the generated code to change. On the flip-side, the functionality of annotated code must be invariant against changes to all source code except the spans referenced in the source notes (see "Causality of optimized Haskell" paper for details). Therefore extending the scope of any given source note is always valid. Note that it is still undesirable though, as this reduces their usefulness for debugging and profiling. Therefore we will generally try only to make use of this property where it is necessary to enable optimizations.
Fields sourceSpan :: RealSrcSpan Source covered sourceName :: LexicalFastString Name for source location (uses same names as CCs)

Instances

Instances details

Data (GenTickish 'TickishPassCmm)
Instance details Defined in GHC.Types.Tickish Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GenTickish 'TickishPassCmm -> c (GenTickish 'TickishPassCmm) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GenTickish 'TickishPassCmm) # toConstr :: GenTickish 'TickishPassCmm -> Constr # dataTypeOf :: GenTickish 'TickishPassCmm -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GenTickish 'TickishPassCmm)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GenTickish 'TickishPassCmm)) # gmapT :: (forall b. Data b => b -> b) -> GenTickish 'TickishPassCmm -> GenTickish 'TickishPassCmm # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GenTickish 'TickishPassCmm -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GenTickish 'TickishPassCmm -> r # gmapQ :: (forall d. Data d => d -> u) -> GenTickish 'TickishPassCmm -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> GenTickish 'TickishPassCmm -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> GenTickish 'TickishPassCmm -> m (GenTickish 'TickishPassCmm) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GenTickish 'TickishPassCmm -> m (GenTickish 'TickishPassCmm) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GenTickish 'TickishPassCmm -> m (GenTickish 'TickishPassCmm) #
Data (GenTickish 'TickishPassCore)
Instance details Defined in GHC.Types.Tickish Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GenTickish 'TickishPassCore -> c (GenTickish 'TickishPassCore) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GenTickish 'TickishPassCore) # toConstr :: GenTickish 'TickishPassCore -> Constr # dataTypeOf :: GenTickish 'TickishPassCore -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GenTickish 'TickishPassCore)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GenTickish 'TickishPassCore)) # gmapT :: (forall b. Data b => b -> b) -> GenTickish 'TickishPassCore -> GenTickish 'TickishPassCore # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GenTickish 'TickishPassCore -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GenTickish 'TickishPassCore -> r # gmapQ :: (forall d. Data d => d -> u) -> GenTickish 'TickishPassCore -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> GenTickish 'TickishPassCore -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> GenTickish 'TickishPassCore -> m (GenTickish 'TickishPassCore) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GenTickish 'TickishPassCore -> m (GenTickish 'TickishPassCore) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GenTickish 'TickishPassCore -> m (GenTickish 'TickishPassCore) #
Data (GenTickish 'TickishPassStg)
Instance details Defined in GHC.Types.Tickish Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GenTickish 'TickishPassStg -> c (GenTickish 'TickishPassStg) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GenTickish 'TickishPassStg) # toConstr :: GenTickish 'TickishPassStg -> Constr # dataTypeOf :: GenTickish 'TickishPassStg -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GenTickish 'TickishPassStg)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GenTickish 'TickishPassStg)) # gmapT :: (forall b. Data b => b -> b) -> GenTickish 'TickishPassStg -> GenTickish 'TickishPassStg # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GenTickish 'TickishPassStg -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GenTickish 'TickishPassStg -> r # gmapQ :: (forall d. Data d => d -> u) -> GenTickish 'TickishPassStg -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> GenTickish 'TickishPassStg -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> GenTickish 'TickishPassStg -> m (GenTickish 'TickishPassStg) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GenTickish 'TickishPassStg -> m (GenTickish 'TickishPassStg) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GenTickish 'TickishPassStg -> m (GenTickish 'TickishPassStg) #
Eq (GenTickish 'TickishPassCmm)
Instance details Defined in GHC.Types.Tickish Methods (==) :: GenTickish 'TickishPassCmm -> GenTickish 'TickishPassCmm -> Bool # (/=) :: GenTickish 'TickishPassCmm -> GenTickish 'TickishPassCmm -> Bool #
Eq (GenTickish 'TickishPassCore)
Instance details Defined in GHC.Types.Tickish Methods (==) :: GenTickish 'TickishPassCore -> GenTickish 'TickishPassCore -> Bool # (/=) :: GenTickish 'TickishPassCore -> GenTickish 'TickishPassCore -> Bool #
Ord (GenTickish 'TickishPassCmm)
Instance details Defined in GHC.Types.Tickish Methods compare :: GenTickish 'TickishPassCmm -> GenTickish 'TickishPassCmm -> Ordering # (<) :: GenTickish 'TickishPassCmm -> GenTickish 'TickishPassCmm -> Bool # (<=) :: GenTickish 'TickishPassCmm -> GenTickish 'TickishPassCmm -> Bool # (>) :: GenTickish 'TickishPassCmm -> GenTickish 'TickishPassCmm -> Bool # (>=) :: GenTickish 'TickishPassCmm -> GenTickish 'TickishPassCmm -> Bool # max :: GenTickish 'TickishPassCmm -> GenTickish 'TickishPassCmm -> GenTickish 'TickishPassCmm # min :: GenTickish 'TickishPassCmm -> GenTickish 'TickishPassCmm -> GenTickish 'TickishPassCmm #
Ord (GenTickish 'TickishPassCore)
Instance details Defined in GHC.Types.Tickish Methods compare :: GenTickish 'TickishPassCore -> GenTickish 'TickishPassCore -> Ordering # (<) :: GenTickish 'TickishPassCore -> GenTickish 'TickishPassCore -> Bool # (<=) :: GenTickish 'TickishPassCore -> GenTickish 'TickishPassCore -> Bool # (>) :: GenTickish 'TickishPassCore -> GenTickish 'TickishPassCore -> Bool # (>=) :: GenTickish 'TickishPassCore -> GenTickish 'TickishPassCore -> Bool # max :: GenTickish 'TickishPassCore -> GenTickish 'TickishPassCore -> GenTickish 'TickishPassCore # min :: GenTickish 'TickishPassCore -> GenTickish 'TickishPassCore -> GenTickish 'TickishPassCore #

expandTypeSynonyms :: Type -> Type #

Expand out all type synonyms. Actually, it'd suffice to expand out just the ones that discard type variables (e.g. type Funny a = Int) But we don't know which those are currently, so we just expand all.

expandTypeSynonyms only expands out type synonyms mentioned in the type, not in the kinds of any TyCon or TyVar mentioned in the type.

Keep this synchronized with synonymTyConsOfType

data Session #

The Session is a handle to the complete state of a compilation session. A compilation session consists of a set of modules constituting the current program or library, the context for interactive evaluation, and various caches.

Constructors

Session !(IORef HscEnv)

data TcGblEnv #

TcGblEnv describes the top-level of the module at the point at which the typechecker is finished work. It is this structure that is handed on to the desugarer For state that needs to be updated during the typechecking phase and returned at end, use a TcRef (= IORef).

Instances

Instances details

ContainsModule TcGblEnv
Instance details Defined in GHC.Tc.Types Methods extractModule :: TcGblEnv -> Module #

simplifyInfer :: TcLevel -> InferMode -> [TcIdSigInst] -> [(Name, TcTauType)] -> WantedConstraints -> TcM ([TcTyVar], [EvVar], TcEvBinds, Bool) #

data DynFlags #

Contains not only a collection of GeneralFlags but also a plethora of information relating to the compilation of a single file or GHC session

data SourceError #

A source error is an error that is caused by one or more errors in the source code. A SourceError is thrown by many functions in the compilation pipeline. Inside GHC these errors are merely printed via log_action, but API clients may treat them differently, for example, insert them into a list box. If you want the default behaviour, use the idiom:

handleSourceError printExceptionAndWarnings $ do
  ... api calls that may fail ...

The SourceErrors error messages can be accessed via srcErrorMessages. This list may be empty if the compiler failed due to -Werror (Opt_WarnIsError).

See printExceptionAndWarnings for more information on what to take care of when writing a custom error handler.

Instances

Instances details

Exception SourceError
Instance details Defined in GHC.Types.SourceError Methods toException :: SourceError -> SomeException # fromException :: SomeException -> Maybe SourceError # displayException :: SourceError -> String # backtraceDesired :: SourceError -> Bool #
Show SourceError
Instance details Defined in GHC.Types.SourceError Methods showsPrec :: Int -> SourceError -> ShowS # show :: SourceError -> String # showList :: [SourceError] -> ShowS #
PPrint SourceError Source #	A whole bunch of PPrint instances follow ----------------------------------
Instance details Defined in Language.Haskell.Liquid.Types.PrettyPrint Methods pprintTidy :: Tidy -> SourceError -> Doc # pprintPrec :: Int -> Tidy -> SourceError -> Doc #
Result SourceError Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Interface Methods result :: SourceError -> FixResult UserError Source #

data Plugin #

Plugin is the compiler plugin data type. Try to avoid constructing one of these directly, and just modify some fields of defaultPlugin instead: this is to try and preserve source-code compatibility when we add fields to this.

Nonetheless, this API is preliminary and highly likely to change in the future.

Constructors

Plugin

Fields

installCoreToDos :: CorePlugin
Modify the Core pipeline that will be used for compilation. This is called as the Core pipeline is built for every module being compiled, and plugins get the opportunity to modify the pipeline in a nondeterministic order.
tcPlugin :: TcPlugin
An optional typechecker plugin, which may modify the behaviour of the constraint solver.
defaultingPlugin :: DefaultingPlugin
An optional defaulting plugin, which may specify the additional type-defaulting rules.
holeFitPlugin :: HoleFitPlugin
An optional plugin to handle hole fits, which may re-order or change the list of valid hole fits and refinement hole fits.
driverPlugin :: [CommandLineOption] -> HscEnv -> IO HscEnv
An optional plugin to update HscEnv, right after plugin loading. This can be used to register hooks or tweak any field of DynFlags before doing actual work on a module.
Since: ghc-8.10.1
latePlugin :: LatePlugin
A plugin that runs after interface creation and after late cost centre insertion. Useful for transformations that should not impact interfaces or optimization at all.
Since: ghc-9.10.1
pluginRecompile :: [CommandLineOption] -> IO PluginRecompile
Specify how the plugin should affect recompilation.
parsedResultAction :: [CommandLineOption] -> ModSummary -> ParsedResult -> Hsc ParsedResult
Modify the module when it is parsed. This is called by GHC.Driver.Main when the parser has produced no or only non-fatal errors. Compilation will fail if the messages produced by this function contain any errors.
renamedResultAction :: [CommandLineOption] -> TcGblEnv -> HsGroup GhcRn -> TcM (TcGblEnv, HsGroup GhcRn)
Modify each group after it is renamed. This is called after each HsGroup has been renamed.
typeCheckResultAction :: [CommandLineOption] -> ModSummary -> TcGblEnv -> TcM TcGblEnv
Modify the module when it is type checked. This is called at the very end of typechecking.
spliceRunAction :: [CommandLineOption] -> LHsExpr GhcTc -> TcM (LHsExpr GhcTc)
Modify the TH splice or quasiqoute before it is run.
interfaceLoadAction :: forall lcl. [CommandLineOption] -> ModIface -> IfM lcl ModIface
Modify an interface that have been loaded. This is called by GHC.Iface.Load when an interface is successfully loaded. Not applied to the loading of the plugin interface. Tools that rely on information from modules other than the currently compiled one should implement this function.

panic :: HasCallStack => String -> a #

Panics and asserts.

data FastString #

A FastString is a UTF-8 encoded string together with a unique ID. All FastStrings are stored in a global hashtable to support fast O(1) comparison.

It is also associated with a lazy reference to the Z-encoding of this string which is used by the compiler internally.

Instances

Instances details

NFData FastString
Instance details Defined in GHC.Data.FastString Methods rnf :: FastString -> () #
ToJExpr FastString
Instance details Defined in GHC.JS.Make Methods toJExpr :: FastString -> JStgExpr # toJExprFromList :: [FastString] -> JStgExpr #
Uniquable FastString
Instance details Defined in GHC.Types.Unique Methods getUnique :: FastString -> Unique #
Binary FastString
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> FastString -> IO () # put :: BinHandle -> FastString -> IO (Bin FastString) # get :: BinHandle -> IO FastString #
Outputable FastString
Instance details Defined in GHC.Utils.Outputable Methods ppr :: FastString -> SDoc #
Monoid FastString
Instance details Defined in GHC.Data.FastString Methods mempty :: FastString # mappend :: FastString -> FastString -> FastString # mconcat :: [FastString] -> FastString #
Semigroup FastString
Instance details Defined in GHC.Data.FastString Methods (<>) :: FastString -> FastString -> FastString # sconcat :: NonEmpty FastString -> FastString # stimes :: Integral b => b -> FastString -> FastString #
Data FastString
Instance details Defined in GHC.Data.FastString Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FastString -> c FastString # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FastString # toConstr :: FastString -> Constr # dataTypeOf :: FastString -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FastString) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FastString) # gmapT :: (forall b. Data b => b -> b) -> FastString -> FastString # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FastString -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FastString -> r # gmapQ :: (forall d. Data d => d -> u) -> FastString -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FastString -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FastString -> m FastString # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FastString -> m FastString # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FastString -> m FastString #
IsString FastString
Instance details Defined in GHC.Data.FastString Methods fromString :: String -> FastString #
Show FastString
Instance details Defined in GHC.Data.FastString Methods showsPrec :: Int -> FastString -> ShowS # show :: FastString -> String # showList :: [FastString] -> ShowS #
Eq FastString
Instance details Defined in GHC.Data.FastString Methods (==) :: FastString -> FastString -> Bool # (/=) :: FastString -> FastString -> Bool #
Symbolic FastString Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Misc Methods symbol :: FastString -> Symbol #
ToJExpr a => ToJExpr (UniqMap FastString a)
Instance details Defined in GHC.JS.Make Methods toJExpr :: UniqMap FastString a -> JStgExpr # toJExprFromList :: [UniqMap FastString a] -> JStgExpr #
type Anno FastString
Instance details Defined in GHC.Hs.Expr type Anno FastString = EpAnnCO
type Anno (SourceText, RuleName)
Instance details Defined in GHC.Hs.Decls type Anno (SourceText, RuleName) = EpAnnCO

bytesFS :: FastString -> ByteString #

Gives the Modified UTF-8 encoded bytes corresponding to a FastString

lexicalCompareFS :: FastString -> FastString -> Ordering #

Compare FastString lexically

If you don't care about the lexical ordering, use uniqCompareFS instead.

mkFastStringByteString :: ByteString -> FastString #

Create a FastString by copying an existing ByteString

mkFastString :: String -> FastString #

Creates a UTF-8 encoded FastString from a String

unpackFS :: FastString -> String #

Lazily unpacks and decodes the FastString

concatFS :: [FastString] -> FastString #

mkPtrString# :: Addr# -> PtrString #

Wrap an unboxed address into a PtrString.

fsLit :: String -> FastString #

ptext :: PtrString -> SDoc #

semi :: IsLine doc => doc #

equals :: IsLine doc => doc #

lparen :: IsLine doc => doc #

rparen :: IsLine doc => doc #

lbrack :: IsLine doc => doc #

rbrack :: IsLine doc => doc #

lbrace :: IsLine doc => doc #

rbrace :: IsLine doc => doc #

quotes :: SDoc -> SDoc #

doubleQuotes :: IsLine doc => doc -> doc #

brackets :: IsLine doc => doc -> doc #

braces :: IsLine doc => doc -> doc #

nest :: Int -> SDoc -> SDoc #

Indent SDoc some specified amount

hang #

Arguments

:: SDoc	The header
-> Int	Amount to indent the hung body
-> SDoc	The hung body, indented and placed below the header
-> SDoc

hangNotEmpty :: SDoc -> Int -> SDoc -> SDoc #

This behaves like hang, but does not indent the second document when the header is empty.

punctuate #

Arguments

:: IsLine doc
=> doc	The punctuation
-> [doc]	The list that will have punctuation added between every adjacent pair of elements
-> [doc]	Punctuated list

($+$) :: SDoc -> SDoc -> SDoc #

Join two SDoc together vertically

cat :: [SDoc] -> SDoc #

A paragraph-fill combinator. It's much like sep, only it keeps fitting things on one line until it can't fit any more.

fcat :: [SDoc] -> SDoc #

This behaves like fsep, but it uses <> for horizontal composition rather than <+>

data Role #

See Note [Roles] in GHC.Core.Coercion

Order of constructors matters: the Ord instance coincides with the *super*typing relation on roles.

Instances

Instances details

Data Role
Instance details Defined in Language.Haskell.Syntax.Basic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Role -> c Role # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Role # toConstr :: Role -> Constr # dataTypeOf :: Role -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Role) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Role) # gmapT :: (forall b. Data b => b -> b) -> Role -> Role # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r # gmapQ :: (forall d. Data d => d -> u) -> Role -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Role -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Role -> m Role # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Role -> m Role # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Role -> m Role #
Eq Role
Instance details Defined in Language.Haskell.Syntax.Basic Methods (==) :: Role -> Role -> Bool # (/=) :: Role -> Role -> Bool #
Ord Role
Instance details Defined in Language.Haskell.Syntax.Basic Methods compare :: Role -> Role -> Ordering # (<) :: Role -> Role -> Bool # (<=) :: Role -> Role -> Bool # (>) :: Role -> Role -> Bool # (>=) :: Role -> Role -> Bool # max :: Role -> Role -> Role # min :: Role -> Role -> Role #
type Anno (Maybe Role)
Instance details Defined in GHC.Hs.Decls type Anno (Maybe Role) = EpAnnCO
type Anno (Maybe Role)
Instance details Defined in GHC.Hs.Decls type Anno (Maybe Role) = EpAnnCO

data Boxity #

Constructors

Boxed

Instances

Instances details

Data Boxity
Instance details Defined in Language.Haskell.Syntax.Basic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Boxity -> c Boxity # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Boxity # toConstr :: Boxity -> Constr # dataTypeOf :: Boxity -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Boxity) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Boxity) # gmapT :: (forall b. Data b => b -> b) -> Boxity -> Boxity # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Boxity -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Boxity -> r # gmapQ :: (forall d. Data d => d -> u) -> Boxity -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Boxity -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Boxity -> m Boxity # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Boxity -> m Boxity # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Boxity -> m Boxity #
Eq Boxity
Instance details Defined in Language.Haskell.Syntax.Basic Methods (==) :: Boxity -> Boxity -> Bool # (/=) :: Boxity -> Boxity -> Bool #

type family IdP p #

Maps the "normal" id type for a given pass

Instances

Instances details

type IdP (GhcPass p)
Instance details Defined in GHC.Hs.Extension type IdP (GhcPass p) = IdGhcP p

noExtField :: NoExtField #

Used when constructing a term with an unused extension point.

moduleNameFS :: ModuleName -> FastString #

moduleNameString :: ModuleName -> String #

mkModuleName :: String -> ModuleName #

mkModuleNameFS :: FastString -> ModuleName #

data OccName #

Occurrence Name

In this context that means: "classified (i.e. as a type name, value name, etc) but not qualified and not yet resolved"

Instances

Instances details

NFData OccName
Instance details Defined in GHC.Types.Name.Occurrence Methods rnf :: OccName -> () #
HasOccName OccName
Instance details Defined in GHC.Types.Name.Occurrence Methods occName :: OccName -> OccName #
Binary OccName
Instance details Defined in GHC.Types.Name.Occurrence Methods put_ :: BinHandle -> OccName -> IO () # put :: BinHandle -> OccName -> IO (Bin OccName) # get :: BinHandle -> IO OccName #
Outputable OccName
Instance details Defined in GHC.Types.Name.Occurrence Methods ppr :: OccName -> SDoc #
OutputableBndr OccName
Instance details Defined in GHC.Types.Name.Occurrence Methods pprBndr :: BindingSite -> OccName -> SDoc # pprPrefixOcc :: OccName -> SDoc # pprInfixOcc :: OccName -> SDoc # bndrIsJoin_maybe :: OccName -> JoinPointHood #
Data OccName
Instance details Defined in GHC.Types.Name.Occurrence Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OccName -> c OccName # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OccName # toConstr :: OccName -> Constr # dataTypeOf :: OccName -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OccName) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OccName) # gmapT :: (forall b. Data b => b -> b) -> OccName -> OccName # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OccName -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OccName -> r # gmapQ :: (forall d. Data d => d -> u) -> OccName -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> OccName -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> OccName -> m OccName # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OccName -> m OccName # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OccName -> m OccName #
Eq OccName
Instance details Defined in GHC.Types.Name.Occurrence Methods (==) :: OccName -> OccName -> Bool # (/=) :: OccName -> OccName -> Bool #
Ord OccName
Instance details Defined in GHC.Types.Name.Occurrence Methods compare :: OccName -> OccName -> Ordering # (<) :: OccName -> OccName -> Bool # (<=) :: OccName -> OccName -> Bool # (>) :: OccName -> OccName -> Bool # (>=) :: OccName -> OccName -> Bool # max :: OccName -> OccName -> OccName # min :: OccName -> OccName -> OccName #

mkVarOccFS :: FastString -> OccName #

data IsBootInterface #

Indicates whether a module name is referring to a boot interface (hs-boot file) or regular module (hs file). We need to treat boot modules specially when building compilation graphs, since they break cycles. Regular source files and signature files are treated equivalently.

Constructors

NotBoot
IsBoot

Instances

Instances details

Data IsBootInterface
Instance details Defined in Language.Haskell.Syntax.ImpExp Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IsBootInterface -> c IsBootInterface # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IsBootInterface # toConstr :: IsBootInterface -> Constr # dataTypeOf :: IsBootInterface -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c IsBootInterface) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IsBootInterface) # gmapT :: (forall b. Data b => b -> b) -> IsBootInterface -> IsBootInterface # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IsBootInterface -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IsBootInterface -> r # gmapQ :: (forall d. Data d => d -> u) -> IsBootInterface -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> IsBootInterface -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> IsBootInterface -> m IsBootInterface # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IsBootInterface -> m IsBootInterface # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IsBootInterface -> m IsBootInterface #
Show IsBootInterface
Instance details Defined in Language.Haskell.Syntax.ImpExp Methods showsPrec :: Int -> IsBootInterface -> ShowS # show :: IsBootInterface -> String # showList :: [IsBootInterface] -> ShowS #
Eq IsBootInterface
Instance details Defined in Language.Haskell.Syntax.ImpExp Methods (==) :: IsBootInterface -> IsBootInterface -> Bool # (/=) :: IsBootInterface -> IsBootInterface -> Bool #
Ord IsBootInterface
Instance details Defined in Language.Haskell.Syntax.ImpExp Methods compare :: IsBootInterface -> IsBootInterface -> Ordering # (<) :: IsBootInterface -> IsBootInterface -> Bool # (<=) :: IsBootInterface -> IsBootInterface -> Bool # (>) :: IsBootInterface -> IsBootInterface -> Bool # (>=) :: IsBootInterface -> IsBootInterface -> Bool # max :: IsBootInterface -> IsBootInterface -> IsBootInterface # min :: IsBootInterface -> IsBootInterface -> IsBootInterface #

data HDoc #

Represents a (possibly empty) sequence of lines that can be efficiently printed directly to a Handle (actually a BufHandle). See Note [SDoc versus HDoc] and Note [HLine versus HDoc] for more details.

Instances

Instances details

IsDoc HDoc

Instance details

Defined in GHC.Utils.Outputable

Associated Types

type Line HDoc
Instance details Defined in GHC.Utils.Outputable type Line HDoc = HLine

Methods

line :: Line HDoc -> HDoc #

($$) :: HDoc -> HDoc -> HDoc #

lines_ :: [Line HDoc] -> HDoc #

vcat :: [HDoc] -> HDoc #

dualDoc :: SDoc -> HDoc -> HDoc #

IsOutput HDoc

Instance details

Defined in GHC.Utils.Outputable

Methods

empty :: HDoc #

docWithContext :: (SDocContext -> HDoc) -> HDoc #

docWithStyle :: HDoc -> (PprStyle -> SDoc) -> HDoc #

type Line HDoc

Instance details

Defined in GHC.Utils.Outputable

type Line HDoc = HLine

data HLine #

Represents a single line of output that can be efficiently printed directly to a Handle (actually a BufHandle). See Note [SDoc versus HDoc] and Note [HLine versus HDoc] for more details.

Instances

Instances details

JsRender HLine
Instance details Defined in GHC.JS.Ppr Methods (<+?>) :: HLine -> HLine -> HLine # ($$$) :: HLine -> HLine -> HLine # jcat :: [HLine] -> HLine # jnest :: HLine -> HLine # addSemi :: HLine -> HLine #
IsLine HLine
Instance details Defined in GHC.Utils.Outputable Methods char :: Char -> HLine # text :: String -> HLine # ftext :: FastString -> HLine # ztext :: FastZString -> HLine # (<>) :: HLine -> HLine -> HLine # (<+>) :: HLine -> HLine -> HLine # sep :: [HLine] -> HLine # fsep :: [HLine] -> HLine # hcat :: [HLine] -> HLine # hsep :: [HLine] -> HLine # dualLine :: SDoc -> HLine -> HLine #
IsOutput HLine
Instance details Defined in GHC.Utils.Outputable Methods empty :: HLine # docWithContext :: (SDocContext -> HLine) -> HLine # docWithStyle :: HLine -> (PprStyle -> SDoc) -> HLine #

data JoinPointHood #

Constructors

JoinPoint !Int
NotJoinPoint

Instances

Instances details

NFData JoinPointHood
Instance details Defined in GHC.Utils.Outputable Methods rnf :: JoinPointHood -> () #
Binary JoinPointHood
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> JoinPointHood -> IO () # put :: BinHandle -> JoinPointHood -> IO (Bin JoinPointHood) # get :: BinHandle -> IO JoinPointHood #
Outputable JoinPointHood
Instance details Defined in GHC.Utils.Outputable Methods ppr :: JoinPointHood -> SDoc #
Eq JoinPointHood
Instance details Defined in GHC.Utils.Outputable Methods (==) :: JoinPointHood -> JoinPointHood -> Bool # (/=) :: JoinPointHood -> JoinPointHood -> Bool #

data BindingSite #

BindingSite is used to tell the thing that prints binder what language construct is binding the identifier. This can be used to decide how much info to print. Also see Note [Binding-site specific printing] in GHC.Core.Ppr

Constructors

LambdaBind	The x in (x. e)
CaseBind	The x in case scrut of x { (y,z) -> ... }
CasePatBind	The y,z in case scrut of x { (y,z) -> ... }
LetBind	The x in (let x = rhs in e)

Instances

Instances details

Eq BindingSite
Instance details Defined in GHC.Utils.Outputable Methods (==) :: BindingSite -> BindingSite -> Bool # (/=) :: BindingSite -> BindingSite -> Bool #

class Outputable a => OutputableBndr a where #

When we print a binder, we often want to print its type too. The OutputableBndr class encapsulates this idea.

Minimal complete definition

pprPrefixOcc, pprInfixOcc

Methods

pprBndr :: BindingSite -> a -> SDoc #

pprPrefixOcc :: a -> SDoc #

pprInfixOcc :: a -> SDoc #

bndrIsJoin_maybe :: a -> JoinPointHood #

Instances

Instances details

OutputableBndr ConLike
Instance details Defined in GHC.Core.ConLike Methods pprBndr :: BindingSite -> ConLike -> SDoc # pprPrefixOcc :: ConLike -> SDoc # pprInfixOcc :: ConLike -> SDoc # bndrIsJoin_maybe :: ConLike -> JoinPointHood #
OutputableBndr DataCon
Instance details Defined in GHC.Core.DataCon Methods pprBndr :: BindingSite -> DataCon -> SDoc # pprPrefixOcc :: DataCon -> SDoc # pprInfixOcc :: DataCon -> SDoc # bndrIsJoin_maybe :: DataCon -> JoinPointHood #
OutputableBndr PatSyn
Instance details Defined in GHC.Core.PatSyn Methods pprBndr :: BindingSite -> PatSyn -> SDoc # pprPrefixOcc :: PatSyn -> SDoc # pprInfixOcc :: PatSyn -> SDoc # bndrIsJoin_maybe :: PatSyn -> JoinPointHood #
OutputableBndr BinderInfo
Instance details Defined in GHC.Stg.Lift.Types Methods pprBndr :: BindingSite -> BinderInfo -> SDoc # pprPrefixOcc :: BinderInfo -> SDoc # pprInfixOcc :: BinderInfo -> SDoc # bndrIsJoin_maybe :: BinderInfo -> JoinPointHood #
OutputableBndr Name
Instance details Defined in GHC.Types.Name Methods pprBndr :: BindingSite -> Name -> SDoc # pprPrefixOcc :: Name -> SDoc # pprInfixOcc :: Name -> SDoc # bndrIsJoin_maybe :: Name -> JoinPointHood #
OutputableBndr OccName
Instance details Defined in GHC.Types.Name.Occurrence Methods pprBndr :: BindingSite -> OccName -> SDoc # pprPrefixOcc :: OccName -> SDoc # pprInfixOcc :: OccName -> SDoc # bndrIsJoin_maybe :: OccName -> JoinPointHood #
OutputableBndr RdrName
Instance details Defined in GHC.Types.Name.Reader Methods pprBndr :: BindingSite -> RdrName -> SDoc # pprPrefixOcc :: RdrName -> SDoc # pprInfixOcc :: RdrName -> SDoc # bndrIsJoin_maybe :: RdrName -> JoinPointHood #
(Outputable a, OutputableBndr e) => OutputableBndr (GenLocated (EpAnn a) e)
Instance details Defined in GHC.Parser.Annotation Methods pprBndr :: BindingSite -> GenLocated (EpAnn a) e -> SDoc # pprPrefixOcc :: GenLocated (EpAnn a) e -> SDoc # pprInfixOcc :: GenLocated (EpAnn a) e -> SDoc # bndrIsJoin_maybe :: GenLocated (EpAnn a) e -> JoinPointHood #
OutputableBndr (Id, TagSig)
Instance details Defined in GHC.Stg.InferTags.TagSig Methods pprBndr :: BindingSite -> (Id, TagSig) -> SDoc # pprPrefixOcc :: (Id, TagSig) -> SDoc # pprInfixOcc :: (Id, TagSig) -> SDoc # bndrIsJoin_maybe :: (Id, TagSig) -> JoinPointHood #

newtype PDoc a #

Wrapper for types having a Outputable instance when an OutputableP instance is required.

Constructors

PDoc a

Instances

Instances details

Outputable a => OutputableP env (PDoc a)
Instance details Defined in GHC.Utils.Outputable Methods pdoc :: env -> PDoc a -> SDoc #

class OutputableP env a where #

Outputable class with an additional environment value

See Note [The OutputableP class]

Methods

pdoc :: env -> a -> SDoc #

Instances

Instances details

OutputableP Platform CmmGraph
Instance details Defined in GHC.Cmm Methods pdoc :: Platform -> CmmGraph -> SDoc #
OutputableP Platform CmmInfoTable
Instance details Defined in GHC.Cmm Methods pdoc :: Platform -> CmmInfoTable -> SDoc #
OutputableP Platform CmmStatic
Instance details Defined in GHC.Cmm Methods pdoc :: Platform -> CmmStatic -> SDoc #
OutputableP Platform CmmTopInfo
Instance details Defined in GHC.Cmm Methods pdoc :: Platform -> CmmTopInfo -> SDoc #
OutputableP Platform CLabel
Instance details Defined in GHC.Cmm.CLabel Methods pdoc :: Platform -> CLabel -> SDoc #
OutputableP Platform InfoProvEnt
Instance details Defined in GHC.Cmm.CLabel Methods pdoc :: Platform -> InfoProvEnt -> SDoc #
OutputableP Platform DebugBlock
Instance details Defined in GHC.Cmm.DebugBlock Methods pdoc :: Platform -> DebugBlock -> SDoc #
OutputableP Platform UnwindExpr
Instance details Defined in GHC.Cmm.DebugBlock Methods pdoc :: Platform -> UnwindExpr -> SDoc #
OutputableP Platform UnwindPoint
Instance details Defined in GHC.Cmm.DebugBlock Methods pdoc :: Platform -> UnwindPoint -> SDoc #
OutputableP Platform CmmExpr
Instance details Defined in GHC.Cmm.Expr Methods pdoc :: Platform -> CmmExpr -> SDoc #
OutputableP Platform CmmLit
Instance details Defined in GHC.Cmm.Expr Methods pdoc :: Platform -> CmmLit -> SDoc #
OutputableP Platform ForeignTarget
Instance details Defined in GHC.Cmm.Node Methods pdoc :: Platform -> ForeignTarget -> SDoc #
OutputableP Platform DwarfFrameBlock
Instance details Defined in GHC.CmmToAsm.Dwarf.Types Methods pdoc :: Platform -> DwarfFrameBlock -> SDoc #
OutputableP Platform LiveInfo
Instance details Defined in GHC.CmmToAsm.Reg.Liveness Methods pdoc :: Platform -> LiveInfo -> SDoc #
OutputableP Platform CgLoc
Instance details Defined in GHC.StgToCmm.Closure Methods pdoc :: Platform -> CgLoc -> SDoc #
OutputableP Platform CgIdInfo
Instance details Defined in GHC.StgToCmm.Monad Methods pdoc :: Platform -> CgIdInfo -> SDoc #
OutputableP env Label
Instance details Defined in GHC.Cmm.Dataflow.Label Methods pdoc :: env -> Label -> SDoc #
OutputableP env CLabel => OutputableP env CAFfyLabel
Instance details Defined in GHC.Cmm.Info.Build Methods pdoc :: env -> CAFfyLabel -> SDoc #
OutputableP env CLabel => OutputableP env ModuleSRTInfo
Instance details Defined in GHC.Cmm.Info.Build Methods pdoc :: env -> ModuleSRTInfo -> SDoc #
OutputableP env CLabel => OutputableP env SRTEntry
Instance details Defined in GHC.Cmm.Info.Build Methods pdoc :: env -> SRTEntry -> SDoc #
OutputableP env CLabel => OutputableP env SomeLabel
Instance details Defined in GHC.Cmm.Info.Build Methods pdoc :: env -> SomeLabel -> SDoc #
OutputableP env GlobalReg
Instance details Defined in GHC.Cmm.Reg Methods pdoc :: env -> GlobalReg -> SDoc #
OutputableP env Alignment
Instance details Defined in GHC.Types.Basic Methods pdoc :: env -> Alignment -> SDoc #
OutputableP env SDoc
Instance details Defined in GHC.Utils.Outputable Methods pdoc :: env -> SDoc -> SDoc #
OutputableP env Void
Instance details Defined in GHC.Utils.Outputable Methods pdoc :: env -> Void -> SDoc #
OutputableP Platform (GenCmmStatics a)
Instance details Defined in GHC.Cmm Methods pdoc :: Platform -> GenCmmStatics a -> SDoc #
OutputableP env a => OutputableP env (SCC a)
Instance details Defined in GHC.Utils.Outputable Methods pdoc :: env -> SCC a -> SDoc #
OutputableP env a => OutputableP env (Set a)
Instance details Defined in GHC.Utils.Outputable Methods pdoc :: env -> Set a -> SDoc #
OutputableP env instr => OutputableP env (GenBasicBlock instr)
Instance details Defined in GHC.Cmm Methods pdoc :: env -> GenBasicBlock instr -> SDoc #
OutputableP env instr => OutputableP env (ListGraph instr)
Instance details Defined in GHC.Cmm Methods pdoc :: env -> ListGraph instr -> SDoc #
OutputableP env a => OutputableP env (LabelMap a)
Instance details Defined in GHC.Cmm.Dataflow.Label Methods pdoc :: env -> LabelMap a -> SDoc #
OutputableP env instr => OutputableP env (LiveInstr instr)
Instance details Defined in GHC.CmmToAsm.Reg.Liveness Methods pdoc :: env -> LiveInstr instr -> SDoc #
Outputable a => OutputableP env (PDoc a)
Instance details Defined in GHC.Utils.Outputable Methods pdoc :: env -> PDoc a -> SDoc #
OutputableP env a => OutputableP env (Maybe a)
Instance details Defined in GHC.Utils.Outputable Methods pdoc :: env -> Maybe a -> SDoc #
OutputableP env a => OutputableP env [a]
Instance details Defined in GHC.Utils.Outputable Methods pdoc :: env -> [a] -> SDoc #
OutputableP Platform (CmmNode e x)
Instance details Defined in GHC.Cmm.Node Methods pdoc :: Platform -> CmmNode e x -> SDoc #
(OutputableP env key, OutputableP env elt) => OutputableP env (Map key elt)
Instance details Defined in GHC.Utils.Outputable Methods pdoc :: env -> Map key elt -> SDoc #
(OutputableP env a, OutputableP env b) => OutputableP env (a, b)
Instance details Defined in GHC.Utils.Outputable Methods pdoc :: env -> (a, b) -> SDoc #
(OutputableP Platform d, OutputableP Platform info, OutputableP Platform i) => OutputableP Platform (GenCmmDecl d info i)
Instance details Defined in GHC.Cmm Methods pdoc :: Platform -> GenCmmDecl d info i -> SDoc #
OutputableP Platform (Block CmmNode C C)
Instance details Defined in GHC.Cmm.Node Methods pdoc :: Platform -> Block CmmNode C C -> SDoc #
OutputableP Platform (Block CmmNode C O)
Instance details Defined in GHC.Cmm.Node Methods pdoc :: Platform -> Block CmmNode C O -> SDoc #
OutputableP Platform (Block CmmNode O C)
Instance details Defined in GHC.Cmm.Node Methods pdoc :: Platform -> Block CmmNode O C -> SDoc #
OutputableP Platform (Block CmmNode O O)
Instance details Defined in GHC.Cmm.Node Methods pdoc :: Platform -> Block CmmNode O O -> SDoc #
OutputableP Platform (Graph CmmNode e x)
Instance details Defined in GHC.Cmm.Node Methods pdoc :: Platform -> Graph CmmNode e x -> SDoc #
(OutputableP env a, OutputableP env b, OutputableP env c) => OutputableP env (a, b, c)
Instance details Defined in GHC.Utils.Outputable Methods pdoc :: env -> (a, b, c) -> SDoc #

data SDocContext #

Constructors

SDC

Fields

sdocStyle :: !PprStyle
sdocColScheme :: !Scheme
sdocLastColour :: !PprColour
The most recently used colour. This allows nesting colours.
sdocShouldUseColor :: !Bool
sdocDefaultDepth :: !Int
sdocLineLength :: !Int
sdocCanUseUnicode :: !Bool
True if Unicode encoding is supported and not disabled by GHC_NO_UNICODE environment variable
sdocPrintErrIndexLinks :: !Bool
sdocHexWordLiterals :: !Bool
sdocPprDebug :: !Bool
sdocPrintUnicodeSyntax :: !Bool
sdocPrintCaseAsLet :: !Bool
sdocPrintTypecheckerElaboration :: !Bool
sdocPrintAxiomIncomps :: !Bool
sdocPrintExplicitKinds :: !Bool
sdocPrintExplicitCoercions :: !Bool
sdocPrintExplicitRuntimeReps :: !Bool
sdocPrintExplicitForalls :: !Bool
sdocPrintPotentialInstances :: !Bool
sdocPrintEqualityRelations :: !Bool
sdocSuppressTicks :: !Bool
sdocSuppressTypeSignatures :: !Bool
sdocSuppressTypeApplications :: !Bool
sdocSuppressIdInfo :: !Bool
sdocSuppressCoercions :: !Bool
sdocSuppressCoercionTypes :: !Bool
sdocSuppressUnfoldings :: !Bool
sdocSuppressVarKinds :: !Bool
sdocSuppressUniques :: !Bool
sdocSuppressModulePrefixes :: !Bool
sdocSuppressStgExts :: !Bool
sdocSuppressStgReps :: !Bool
sdocErrorSpans :: !Bool
sdocStarIsType :: !Bool
sdocLinearTypes :: !Bool
sdocListTuplePuns :: !Bool
sdocPrintTypeAbbreviations :: !Bool
sdocUnitIdForUser :: !(FastString -> SDoc)
Used to map UnitIds to more friendly "package-version:component" strings while pretty-printing.
Use pprWithUnitState to set it. Users should never have to set it to pretty-print SDocs emitted by GHC, otherwise it's a bug. It's an internal field used to thread the UnitState so that the Outputable instance of UnitId can use it.
See Note [Pretty-printing UnitId] in GHC.Unit for more details.
Note that we use FastString instead of UnitId to avoid boring module inter-dependency issues.

data QualifyName #

Constructors

NameUnqual
NameQual ModuleName
NameNotInScope1
NameNotInScope2

Instances

Instances details

Outputable QualifyName
Instance details Defined in GHC.Utils.Outputable Methods ppr :: QualifyName -> SDoc #

newtype IsEmptyOrSingleton #

Constructors

IsEmptyOrSingleton Bool

data PromotedItem #

Constructors

PromotedItemListSyntax IsEmptyOrSingleton
PromotedItemTupleSyntax
PromotedItemDataCon OccName

data PromotionTickContext #

Flags that affect whether a promotion tick is printed.

Constructors

PromTickCtx
Fields ptcListTuplePuns :: !Bool ptcPrintRedundantPromTicks :: !Bool

type QueryPromotionTick = PromotedItem -> Bool #

Given a promoted data constructor, decide whether to print a tick to disambiguate the namespace.

type QueryQualifyPackage = Unit -> Bool #

For a given package, we need to know whether to print it with the component id to disambiguate it.

type QueryQualifyModule = Module -> Bool #

For a given module, we need to know whether to print it with a package name to disambiguate it.

type QueryQualifyName = Module -> OccName -> QualifyName #

Given a Name's Module and OccName, decide whether and how to qualify it.

data NamePprCtx #

When printing code that contains original names, we need to map the original names back to something the user understands. This is the purpose of the triple of functions that gets passed around when rendering SDoc.

Constructors

QueryQualify
Fields queryQualifyName :: QueryQualifyName queryQualifyModule :: QueryQualifyModule queryQualifyPackage :: QueryQualifyPackage queryPromotionTick :: QueryPromotionTick

data Depth #

Constructors

AllTheWay
PartWay Int	0 => stop
DefaultDepth	Use `sdocDefaultDepth` field as depth

data PprStyle #

Constructors

PprUser NamePprCtx Depth Coloured
PprDump NamePprCtx
PprCode	Print code; either C or assembler

Instances

Instances details

Outputable PprStyle
Instance details Defined in GHC.Utils.Outputable Methods ppr :: PprStyle -> SDoc #

isListEmptyOrSingleton :: [a] -> IsEmptyOrSingleton #

reallyAlwaysQualifyNames :: QueryQualifyName #

alwaysQualifyNames :: QueryQualifyName #

NB: This won't ever show package IDs

neverQualifyNames :: QueryQualifyName #

alwaysQualifyModules :: QueryQualifyModule #

neverQualifyModules :: QueryQualifyModule #

alwaysQualifyPackages :: QueryQualifyPackage #

neverQualifyPackages :: QueryQualifyPackage #

alwaysPrintPromTick :: QueryPromotionTick #

reallyAlwaysQualify :: NamePprCtx #

alwaysQualify :: NamePprCtx #

neverQualify :: NamePprCtx #

defaultUserStyle :: PprStyle #

defaultDumpStyle :: PprStyle #

mkDumpStyle :: NamePprCtx -> PprStyle #

defaultErrStyle :: PprStyle #

Default style for error messages, when we don't know NamePprCtx It's a bit of a hack because it doesn't take into account what's in scope Only used for desugarer warnings, and typechecker errors in interface sigs

mkErrStyle :: NamePprCtx -> PprStyle #

Style for printing error messages

cmdlineParserStyle :: PprStyle #

mkUserStyle :: NamePprCtx -> Depth -> PprStyle #

withUserStyle :: NamePprCtx -> Depth -> SDoc -> SDoc #

withErrStyle :: NamePprCtx -> SDoc -> SDoc #

setStyleColoured :: Bool -> PprStyle -> PprStyle #

runSDoc :: SDoc -> SDocContext -> Doc #

defaultSDocContext :: SDocContext #

Default pretty-printing options

traceSDocContext :: SDocContext #

withPprStyle :: PprStyle -> SDoc -> SDoc #

pprDeeper :: SDoc -> SDoc #

pprDeeperList :: ([SDoc] -> SDoc) -> [SDoc] -> SDoc #

Truncate a list that is longer than the current depth.

pprSetDepth :: Depth -> SDoc -> SDoc #

getPprStyle :: (PprStyle -> SDoc) -> SDoc #

sdocWithContext :: (SDocContext -> SDoc) -> SDoc #

sdocOption :: (SDocContext -> a) -> (a -> SDoc) -> SDoc #

updSDocContext :: (SDocContext -> SDocContext) -> SDoc -> SDoc #

qualName :: PprStyle -> QueryQualifyName #

qualModule :: PprStyle -> QueryQualifyModule #

qualPackage :: PprStyle -> QueryQualifyPackage #

promTick :: PprStyle -> QueryPromotionTick #

queryQual :: PprStyle -> NamePprCtx #

codeStyle :: PprStyle -> Bool #

dumpStyle :: PprStyle -> Bool #

userStyle :: PprStyle -> Bool #

getPprDebug :: IsOutput doc => (Bool -> doc) -> doc #

Indicate if -dppr-debug mode is enabled

ifPprDebug :: IsOutput doc => doc -> doc -> doc #

Says what to do with and without -dppr-debug

whenPprDebug :: IsOutput doc => doc -> doc #

Says what to do with -dppr-debug; without, return empty

printSDoc :: SDocContext -> Mode -> Handle -> SDoc -> IO () #

The analog of printDoc_ for SDoc, which tries to make sure the terminal doesn't get screwed up by the ANSI color codes if an exception is thrown during pretty-printing.

printSDocLn :: SDocContext -> Mode -> Handle -> SDoc -> IO () #

Like printSDoc but appends an extra newline.

bufLeftRenderSDoc :: SDocContext -> BufHandle -> SDoc -> IO () #

An efficient variant of printSDoc specialized for LeftMode that outputs to a BufHandle.

pprCode :: SDoc -> SDoc #

renderWithContext :: SDocContext -> SDoc -> String #

showSDocOneLine :: SDocContext -> SDoc -> String #

showSDocUnsafe :: SDoc -> String #

showPprUnsafe :: Outputable a => a -> String #

pprDebugAndThen :: SDocContext -> (String -> a) -> SDoc -> SDoc -> a #

docToSDoc :: Doc -> SDoc #

doublePrec :: Int -> Double -> SDoc #

doublePrec p n shows a floating point number n with p digits of precision after the decimal point.

angleBrackets :: IsLine doc => doc -> doc #

cparen :: Bool -> SDoc -> SDoc #

quoteIfPunsEnabled :: SDoc -> SDoc #

blankLine :: SDoc #

dcolon :: SDoc #

arrow :: SDoc #

lollipop :: SDoc #

larrow :: SDoc #

darrow :: SDoc #

arrowt :: SDoc #

larrowt :: SDoc #

arrowtt :: SDoc #

larrowtt :: SDoc #

lambda :: SDoc #

underscore :: IsLine doc => doc #

dot :: IsLine doc => doc #

vbar :: IsLine doc => doc #

forAllLit :: SDoc #

bullet :: SDoc #

unicodeSyntax :: SDoc -> SDoc -> SDoc #

punctuateFinal #

Arguments

:: IsLine doc
=> doc	The interstitial punctuation
-> doc	The final punctuation
-> [doc]	The list that will have punctuation added between every adjacent pair of elements
-> [doc]	Punctuated list

Punctuate a list, e.g. with commas and dots.

sep $ punctuateFinal comma dot [text "ab", text "cd", text "ef"]
ab, cd, ef.

ppWhen :: IsOutput doc => Bool -> doc -> doc #

ppUnless :: IsOutput doc => Bool -> doc -> doc #

ppWhenOption :: (SDocContext -> Bool) -> SDoc -> SDoc #

ppUnlessOption :: (SDocContext -> Bool) -> SDoc -> SDoc #

coloured :: PprColour -> SDoc -> SDoc #

Apply the given colour/style for the argument.

Only takes effect if colours are enabled.

keyword :: SDoc -> SDoc #

pprModuleName :: IsLine doc => ModuleName -> doc #

isJoinPoint :: JoinPointHood -> Bool #

pprHsChar :: Char -> SDoc #

Special combinator for showing character literals.

pprHsString :: FastString -> SDoc #

Special combinator for showing string literals.

pprHsBytes :: ByteString -> SDoc #

Special combinator for showing bytestring literals.

primCharSuffix :: SDoc #

primFloatSuffix :: SDoc #

primIntSuffix :: SDoc #

primDoubleSuffix :: SDoc #

primWordSuffix :: SDoc #

primInt8Suffix :: SDoc #

primWord8Suffix :: SDoc #

primInt16Suffix :: SDoc #

primWord16Suffix :: SDoc #

primInt32Suffix :: SDoc #

primWord32Suffix :: SDoc #

primInt64Suffix :: SDoc #

primWord64Suffix :: SDoc #

pprPrimChar :: Char -> SDoc #

Special combinator for showing unboxed literals.

pprPrimInt :: Integer -> SDoc #

pprPrimWord :: Integer -> SDoc #

pprPrimInt8 :: Integer -> SDoc #

pprPrimInt16 :: Integer -> SDoc #

pprPrimInt32 :: Integer -> SDoc #

pprPrimInt64 :: Integer -> SDoc #

pprPrimWord8 :: Integer -> SDoc #

pprPrimWord16 :: Integer -> SDoc #

pprPrimWord32 :: Integer -> SDoc #

pprPrimWord64 :: Integer -> SDoc #

pprPrefixVar :: Bool -> SDoc -> SDoc #

pprInfixVar :: Bool -> SDoc -> SDoc #

pprFastFilePath :: FastString -> SDoc #

pprFilePathString :: IsLine doc => FilePath -> doc #

Normalise, escape and render a string representing a path

e.g. "c:\whatever"

pprWithCommas #

Arguments

:: (a -> SDoc)	The pretty printing function to use
-> [a]	The things to be pretty printed
-> SDoc	`SDoc` where the things have been pretty printed, comma-separated and finally packed into a paragraph.

pprWithBars #

Arguments

:: (a -> SDoc)	The pretty printing function to use
-> [a]	The things to be pretty printed
-> SDoc	`SDoc` where the things have been pretty printed, bar-separated and finally packed into a paragraph.

spaceIfSingleQuote :: SDoc -> SDoc #

interppSP :: Outputable a => [a] -> SDoc #

Returns the separated concatenation of the pretty printed things.

interpp'SP :: Outputable a => [a] -> SDoc #

Returns the comma-separated concatenation of the pretty printed things.

interpp'SP' :: (a -> SDoc) -> [a] -> SDoc #

pprQuotedList :: Outputable a => [a] -> SDoc #

Returns the comma-separated concatenation of the quoted pretty printed things.

[x,y,z]  ==>  `x', `y', `z'

quotedListWithOr :: [SDoc] -> SDoc #

quotedListWithNor :: [SDoc] -> SDoc #

quotedListWithAnd :: [SDoc] -> SDoc #

intWithCommas :: Integral a => a -> SDoc #

speakNth :: Int -> SDoc #

Converts an integer to a verbal index:

speakNth 1 = text "first"
speakNth 5 = text "fifth"
speakNth 21 = text "21st"

speakN :: Int -> SDoc #

Converts an integer to a verbal multiplicity:

speakN 0 = text "none"
speakN 5 = text "five"
speakN 10 = text "10"

speakNOf :: Int -> SDoc -> SDoc #

Converts an integer and object description to a statement about the multiplicity of those objects:

speakNOf 0 (text "melon") = text "no melons"
speakNOf 1 (text "melon") = text "one melon"
speakNOf 3 (text "melon") = text "three melons"

plural :: [a] -> SDoc #

Determines the pluralisation suffix appropriate for the length of a list:

plural [] = char 's'
plural ["Hello"] = empty
plural ["Hello", "World"] = char 's'

singular :: [a] -> SDoc #

Determines the singular verb suffix appropriate for the length of a list:

singular [] = empty
singular["Hello"] = char 's'
singular ["Hello", "World"] = empty

isOrAre :: [a] -> SDoc #

Determines the form of to be appropriate for the length of a list:

isOrAre [] = text "are"
isOrAre ["Hello"] = text "is"
isOrAre ["Hello", "World"] = text "are"

doOrDoes :: [a] -> SDoc #

Determines the form of to do appropriate for the length of a list:

doOrDoes [] = text "do"
doOrDoes ["Hello"] = text "does"
doOrDoes ["Hello", "World"] = text "do"

itsOrTheir :: [a] -> SDoc #

Determines the form of possessive appropriate for the length of a list:

itsOrTheir [x]   = text "its"
itsOrTheir [x,y] = text "their"
itsOrTheir []    = text "their"  -- probably avoid this

itOrThey :: [a] -> SDoc #

it or they, depeneding on the length of the list.

itOrThey [x]   = text "it"
itOrThey [x,y] = text "they"
itOrThey []    = text "they"  -- probably avoid this

thisOrThese :: [a] -> SDoc #

Determines the form of subject appropriate for the length of a list:

thisOrThese [x]   = text "This"
thisOrThese [x,y] = text "These"
thisOrThese []    = text "These"  -- probably avoid this

hasOrHave :: [a] -> SDoc #

"has" or "have" depending on the length of a list.

bPutHDoc :: BufHandle -> SDocContext -> HDoc -> IO () #

throwGhcException :: GhcException -> a #

throwGhcExceptionIO :: GhcException -> IO a #

data IdDetails #

Identifier Details

The IdDetails of an Id give stable, and necessary, information about the Id.

Constructors

VanillaId
RecSelId RecSelParent FieldLabel Bool ([ConLike], [ConLike])	The `Id` for a record selector
DataConWorkId DataCon	The `Id` is for a data constructor worker
DataConWrapId DataCon	The `Id` is for a data constructor wrapper
ClassOpId Class Bool	The `Id` is a superclass selector or class operation

Instances

Instances details

Outputable IdDetails
Instance details Defined in GHC.Types.Id.Info Methods ppr :: IdDetails -> SDoc #

data IdInfo #

Identifier Information

An IdInfo gives optional information about an Id. If present it never lies, but it may not be present, in which case there is always a conservative assumption which can be made.

Two Ids may have different info even though they have the same Unique (and are hence the same Id); for example, one might lack the properties attached to the other.

Most of the IdInfo gives information about the value, or definition, of the Id, independent of its usage. Exceptions to this are demandInfo, occInfo, oneShotInfo and callArityInfo.

Performance note: when we update IdInfo, we have to reallocate this entire record, so it is a good idea not to let this data structure get too big.

vanillaIdInfo :: IdInfo #

Basic IdInfo that carries no useful information whatsoever

class Uniquable a where #

Class of things that we can obtain a Unique from

Methods

getUnique :: a -> Unique #

Instances

Instances details

Uniquable Label
Instance details Defined in GHC.Cmm.Dataflow.Label Methods getUnique :: Label -> Unique #
Uniquable LocalReg
Instance details Defined in GHC.Cmm.Reg Methods getUnique :: LocalReg -> Unique #
Uniquable Reg	so we can put regs in UniqSets
Instance details Defined in GHC.CmmToAsm.Reg.Graph.Base Methods getUnique :: Reg -> Unique #
Uniquable Store
Instance details Defined in GHC.CmmToAsm.Reg.Graph.SpillClean Methods getUnique :: Store -> Unique #
Uniquable SymName
Instance details Defined in GHC.CmmToAsm.Wasm.Types Methods getUnique :: SymName -> Unique #
Uniquable Class
Instance details Defined in GHC.Core.Class Methods getUnique :: Class -> Unique #
Uniquable CoAxiomRule
Instance details Defined in GHC.Core.Coercion.Axiom Methods getUnique :: CoAxiomRule -> Unique #
Uniquable ConLike
Instance details Defined in GHC.Core.ConLike Methods getUnique :: ConLike -> Unique #
Uniquable DataCon
Instance details Defined in GHC.Core.DataCon Methods getUnique :: DataCon -> Unique #
Uniquable PatSyn
Instance details Defined in GHC.Core.PatSyn Methods getUnique :: PatSyn -> Unique #
Uniquable CoercionHole
Instance details Defined in GHC.Core.TyCo.Rep Methods getUnique :: CoercionHole -> Unique #
Uniquable TyCon
Instance details Defined in GHC.Core.TyCon Methods getUnique :: TyCon -> Unique #
Uniquable FastString
Instance details Defined in GHC.Types.Unique Methods getUnique :: FastString -> Unique #
Uniquable Ident
Instance details Defined in GHC.JS.Ident Methods getUnique :: Ident -> Unique #
Uniquable RealReg
Instance details Defined in GHC.Platform.Reg Methods getUnique :: RealReg -> Unique #
Uniquable Reg
Instance details Defined in GHC.Platform.Reg Methods getUnique :: Reg -> Unique #
Uniquable VirtualReg
Instance details Defined in GHC.Platform.Reg Methods getUnique :: VirtualReg -> Unique #
Uniquable RegClass
Instance details Defined in GHC.Platform.Reg.Class Methods getUnique :: RegClass -> Unique #
Uniquable EvBindsVar
Instance details Defined in GHC.Tc.Types.Evidence Methods getUnique :: EvBindsVar -> Unique #
Uniquable SkolemInfo
Instance details Defined in GHC.Tc.Types.Origin Methods getUnique :: SkolemInfo -> Unique #
Uniquable ConLikeName
Instance details Defined in GHC.Types.GREInfo Methods getUnique :: ConLikeName -> Unique #
Uniquable Name
Instance details Defined in GHC.Types.Name Methods getUnique :: Name -> Unique #
Uniquable NameSpace
Instance details Defined in GHC.Types.Name.Occurrence Methods getUnique :: NameSpace -> Unique #
Uniquable Unique
Instance details Defined in GHC.Types.Unique Methods getUnique :: Unique -> Unique #
Uniquable Var
Instance details Defined in GHC.Types.Var Methods getUnique :: Var -> Unique #
Uniquable PackageId
Instance details Defined in GHC.Unit.Info Methods getUnique :: PackageId -> Unique #
Uniquable PackageName
Instance details Defined in GHC.Unit.Info Methods getUnique :: PackageName -> Unique #
Uniquable WarningCategory
Instance details Defined in GHC.Unit.Module.Warnings Methods getUnique :: WarningCategory -> Unique #
Uniquable Module
Instance details Defined in GHC.Unit.Types Methods getUnique :: Module -> Unique #
Uniquable UnitId
Instance details Defined in GHC.Unit.Types Methods getUnique :: UnitId -> Unique #
Uniquable ModuleName
Instance details Defined in GHC.Types.Unique Methods getUnique :: ModuleName -> Unique #
Uniquable Int
Instance details Defined in GHC.Types.Unique Methods getUnique :: Int -> Unique #
Uniquable (CoAxiom br)
Instance details Defined in GHC.Core.Coercion.Axiom Methods getUnique :: CoAxiom br -> Unique #
Uniquable unit => Uniquable (Definite unit)
Instance details Defined in GHC.Unit.Types Methods getUnique :: Definite unit -> Unique #
IsUnitId u => Uniquable (GenUnit u)
Instance details Defined in GHC.Unit.Types Methods getUnique :: GenUnit u -> Unique #

getKey :: Unique -> Word64 #

mkUnique :: Char -> Word64 -> Unique #

hasKey :: Uniquable a => a -> Unique -> Bool #

nameOccName :: Name -> OccName #

nameUnique :: Name -> Unique #

type TyVar = Var #

Type or kind Variable

data Specificity #

Whether an Invisible argument may appear in source Haskell.

Constructors

SpecifiedSpec

the argument may appear in source Haskell, but isn't required.

Instances

Instances details

NFData Specificity
Instance details Defined in GHC.Types.Var Methods rnf :: Specificity -> () #
Binary Specificity
Instance details Defined in GHC.Types.Var Methods put_ :: BinHandle -> Specificity -> IO () # put :: BinHandle -> Specificity -> IO (Bin Specificity) # get :: BinHandle -> IO Specificity #
Data Specificity
Instance details Defined in GHC.Types.Var Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Specificity -> c Specificity # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Specificity # toConstr :: Specificity -> Constr # dataTypeOf :: Specificity -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Specificity) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Specificity) # gmapT :: (forall b. Data b => b -> b) -> Specificity -> Specificity # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Specificity -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Specificity -> r # gmapQ :: (forall d. Data d => d -> u) -> Specificity -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Specificity -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Specificity -> m Specificity # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Specificity -> m Specificity # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Specificity -> m Specificity #
Eq Specificity
Instance details Defined in GHC.Types.Var Methods (==) :: Specificity -> Specificity -> Bool # (/=) :: Specificity -> Specificity -> Bool #
Ord Specificity
Instance details Defined in GHC.Types.Var Methods compare :: Specificity -> Specificity -> Ordering # (<) :: Specificity -> Specificity -> Bool # (<=) :: Specificity -> Specificity -> Bool # (>) :: Specificity -> Specificity -> Bool # (>=) :: Specificity -> Specificity -> Bool # max :: Specificity -> Specificity -> Specificity # min :: Specificity -> Specificity -> Specificity #
OutputableBndrFlag Specificity p
Instance details Defined in GHC.Hs.Type Methods pprTyVarBndr :: HsTyVarBndr Specificity (GhcPass p) -> SDoc
RepTV Specificity Specificity
Instance details Defined in GHC.HsToCore.Quote Methods tyVarBndrName :: Name repPlainTV :: Core Name -> Specificity -> MetaM (Core (M (TyVarBndr Specificity))) repKindedTV :: Core Name -> Specificity -> Core (M Kind) -> MetaM (Core (M (TyVarBndr Specificity)))
ReifyFlag Specificity Specificity
Instance details Defined in GHC.Tc.Gen.Splice Methods reifyFlag :: Specificity -> Specificity
CvtFlag Specificity Specificity
Instance details Defined in GHC.ThToHs Methods cvtFlag :: Specificity -> Specificity
Outputable tv => Outputable (VarBndr tv Specificity)
Instance details Defined in GHC.Types.Var Methods ppr :: VarBndr tv Specificity -> SDoc #

data VarBndr var argf #

Constructors

Bndr var argf

Instances

Instances details

NamedThing tv => NamedThing (VarBndr tv flag)
Instance details Defined in GHC.Types.Var Methods getOccName :: VarBndr tv flag -> OccName # getName :: VarBndr tv flag -> Name #
(Binary tv, Binary vis) => Binary (VarBndr tv vis)
Instance details Defined in GHC.Types.Var Methods put_ :: BinHandle -> VarBndr tv vis -> IO () # put :: BinHandle -> VarBndr tv vis -> IO (Bin (VarBndr tv vis)) # get :: BinHandle -> IO (VarBndr tv vis) #
OutputableBndr tv => Outputable (VarBndr tv TyConBndrVis)
Instance details Defined in GHC.Core.TyCon Methods ppr :: VarBndr tv TyConBndrVis -> SDoc #
Outputable tv => Outputable (VarBndr tv ForAllTyFlag)
Instance details Defined in GHC.Types.Var Methods ppr :: VarBndr tv ForAllTyFlag -> SDoc #
Outputable tv => Outputable (VarBndr tv Specificity)
Instance details Defined in GHC.Types.Var Methods ppr :: VarBndr tv Specificity -> SDoc #
(Data var, Data argf) => Data (VarBndr var argf)
Instance details Defined in GHC.Types.Var Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VarBndr var argf -> c (VarBndr var argf) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (VarBndr var argf) # toConstr :: VarBndr var argf -> Constr # dataTypeOf :: VarBndr var argf -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (VarBndr var argf)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (VarBndr var argf)) # gmapT :: (forall b. Data b => b -> b) -> VarBndr var argf -> VarBndr var argf # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VarBndr var argf -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VarBndr var argf -> r # gmapQ :: (forall d. Data d => d -> u) -> VarBndr var argf -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VarBndr var argf -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VarBndr var argf -> m (VarBndr var argf) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VarBndr var argf -> m (VarBndr var argf) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VarBndr var argf -> m (VarBndr var argf) #
(Eq tyvar, Eq argf) => Eq (VarBndr tyvar argf) Source #
Instance details Defined in Language.Haskell.Liquid.GHC.TypeRep Methods (==) :: VarBndr tyvar argf -> VarBndr tyvar argf -> Bool # (/=) :: VarBndr tyvar argf -> VarBndr tyvar argf -> Bool #

data FunTyFlag #

The non-dependent version of ForAllTyFlag. See Note [FunTyFlag] Appears here partly so that it's together with its friends ForAllTyFlag and ForallVisFlag, but also because it is used in IfaceType, rather early in the compilation chain

Constructors

FTF_T_T
FTF_C_T

Instances

Instances details

Binary FunTyFlag
Instance details Defined in GHC.Types.Var Methods put_ :: BinHandle -> FunTyFlag -> IO () # put :: BinHandle -> FunTyFlag -> IO (Bin FunTyFlag) # get :: BinHandle -> IO FunTyFlag #
Outputable FunTyFlag
Instance details Defined in GHC.Types.Var Methods ppr :: FunTyFlag -> SDoc #
Data FunTyFlag
Instance details Defined in GHC.Types.Var Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunTyFlag -> c FunTyFlag # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FunTyFlag # toConstr :: FunTyFlag -> Constr # dataTypeOf :: FunTyFlag -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FunTyFlag) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunTyFlag) # gmapT :: (forall b. Data b => b -> b) -> FunTyFlag -> FunTyFlag # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunTyFlag -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunTyFlag -> r # gmapQ :: (forall d. Data d => d -> u) -> FunTyFlag -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FunTyFlag -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunTyFlag -> m FunTyFlag # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunTyFlag -> m FunTyFlag # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunTyFlag -> m FunTyFlag #
Eq FunTyFlag
Instance details Defined in GHC.Types.Var Methods (==) :: FunTyFlag -> FunTyFlag -> Bool # (/=) :: FunTyFlag -> FunTyFlag -> Bool #
Ord FunTyFlag
Instance details Defined in GHC.Types.Var Methods compare :: FunTyFlag -> FunTyFlag -> Ordering # (<) :: FunTyFlag -> FunTyFlag -> Bool # (<=) :: FunTyFlag -> FunTyFlag -> Bool # (>) :: FunTyFlag -> FunTyFlag -> Bool # (>=) :: FunTyFlag -> FunTyFlag -> Bool # max :: FunTyFlag -> FunTyFlag -> FunTyFlag # min :: FunTyFlag -> FunTyFlag -> FunTyFlag #

data ForAllTyFlag #

ForAllTyFlag

Is something required to appear in source Haskell (Required), permitted by request (Specified) (visible type application), or prohibited entirely from appearing in source Haskell (Inferred)? See Note [VarBndrs, ForAllTyBinders, TyConBinders, and visibility] in GHC.Core.TyCo.Rep

Constructors

Required

Instances

Instances details

NFData ForAllTyFlag
Instance details Defined in GHC.Types.Var Methods rnf :: ForAllTyFlag -> () #
Binary ForAllTyFlag
Instance details Defined in GHC.Types.Var Methods put_ :: BinHandle -> ForAllTyFlag -> IO () # put :: BinHandle -> ForAllTyFlag -> IO (Bin ForAllTyFlag) # get :: BinHandle -> IO ForAllTyFlag #
Outputable ForAllTyFlag
Instance details Defined in GHC.Types.Var Methods ppr :: ForAllTyFlag -> SDoc #
Data ForAllTyFlag
Instance details Defined in GHC.Types.Var Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForAllTyFlag -> c ForAllTyFlag # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ForAllTyFlag # toConstr :: ForAllTyFlag -> Constr # dataTypeOf :: ForAllTyFlag -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ForAllTyFlag) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ForAllTyFlag) # gmapT :: (forall b. Data b => b -> b) -> ForAllTyFlag -> ForAllTyFlag # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForAllTyFlag -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForAllTyFlag -> r # gmapQ :: (forall d. Data d => d -> u) -> ForAllTyFlag -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ForAllTyFlag -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForAllTyFlag -> m ForAllTyFlag # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForAllTyFlag -> m ForAllTyFlag # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForAllTyFlag -> m ForAllTyFlag #
Eq ForAllTyFlag
Instance details Defined in GHC.Types.Var Methods (==) :: ForAllTyFlag -> ForAllTyFlag -> Bool # (/=) :: ForAllTyFlag -> ForAllTyFlag -> Bool #
Ord ForAllTyFlag
Instance details Defined in GHC.Types.Var Methods compare :: ForAllTyFlag -> ForAllTyFlag -> Ordering # (<) :: ForAllTyFlag -> ForAllTyFlag -> Bool # (<=) :: ForAllTyFlag -> ForAllTyFlag -> Bool # (>) :: ForAllTyFlag -> ForAllTyFlag -> Bool # (>=) :: ForAllTyFlag -> ForAllTyFlag -> Bool # max :: ForAllTyFlag -> ForAllTyFlag -> ForAllTyFlag # min :: ForAllTyFlag -> ForAllTyFlag -> ForAllTyFlag #
Outputable tv => Outputable (VarBndr tv ForAllTyFlag)
Instance details Defined in GHC.Types.Var Methods ppr :: VarBndr tv ForAllTyFlag -> SDoc #

type CoreExpr = Expr CoreBndr #

Expressions where binders are CoreBndrs

type CoreBndr = Var #

The common case for the type of binders and variables when we are manipulating the Core language within GHC

isTupleTyCon :: TyCon -> Bool #

Does this TyCon represent a tuple?

NB: when compiling Data.Tuple, the tycons won't reply True to isTupleTyCon, because they are built as AlgTyCons. However they get spat into the interface file as tuple tycons, so I don't think it matters.

data TyThing #

A global typecheckable-thing, essentially anything that has a name. Not to be confused with a TcTyThing, which is also a typecheckable thing but in the *local* context. See GHC.Tc.Utils.Env for how to retrieve a TyThing given a Name.

Constructors

AnId Id
AConLike ConLike
ATyCon TyCon

Instances

Instances details

NamedThing TyThing
Instance details Defined in GHC.Types.TyThing Methods getOccName :: TyThing -> OccName # getName :: TyThing -> Name #
Outputable TyThing
Instance details Defined in GHC.Types.TyThing Methods ppr :: TyThing -> SDoc #
PPrint TyThing Source #
Instance details Defined in Language.Haskell.Liquid.Types.Types Methods pprintTidy :: Tidy -> TyThing -> Doc # pprintPrec :: Int -> Tidy -> TyThing -> Doc #

type PredType = Type #

A type of the form p of constraint kind represents a value whose type is the Haskell predicate p, where a predicate is what occurs before the => in a Haskell type.

We use PredType as documentation to mark those types that we guarantee to have this kind.

It can be expanded into its representation, but:

The type checker must treat it as opaque
The rest of the compiler treats it as transparent

Consider these examples:

f :: (Eq a) => a -> Int
g :: (?x :: Int -> Int) => a -> Int
h :: (r\l) => {r} => {l::Int | r}

Here the Eq a and ?x :: Int -> Int and rl are all called "predicates"

data TyLit #

Constructors

NumTyLit Integer
StrTyLit FastString
CharTyLit Char

Instances

Instances details

Outputable TyLit
Instance details Defined in GHC.Core.TyCo.Rep Methods ppr :: TyLit -> SDoc #
Data TyLit
Instance details Defined in GHC.Core.TyCo.Rep Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyLit -> c TyLit # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TyLit # toConstr :: TyLit -> Constr # dataTypeOf :: TyLit -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TyLit) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyLit) # gmapT :: (forall b. Data b => b -> b) -> TyLit -> TyLit # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r # gmapQ :: (forall d. Data d => d -> u) -> TyLit -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TyLit -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit #
Eq TyLit
Instance details Defined in GHC.Core.TyCo.Rep Methods (==) :: TyLit -> TyLit -> Bool # (/=) :: TyLit -> TyLit -> Bool #

data UnivCoProvenance #

For simplicity, we have just one UnivCo that represents a coercion from some type to some other type, with (in general) no restrictions on the type. The UnivCoProvenance specifies more exactly what the coercion really is and why a program should (or shouldn't!) trust the coercion. It is reasonable to consider each constructor of UnivCoProvenance as a totally independent coercion form; their only commonality is that they don't tell you what types they coercion between. (That info is in the UnivCo constructor of Coercion.

Constructors

PhantomProv KindCoercion	See Note [Phantom coercions]. Only in Phantom roled coercions
ProofIrrelProv KindCoercion	From the fact that any two coercions are considered equivalent. See Note [ProofIrrelProv]. Can be used in Nominal or Representational coercions

Instances

Instances details

Outputable UnivCoProvenance
Instance details Defined in GHC.Core.TyCo.Rep Methods ppr :: UnivCoProvenance -> SDoc #
Data UnivCoProvenance
Instance details Defined in GHC.Core.TyCo.Rep Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UnivCoProvenance -> c UnivCoProvenance # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UnivCoProvenance # toConstr :: UnivCoProvenance -> Constr # dataTypeOf :: UnivCoProvenance -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UnivCoProvenance) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnivCoProvenance) # gmapT :: (forall b. Data b => b -> b) -> UnivCoProvenance -> UnivCoProvenance # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UnivCoProvenance -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UnivCoProvenance -> r # gmapQ :: (forall d. Data d => d -> u) -> UnivCoProvenance -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> UnivCoProvenance -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> UnivCoProvenance -> m UnivCoProvenance # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UnivCoProvenance -> m UnivCoProvenance # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UnivCoProvenance -> m UnivCoProvenance #

class Monad m => MonadUnique (m :: Type -> Type) where #

A monad for generating unique identifiers

Minimal complete definition

getUniqueSupplyM

Methods

getUniqueM :: m Unique #

Get a new unique identifier

Instances

Instances details

MonadUnique NatM
Instance details Defined in GHC.CmmToAsm.Monad Methods getUniqueSupplyM :: NatM UniqSupply # getUniqueM :: NatM Unique # getUniquesM :: NatM [Unique] #
MonadUnique LlvmM
Instance details Defined in GHC.CmmToLlvm.Base Methods getUniqueSupplyM :: LlvmM UniqSupply # getUniqueM :: LlvmM Unique # getUniquesM :: LlvmM [Unique] #
MonadUnique CoreM
Instance details Defined in GHC.Core.Opt.Monad Methods getUniqueSupplyM :: CoreM UniqSupply # getUniqueM :: CoreM Unique # getUniquesM :: CoreM [Unique] #
MonadUnique SimplM
Instance details Defined in GHC.Core.Opt.Simplify.Monad Methods getUniqueSupplyM :: SimplM UniqSupply # getUniqueM :: SimplM Unique # getUniquesM :: SimplM [Unique] #
MonadUnique NullCollapseViz
Instance details Defined in GHC.Data.Graph.Collapse Methods getUniqueSupplyM :: NullCollapseViz UniqSupply # getUniqueM :: NullCollapseViz Unique # getUniquesM :: NullCollapseViz [Unique] #
MonadUnique RM
Instance details Defined in GHC.Stg.InferTags.Rewrite Methods getUniqueSupplyM :: RM UniqSupply # getUniqueM :: RM Unique # getUniquesM :: RM [Unique] #
MonadUnique LiftM
Instance details Defined in GHC.Stg.Lift.Monad Methods getUniqueSupplyM :: LiftM UniqSupply # getUniqueM :: LiftM Unique # getUniquesM :: LiftM [Unique] #
MonadUnique StgM
Instance details Defined in GHC.Stg.Pipeline Methods getUniqueSupplyM :: StgM UniqSupply # getUniqueM :: StgM Unique # getUniquesM :: StgM [Unique] #
MonadUnique CmmParse
Instance details Defined in GHC.StgToCmm.ExtCode Methods getUniqueSupplyM :: CmmParse UniqSupply # getUniqueM :: CmmParse Unique # getUniquesM :: CmmParse [Unique] #
MonadUnique FCode
Instance details Defined in GHC.StgToCmm.Monad Methods getUniqueSupplyM :: FCode UniqSupply # getUniqueM :: FCode Unique # getUniquesM :: FCode [Unique] #
MonadUnique TcS
Instance details Defined in GHC.Tc.Solver.Monad Methods getUniqueSupplyM :: TcS UniqSupply # getUniqueM :: TcS Unique # getUniquesM :: TcS [Unique] #
MonadUnique UniqSM
Instance details Defined in GHC.Types.Unique.Supply Methods getUniqueSupplyM :: UniqSM UniqSupply # getUniqueM :: UniqSM Unique # getUniquesM :: UniqSM [Unique] #
MonadUnique (WasmCodeGenM w)
Instance details Defined in GHC.CmmToAsm.Wasm.Types Methods getUniqueSupplyM :: WasmCodeGenM w UniqSupply # getUniqueM :: WasmCodeGenM w Unique # getUniquesM :: WasmCodeGenM w [Unique] #

type Located = GenLocated SrcSpan #

data UnhelpfulSpanReason #

Constructors

UnhelpfulNoLocationInfo
UnhelpfulWiredIn
UnhelpfulInteractive
UnhelpfulGenerated
UnhelpfulOther !FastString

Instances

Instances details

Binary UnhelpfulSpanReason
Instance details Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> UnhelpfulSpanReason -> IO () # put :: BinHandle -> UnhelpfulSpanReason -> IO (Bin UnhelpfulSpanReason) # get :: BinHandle -> IO UnhelpfulSpanReason #
Outputable UnhelpfulSpanReason
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: UnhelpfulSpanReason -> SDoc #
Show UnhelpfulSpanReason
Instance details Defined in GHC.Types.SrcLoc Methods showsPrec :: Int -> UnhelpfulSpanReason -> ShowS # show :: UnhelpfulSpanReason -> String # showList :: [UnhelpfulSpanReason] -> ShowS #
Eq UnhelpfulSpanReason
Instance details Defined in GHC.Types.SrcLoc Methods (==) :: UnhelpfulSpanReason -> UnhelpfulSpanReason -> Bool # (/=) :: UnhelpfulSpanReason -> UnhelpfulSpanReason -> Bool #

data SrcSpan #

Source Span

A SrcSpan identifies either a specific portion of a text file or a human-readable description of a location.

Constructors

RealSrcSpan !RealSrcSpan !(Maybe BufSpan)
UnhelpfulSpan !UnhelpfulSpanReason

Instances

Instances details

FromJSON SrcSpan Source #
Instance details Defined in Language.Haskell.Liquid.Types.Errors Methods parseJSON :: Value -> Parser SrcSpan # parseJSONList :: Value -> Parser [SrcSpan] # omittedField :: Maybe SrcSpan #
FromJSONKey SrcSpan Source #
Instance details Defined in Language.Haskell.Liquid.Types.Errors Methods fromJSONKey :: FromJSONKeyFunction SrcSpan # fromJSONKeyList :: FromJSONKeyFunction [SrcSpan] #
ToJSON SrcSpan Source #
Instance details Defined in Language.Haskell.Liquid.Types.Errors Methods toJSON :: SrcSpan -> Value # toEncoding :: SrcSpan -> Encoding # toJSONList :: [SrcSpan] -> Value # toEncodingList :: [SrcSpan] -> Encoding # omitField :: SrcSpan -> Bool #
ToJSONKey SrcSpan Source #
Instance details Defined in Language.Haskell.Liquid.Types.Errors Methods toJSONKey :: ToJSONKeyFunction SrcSpan # toJSONKeyList :: ToJSONKeyFunction [SrcSpan] #
NFData SrcSpan
Instance details Defined in GHC.Types.SrcLoc Methods rnf :: SrcSpan -> () #
HasAnnotation SrcSpan
Instance details Defined in GHC.Parser.Annotation Methods noAnnSrcSpan :: SrcSpan -> SrcSpan #
HasLoc SrcSpan
Instance details Defined in GHC.Parser.Annotation Methods getHasLoc :: SrcSpan -> SrcSpan #
ToJson SrcSpan
Instance details Defined in GHC.Types.SrcLoc Methods json :: SrcSpan -> JsonDoc #
Outputable SrcSpan
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: SrcSpan -> SDoc #
Data SrcSpan
Instance details Defined in GHC.Types.SrcLoc Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcSpan -> c SrcSpan # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SrcSpan # toConstr :: SrcSpan -> Constr # dataTypeOf :: SrcSpan -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SrcSpan) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcSpan) # gmapT :: (forall b. Data b => b -> b) -> SrcSpan -> SrcSpan # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcSpan -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SrcSpan -> r # gmapQ :: (forall d. Data d => d -> u) -> SrcSpan -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcSpan -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan #
Show SrcSpan
Instance details Defined in GHC.Types.SrcLoc Methods showsPrec :: Int -> SrcSpan -> ShowS # show :: SrcSpan -> String # showList :: [SrcSpan] -> ShowS #
Eq SrcSpan
Instance details Defined in GHC.Types.SrcLoc Methods (==) :: SrcSpan -> SrcSpan -> Bool # (/=) :: SrcSpan -> SrcSpan -> Bool #
Hashable SrcSpan Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Misc Methods hashWithSalt :: Int -> SrcSpan -> Int # hash :: SrcSpan -> Int #
PPrint SrcSpan Source #
Instance details Defined in Language.Haskell.Liquid.Types.Errors Methods pprintTidy :: Tidy -> SrcSpan -> Doc # pprintPrec :: Int -> Tidy -> SrcSpan -> Doc #
ToHie (LHsDoc GhcRn)
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LHsDoc GhcRn -> HieM [HieAST Type]
ToHie (Context (Located Name))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: Context (Located Name) -> HieM [HieAST Type]
ToHie (Context (Located Var))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: Context (Located Var) -> HieM [HieAST Type]
ToHie (Context (Located NoExtField))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: Context (Located NoExtField) -> HieM [HieAST Type]
ToHie (IEContext (Located RecFieldInfo))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: IEContext (Located RecFieldInfo) -> HieM [HieAST Type]
HiePass p => ToHie (Located (PatSynBind (GhcPass p) (GhcPass p)))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: Located (PatSynBind (GhcPass p) (GhcPass p)) -> HieM [HieAST Type]
ToHie (Located [LocatedAn NoEpAnns (HsDerivingClause GhcRn)])
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: Located [LocatedAn NoEpAnns (HsDerivingClause GhcRn)] -> HieM [HieAST Type]
HasHaddock (Located (HsModule GhcPs))
Instance details Defined in GHC.Parser.PostProcess.Haddock Methods addHaddock :: Located (HsModule GhcPs) -> HdkA (Located (HsModule GhcPs))
HasHaddock (Located [LocatedAn NoEpAnns (HsDerivingClause GhcPs)])
Instance details Defined in GHC.Parser.PostProcess.Haddock Methods addHaddock :: Located [LocatedAn NoEpAnns (HsDerivingClause GhcPs)] -> HdkA (Located [LocatedAn NoEpAnns (HsDerivingClause GhcPs)])
NamedThing e => NamedThing (Located e)
Instance details Defined in GHC.Types.Name Methods getOccName :: Located e -> OccName # getName :: Located e -> Name #
Outputable e => Outputable (Located e)
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: Located e -> SDoc #

data RealSrcSpan #

A RealSrcSpan delimits a portion of a text file. It could be represented by a pair of (line,column) coordinates, but in fact we optimise slightly by using more compact representations for single-line and zero-length spans, both of which are quite common.

The end position is defined to be the column after the end of the span. That is, a span of (1,1)-(1,2) is one character long, and a span of (1,1)-(1,1) is zero characters long.

Real Source Span

Instances

Instances details

FromJSON RealSrcSpan Source #
Instance details Defined in Language.Haskell.Liquid.Types.Errors Methods parseJSON :: Value -> Parser RealSrcSpan # parseJSONList :: Value -> Parser [RealSrcSpan] # omittedField :: Maybe RealSrcSpan #
ToJSON RealSrcSpan Source #
Instance details Defined in Language.Haskell.Liquid.Types.Errors Methods toJSON :: RealSrcSpan -> Value # toEncoding :: RealSrcSpan -> Encoding # toJSONList :: [RealSrcSpan] -> Value # toEncodingList :: [RealSrcSpan] -> Encoding # omitField :: RealSrcSpan -> Bool #
ToJson RealSrcSpan
Instance details Defined in GHC.Types.SrcLoc Methods json :: RealSrcSpan -> JsonDoc #
Outputable RealSrcSpan
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: RealSrcSpan -> SDoc #
Data RealSrcSpan
Instance details Defined in GHC.Types.SrcLoc Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RealSrcSpan -> c RealSrcSpan # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RealSrcSpan # toConstr :: RealSrcSpan -> Constr # dataTypeOf :: RealSrcSpan -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RealSrcSpan) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RealSrcSpan) # gmapT :: (forall b. Data b => b -> b) -> RealSrcSpan -> RealSrcSpan # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RealSrcSpan -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RealSrcSpan -> r # gmapQ :: (forall d. Data d => d -> u) -> RealSrcSpan -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RealSrcSpan -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RealSrcSpan -> m RealSrcSpan # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RealSrcSpan -> m RealSrcSpan # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RealSrcSpan -> m RealSrcSpan #
Show RealSrcSpan
Instance details Defined in GHC.Types.SrcLoc Methods showsPrec :: Int -> RealSrcSpan -> ShowS # show :: RealSrcSpan -> String # showList :: [RealSrcSpan] -> ShowS #
Eq RealSrcSpan
Instance details Defined in GHC.Types.SrcLoc Methods (==) :: RealSrcSpan -> RealSrcSpan -> Bool # (/=) :: RealSrcSpan -> RealSrcSpan -> Bool #
Ord RealSrcSpan
Instance details Defined in GHC.Types.SrcLoc Methods compare :: RealSrcSpan -> RealSrcSpan -> Ordering # (<) :: RealSrcSpan -> RealSrcSpan -> Bool # (<=) :: RealSrcSpan -> RealSrcSpan -> Bool # (>) :: RealSrcSpan -> RealSrcSpan -> Bool # (>=) :: RealSrcSpan -> RealSrcSpan -> Bool # max :: RealSrcSpan -> RealSrcSpan -> RealSrcSpan # min :: RealSrcSpan -> RealSrcSpan -> RealSrcSpan #
Outputable e => Outputable (GenLocated RealSrcSpan e)
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: GenLocated RealSrcSpan e -> SDoc #

data RealSrcLoc #

Real Source Location

Represents a single point within a file

Instances

Instances details

Outputable RealSrcLoc
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: RealSrcLoc -> SDoc #
Show RealSrcLoc
Instance details Defined in GHC.Types.SrcLoc Methods showsPrec :: Int -> RealSrcLoc -> ShowS # show :: RealSrcLoc -> String # showList :: [RealSrcLoc] -> ShowS #
Eq RealSrcLoc
Instance details Defined in GHC.Types.SrcLoc Methods (==) :: RealSrcLoc -> RealSrcLoc -> Bool # (/=) :: RealSrcLoc -> RealSrcLoc -> Bool #
Ord RealSrcLoc
Instance details Defined in GHC.Types.SrcLoc Methods compare :: RealSrcLoc -> RealSrcLoc -> Ordering # (<) :: RealSrcLoc -> RealSrcLoc -> Bool # (<=) :: RealSrcLoc -> RealSrcLoc -> Bool # (>) :: RealSrcLoc -> RealSrcLoc -> Bool # (>=) :: RealSrcLoc -> RealSrcLoc -> Bool # max :: RealSrcLoc -> RealSrcLoc -> RealSrcLoc # min :: RealSrcLoc -> RealSrcLoc -> RealSrcLoc #

mkSrcLoc :: FastString -> Int -> Int -> SrcLoc #

mkRealSrcLoc :: FastString -> Int -> Int -> RealSrcLoc #

srcLocLine :: RealSrcLoc -> Int #

Raises an error when used on a "bad" SrcLoc

srcLocCol :: RealSrcLoc -> Int #

Raises an error when used on a "bad" SrcLoc

noSrcSpan :: SrcSpan #

Built-in "bad" SrcSpans for common sources of location uncertainty

mkGeneralSrcSpan :: FastString -> SrcSpan #

Create a "bad" SrcSpan that has not location information

mkRealSrcSpan :: RealSrcLoc -> RealSrcLoc -> RealSrcSpan #

Create a SrcSpan between two points in a file

mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan #

Create a SrcSpan between two points in a file

combineSrcSpans :: SrcSpan -> SrcSpan -> SrcSpan #

Combines two SrcSpan into one that spans at least all the characters within both spans. Returns UnhelpfulSpan if the files differ.

isGoodSrcSpan :: SrcSpan -> Bool #

Test if a SrcSpan is "good", i.e. has precise location information

srcSpanStartLine :: RealSrcSpan -> Int #

srcSpanEndLine :: RealSrcSpan -> Int #

srcSpanStartCol :: RealSrcSpan -> Int #

srcSpanEndCol :: RealSrcSpan -> Int #

realSrcSpanStart :: RealSrcSpan -> RealSrcLoc #

srcSpanFileName_maybe :: SrcSpan -> Maybe FastString #

Obtains the filename for a SrcSpan if it is "good"

srcSpanToRealSrcSpan :: SrcSpan -> Maybe RealSrcSpan #

unLoc :: GenLocated l e -> e #

withBinBuffer :: BinHandle -> (ByteString -> IO a) -> IO a #

Get access to the underlying buffer.

unsafeUnpackBinBuffer :: ByteString -> IO BinHandle #

openBinMem :: Int -> IO BinHandle #

putByte :: BinHandle -> Word8 -> IO () #

getByte :: BinHandle -> IO Word8 #

mkUniqSet :: Uniquable a => [a] -> UniqSet a #

data SourceText #

Constructors

SourceText FastString
NoSourceText	For when code is generated, e.g. TH, deriving. The pretty printer will then make its own representation of the item.

Instances

Instances details

NFData SourceText
Instance details Defined in GHC.Types.SourceText Methods rnf :: SourceText -> () #
Binary SourceText
Instance details Defined in GHC.Types.SourceText Methods put_ :: BinHandle -> SourceText -> IO () # put :: BinHandle -> SourceText -> IO (Bin SourceText) # get :: BinHandle -> IO SourceText #
Outputable SourceText
Instance details Defined in GHC.Types.SourceText Methods ppr :: SourceText -> SDoc #
Data SourceText
Instance details Defined in GHC.Types.SourceText Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SourceText -> c SourceText # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SourceText # toConstr :: SourceText -> Constr # dataTypeOf :: SourceText -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SourceText) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceText) # gmapT :: (forall b. Data b => b -> b) -> SourceText -> SourceText # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SourceText -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SourceText -> r # gmapQ :: (forall d. Data d => d -> u) -> SourceText -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceText -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SourceText -> m SourceText # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceText -> m SourceText # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceText -> m SourceText #
Show SourceText
Instance details Defined in GHC.Types.SourceText Methods showsPrec :: Int -> SourceText -> ShowS # show :: SourceText -> String # showList :: [SourceText] -> ShowS #
Eq SourceText
Instance details Defined in GHC.Types.SourceText Methods (==) :: SourceText -> SourceText -> Bool # (/=) :: SourceText -> SourceText -> Bool #
type Anno (SourceText, RuleName)
Instance details Defined in GHC.Hs.Decls type Anno (SourceText, RuleName) = EpAnnCO

mkIntegralLit :: Integral a => a -> IntegralLit #

mkTHFractionalLit :: Rational -> FractionalLit #

data FieldLabel #

Fields in an algebraic record type; see Note [FieldLabel].

Instances

Instances details

HasOccName FieldLabel
Instance details Defined in GHC.Types.FieldLabel Methods occName :: FieldLabel -> OccName #
Binary Name => Binary FieldLabel	We need the `Binary Name` constraint here even though there is an instance defined in GHC.Types.Name, because the we have a SOURCE import, so the instance is not in scope. And the instance cannot be added to Name.hs-boot because GHC.Utils.Binary itself depends on GHC.Types.Name.
Instance details Defined in GHC.Types.FieldLabel Methods put_ :: BinHandle -> FieldLabel -> IO () # put :: BinHandle -> FieldLabel -> IO (Bin FieldLabel) # get :: BinHandle -> IO FieldLabel #
Outputable FieldLabel
Instance details Defined in GHC.Types.FieldLabel Methods ppr :: FieldLabel -> SDoc #
Data FieldLabel
Instance details Defined in GHC.Types.FieldLabel Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FieldLabel -> c FieldLabel # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FieldLabel # toConstr :: FieldLabel -> Constr # dataTypeOf :: FieldLabel -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FieldLabel) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldLabel) # gmapT :: (forall b. Data b => b -> b) -> FieldLabel -> FieldLabel # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FieldLabel -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FieldLabel -> r # gmapQ :: (forall d. Data d => d -> u) -> FieldLabel -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldLabel -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FieldLabel -> m FieldLabel # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldLabel -> m FieldLabel # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldLabel -> m FieldLabel #
Eq FieldLabel
Instance details Defined in GHC.Types.FieldLabel Methods (==) :: FieldLabel -> FieldLabel -> Bool # (/=) :: FieldLabel -> FieldLabel -> Bool #

data Bag a #

Instances

Instances details

Functor Bag

Instance details

Defined in GHC.Data.Bag

Methods

fmap :: (a -> b) -> Bag a -> Bag b #

(<$) :: a -> Bag b -> Bag a #

Foldable Bag

Instance details

Defined in GHC.Data.Bag

Methods

fold :: Monoid m => Bag m -> m #

foldMap :: Monoid m => (a -> m) -> Bag a -> m #

foldMap' :: Monoid m => (a -> m) -> Bag a -> m #

foldr :: (a -> b -> b) -> b -> Bag a -> b #

foldr' :: (a -> b -> b) -> b -> Bag a -> b #

foldl :: (b -> a -> b) -> b -> Bag a -> b #

foldl' :: (b -> a -> b) -> b -> Bag a -> b #

foldr1 :: (a -> a -> a) -> Bag a -> a #

foldl1 :: (a -> a -> a) -> Bag a -> a #

toList :: Bag a -> [a] #

null :: Bag a -> Bool #

length :: Bag a -> Int #

elem :: Eq a => a -> Bag a -> Bool #

maximum :: Ord a => Bag a -> a #

minimum :: Ord a => Bag a -> a #

sum :: Num a => Bag a -> a #

product :: Num a => Bag a -> a #

Traversable Bag

Instance details

Defined in GHC.Data.Bag

Methods

traverse :: Applicative f => (a -> f b) -> Bag a -> f (Bag b) #

sequenceA :: Applicative f => Bag (f a) -> f (Bag a) #

mapM :: Monad m => (a -> m b) -> Bag a -> m (Bag b) #

sequence :: Monad m => Bag (m a) -> m (Bag a) #

NFData a => NFData (Bag a)

Instance details

Defined in GHC.Data.Bag

Methods

rnf :: Bag a -> () #

ToHie a => ToHie (Bag a)

Instance details

Defined in GHC.Iface.Ext.Ast

Methods

toHie :: Bag a -> HieM [HieAST Type]

Outputable a => Outputable (Bag a)

Instance details

Defined in GHC.Data.Bag

Methods

ppr :: Bag a -> SDoc #

Monoid (Bag a)

Instance details

Defined in GHC.Data.Bag

Methods

mempty :: Bag a #

mappend :: Bag a -> Bag a -> Bag a #

mconcat :: [Bag a] -> Bag a #

Semigroup (Bag a)

Instance details

Defined in GHC.Data.Bag

Methods

(<>) :: Bag a -> Bag a -> Bag a #

sconcat :: NonEmpty (Bag a) -> Bag a #

stimes :: Integral b => b -> Bag a -> Bag a #

Data a => Data (Bag a)

Instance details

Defined in GHC.Data.Bag

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bag a -> c (Bag a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Bag a) #

toConstr :: Bag a -> Constr #

dataTypeOf :: Bag a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Bag a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Bag a)) #

gmapT :: (forall b. Data b => b -> b) -> Bag a -> Bag a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bag a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bag a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Bag a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Bag a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bag a -> m (Bag a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bag a -> m (Bag a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bag a -> m (Bag a) #

IsList (Bag a)

Instance details

Defined in GHC.Data.Bag

Associated Types

type Item (Bag a)
Instance details Defined in GHC.Data.Bag type Item (Bag a) = a

Methods

fromList :: [Item (Bag a)] -> Bag a #

fromListN :: Int -> [Item (Bag a)] -> Bag a #

toList :: Bag a -> [Item (Bag a)] #

type Item (Bag a)

Instance details

Defined in GHC.Data.Bag

type Item (Bag a) = a

bagToList :: Bag a -> [a] #

data FixityDirection #

Constructors

InfixR
InfixN

Instances

Instances details

Binary FixityDirection
Instance details Defined in GHC.Types.Fixity Methods put_ :: BinHandle -> FixityDirection -> IO () # put :: BinHandle -> FixityDirection -> IO (Bin FixityDirection) # get :: BinHandle -> IO FixityDirection #
Outputable FixityDirection
Instance details Defined in GHC.Types.Fixity Methods ppr :: FixityDirection -> SDoc #
Data FixityDirection
Instance details Defined in GHC.Types.Fixity Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FixityDirection -> c FixityDirection # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FixityDirection # toConstr :: FixityDirection -> Constr # dataTypeOf :: FixityDirection -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FixityDirection) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FixityDirection) # gmapT :: (forall b. Data b => b -> b) -> FixityDirection -> FixityDirection # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r # gmapQ :: (forall d. Data d => d -> u) -> FixityDirection -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FixityDirection -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection #
Eq FixityDirection
Instance details Defined in GHC.Types.Fixity Methods (==) :: FixityDirection -> FixityDirection -> Bool # (/=) :: FixityDirection -> FixityDirection -> Bool #

data GeneralFlag #

Enumerates the simple on-or-off dynamic flags

Constructors

Opt_DumpToFile	Append dump output to files instead of stdout.
Opt_DumpWithWays	Use foo.ways.dumpFlag instead of foo.dumpFlag
Opt_D_dump_minimal_imports
Opt_DoCoreLinting
Opt_DoLinearCoreLinting
Opt_DoStgLinting
Opt_DoCmmLinting
Opt_DoAsmLinting
Opt_DoAnnotationLinting
Opt_DoBoundsChecking
Opt_NoLlvmMangler
Opt_FastLlvm
Opt_NoTypeableBinds
Opt_DistinctConstructorTables
Opt_InfoTableMap
Opt_InfoTableMapWithFallback
Opt_InfoTableMapWithStack
Opt_WarnIsError
Opt_ShowWarnGroups
Opt_HideSourcePaths
Opt_PrintExplicitForalls
Opt_PrintExplicitKinds
Opt_PrintExplicitCoercions
Opt_PrintExplicitRuntimeReps
Opt_PrintEqualityRelations
Opt_PrintAxiomIncomps
Opt_PrintUnicodeSyntax
Opt_PrintExpandedSynonyms
Opt_PrintPotentialInstances
Opt_PrintRedundantPromotionTicks
Opt_PrintTypecheckerElaboration
Opt_CallArity
Opt_Exitification
Opt_Strictness
Opt_LateDmdAnal
Opt_KillAbsence
Opt_KillOneShot
Opt_FullLaziness
Opt_FloatIn
Opt_LocalFloatOut	Enable floating out of let-bindings in the simplifier
Opt_LocalFloatOutTopLevel	Enable floating out of let-bindings at the top level in the simplifier N.B. See Note [RHS Floating]
Opt_LateSpecialise
Opt_Specialise
Opt_SpecialiseAggressively
Opt_CrossModuleSpecialise
Opt_PolymorphicSpecialisation
Opt_InlineGenerics
Opt_InlineGenericsAggressively
Opt_StaticArgumentTransformation
Opt_CSE
Opt_StgCSE
Opt_StgLiftLams
Opt_LiberateCase
Opt_SpecConstr
Opt_SpecConstrKeen
Opt_SpecialiseIncoherents
Opt_DoLambdaEtaExpansion
Opt_DoCleverArgEtaExpansion
Opt_IgnoreAsserts
Opt_DoEtaReduction
Opt_CaseMerge
Opt_CaseFolding
Opt_UnboxStrictFields
Opt_UnboxSmallStrictFields
Opt_DictsCheap
Opt_EnableRewriteRules
Opt_EnableThSpliceWarnings
Opt_RegsGraph
Opt_RegsIterative
Opt_PedanticBottoms
Opt_LlvmFillUndefWithGarbage
Opt_IrrefutableTuples
Opt_CmmSink
Opt_CmmStaticPred
Opt_CmmElimCommonBlocks
Opt_CmmControlFlow
Opt_AsmShortcutting
Opt_OmitYields
Opt_FunToThunk
Opt_DictsStrict
Opt_DmdTxDictSel	deprecated, no effect and behaviour is now default. Allowed switching of a special demand transformer for dictionary selectors
Opt_Loopification
Opt_CfgBlocklayout	Use the cfg based block layout algorithm.
Opt_WeightlessBlocklayout	Layout based on last instruction per block.
Opt_CprAnal
Opt_WorkerWrapper
Opt_WorkerWrapperUnlift	Do W/W split for unlifting even if we won't unbox anything.
Opt_SolveConstantDicts
Opt_AlignmentSanitisation
Opt_CatchNonexhaustiveCases
Opt_NumConstantFolding
Opt_CoreConstantFolding
Opt_FastPAPCalls
Opt_DoTagInferenceChecks
Opt_SimplPreInlining
Opt_IgnoreInterfacePragmas
Opt_OmitInterfacePragmas
Opt_ExposeAllUnfoldings
Opt_KeepAutoRules	Keep auto-generated rules even if they seem to have become useless
Opt_WriteInterface
Opt_WriteHie
Opt_DisableJsMinifier	render JavaScript pretty-printed instead of minified (compacted)
Opt_DisableJsCsources	don't link C sources (compiled to JS) with Haskell code (compiled to JS)
Opt_AutoSccsOnIndividualCafs
Opt_ProfCountEntries
Opt_ProfLateInlineCcs
Opt_ProfLateCcs
Opt_ProfLateOverloadedCcs
Opt_ProfLateoverloadedCallsCCs
Opt_ProfManualCcs	Ignore manual SCC annotations
Opt_Pp
Opt_ForceRecomp
Opt_IgnoreOptimChanges
Opt_IgnoreHpcChanges
Opt_ExcessPrecision
Opt_EagerBlackHoling
Opt_OrigThunkInfo
Opt_NoHsMain
Opt_SplitSections
Opt_StgStats
Opt_HideAllPackages
Opt_HideAllPluginPackages
Opt_PrintBindResult
Opt_Haddock
Opt_HaddockOptions
Opt_BreakOnException
Opt_BreakOnError
Opt_PrintEvldWithShow
Opt_PrintBindContents
Opt_GenManifest
Opt_EmbedManifest
Opt_SharedImplib
Opt_BuildingCabalPackage
Opt_IgnoreDotGhci
Opt_GhciSandbox
Opt_InsertBreakpoints
Opt_GhciHistory
Opt_GhciLeakCheck
Opt_ValidateHie
Opt_LocalGhciHistory
Opt_NoIt
Opt_HelpfulErrors
Opt_DeferTypeErrors
Opt_DeferTypedHoles
Opt_DeferOutOfScopeVariables
Opt_PIC	-fPIC
Opt_PIE	-fPIE
Opt_PICExecutable	-pie
Opt_ExternalDynamicRefs
Opt_Ticky
Opt_Ticky_Allocd
Opt_Ticky_LNE
Opt_Ticky_Dyn_Thunk
Opt_Ticky_Tag
Opt_Ticky_AP	Use regular thunks even when we could use std ap thunks in order to get entry counts
Opt_CmmThreadSanitizer
Opt_RPath
Opt_RelativeDynlibPaths
Opt_CompactUnwind	-fcompact-unwind
Opt_Hpc
Opt_FamAppCache
Opt_ExternalInterpreter
Opt_OptimalApplicativeDo
Opt_VersionMacros
Opt_WholeArchiveHsLibs
Opt_SingleLibFolder
Opt_ExposeInternalSymbols
Opt_KeepCAFs
Opt_KeepGoing
Opt_ByteCode
Opt_ByteCodeAndObjectCode
Opt_UnoptimizedCoreForInterpreter
Opt_LinkRts
Opt_ErrorSpans
Opt_DeferDiagnostics
Opt_DiagnosticsAsJSON	Dump diagnostics as JSON
Opt_DiagnosticsShowCaret
Opt_PprCaseAsLet
Opt_PprShowTicks
Opt_ShowHoleConstraints
Opt_ShowValidHoleFits
Opt_SortValidHoleFits
Opt_SortBySizeHoleFits
Opt_SortBySubsumHoleFits
Opt_AbstractRefHoleFits
Opt_UnclutterValidHoleFits
Opt_ShowTypeAppOfHoleFits
Opt_ShowTypeAppVarsOfHoleFits
Opt_ShowDocsOfHoleFits
Opt_ShowTypeOfHoleFits
Opt_ShowProvOfHoleFits
Opt_ShowMatchesOfHoleFits
Opt_ShowLoadedModules
Opt_HexWordLiterals
Opt_SuppressCoercions
Opt_SuppressCoercionTypes
Opt_SuppressVarKinds
Opt_SuppressModulePrefixes
Opt_SuppressTypeApplications
Opt_SuppressIdInfo
Opt_SuppressUnfoldings
Opt_SuppressTypeSignatures
Opt_SuppressUniques
Opt_SuppressStgExts
Opt_SuppressStgReps
Opt_SuppressTicks
Opt_SuppressTimestamps	Suppress timestamps in dumps
Opt_SuppressCoreSizes	Suppress per binding Core size stats in dumps
Opt_ShowErrorContext
Opt_AutoLinkPackages
Opt_ImplicitImportQualified
Opt_KeepHscppFiles
Opt_KeepHiDiffs
Opt_KeepHcFiles
Opt_KeepSFiles
Opt_KeepTmpFiles
Opt_KeepRawTokenStream
Opt_KeepLlvmFiles
Opt_KeepHiFiles
Opt_KeepOFiles
Opt_BuildDynamicToo
Opt_WriteIfSimplifiedCore
Opt_UseBytecodeRatherThanObjects
Opt_DistrustAllPackages
Opt_PackageTrust
Opt_PluginTrustworthy
Opt_G_NoStateHack
Opt_G_NoOptCoercion

Instances

Instances details

Enum GeneralFlag
Instance details Defined in GHC.Driver.Flags Methods succ :: GeneralFlag -> GeneralFlag # pred :: GeneralFlag -> GeneralFlag # toEnum :: Int -> GeneralFlag # fromEnum :: GeneralFlag -> Int # enumFrom :: GeneralFlag -> [GeneralFlag] # enumFromThen :: GeneralFlag -> GeneralFlag -> [GeneralFlag] # enumFromTo :: GeneralFlag -> GeneralFlag -> [GeneralFlag] # enumFromThenTo :: GeneralFlag -> GeneralFlag -> GeneralFlag -> [GeneralFlag] #
Show GeneralFlag
Instance details Defined in GHC.Driver.Flags Methods showsPrec :: Int -> GeneralFlag -> ShowS # show :: GeneralFlag -> String # showList :: [GeneralFlag] -> ShowS #
Eq GeneralFlag
Instance details Defined in GHC.Driver.Flags Methods (==) :: GeneralFlag -> GeneralFlag -> Bool # (/=) :: GeneralFlag -> GeneralFlag -> Bool #

type ModuleNameWithIsBoot = GenWithIsBoot ModuleName #

data GenWithIsBoot mod #

This data type just pairs a value mod with an IsBootInterface flag. In practice, mod is usually a Module or ModuleName'.

Instances

Instances details

Functor GenWithIsBoot
Instance details Defined in GHC.Unit.Types Methods fmap :: (a -> b) -> GenWithIsBoot a -> GenWithIsBoot b # (<$) :: a -> GenWithIsBoot b -> GenWithIsBoot a #
Foldable GenWithIsBoot
Instance details Defined in GHC.Unit.Types Methods fold :: Monoid m => GenWithIsBoot m -> m # foldMap :: Monoid m => (a -> m) -> GenWithIsBoot a -> m # foldMap' :: Monoid m => (a -> m) -> GenWithIsBoot a -> m # foldr :: (a -> b -> b) -> b -> GenWithIsBoot a -> b # foldr' :: (a -> b -> b) -> b -> GenWithIsBoot a -> b # foldl :: (b -> a -> b) -> b -> GenWithIsBoot a -> b # foldl' :: (b -> a -> b) -> b -> GenWithIsBoot a -> b # foldr1 :: (a -> a -> a) -> GenWithIsBoot a -> a # foldl1 :: (a -> a -> a) -> GenWithIsBoot a -> a # toList :: GenWithIsBoot a -> [a] # null :: GenWithIsBoot a -> Bool # length :: GenWithIsBoot a -> Int # elem :: Eq a => a -> GenWithIsBoot a -> Bool # maximum :: Ord a => GenWithIsBoot a -> a # minimum :: Ord a => GenWithIsBoot a -> a # sum :: Num a => GenWithIsBoot a -> a # product :: Num a => GenWithIsBoot a -> a #
Traversable GenWithIsBoot
Instance details Defined in GHC.Unit.Types Methods traverse :: Applicative f => (a -> f b) -> GenWithIsBoot a -> f (GenWithIsBoot b) # sequenceA :: Applicative f => GenWithIsBoot (f a) -> f (GenWithIsBoot a) # mapM :: Monad m => (a -> m b) -> GenWithIsBoot a -> m (GenWithIsBoot b) # sequence :: Monad m => GenWithIsBoot (m a) -> m (GenWithIsBoot a) #
Binary a => Binary (GenWithIsBoot a)
Instance details Defined in GHC.Unit.Types Methods put_ :: BinHandle -> GenWithIsBoot a -> IO () # put :: BinHandle -> GenWithIsBoot a -> IO (Bin (GenWithIsBoot a)) # get :: BinHandle -> IO (GenWithIsBoot a) #
Outputable a => Outputable (GenWithIsBoot a)
Instance details Defined in GHC.Unit.Types Methods ppr :: GenWithIsBoot a -> SDoc #
Show mod => Show (GenWithIsBoot mod)
Instance details Defined in GHC.Unit.Types Methods showsPrec :: Int -> GenWithIsBoot mod -> ShowS # show :: GenWithIsBoot mod -> String # showList :: [GenWithIsBoot mod] -> ShowS #
Eq mod => Eq (GenWithIsBoot mod)
Instance details Defined in GHC.Unit.Types Methods (==) :: GenWithIsBoot mod -> GenWithIsBoot mod -> Bool # (/=) :: GenWithIsBoot mod -> GenWithIsBoot mod -> Bool #
Ord mod => Ord (GenWithIsBoot mod)
Instance details Defined in GHC.Unit.Types Methods compare :: GenWithIsBoot mod -> GenWithIsBoot mod -> Ordering # (<) :: GenWithIsBoot mod -> GenWithIsBoot mod -> Bool # (<=) :: GenWithIsBoot mod -> GenWithIsBoot mod -> Bool # (>) :: GenWithIsBoot mod -> GenWithIsBoot mod -> Bool # (>=) :: GenWithIsBoot mod -> GenWithIsBoot mod -> Bool # max :: GenWithIsBoot mod -> GenWithIsBoot mod -> GenWithIsBoot mod # min :: GenWithIsBoot mod -> GenWithIsBoot mod -> GenWithIsBoot mod #

moduleUnitId :: Module -> UnitId #

fsToUnit :: FastString -> Unit #

Create a new simple unit identifier from a FastString. Internally, this is primarily used to specify wired-in unit identifiers.

unitString :: IsUnitId u => u -> String #

toUnitId :: Unit -> UnitId #

Return the UnitId of the Unit. For on-the-fly instantiated units, return the UnitId of the indefinite unit this unit is an instance of.

unitIdString :: UnitId -> String #

data ModLocation #

Module Location

Where a module lives on the file system: the actual locations of the .hs, .hi, .dyn_hi, .o, .dyn_o and .hie files, if we have them.

For a module in another unit, the ml_hs_file and ml_obj_file components of ModLocation are undefined.

The locations specified by a ModLocation may or may not correspond to actual files yet: for example, even if the object file doesn't exist, the ModLocation still contains the path to where the object file will reside if/when it is created.

The paths of anything which can affect recompilation should be placed inside ModLocation.

When a ModLocation is created none of the filepaths will have -boot suffixes. This is because in --make mode the ModLocation is put in the finder cache which is indexed by ModuleName, when a ModLocation is retrieved from the FinderCache the boot suffixes are appended. The other case is in -c mode, there the ModLocation immediately gets given the boot suffixes in mkOneShotModLocation.

Instances

Instances details

Outputable ModLocation
Instance details Defined in GHC.Unit.Module.Location Methods ppr :: ModLocation -> SDoc #
Show ModLocation
Instance details Defined in GHC.Unit.Module.Location Methods showsPrec :: Int -> ModLocation -> ShowS # show :: ModLocation -> String # showList :: [ModLocation] -> ShowS #

lookupModuleEnv :: ModuleEnv a -> Module -> Maybe a #

moduleEnvKeys :: ModuleEnv a -> [Module] #

moduleStableString :: Module -> String #

Get a string representation of a Module that's unique and stable across recompilations. eg. "$aeson_70dylHtv1FFGeai1IoxcQr$Data.Aeson.Types.Internal"

stableModuleCmp :: Module -> Module -> Ordering #

This gives a stable ordering, as opposed to the Ord instance which gives an ordering based on the Uniques of the components, which may not be stable from run to run of the compiler.

data PkgQual #

Package-qualifier after renaming

Renaming detects if "this" or the unit-id of the home-unit was used as a package qualifier.

Constructors

NoPkgQual

No package qualifier

Instances

Instances details

Outputable PkgQual
Instance details Defined in GHC.Types.PkgQual Methods ppr :: PkgQual -> SDoc #
Data PkgQual
Instance details Defined in GHC.Types.PkgQual Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PkgQual -> c PkgQual # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PkgQual # toConstr :: PkgQual -> Constr # dataTypeOf :: PkgQual -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PkgQual) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PkgQual) # gmapT :: (forall b. Data b => b -> b) -> PkgQual -> PkgQual # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PkgQual -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PkgQual -> r # gmapQ :: (forall d. Data d => d -> u) -> PkgQual -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> PkgQual -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PkgQual -> m PkgQual # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PkgQual -> m PkgQual # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PkgQual -> m PkgQual #
Eq PkgQual
Instance details Defined in GHC.Types.PkgQual Methods (==) :: PkgQual -> PkgQual -> Bool # (/=) :: PkgQual -> PkgQual -> Bool #
Ord PkgQual
Instance details Defined in GHC.Types.PkgQual Methods compare :: PkgQual -> PkgQual -> Ordering # (<) :: PkgQual -> PkgQual -> Bool # (<=) :: PkgQual -> PkgQual -> Bool # (>) :: PkgQual -> PkgQual -> Bool # (>=) :: PkgQual -> PkgQual -> Bool # max :: PkgQual -> PkgQual -> PkgQual # min :: PkgQual -> PkgQual -> PkgQual #

type LHsExpr p #

Arguments

= XRec p (HsExpr p)

May have AnnKeywordId : AnnComma when in a list

Located Haskell Expression

data PromotionFlag #

Is a TyCon a promoted data constructor or just a normal type constructor?

Constructors

NotPromoted

Instances

Instances details

Data PromotionFlag
Instance details Defined in Language.Haskell.Syntax.Type Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PromotionFlag -> c PromotionFlag # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PromotionFlag # toConstr :: PromotionFlag -> Constr # dataTypeOf :: PromotionFlag -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PromotionFlag) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PromotionFlag) # gmapT :: (forall b. Data b => b -> b) -> PromotionFlag -> PromotionFlag # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PromotionFlag -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PromotionFlag -> r # gmapQ :: (forall d. Data d => d -> u) -> PromotionFlag -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> PromotionFlag -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PromotionFlag -> m PromotionFlag # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PromotionFlag -> m PromotionFlag # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PromotionFlag -> m PromotionFlag #
Eq PromotionFlag
Instance details Defined in Language.Haskell.Syntax.Type Methods (==) :: PromotionFlag -> PromotionFlag -> Bool # (/=) :: PromotionFlag -> PromotionFlag -> Bool #

data InlinePragma #

Instances

Instances details

Binary InlinePragma
Instance details Defined in GHC.Types.Basic Methods put_ :: BinHandle -> InlinePragma -> IO () # put :: BinHandle -> InlinePragma -> IO (Bin InlinePragma) # get :: BinHandle -> IO InlinePragma #
Outputable InlinePragma
Instance details Defined in GHC.Types.Basic Methods ppr :: InlinePragma -> SDoc #
Data InlinePragma
Instance details Defined in GHC.Types.Basic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InlinePragma -> c InlinePragma # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c InlinePragma # toConstr :: InlinePragma -> Constr # dataTypeOf :: InlinePragma -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c InlinePragma) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InlinePragma) # gmapT :: (forall b. Data b => b -> b) -> InlinePragma -> InlinePragma # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InlinePragma -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InlinePragma -> r # gmapQ :: (forall d. Data d => d -> u) -> InlinePragma -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> InlinePragma -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> InlinePragma -> m InlinePragma # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InlinePragma -> m InlinePragma # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InlinePragma -> m InlinePragma #
Eq InlinePragma
Instance details Defined in GHC.Types.Basic Methods (==) :: InlinePragma -> InlinePragma -> Bool # (/=) :: InlinePragma -> InlinePragma -> Bool #

data Phase #

Untyped Phase description

Constructors

StopLn

Instances

Instances details

Outputable Phase
Instance details Defined in GHC.Driver.Phases Methods ppr :: Phase -> SDoc #
Show Phase
Instance details Defined in GHC.Driver.Phases Methods showsPrec :: Int -> Phase -> ShowS # show :: Phase -> String # showList :: [Phase] -> ShowS #
Eq Phase
Instance details Defined in GHC.Driver.Phases Methods (==) :: Phase -> Phase -> Bool # (/=) :: Phase -> Phase -> Bool #

data DefMethSpec ty #

Default Method Specification

Constructors

VanillaDM

Instances

Instances details

Binary (DefMethSpec IfaceType)
Instance details Defined in GHC.Iface.Type Methods put_ :: BinHandle -> DefMethSpec IfaceType -> IO () # put :: BinHandle -> DefMethSpec IfaceType -> IO (Bin (DefMethSpec IfaceType)) # get :: BinHandle -> IO (DefMethSpec IfaceType) #
Outputable (DefMethSpec ty)
Instance details Defined in GHC.Types.Basic Methods ppr :: DefMethSpec ty -> SDoc #

data TupleSort #

Constructors

BoxedTuple

Instances

Instances details

Binary TupleSort
Instance details Defined in GHC.Types.Basic Methods put_ :: BinHandle -> TupleSort -> IO () # put :: BinHandle -> TupleSort -> IO (Bin TupleSort) # get :: BinHandle -> IO TupleSort #
Outputable TupleSort
Instance details Defined in GHC.Types.Basic Methods ppr :: TupleSort -> SDoc #
Data TupleSort
Instance details Defined in GHC.Types.Basic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TupleSort -> c TupleSort # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TupleSort # toConstr :: TupleSort -> Constr # dataTypeOf :: TupleSort -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TupleSort) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TupleSort) # gmapT :: (forall b. Data b => b -> b) -> TupleSort -> TupleSort # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TupleSort -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TupleSort -> r # gmapQ :: (forall d. Data d => d -> u) -> TupleSort -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TupleSort -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TupleSort -> m TupleSort # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TupleSort -> m TupleSort # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TupleSort -> m TupleSort #
Eq TupleSort
Instance details Defined in GHC.Types.Basic Methods (==) :: TupleSort -> TupleSort -> Bool # (/=) :: TupleSort -> TupleSort -> Bool #

data PprPrec #

A general-purpose pretty-printing precedence type.

Instances

Instances details

Show PprPrec
Instance details Defined in GHC.Types.Basic Methods showsPrec :: Int -> PprPrec -> ShowS # show :: PprPrec -> String # showList :: [PprPrec] -> ShowS #
Eq PprPrec
Instance details Defined in GHC.Types.Basic Methods (==) :: PprPrec -> PprPrec -> Bool # (/=) :: PprPrec -> PprPrec -> Bool #
Ord PprPrec
Instance details Defined in GHC.Types.Basic Methods compare :: PprPrec -> PprPrec -> Ordering # (<) :: PprPrec -> PprPrec -> Bool # (<=) :: PprPrec -> PprPrec -> Bool # (>) :: PprPrec -> PprPrec -> Bool # (>=) :: PprPrec -> PprPrec -> Bool # max :: PprPrec -> PprPrec -> PprPrec # min :: PprPrec -> PprPrec -> PprPrec #

data TopLevelFlag #

Constructors

NotTopLevel

Instances

Instances details

Outputable TopLevelFlag
Instance details Defined in GHC.Types.Basic Methods ppr :: TopLevelFlag -> SDoc #
Data TopLevelFlag
Instance details Defined in GHC.Types.Basic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TopLevelFlag -> c TopLevelFlag # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TopLevelFlag # toConstr :: TopLevelFlag -> Constr # dataTypeOf :: TopLevelFlag -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TopLevelFlag) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TopLevelFlag) # gmapT :: (forall b. Data b => b -> b) -> TopLevelFlag -> TopLevelFlag # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TopLevelFlag -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TopLevelFlag -> r # gmapQ :: (forall d. Data d => d -> u) -> TopLevelFlag -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TopLevelFlag -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TopLevelFlag -> m TopLevelFlag # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TopLevelFlag -> m TopLevelFlag # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TopLevelFlag -> m TopLevelFlag #

topPrec :: PprPrec #

funPrec :: PprPrec #

noOccInfo :: OccInfo #

isStrongLoopBreaker :: OccInfo -> Bool #

isDeadOcc :: OccInfo -> Bool #

isNoInlinePragma :: InlinePragma -> Bool #

data DataCon #

A data constructor

AnnKeywordId : AnnOpen, AnnClose,AnnComma

Instances

Instances details

NamedThing DataCon
Instance details Defined in GHC.Core.DataCon Methods getOccName :: DataCon -> OccName # getName :: DataCon -> Name #
Uniquable DataCon
Instance details Defined in GHC.Core.DataCon Methods getUnique :: DataCon -> Unique #
Outputable DataCon
Instance details Defined in GHC.Core.DataCon Methods ppr :: DataCon -> SDoc #
Outputable OccurrenceMap Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Play Methods ppr :: OccurrenceMap -> SDoc #
OutputableBndr DataCon
Instance details Defined in GHC.Core.DataCon Methods pprBndr :: BindingSite -> DataCon -> SDoc # pprPrefixOcc :: DataCon -> SDoc # pprInfixOcc :: DataCon -> SDoc # bndrIsJoin_maybe :: DataCon -> JoinPointHood #
Data DataCon
Instance details Defined in GHC.Core.DataCon Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DataCon -> c DataCon # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DataCon # toConstr :: DataCon -> Constr # dataTypeOf :: DataCon -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DataCon) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataCon) # gmapT :: (forall b. Data b => b -> b) -> DataCon -> DataCon # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DataCon -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DataCon -> r # gmapQ :: (forall d. Data d => d -> u) -> DataCon -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DataCon -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DataCon -> m DataCon # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DataCon -> m DataCon # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DataCon -> m DataCon #
Show DataCon Source #
Instance details Defined in Language.Haskell.Liquid.Types.DataDecl Methods showsPrec :: Int -> DataCon -> ShowS # show :: DataCon -> String # showList :: [DataCon] -> ShowS #
Eq DataCon
Instance details Defined in GHC.Core.DataCon Methods (==) :: DataCon -> DataCon -> Bool # (/=) :: DataCon -> DataCon -> Bool #
Ord DataCon Source #
Instance details Defined in Language.Haskell.Liquid.Types.Types Methods compare :: DataCon -> DataCon -> Ordering # (<) :: DataCon -> DataCon -> Bool # (<=) :: DataCon -> DataCon -> Bool # (>) :: DataCon -> DataCon -> Bool # (>=) :: DataCon -> DataCon -> Bool # max :: DataCon -> DataCon -> DataCon # min :: DataCon -> DataCon -> DataCon #
Hashable DataCon Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Misc Methods hashWithSalt :: Int -> DataCon -> Int # hash :: DataCon -> Int #
Symbolic DataCon Source #
Instance details Defined in Language.Haskell.Liquid.Types.Types Methods symbol :: DataCon -> Symbol #
PPrint DataCon Source #
Instance details Defined in Language.Haskell.Liquid.Types.DataDecl Methods pprintTidy :: Tidy -> DataCon -> Doc # pprintPrec :: Int -> Tidy -> DataCon -> Doc #

promoteDataCon :: DataCon -> TyCon #

dataConWrapId :: DataCon -> Id #

Returns an Id which looks like the Haskell-source constructor by using the wrapper if it exists (see dataConWrapId_maybe) and failing over to the worker (see dataConWorkId)

dataConFullSig :: DataCon -> ([TyVar], [TyCoVar], [EqSpec], ThetaType, [Scaled Type], Type) #

The "full signature" of the DataCon returns, in order:

1) The result of dataConUnivTyVars

2) The result of dataConExTyCoVars

3) The non-dependent GADT equalities. Dependent GADT equalities are implied by coercion variables in return value (2).

4) The other constraints of the data constructor type, excluding GADT equalities

5) The original argument types to the DataCon (i.e. before any change of the representation of the type) with linearity annotations

6) The original result type of the DataCon

dataConFieldLabels :: DataCon -> [FieldLabel] #

The labels for the fields of this particular DataCon

dataConExTyCoVars :: DataCon -> [TyCoVar] #

The existentially-quantified type/coercion variables of the constructor including dependent (kind-) GADT equalities

dataConTyCon :: DataCon -> TyCon #

The type constructor that we are building via this data constructor

dataConWorkId :: DataCon -> Id #

Get the Id of the DataCon worker: a function that is the "actual" constructor and has no top level binding in the program. The type may be different from the obvious one written in the source program. Panics if there is no such Id for this DataCon

dataConName :: DataCon -> Name #

The Name of the DataCon, giving it a unique, rooted identification

tupleTyCon :: Boxity -> Arity -> TyCon #

tupleDataCon :: Boxity -> Arity -> DataCon #

naturalTy :: Type #

tupleTyConName :: TupleSort -> Arity -> Name #

liftedTypeKind :: Type #

liftedTypeKindTyConName :: Name #

typeSymbolKind :: Kind #

listTyCon :: TyCon #

data NameSpace #

Instances

Instances details

NFData NameSpace
Instance details Defined in GHC.Types.Name.Occurrence Methods rnf :: NameSpace -> () #
Uniquable NameSpace
Instance details Defined in GHC.Types.Name.Occurrence Methods getUnique :: NameSpace -> Unique #
Binary NameSpace
Instance details Defined in GHC.Types.Name.Occurrence Methods put_ :: BinHandle -> NameSpace -> IO () # put :: BinHandle -> NameSpace -> IO (Bin NameSpace) # get :: BinHandle -> IO NameSpace #
Eq NameSpace
Instance details Defined in GHC.Types.Name.Occurrence Methods (==) :: NameSpace -> NameSpace -> Bool # (/=) :: NameSpace -> NameSpace -> Bool #
Ord NameSpace
Instance details Defined in GHC.Types.Name.Occurrence Methods compare :: NameSpace -> NameSpace -> Ordering # (<) :: NameSpace -> NameSpace -> Bool # (<=) :: NameSpace -> NameSpace -> Bool # (>) :: NameSpace -> NameSpace -> Bool # (>=) :: NameSpace -> NameSpace -> Bool # max :: NameSpace -> NameSpace -> NameSpace # min :: NameSpace -> NameSpace -> NameSpace #

tcName :: NameSpace #

dataName :: NameSpace #

isFieldNameSpace :: NameSpace -> Bool #

mkOccName :: NameSpace -> String -> OccName #

mkVarOcc :: String -> OccName #

mkTyVarOcc :: String -> OccName #

mkTcOcc :: String -> OccName #

occNameString :: OccName -> String #

nameNameSpace :: Name -> NameSpace #

nameSrcLoc :: Name -> SrcLoc #

nameSrcSpan :: Name -> SrcSpan #

isTupleTyConName :: Name -> Bool #

isExternalName :: Name -> Bool #

isInternalName :: Name -> Bool #

nameModule :: HasDebugCallStack => Name -> Module #

nameModule_maybe :: Name -> Maybe Module #

isSystemName :: Name -> Bool #

mkInternalName :: Unique -> OccName -> SrcSpan -> Name #

Create a name which is (for now at least) local to the current module and hence does not need a Module to disambiguate it from other Names

mkSystemName :: Unique -> OccName -> Name #

Create a name brought into being by the compiler

stableNameCmp :: Name -> Name -> Ordering #

Compare Names lexicographically This only works for Names that originate in the source code or have been tidied.

nameStableString :: Name -> String #

Get a string representation of a Name that's unique and stable across recompilations. Used for deterministic generation of binds for derived instances. eg. "$aeson_70dylHtv1FFGeai1IoxcQr$Data.Aeson.Types.Internal$String"

getSrcSpan :: NamedThing a => a -> SrcSpan #

getOccString :: NamedThing a => a -> String #

type NameSet = UniqSet Name #

elemNameSet :: Name -> NameSet -> Bool #

nameSetElemsStable :: NameSet -> [Name] #

Get the elements of a NameSet with some stable ordering. This only works for Names that originate in the source code or have been tidied. See Note [Deterministic UniqFM] to learn about nondeterminism

type NameEnv a = UniqFM Name a #

Name Environment

lookupNameEnv :: NameEnv a -> Name -> Maybe a #

mkNameEnv :: [(Name, a)] -> NameEnv a #

mkNameEnvWith :: (a -> Name) -> [a] -> NameEnv a #

type TyVarBinder = VarBndr TyVar ForAllTyFlag #

type DFunId = Id #

Dictionary Function Identifier

varUnique :: Var -> Unique #

setVarUnique :: Var -> Unique -> Var #

setVarName :: Var -> Name -> Var #

setVarType :: Var -> Type -> Var #

binderVar :: VarBndr tv argf -> tv #

tyVarKind :: TyVar -> Kind #

mkTyVar :: Name -> Kind -> TyVar #

idInfo :: HasDebugCallStack => Id -> IdInfo #

idDetails :: Id -> IdDetails #

mkLocalVar :: IdDetails -> Name -> Mult -> Type -> IdInfo -> Id #

isId :: Var -> Bool #

Is this a value-level (i.e., computationally relevant) Identifier? Satisfies isId = not . isTyVar.

isCoVar :: Var -> Bool #

Is this a coercion variable? Satisfies isId v ==> isCoVar v == not (isNonCoVarId v).

isLocalId :: Var -> Bool #

tyConAppTyCon_maybe :: Type -> Maybe TyCon #

The same as fst . splitTyConApp We can short-cut the FunTy case

splitTyConApp_maybe :: HasDebugCallStack => Type -> Maybe (TyCon, [Type]) #

Attempts to tease a type apart into a type constructor and the application of a number of arguments to that constructor

mkTyConApp :: TyCon -> [Type] -> Type #

A key function: builds a TyConApp or FunTy as appropriate to its arguments. Applies its arguments to the constructor from left to right.

type VarSet = UniqSet Var #

A non-deterministic Variable Set

A non-deterministic set of variables. See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM for explanation why it's not deterministic and why it matters. Use DVarSet if the set eventually gets converted into a list or folded over in a way where the order changes the generated code, for example when abstracting variables.

emptyVarSet :: VarSet #

unitVarSet :: Var -> VarSet #

extendVarSet :: VarSet -> Var -> VarSet #

extendVarSetList :: VarSet -> [Var] -> VarSet #

elemVarSet :: Var -> VarSet -> Bool #

tyCoVarsOfType :: Type -> TyCoVarSet #

emptyInScopeSet :: InScopeSet #

mkRnEnv2 :: InScopeSet -> RnEnv2 #

noAnn :: NoAnn a => a #

equivalent of mempty, but does not need Semigroup

noAnnSrcSpan :: HasAnnotation e => SrcSpan -> e #

type LocatedN = GenLocated SrcSpanAnnN #

noLocA :: HasAnnotation e => a -> GenLocated e a #

getLocA :: HasLoc a => GenLocated a e -> SrcSpan #

data GREInfo #

Information about a Name that is pertinent to the renamer.

See Note [GREInfo]

Instances

Instances details

NFData GREInfo
Instance details Defined in GHC.Types.GREInfo Methods rnf :: GREInfo -> () #
Outputable GREInfo
Instance details Defined in GHC.Types.GREInfo Methods ppr :: GREInfo -> SDoc #
Data GREInfo
Instance details Defined in GHC.Types.GREInfo Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GREInfo -> c GREInfo # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c GREInfo # toConstr :: GREInfo -> Constr # dataTypeOf :: GREInfo -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c GREInfo) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GREInfo) # gmapT :: (forall b. Data b => b -> b) -> GREInfo -> GREInfo # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GREInfo -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GREInfo -> r # gmapQ :: (forall d. Data d => d -> u) -> GREInfo -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> GREInfo -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> GREInfo -> m GREInfo # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GREInfo -> m GREInfo # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GREInfo -> m GREInfo #

data AvailInfo #

Records what things are "available", i.e. in scope

Constructors

Avail Name

An ordinary identifier in scope, or a field label without a parent type (see Note [Representing pattern synonym fields in AvailInfo]).

AvailTC

A type or class in scope

The AvailTC Invariant: If the type or class is itself to be in scope, it must be first in this list. Thus, typically:

AvailTC Eq [Eq, ==, \/=]

Fields

Name
The name of the type or class
[Name]
The available pieces of type or class

Instances

Instances details

NFData AvailInfo
Instance details Defined in GHC.Types.Avail Methods rnf :: AvailInfo -> () #
Binary AvailInfo
Instance details Defined in GHC.Types.Avail Methods put_ :: BinHandle -> AvailInfo -> IO () # put :: BinHandle -> AvailInfo -> IO (Bin AvailInfo) # get :: BinHandle -> IO AvailInfo #
Outputable AvailInfo
Instance details Defined in GHC.Types.Avail Methods ppr :: AvailInfo -> SDoc #
Data AvailInfo
Instance details Defined in GHC.Types.Avail Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AvailInfo -> c AvailInfo # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AvailInfo # toConstr :: AvailInfo -> Constr # dataTypeOf :: AvailInfo -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AvailInfo) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AvailInfo) # gmapT :: (forall b. Data b => b -> b) -> AvailInfo -> AvailInfo # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AvailInfo -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AvailInfo -> r # gmapQ :: (forall d. Data d => d -> u) -> AvailInfo -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AvailInfo -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AvailInfo -> m AvailInfo # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AvailInfo -> m AvailInfo # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AvailInfo -> m AvailInfo #

availsToNameSet :: [AvailInfo] -> NameSet #

availNames :: AvailInfo -> [Name] #

Names and fields made available by the availability information.

data ImpItemSpec #

Import Item Specification

Describes import info a particular Name

Constructors

ImpAll

The import had no import list, or had a hiding list

Instances

Instances details

Data ImpItemSpec
Instance details Defined in GHC.Types.Name.Reader Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImpItemSpec -> c ImpItemSpec # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ImpItemSpec # toConstr :: ImpItemSpec -> Constr # dataTypeOf :: ImpItemSpec -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ImpItemSpec) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImpItemSpec) # gmapT :: (forall b. Data b => b -> b) -> ImpItemSpec -> ImpItemSpec # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImpItemSpec -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImpItemSpec -> r # gmapQ :: (forall d. Data d => d -> u) -> ImpItemSpec -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ImpItemSpec -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImpItemSpec -> m ImpItemSpec # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImpItemSpec -> m ImpItemSpec # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImpItemSpec -> m ImpItemSpec #
Eq ImpItemSpec
Instance details Defined in GHC.Types.Name.Reader Methods (==) :: ImpItemSpec -> ImpItemSpec -> Bool # (/=) :: ImpItemSpec -> ImpItemSpec -> Bool #

data WhichGREs info where #

How should we look up in a GlobalRdrEnv? Which NameSpaces are considered relevant for a given lookup?

Constructors

SameNameSpace :: forall info. WhichGREs info	Only consider `GlobalRdrElt`s with the exact `NameSpace` we look up.
RelevantGREs	Allow `GlobalRdrElt`s with different `NameSpace`s, e.g. allow looking up record fields from the variable `NameSpace`, or looking up a `TyCon` from the data constructor `NameSpace`.
Fields :: { includeFieldSelectors :: !FieldsOrSelectors how should we handle looking up variables? should we include record fields defined with `-XNoFieldSelectors`? should we include non-fields? See Note [NoFieldSelectors]. , lookupVariablesForFields :: !Bool when looking up a record field, should we also look up plain variables? , lookupTyConsAsWell :: !Bool when looking up a variable, field or data constructor, should we also try the type constructor `NameSpace`? } -> WhichGREs GREInfo

Instances

Instances details

Outputable (WhichGREs info)
Instance details Defined in GHC.Types.Name.Reader Methods ppr :: WhichGREs info -> SDoc #

data LookupGRE info where #

What should we look up in a GlobalRdrEnv? Should we only look up names with the exact same OccName, or do we allow different NameSpaces?

Depending on the answer, we might need more or less information from the GlobalRdrEnv, e.g. if we want to include matching record fields we need to know if the corresponding record fields define field selectors, for which we need to consult the GREInfo. This is why this datatype is a GADT.

See Note [IfGlobalRdrEnv].

Constructors

LookupRdrName

Look up the OccName of this RdrName in the GlobalRdrEnv, filtering out those whose qualification matches that of the RdrName.

Lookup returns an empty result for Exact or Orig RdrNames.

Fields

:: forall info. RdrName
the RdrName to look up
-> WhichGREs info
information about other relevant NameSpaces
-> LookupGRE info

data FieldsOrSelectors #

When looking up GREs, we may or may not want to include fields that were defined in modules with NoFieldSelectors enabled. See Note [NoFieldSelectors].

Constructors

WantNormal

Include normal names, and fields with selectors, but ignore fields without selectors.

Instances

Instances details

Show FieldsOrSelectors
Instance details Defined in GHC.Types.Name.Reader Methods showsPrec :: Int -> FieldsOrSelectors -> ShowS # show :: FieldsOrSelectors -> String # showList :: [FieldsOrSelectors] -> ShowS #
Eq FieldsOrSelectors
Instance details Defined in GHC.Types.Name.Reader Methods (==) :: FieldsOrSelectors -> FieldsOrSelectors -> Bool # (/=) :: FieldsOrSelectors -> FieldsOrSelectors -> Bool #

type GlobalRdrEnv = GlobalRdrEnvX GREInfo #

Global Reader Environment

Keyed by OccName; when looking up a qualified name we look up the OccName part, and then check the Provenance to see if the appropriate qualification is valid. This saves routinely doubling the size of the env by adding both qualified and unqualified names to the domain.

The list in the codomain is required because there may be name clashes These only get reported on lookup, not on construction

INVARIANT 1: All the members of the list have distinct gre_name fields; that is, no duplicate Names

INVARIANT 2: Imported provenance => Name is an ExternalName However LocalDefs can have an InternalName. This happens only when type-checking a [d| ... |] Template Haskell quotation; see this note in GHC.Rename.Names Note [Top-level Names in Template Haskell decl quotes]

INVARIANT 3: If the GlobalRdrEnv maps [occ -> gre], then greOccName gre = occ

mkRdrUnqual :: OccName -> RdrName #

mkRdrQual :: ModuleName -> OccName -> RdrName #

mkUnqual :: NameSpace -> FastString -> RdrName #

mkVarUnqual :: FastString -> RdrName #

mkQual :: NameSpace -> (FastString, FastString) -> RdrName #

Make a qualified RdrName in the given namespace and where the ModuleName and the OccName are taken from the first and second elements of the tuple respectively

getRdrName :: NamedThing thing => thing -> RdrName #

nameRdrName :: Name -> RdrName #

greName :: GlobalRdrEltX info -> Name #

globalRdrEnvElts :: GlobalRdrEnvX info -> [GlobalRdrEltX info] #

lookupGRE :: GlobalRdrEnvX info -> LookupGRE info -> [GlobalRdrEltX info] #

Look something up in the Global Reader Environment.

The LookupGRE argument specifies what to look up, and in particular whether there should there be any lee-way if the NameSpaces don't exactly match.

lookupGRE_Name :: Outputable info => GlobalRdrEnvX info -> Name -> Maybe (GlobalRdrEltX info) #

Look for precisely this Name in the environment, in the same NameSpace as the Name.

This tests whether it is in scope, ignoring anything else that might be in scope which doesn't have the same Unique.

isLocalGRE :: GlobalRdrEltX info -> Bool #

Is this GlobalRdrElt defined locally?

type GhcRn = GhcPass 'Renamed #

type GhcPs = GhcPass 'Parsed #

ideclAs :: ImportDecl pass -> Maybe (XRec pass ModuleName) #

as Module

ideclName :: ImportDecl pass -> XRec pass ModuleName #

Module name.

type LImportDecl pass #

Arguments

= XRec pass (ImportDecl pass)

When in a list this may have

AnnKeywordId : AnnSemi

Located Import Declaration

data ImportedModsVal #

type ImportedMods = ModuleEnv [ImportedBy] #

Records the modules directly imported by a module for extracting e.g. usage information, and also to give better error message

importedByUser :: [ImportedBy] -> [ImportedModsVal] #

itName :: Unique -> SrcSpan -> Name #

ge_RDR :: RdrName #

le_RDR :: RdrName #

lt_RDR :: RdrName #

gt_RDR :: RdrName #

times_RDR :: RdrName #

plus_RDR :: RdrName #

and_RDR :: RdrName #

not_RDR :: RdrName #

varQual_RDR :: Module -> FastString -> RdrName #

eqClassName :: Name #

ordClassName :: Name #

bindMName :: Name #

negateName :: Name #

isStringClassName :: Name #

eqClassKey :: Unique #

fractionalClassKey :: Unique #

ordClassKey :: Unique #

numericClassKeys :: [Unique] #

fractionalClassKeys :: [Unique] #

data AnnTarget name #

An annotation target

Constructors

ModuleTarget Module

We are annotating a particular module

Instances

Instances details

Functor AnnTarget
Instance details Defined in GHC.Types.Annotations Methods fmap :: (a -> b) -> AnnTarget a -> AnnTarget b # (<$) :: a -> AnnTarget b -> AnnTarget a #
Binary name => Binary (AnnTarget name)
Instance details Defined in GHC.Types.Annotations Methods put_ :: BinHandle -> AnnTarget name -> IO () # put :: BinHandle -> AnnTarget name -> IO (Bin (AnnTarget name)) # get :: BinHandle -> IO (AnnTarget name) #
Outputable name => Outputable (AnnTarget name)
Instance details Defined in GHC.Types.Annotations Methods ppr :: AnnTarget name -> SDoc #

type AnnPayload #

Arguments

= Serialized

The "payload" of an annotation allows recovery of its value at a given type, and can be persisted to an interface file

findAnns :: Typeable a => ([Word8] -> a) -> AnnEnv -> CoreAnnTarget -> [a] #

Find the annotations attached to the given target as Typeable values of your choice. If no deserializer is specified, only transient annotations will be returned.

data Hsc a #

The Hsc monad: Passing an environment and diagnostic state

Instances

Instances details

MonadIO Hsc
Instance details Defined in GHC.Driver.Env.Types Methods liftIO :: IO a -> Hsc a #
HasDynFlags Hsc
Instance details Defined in GHC.Driver.Env.Types Methods getDynFlags :: Hsc DynFlags #
HasLogger Hsc
Instance details Defined in GHC.Driver.Env.Types Methods getLogger :: Hsc Logger #
Applicative Hsc
Instance details Defined in GHC.Driver.Env.Types Methods pure :: a -> Hsc a # (<>) :: Hsc (a -> b) -> Hsc a -> Hsc b # liftA2 :: (a -> b -> c) -> Hsc a -> Hsc b -> Hsc c # (>) :: Hsc a -> Hsc b -> Hsc b # (<*) :: Hsc a -> Hsc b -> Hsc a #
Functor Hsc
Instance details Defined in GHC.Driver.Env.Types Methods fmap :: (a -> b) -> Hsc a -> Hsc b # (<$) :: a -> Hsc b -> Hsc a #
Monad Hsc
Instance details Defined in GHC.Driver.Env.Types Methods (>>=) :: Hsc a -> (a -> Hsc b) -> Hsc b # (>>) :: Hsc a -> Hsc b -> Hsc b # return :: a -> Hsc a #

coAxiomTyCon :: forall (br :: BranchFlag). CoAxiom br -> TyCon #

coercionKind :: Coercion -> Pair Type #

If it is the case that

c :: (t1 ~ t2)

i.e. the kind of c relates t1 and t2, then coercionKind c = Pair t1 t2.

data Class #

Instances

Instances details

NFData Class Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Misc Methods rnf :: Class -> () #
NamedThing Class
Instance details Defined in GHC.Core.Class Methods getOccName :: Class -> OccName # getName :: Class -> Name #
Uniquable Class
Instance details Defined in GHC.Core.Class Methods getUnique :: Class -> Unique #
Outputable Class
Instance details Defined in GHC.Core.Class Methods ppr :: Class -> SDoc #
Data Class
Instance details Defined in GHC.Core.Class Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Class -> c Class # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Class # toConstr :: Class -> Constr # dataTypeOf :: Class -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Class) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Class) # gmapT :: (forall b. Data b => b -> b) -> Class -> Class # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Class -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Class -> r # gmapQ :: (forall d. Data d => d -> u) -> Class -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Class -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Class -> m Class # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Class -> m Class # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Class -> m Class #
Show Class Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Misc Methods showsPrec :: Int -> Class -> ShowS # show :: Class -> String # showList :: [Class] -> ShowS #
Eq Class
Instance details Defined in GHC.Core.Class Methods (==) :: Class -> Class -> Bool # (/=) :: Class -> Class -> Bool #
Hashable Class Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Misc Methods hashWithSalt :: Int -> Class -> Int # hash :: Class -> Int #
Symbolic Class Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Misc Methods symbol :: Class -> Symbol #
Fixpoint Class Source #
Instance details Defined in Language.Haskell.Liquid.Types.RefType Methods toFix :: Class -> Doc # simplify :: Class -> Class #
PPrint Class Source #
Instance details Defined in Language.Haskell.Liquid.Types.PrettyPrint Methods pprintTidy :: Tidy -> Class -> Doc # pprintPrec :: Int -> Tidy -> Class -> Doc #

classAllSelIds :: Class -> [Id] #

classSCSelIds :: Class -> [Id] #

classMethods :: Class -> [Id] #

classOpItems :: Class -> [ClassOpItem] #

classSCTheta :: Class -> [PredType] #

classBigSig :: Class -> ([TyVar], [PredType], [Id], [ClassOpItem]) #

data TyConBndrVis #

Constructors

AnonTCB

an ordinary, visible type argument

Instances

Instances details

Binary TyConBndrVis
Instance details Defined in GHC.Core.TyCon Methods put_ :: BinHandle -> TyConBndrVis -> IO () # put :: BinHandle -> TyConBndrVis -> IO (Bin TyConBndrVis) # get :: BinHandle -> IO TyConBndrVis #
Outputable TyConBndrVis
Instance details Defined in GHC.Core.TyCon Methods ppr :: TyConBndrVis -> SDoc #
ReifyFlag TyConBndrVis (Maybe BndrVis)
Instance details Defined in GHC.Tc.Gen.Splice Methods reifyFlag :: TyConBndrVis -> Maybe BndrVis
OutputableBndr tv => Outputable (VarBndr tv TyConBndrVis)
Instance details Defined in GHC.Core.TyCon Methods ppr :: VarBndr tv TyConBndrVis -> SDoc #

type TyConBinder = VarBndr TyVar TyConBndrVis #

mkPrimTyCon #

Arguments

:: Name
-> [TyConBinder]
-> Kind	result kind Must answer `True` to `isFixedRuntimeRepKind` (i.e., no representation polymorphism). (If you need a representation-polymorphic PrimTyCon, change tcHasFixedRuntimeRep, marshalablePrimTyCon, reifyTyCon for PrimTyCons.)
-> [Role]
-> TyCon

Create an primitive TyCon, such as Int#, Type or RealWorld Primitive TyCons are marshalable iff not lifted. If you'd like to change this, modify marshalablePrimTyCon.

isPrimTyCon :: TyCon -> Bool #

Does this TyCon represent something that cannot be defined in Haskell?

isAlgTyCon :: TyCon -> Bool #

Returns True if the supplied TyCon resulted from either a data or newtype declaration

isVanillaAlgTyCon :: TyCon -> Bool #

Returns True for vanilla AlgTyCons -- that is, those created with a data or newtype declaration.

isNewTyCon :: TyCon -> Bool #

Is this TyCon that for a newtype

isTypeSynonymTyCon :: TyCon -> Bool #

Is this a TyCon representing a regular H98 type synonym (type)?

isGadtSyntaxTyCon :: TyCon -> Bool #

Is this an algebraic TyCon declared with the GADT syntax?

isFamilyTyCon :: TyCon -> Bool #

Is this a TyCon, synonym or otherwise, that defines a family?

isBoxedTupleTyCon :: TyCon -> Bool #

Is this the TyCon for a boxed tuple?

isPromotedDataCon :: TyCon -> Bool #

Is this a PromotedDataCon?

tyConDataCons :: TyCon -> [DataCon] #

As tyConDataCons_maybe, but returns the empty list of constructors if no constructors could be found

tyConDataCons_maybe :: TyCon -> Maybe [DataCon] #

Determine the DataCons originating from the given TyCon, if the TyCon is the sort that can have any constructors (note: this does not include abstract algebraic types)

tyConSingleDataCon_maybe :: TyCon -> Maybe DataCon #

If the given TyCon has a single data constructor, i.e. it is a data type with one alternative, a tuple type or a newtype then that constructor is returned. If the TyCon has more than one constructor, or represents a primitive or function type constructor then Nothing is returned.

newTyConRhs :: TyCon -> ([TyVar], Type) #

Extract the bound type variables and type expansion of a type synonym TyCon. Panics if the TyCon is not a synonym

newTyConEtadArity :: TyCon -> Int #

The number of type parameters that need to be passed to a newtype to resolve it. May be less than in the definition if it can be eta-contracted.

synTyConDefn_maybe :: TyCon -> Maybe ([TyVar], Type) #

Extract the TyVars bound by a vanilla type synonym and the corresponding (unsubstituted) right hand side.

synTyConRhs_maybe :: TyCon -> Maybe Type #

Extract the information pertaining to the right hand side of a type synonym (type) declaration.

isClassTyCon :: TyCon -> Bool #

Is this TyCon that for a class instance?

tyConClass_maybe :: TyCon -> Maybe Class #

If this TyCon is that for a class instance, return the class it is for. Otherwise returns Nothing

isFamInstTyCon :: TyCon -> Bool #

Is this TyCon that for a data family instance?

tyConFamInst_maybe :: TyCon -> Maybe (TyCon, [Type]) #

If this TyCon is that of a data family instance, return the family in question and the instance types. Otherwise, return Nothing

mkTyVarTy :: TyVar -> Type #

mkTyVarTys :: [TyVar] -> [Type] #

mkForAllTys :: [ForAllTyBinder] -> Type -> Type #

Wraps foralls over the type using the provided TyCoVars from left to right

primTyCons :: [TyCon] #

isArrowTyCon :: TyCon -> Bool #

eqPrimTyCon :: TyCon #

eqReprPrimTyCon :: TyCon #

tyCoVarsOfCo :: Coercion -> TyCoVarSet #

emptyTvSubstEnv :: TvSubstEnv #

emptySubst :: Subst #

extendSubstInScopeSet :: Subst -> VarSet -> Subst #

Add the Vars to the in-scope set: see also extendInScope

extendCvSubst :: Subst -> CoVar -> Coercion -> Subst #

Add a substitution from a CoVar to a Coercion to the Subst: you must ensure that the in-scope set satisfies Note [The substitution invariant] after extending the substitution like this

zipTvSubst :: HasDebugCallStack => [TyVar] -> [Type] -> Subst #

Generates the in-scope set for the Subst from the types in the incoming environment. No CoVars or Ids, please!

mkTvSubstPrs :: [(TyVar, Type)] -> Subst #

Generates the in-scope set for the TCvSubst from the types in the incoming environment. No CoVars, please! The InScopeSet is just a thunk so with a bit of luck it'll never be evaluated

substTyWith :: HasDebugCallStack => [TyVar] -> [Type] -> Type -> Type #

Type substitution, see zipTvSubst

substTy :: HasDebugCallStack => Subst -> Type -> Type #

Substitute within a Type The substitution has to satisfy the invariants described in Note [The substitution invariant].

substCo :: HasDebugCallStack => Subst -> Coercion -> Coercion #

Substitute within a Coercion The substitution has to satisfy the invariants described in Note [The substitution invariant].

pattern ManyTy :: Mult #

isTyVarTy :: Type -> Bool #

splitAppTys :: HasDebugCallStack => Type -> (Type, [Type]) #

Recursively splits a type as far as is possible, leaving a residual type being applied to and the type arguments applied to it. Never fails, even if that means returning an empty list of type applications.

splitFunTy_maybe :: Type -> Maybe (FunTyFlag, Mult, Type, Type) #

Attempts to extract the multiplicity, argument and result types from a type

splitFunTys :: Type -> ([Scaled Type], Type) #

piResultTys :: HasDebugCallStack => Type -> [Type] -> Type #

(piResultTys f_ty [ty1, .., tyn]) gives the type of (f ty1 .. tyn) where f :: f_ty piResultTys is interesting because: 1. f_ty may have more for-alls than there are args 2. Less obviously, it may have fewer for-alls For case 2. think of: piResultTys (forall a.a) [forall b.b, Int] This really can happen, but only (I think) in situations involving undefined. For example: undefined :: forall a. a Term: undefined (forall b. b->b) Int This term should have type (Int -> Int), but notice that there are more type args than foralls in undefineds type.

tyConAppArgs_maybe :: Type -> Maybe [Type] #

The same as snd . splitTyConApp

newTyConInstRhs :: TyCon -> [Type] -> Type #

Unwrap one layer of newtype on a type constructor and its arguments, using an eta-reduced version of the newtype if possible. This requires tys to have at least newTyConInstArity tycon elements.

splitForAllTyCoVars :: Type -> ([TyCoVar], Type) #

Take a ForAllTy apart, returning the list of tycovars and the result type. This always succeeds, even if it returns only an empty list. Note that the result type returned may have free variables that were bound by a forall.

isFunTy :: Type -> Bool #

Is this a function?

dropForAlls :: Type -> Type #

Drops all ForAllTys

isTYPEorCONSTRAINT :: Kind -> Bool #

Does this classify a type allowed to have values? Responds True to things like *, TYPE Lifted, TYPE IntRep, TYPE v, Constraint.

True of a kind `TYPE _` or `CONSTRAINT _`

irrelevantMult :: Scaled a -> a #

eqType :: Type -> Type -> Bool #

Type equality on source types. Does not look through newtypes, PredTypes or type families, but it does look through type synonyms. This first checks that the kinds of the types are equal and then checks whether the types are equal, ignoring casts and coercions. (The kind check is a recursive call, but since all kinds have type Type, there is no need to check the types of kinds.) See also Note [Non-trivial definitional equality] in GHC.Core.TyCo.Rep.

nonDetCmpType :: Type -> Type -> Ordering #

type CoreTickish = GenTickish 'TickishPassCore #

data LitNumType #

Numeric literal type

Constructors

LitNumInt

Int# - according to target machine

Instances

Instances details

Binary LitNumType
Instance details Defined in GHC.Types.Literal Methods put_ :: BinHandle -> LitNumType -> IO () # put :: BinHandle -> LitNumType -> IO (Bin LitNumType) # get :: BinHandle -> IO LitNumType #
Data LitNumType
Instance details Defined in GHC.Types.Literal Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LitNumType -> c LitNumType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LitNumType # toConstr :: LitNumType -> Constr # dataTypeOf :: LitNumType -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c LitNumType) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LitNumType) # gmapT :: (forall b. Data b => b -> b) -> LitNumType -> LitNumType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LitNumType -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LitNumType -> r # gmapQ :: (forall d. Data d => d -> u) -> LitNumType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> LitNumType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> LitNumType -> m LitNumType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LitNumType -> m LitNumType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LitNumType -> m LitNumType #
Enum LitNumType
Instance details Defined in GHC.Types.Literal Methods succ :: LitNumType -> LitNumType # pred :: LitNumType -> LitNumType # toEnum :: Int -> LitNumType # fromEnum :: LitNumType -> Int # enumFrom :: LitNumType -> [LitNumType] # enumFromThen :: LitNumType -> LitNumType -> [LitNumType] # enumFromTo :: LitNumType -> LitNumType -> [LitNumType] # enumFromThenTo :: LitNumType -> LitNumType -> LitNumType -> [LitNumType] #
Eq LitNumType
Instance details Defined in GHC.Types.Literal Methods (==) :: LitNumType -> LitNumType -> Bool # (/=) :: LitNumType -> LitNumType -> Bool #
Ord LitNumType
Instance details Defined in GHC.Types.Literal Methods compare :: LitNumType -> LitNumType -> Ordering # (<) :: LitNumType -> LitNumType -> Bool # (<=) :: LitNumType -> LitNumType -> Bool # (>) :: LitNumType -> LitNumType -> Bool # (>=) :: LitNumType -> LitNumType -> Bool # max :: LitNumType -> LitNumType -> LitNumType # min :: LitNumType -> LitNumType -> LitNumType #

literalType :: Literal -> Type #

Find the Haskell Type the literal occupies

mkRepReflCo :: Type -> Coercion #

Make a representational reflexive coercion

ruleMatchTyKiX #

Arguments

:: TyCoVarSet	template variables
-> RnEnv2
-> TvSubstEnv	type substitution to extend
-> Type	Template
-> Type	Target
-> Maybe TvSubstEnv

This one is called from the expression matcher, which already has a MatchEnv in hand

tcUnifyTy :: Type -> Type -> Maybe Subst #

Simple unification of two types; all type variables are bindable Precondition: the kinds are already equal

mkClassPred :: Class -> [Type] -> PredType #

getClassPredTys :: HasDebugCallStack => PredType -> (Class, [Type]) #

getClassPredTys_maybe :: PredType -> Maybe (Class, [Type]) #

isEvVarType :: Type -> Bool #

isClassPred :: PredType -> Bool #

isEqPred :: PredType -> Bool #

isEqPrimPred :: PredType -> Bool #

isDictId :: Id -> Bool #

data StrictnessMark #

Instances

Instances details

Binary StrictnessMark
Instance details Defined in GHC.Core.DataCon Methods put_ :: BinHandle -> StrictnessMark -> IO () # put :: BinHandle -> StrictnessMark -> IO (Bin StrictnessMark) # get :: BinHandle -> IO StrictnessMark #
Outputable StrictnessMark
Instance details Defined in GHC.Core.DataCon Methods ppr :: StrictnessMark -> SDoc #
Eq StrictnessMark
Instance details Defined in GHC.Core.DataCon Methods (==) :: StrictnessMark -> StrictnessMark -> Bool # (/=) :: StrictnessMark -> StrictnessMark -> Bool #

dataConRepType :: DataCon -> Type #

The representation type of the data constructor, i.e. the sort type that will represent values of this type at runtime

dataConUnivTyVars :: DataCon -> [TyVar] #

The universally-quantified type variables of the constructor

dataConTheta :: DataCon -> ThetaType #

The *full* constraints on the constructor type, including dependent GADT equalities.

dataConWrapId_maybe :: DataCon -> Maybe Id #

Get the Id of the DataCon wrapper: a function that wraps the "actual" constructor so it has the type visible in the source program: c.f. dataConWorkId. Returns Nothing if there is no wrapper, which occurs for an algebraic data constructor and also for a newtype (whose constructor is inlined compulsorily)

dataConImplicitTyThings :: DataCon -> [TyThing] #

Find all the Ids implicitly brought into scope by the data constructor. Currently, the union of the dataConWorkId and the dataConWrapId

dataConRepStrictness :: DataCon -> [StrictnessMark] #

Give the demands on the arguments of a Core constructor application (Con dc args)

dataConWrapperType :: DataCon -> Type #

The user-declared type of the data constructor in the nice-to-read form:

T :: forall a b. a -> b -> T [a]

rather than:

T :: forall a c. forall b. (c~[a]) => a -> b -> T c

The type variables are quantified in the order that the user wrote them. See Note [DataCon user type variable binders].

NB: If the constructor is part of a data instance, the result type mentions the family tycon, not the internal one.

dataConInstArgTys #

Arguments

:: DataCon	A datacon with no existentials or equality constraints However, it can have a dcTheta (notably it can be a class dictionary, with superclasses)
-> [Type]	Instantiated at these types
-> [Scaled Type]

Finds the instantiated types of the arguments required to construct a DataCon representation NB: these INCLUDE any dictionary args but EXCLUDE the data-declaration context, which is discarded It's all post-flattening etc; this is a representation type

dataConOrigArgTys :: DataCon -> [Scaled Type] #

Returns the argument types of the wrapper, excluding all dictionary arguments and without substituting for any type variables

dataConRepArgTys :: DataCon -> [Scaled Type] #

Returns the arg types of the worker, including *all* non-dependent evidence, after any flattening has been done and without substituting for any type variables

isTupleDataCon :: DataCon -> Bool #

isVanillaDataCon :: DataCon -> Bool #

Vanilla DataCons are those that are nice boring Haskell 98 constructors

classDataCon :: Class -> DataCon #

data HsArg p tm ty #

Arguments in an expression/type after splitting

Constructors

HsValArg !(XValArg p) tm

Instances

Instances details

(ToHie tm, ToHie ty) => ToHie (HsArg (GhcPass p) tm ty)
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: HsArg (GhcPass p) tm ty -> HieM [HieAST Type]

data HsType pass #

Haskell Type

Constructors

HsForAllTy (XForAllTy pass) (HsForAllTelescope pass) (LHsType pass)	`AnnKeywordId` : `AnnForall`, `AnnDot`,`AnnDarrow` For details on above see Note [exact print annotations] in GHC.Parser.Annotation
HsQualTy (XQualTy pass) (LHsContext pass) (LHsType pass)
HsTyVar (XTyVar pass) PromotionFlag (LIdP pass)	`AnnKeywordId` : None
HsAppTy (XAppTy pass) (LHsType pass) (LHsType pass)	`AnnKeywordId` : None
HsWildCardTy (XWildCardTy pass)	`AnnKeywordId` : None

Instances

Instances details

ToHie (TScoped (FamEqn GhcRn (LocatedA (HsType GhcRn))))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: TScoped (FamEqn GhcRn (LocatedA (HsType GhcRn))) -> HieM [HieAST Type]
ToHie (TScoped (HsWildCardBndrs GhcRn (LocatedA (HsType GhcRn))))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: TScoped (HsWildCardBndrs GhcRn (LocatedA (HsType GhcRn))) -> HieM [HieAST Type]
ToHie (LocatedA (HsType GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (HsType GhcRn) -> HieM [HieAST Type]
ToHie (LocatedC [LocatedA (HsType GhcRn)])
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedC [LocatedA (HsType GhcRn)] -> HieM [HieAST Type]
DisambTD (HsType GhcPs)
Instance details Defined in GHC.Parser.PostProcess Methods mkHsAppTyHeadPV :: LHsType GhcPs -> PV (LocatedA (HsType GhcPs)) # mkHsAppTyPV :: LocatedA (HsType GhcPs) -> LHsType GhcPs -> PV (LocatedA (HsType GhcPs)) # mkHsAppKindTyPV :: LocatedA (HsType GhcPs) -> EpToken "@" -> LHsType GhcPs -> PV (LocatedA (HsType GhcPs)) # mkHsOpTyPV :: PromotionFlag -> LHsType GhcPs -> LocatedN RdrName -> LHsType GhcPs -> PV (LocatedA (HsType GhcPs)) # mkUnpackednessPV :: Located UnpackednessPragma -> LocatedA (HsType GhcPs) -> PV (LocatedA (HsType GhcPs)) #
HasHaddock (LocatedA (HsType GhcPs))
Instance details Defined in GHC.Parser.PostProcess.Haddock Methods addHaddock :: LocatedA (HsType GhcPs) -> HdkA (LocatedA (HsType GhcPs))
type Anno (BangType (GhcPass p))
Instance details Defined in GHC.Hs.Type type Anno (BangType (GhcPass p)) = SrcSpanAnnA
type Anno (HsKind (GhcPass p))
Instance details Defined in GHC.Hs.Type type Anno (HsKind (GhcPass p)) = SrcSpanAnnA
type Anno (HsType (GhcPass p))
Instance details Defined in GHC.Hs.Type type Anno (HsType (GhcPass p)) = SrcSpanAnnA
type Anno [LocatedA (HsType (GhcPass p))]
Instance details Defined in GHC.Hs.Type type Anno [LocatedA (HsType (GhcPass p))] = SrcSpanAnnC
type Anno (FamEqn p (LocatedA (HsType p)))
Instance details Defined in GHC.Hs.Decls type Anno (FamEqn p (LocatedA (HsType p))) = SrcSpanAnnA

data HsTyVarBndr flag pass #

Haskell Type Variable Binder The flag annotates the binder. It is Specificity in places where explicit specificity is allowed (e.g. x :: forall {a} b. ...) or () in other places.

Constructors

UserTyVar (XUserTyVar pass) flag (LIdP pass)

Instances

Instances details

Data flag => ToHie (TVScoped (LocatedA (HsTyVarBndr flag GhcRn)))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: TVScoped (LocatedA (HsTyVarBndr flag GhcRn)) -> HieM [HieAST Type]
type Anno (HsTyVarBndr _flag (GhcPass _1))
Instance details Defined in GHC.Hs.Type type Anno (HsTyVarBndr _flag (GhcPass _1)) = SrcSpanAnnA
type Anno (HsTyVarBndr _flag GhcPs)
Instance details Defined in GHC.Hs.Type type Anno (HsTyVarBndr _flag GhcPs) = SrcSpanAnnA
type Anno (HsTyVarBndr _flag GhcRn)
Instance details Defined in GHC.Hs.Type type Anno (HsTyVarBndr _flag GhcRn) = SrcSpanAnnA
type Anno (HsTyVarBndr _flag GhcTc)
Instance details Defined in GHC.Hs.Type type Anno (HsTyVarBndr _flag GhcTc) = SrcSpanAnnA

data HsSigType pass #

A type signature that obeys the forall-or-nothing rule. In other words, an LHsType that uses an HsOuterSigTyVarBndrs to represent its outermost type variable quantification. See Note [Representing type signatures].

Constructors

HsSig (XHsSig pass) (HsOuterSigTyVarBndrs pass) (LHsType pass)

Instances

Instances details

ToHie (TScoped (LocatedA (HsSigType GhcRn)))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: TScoped (LocatedA (HsSigType GhcRn)) -> HieM [HieAST Type]
ToHie (TScoped (HsWildCardBndrs GhcRn (LocatedA (HsSigType GhcRn))))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: TScoped (HsWildCardBndrs GhcRn (LocatedA (HsSigType GhcRn))) -> HieM [HieAST Type]
HasHaddock (LocatedA (HsSigType GhcPs))
Instance details Defined in GHC.Parser.PostProcess.Haddock Methods addHaddock :: LocatedA (HsSigType GhcPs) -> HdkA (LocatedA (HsSigType GhcPs))
type Anno (HsSigType (GhcPass p))
Instance details Defined in GHC.Hs.Type type Anno (HsSigType (GhcPass p)) = SrcSpanAnnA

data HsWildCardBndrs pass thing #

Haskell Wildcard Binders

Constructors

HsWC (XHsWC pass thing) thing

Instances

Instances details

ToHie (TScoped (HsWildCardBndrs GhcRn (LocatedA (HsSigType GhcRn))))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: TScoped (HsWildCardBndrs GhcRn (LocatedA (HsSigType GhcRn))) -> HieM [HieAST Type]
ToHie (TScoped (HsWildCardBndrs GhcRn (LocatedA (HsType GhcRn))))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: TScoped (HsWildCardBndrs GhcRn (LocatedA (HsType GhcRn))) -> HieM [HieAST Type]
HasHaddock a => HasHaddock (HsWildCardBndrs GhcPs a)
Instance details Defined in GHC.Parser.PostProcess.Haddock Methods addHaddock :: HsWildCardBndrs GhcPs a -> HdkA (HsWildCardBndrs GhcPs a)

data HsOuterTyVarBndrs flag pass #

The outermost type variables in a type that obeys the forall-or-nothing rule. See Note [forall-or-nothing rule].

Constructors

HsOuterImplicit (XHsOuterImplicit pass)

Implicit forall, e.g., f :: a -> b -> b

Instances

Instances details

Data flag => ToHie (TVScoped (HsOuterTyVarBndrs flag GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: TVScoped (HsOuterTyVarBndrs flag GhcRn) -> HieM [HieAST Type]
type Anno (HsOuterTyVarBndrs _1 (GhcPass _2))
Instance details Defined in GHC.Hs.Type type Anno (HsOuterTyVarBndrs _1 (GhcPass _2)) = SrcSpanAnnA

type LHsType pass #

Arguments

= XRec pass (HsType pass)

May have AnnKeywordId : AnnComma when in a list

Located Haskell Type

data FixitySig pass #

Fixity Signature

Constructors

FixitySig (XFixitySig pass) [LIdP pass] Fixity

Instances

Instances details

ToHie (LocatedA (FixitySig GhcRn))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: LocatedA (FixitySig GhcRn) -> HieM [HieAST Type]
type Anno (FixitySig (GhcPass p))
Instance details Defined in GHC.Hs.Binds type Anno (FixitySig (GhcPass p)) = SrcSpanAnnA

data Sig pass #

Signatures and pragmas

Constructors

TypeSig (XTypeSig pass) [LIdP pass] (LHsSigWcType pass)

An ordinary type signature

f :: Num a => a -> a

After renaming, this list of Names contains the named wildcards brought into scope by this signature. For a signature _ -> _a -> Bool, the renamer will leave the unnamed wildcard _ untouched, and the named wildcard _a is then replaced with fresh meta vars in the type. Their names are stored in the type signature that brought them into scope, in this third field to be more specific.

AnnKeywordId : AnnDcolon, AnnComma

FixSig (XFixSig pass) (FixitySig pass)

An ordinary fixity declaration

    infixl 8 ***

AnnKeywordId : AnnInfix, AnnVal

InlineSig (XInlineSig pass) (LIdP pass) InlinePragma

An inline pragma

{#- INLINE f #-}

AnnKeywordId : AnnOpen '{-# INLINE' and '[', AnnClose,AnnOpen, AnnVal,AnnTilde, AnnClose

Instances

Instances details

HiePass p => ToHie (SigContext (LocatedA (Sig (GhcPass p))))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: SigContext (LocatedA (Sig (GhcPass p))) -> HieM [HieAST Type]
type Anno (Sig (GhcPass p))
Instance details Defined in GHC.Hs.Binds type Anno (Sig (GhcPass p)) = SrcSpanAnnA

data HsDecl p #

A Haskell Declaration

Constructors

SigD (XSigD p) (Sig p)

Signature declaration

Instances

Instances details

HasHaddock (LocatedA (HsDecl GhcPs))
Instance details Defined in GHC.Parser.PostProcess.Haddock Methods addHaddock :: LocatedA (HsDecl GhcPs) -> HdkA (LocatedA (HsDecl GhcPs))
HasHaddock (HsDecl GhcPs)
Instance details Defined in GHC.Parser.PostProcess.Haddock Methods addHaddock :: HsDecl GhcPs -> HdkA (HsDecl GhcPs)
type Anno (HsDecl (GhcPass _1))
Instance details Defined in GHC.Hs.Decls type Anno (HsDecl (GhcPass _1)) = SrcSpanAnnA

type LHsDecl p #

Arguments

= XRec p (HsDecl p)

When in a list this may have

AnnKeywordId : AnnSemi

data HsModule p #

Haskell Module

All we actually declare here is the top-level structure for a module.

Instances

Instances details

HasHaddock (Located (HsModule GhcPs))
Instance details Defined in GHC.Parser.PostProcess.Haddock Methods addHaddock :: Located (HsModule GhcPs) -> HdkA (Located (HsModule GhcPs))

type CoreAlt = Alt CoreBndr #

Case alternatives where binders are CoreBndrs

type CoreBind = Bind CoreBndr #

Binding groups where binders are CoreBndrs

type CoreArg = Arg CoreBndr #

Argument expressions where binders are CoreBndrs

type CoreProgram = [CoreBind] #

data Unfolding #

Records the unfolding of an identifier, which is approximately the form the identifier would have if we substituted its definition in for the identifier. This type should be treated as abstract everywhere except in GHC.Core.Unfold

Constructors

DFunUnfolding [Var] DataCon [CoreExpr]

CoreUnfolding CoreExpr UnfoldingSource Bool UnfoldingCache UnfoldingGuidance

An unfolding with redundant cached information. Parameters:

uf_tmpl: Template used to perform unfolding; NB: Occurrence info is guaranteed correct: see Note [OccInfo in unfoldings and rules]

uf_is_top: Is this a top level binding?

uf_is_value: exprIsHNF template (cached); it is ok to discard a seq on this variable

uf_is_work_free: Does this waste only a little work if we expand it inside an inlining? Basically this is a cached version of exprIsWorkFree

uf_guidance: Tells us about the size of the unfolding template

data Bind b #

Binding, used for top level bindings in a module and local bindings in a let.

Constructors

NonRec b (Expr b)
Rec [(b, Expr b)]

Instances

Instances details

CBVisitable CoreBind Source #
Instance details Defined in Language.Haskell.Liquid.Types.Visitors Methods freeVars :: HashSet Var -> CoreBind -> [Var] Source # readVars :: CoreBind -> [Var] Source # letVars :: CoreBind -> [Var] Source # literals :: CoreBind -> [Literal] Source #
Data b => Data (Bind b)
Instance details Defined in GHC.Core Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Bind b -> c (Bind b) # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Bind b) # toConstr :: Bind b -> Constr # dataTypeOf :: Bind b -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Bind b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Bind b)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Bind b -> Bind b # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bind b -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bind b -> r # gmapQ :: (forall d. Data d => d -> u) -> Bind b -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Bind b -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bind b -> m (Bind b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bind b -> m (Bind b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bind b -> m (Bind b) #
PPrint (Bind Var) Source #
Instance details Defined in Language.Haskell.Liquid.Types.PrettyPrint Methods pprintTidy :: Tidy -> Bind Var -> Doc # pprintPrec :: Int -> Tidy -> Bind Var -> Doc #
Subable (Bind Var) Source #
Instance details Defined in Language.Haskell.Liquid.GHC.Play Methods sub :: HashMap CoreBndr CoreExpr -> Bind Var -> Bind Var Source # subTy :: HashMap TyVar Type -> Bind Var -> Bind Var Source #
CBVisitable [CoreBind] Source #
Instance details Defined in Language.Haskell.Liquid.Types.Visitors Methods freeVars :: HashSet Var -> [CoreBind] -> [Var] Source # readVars :: [CoreBind] -> [Var] Source # letVars :: [CoreBind] -> [Var] Source # literals :: [CoreBind] -> [Literal] Source #

maybeUnfoldingTemplate :: Unfolding -> Maybe CoreExpr #

Retrieves the template of an unfolding if possible maybeUnfoldingTemplate is used mainly when specialising, and we do want to specialise DFuns, so it's important to return a template for DFunUnfoldings

cmpAlt :: Alt a -> Alt a -> Ordering #

mkTyApps :: Expr b -> [Type] -> Expr b infixl 4 #

Apply a list of type argument expressions to a function expression in a nested fashion

mkTyArg :: Type -> Expr b #

mkLams :: [b] -> Expr b -> Expr b #

Bind all supplied binders over an expression in a nested lambda expression. Prefer to use mkCoreLams if possible

mkLets :: [Bind b] -> Expr b -> Expr b #

Bind all supplied binding groups over an expression in a nested let expression. Assumes that the rhs satisfies the let-can-float invariant. Prefer to use mkCoreLets if possible, which does guarantee the invariant

bindersOf :: Bind b -> [b] #

Extract every variable by this group

bindersOfBinds :: [Bind b] -> [b] #

bindersOf applied to a list of binding groups

rhssOfBind :: Bind b -> [Expr b] #

rhssOfAlts :: [Alt b] -> [Expr b] #

flattenBinds :: [Bind b] -> [(b, Expr b)] #

Collapse all the bindings in the supplied groups into a single list of lhs/rhs pairs suitable for binding in a Rec binding group

collectBinders :: Expr b -> ([b], Expr b) #

We often want to strip off leading lambdas before getting down to business. Variants are collectTyBinders, collectValBinders, and collectTyAndValBinders

collectTyBinders :: CoreExpr -> ([TyVar], CoreExpr) #

collectTyAndValBinders :: CoreExpr -> ([TyVar], [Id], CoreExpr) #

collectArgs :: Expr b -> (Expr b, [Arg b]) #

Takes a nested application expression and returns the function being applied and the arguments to which it is applied

isTypeArg :: Expr b -> Bool #

Returns True iff the expression is a Type expression at its top level. Note this does NOT include Coercions.

data Reduction #

A Reduction is the result of an operation that rewrites a type ty_in. The Reduction includes the rewritten type ty_out and a Coercion co such that co :: ty_in ~ ty_out, where the role of the coercion is determined by the context. That is, the LHS type of the coercion is the original type ty_in, while its RHS type is the rewritten type ty_out.

A Reduction is always homogeneous, unless it is wrapped inside a HetReduction, which separately stores the kind coercion.

See Note [The Reduction type].

Constructors

Reduction Coercion !Type

Instances

Instances details

Outputable Reduction
Instance details Defined in GHC.Core.Reduction Methods ppr :: Reduction -> SDoc #

data CafInfo #

Constant applicative form Information

Records whether an Id makes Constant Applicative Form references

Constructors

NoCafRefs

A function or static constructor that refers to no CAFs.

Instances

Instances details

Outputable CafInfo
Instance details Defined in GHC.Types.Id.Info Methods ppr :: CafInfo -> SDoc #
Eq CafInfo
Instance details Defined in GHC.Types.Id.Info Methods (==) :: CafInfo -> CafInfo -> Bool # (/=) :: CafInfo -> CafInfo -> Bool #
Ord CafInfo
Instance details Defined in GHC.Types.Id.Info Methods compare :: CafInfo -> CafInfo -> Ordering # (<) :: CafInfo -> CafInfo -> Bool # (<=) :: CafInfo -> CafInfo -> Bool # (>) :: CafInfo -> CafInfo -> Bool # (>=) :: CafInfo -> CafInfo -> Bool # max :: CafInfo -> CafInfo -> CafInfo # min :: CafInfo -> CafInfo -> CafInfo #

cafInfo :: IdInfo -> CafInfo #

Id CAF info

setOccInfo :: IdInfo -> OccInfo -> IdInfo infixl 1 #

setCafInfo :: IdInfo -> CafInfo -> IdInfo infixl 1 #

mayHaveCafRefs :: CafInfo -> Bool #

idType :: Id -> Kind #

setIdInfo :: Id -> IdInfo -> Id #

modifyIdInfo :: HasDebugCallStack => (IdInfo -> IdInfo) -> Id -> Id #

mkExportedLocalId :: IdDetails -> Name -> Type -> Id #

Create a local Id that is marked as exported. This prevents things attached to it from being removed as dead code. See Note [Exported LocalIds]

mkUserLocalOrCoVar :: OccName -> Unique -> Mult -> Type -> SrcSpan -> Id #

Like mkUserLocal, but checks if we have a coercion type

isRecordSelector :: Id -> Bool #

isClassOpId_maybe :: Id -> Maybe Class #

isDFunId :: Id -> Bool #

idDataCon :: Id -> DataCon #

Get from either the worker or the wrapper Id to the DataCon. Currently used only in the desugarer.

INVARIANT: idDataCon (dataConWrapId d) = d: remember, dataConWrapId can return either the wrapper or the worker

realIdUnfolding :: Id -> Unfolding #

Expose the unfolding if there is one, including for loop breakers

idOccInfo :: Id -> OccInfo #

idInlinePragma :: Id -> InlinePragma #

isConLikeId :: Id -> Bool #

intTyConName :: Name #

boolTyConName :: Name #

listTyConName :: Name #

anyTy :: Type #

true_RDR :: RdrName #

unrestrictedFunTyConName :: Name #

charTyCon :: TyCon #

charDataCon :: DataCon #

stringTy :: Type #

intTy :: Type #

intTyCon :: TyCon #

intDataCon :: DataCon #

boolTy :: Type #

boolTyCon :: TyCon #

falseDataCon :: DataCon #

trueDataCon :: DataCon #

falseDataConId :: Id #

trueDataConId :: Id #

nilDataCon :: DataCon #

consDataCon :: DataCon #

tcSplitDFunTy :: Type -> ([TyVar], [Type], Class, [Type]) #

tcSplitMethodTy :: Type -> ([TyVar], PredType, Type) #

exprFreeVars :: CoreExpr -> VarSet #

Find all locally-defined free Ids or type variables in an expression returning a non-deterministic set.

exprFreeVarsList :: CoreExpr -> [Var] #

Find all locally-defined free Ids or type variables in an expression returning a deterministically ordered list.

exprSomeFreeVarsList #

Arguments

:: InterestingVarFun	Says which `Var`s are interesting
-> CoreExpr
-> [Var]

Finds free variables in an expression selected by a predicate returning a deterministically ordered list.

exprsOrphNames :: [CoreExpr] -> NameSet #

Finds the free external names of several expressions: see exprOrphNames for details

data FamInstEnv #

Instances

Instances details

Outputable FamInstEnv
Instance details Defined in GHC.Core.FamInstEnv Methods ppr :: FamInstEnv -> SDoc #

type FamInstEnvs = (FamInstEnv, FamInstEnv) #

data FamFlavor #

Constructors

DataFamilyInst TyCon

data FamInst #

Constructors

FamInst (CoAxiom Unbranched) FamFlavor Name [RoughMatchTc] [TyVar] [CoVar] [Type] Type IsOrphan

Instances

Instances details

NamedThing FamInst
Instance details Defined in GHC.Core.FamInstEnv Methods getOccName :: FamInst -> OccName # getName :: FamInst -> Name #
Outputable FamInst
Instance details Defined in GHC.Core.FamInstEnv Methods ppr :: FamInst -> SDoc #

emptyFamInstEnv :: FamInstEnv #

famInstEnvElts :: FamInstEnv -> [FamInst] #

topNormaliseType_maybe :: FamInstEnvs -> Type -> Maybe Reduction #

Get rid of *outermost* (or toplevel) * type function redex * data family redex * newtypes returning an appropriate Representational coercion. Specifically, if topNormaliseType_maybe env ty = Just (co, ty') then (a) co :: ty ~R ty' (b) ty' is not a newtype, and is not a type-family or data-family redex

However, ty' can be something like (Maybe (F ty)), where (F ty) is a redex.

Always operates homogeneously: the returned type has the same kind as the original type, and the returned coercion is always homogeneous.

exprType :: HasDebugCallStack => CoreExpr -> Type #

Recover the type of a well-typed Core expression. Fails when applied to the actual Type expression as it cannot really be said to have a type

extendIdSubst :: Subst -> Id -> CoreExpr -> Subst #

Add a substitution for an Id to the Subst: you must ensure that the in-scope set is such that TyCoSubst Note [The substitution invariant] holds after extending the substitution like this

substExpr :: HasDebugCallStack => Subst -> CoreExpr -> CoreExpr #

substExpr applies a substitution to an entire CoreExpr. Remember, you may only apply the substitution once: See Note [Substitutions apply only once] in GHC.Core.TyCo.Subst

Do *not* attempt to short-cut in the case of an empty substitution! See Note [Extending the IdSubstEnv]

occurAnalysePgm :: Module -> (Id -> Bool) -> (Activation -> Bool) -> [CoreRule] -> CoreProgram -> CoreProgram #

pAT_ERROR_ID :: Id #

data IfaceAnnotation #

Instances

Instances details

NFData IfaceAnnotation
Instance details Defined in GHC.Iface.Syntax Methods rnf :: IfaceAnnotation -> () #
Binary IfaceAnnotation
Instance details Defined in GHC.Iface.Syntax Methods put_ :: BinHandle -> IfaceAnnotation -> IO () # put :: BinHandle -> IfaceAnnotation -> IO (Bin IfaceAnnotation) # get :: BinHandle -> IO IfaceAnnotation #
Outputable IfaceAnnotation
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceAnnotation -> SDoc #

data InstEnvs #

InstEnvs represents the combination of the global type class instance environment, the local type class instance environment, and the set of transitively reachable orphan modules (according to what modules have been directly imported) used to test orphan instance visibility.

data ClsInst #

A type-class instance. Note that there is some tricky laziness at work here. See Note [ClsInst laziness and the rough-match fields] for more details.

Instances

Instances details

NamedThing ClsInst
Instance details Defined in GHC.Core.InstEnv Methods getOccName :: ClsInst -> OccName # getName :: ClsInst -> Name #
Outputable ClsInst
Instance details Defined in GHC.Core.InstEnv Methods ppr :: ClsInst -> SDoc #
Data ClsInst
Instance details Defined in GHC.Core.InstEnv Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ClsInst -> c ClsInst # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ClsInst # toConstr :: ClsInst -> Constr # dataTypeOf :: ClsInst -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ClsInst) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ClsInst) # gmapT :: (forall b. Data b => b -> b) -> ClsInst -> ClsInst # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ClsInst -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ClsInst -> r # gmapQ :: (forall d. Data d => d -> u) -> ClsInst -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ClsInst -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ClsInst -> m ClsInst # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ClsInst -> m ClsInst # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ClsInst -> m ClsInst #

instanceDFunId :: ClsInst -> DFunId #

instanceSig :: ClsInst -> ([TyVar], [Type], Class, [Type]) #

instEnvElts :: InstEnv -> [ClsInst] #

lookupInstEnv :: Bool -> InstEnvs -> Class -> [Type] -> ClsInstLookupResult #

See Note [Rules for instance lookup] ^ See Note [Safe Haskell Overlapping Instances] in GHC.Tc.Solver ^ See Note [Safe Haskell Overlapping Instances Implementation] in GHC.Tc.Solver

data TcEvBinds #

Constructors

EvBinds (Bag EvBind)

Instances

Instances details

Outputable TcEvBinds
Instance details Defined in GHC.Tc.Types.Evidence Methods ppr :: TcEvBinds -> SDoc #
Data TcEvBinds
Instance details Defined in GHC.Tc.Types.Evidence Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TcEvBinds -> c TcEvBinds # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TcEvBinds # toConstr :: TcEvBinds -> Constr # dataTypeOf :: TcEvBinds -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TcEvBinds) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TcEvBinds) # gmapT :: (forall b. Data b => b -> b) -> TcEvBinds -> TcEvBinds # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TcEvBinds -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TcEvBinds -> r # gmapQ :: (forall d. Data d => d -> u) -> TcEvBinds -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TcEvBinds -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TcEvBinds -> m TcEvBinds # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TcEvBinds -> m TcEvBinds # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TcEvBinds -> m TcEvBinds #
ToHie (EvBindContext (LocatedA TcEvBinds))
Instance details Defined in GHC.Iface.Ext.Ast Methods toHie :: EvBindContext (LocatedA TcEvBinds) -> HieM [HieAST Type]

mkHsForAllInvisTele :: forall (p :: Pass). EpAnnForallTy -> [LHsTyVarBndr Specificity (GhcPass p)] -> HsForAllTelescope (GhcPass p) #

mkHsApp :: forall (id :: Pass). LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #

mkHsLam :: forall (p :: Pass). (IsPass p, XMG (GhcPass p) (LHsExpr (GhcPass p)) ~ Origin) => [LPat (GhcPass p)] -> LHsExpr (GhcPass p) -> LHsExpr (GhcPass p) #

mkHsIntegral :: IntegralLit -> HsOverLit GhcPs #

mkHsFractional :: FractionalLit -> HsOverLit GhcPs #

nlHsVar :: forall (p :: Pass) a. IsSrcSpanAnn p a => IdP (GhcPass p) -> LHsExpr (GhcPass p) #

nlVarPat :: forall (p :: Pass) a. IsSrcSpanAnn p a => IdP (GhcPass p) -> LPat (GhcPass p) #

nlHsIf :: LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs #

nlList :: [LHsExpr GhcPs] -> LHsExpr GhcPs #

nlHsAppTy :: forall (p :: Pass). LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) #

nlHsTyVar :: forall (p :: Pass) a. IsSrcSpanAnn p a => PromotionFlag -> IdP (GhcPass p) -> LHsType (GhcPass p) #

nlHsFunTy :: forall (p :: Pass). IsPass p => LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) #

nlHsTyConApp :: forall (p :: Pass) a. IsSrcSpanAnn p a => PromotionFlag -> LexicalFixity -> IdP (GhcPass p) -> [LHsTypeArg (GhcPass p)] -> LHsType (GhcPass p) #

hsTypeToHsSigType :: LHsType GhcPs -> LHsSigType GhcPs #

Convert an LHsType to an LHsSigType.

hsTypeToHsSigWcType :: LHsType GhcPs -> LHsSigWcType GhcPs #

Convert an LHsType to an LHsSigWcType.

mkHsDictLet :: TcEvBinds -> LHsExpr GhcTc -> LHsExpr GhcTc #

data Severity #

Used to describe warnings and errors o The message has a file/line/column heading, plus "warning:" or "error:", added by mkLocMessage o With SevIgnore the message is suppressed o Output is intended for end users

Constructors

SevWarning

Instances

Instances details

ToJson Severity
Instance details Defined in GHC.Types.Error Methods json :: Severity -> JsonDoc #
Outputable Severity
Instance details Defined in GHC.Types.Error Methods ppr :: Severity -> SDoc #
Show Severity
Instance details Defined in GHC.Types.Error Methods showsPrec :: Int -> Severity -> ShowS # show :: Severity -> String # showList :: [Severity] -> ShowS #
Eq Severity
Instance details Defined in GHC.Types.Error Methods (==) :: Severity -> Severity -> Bool # (/=) :: Severity -> Severity -> Bool #
Ord Severity
Instance details Defined in GHC.Types.Error Methods compare :: Severity -> Severity -> Ordering # (<) :: Severity -> Severity -> Bool # (<=) :: Severity -> Severity -> Bool # (>) :: Severity -> Severity -> Bool # (>=) :: Severity -> Severity -> Bool # max :: Severity -> Severity -> Severity # min :: Severity -> Severity -> Severity #

data MessageClass #

The class for a diagnostic message. The main purpose is to classify a message within GHC, to distinguish it from a debug/dump message vs a proper diagnostic, for which we include a DiagnosticReason.

Constructors

MCDiagnostic Severity ResolvedDiagnosticReason (Maybe DiagnosticCode)

Diagnostics from the compiler. This constructor is very powerful as it allows the construction of a MessageClass with a completely arbitrary permutation of Severity and DiagnosticReason. As such, users are encouraged to use the mkMCDiagnostic smart constructor instead. Use this constructor directly only if you need to construct and manipulate diagnostic messages directly, for example inside Error. In all the other circumstances, especially when emitting compiler diagnostics, use the smart constructor.

The Maybe DiagnosticCode field carries a code (if available) for this diagnostic. If you are creating a message not tied to any error-message type, then use Nothing. In the long run, this really should always have a DiagnosticCode. See Note [Diagnostic codes].

Instances

Instances details

ToJson MessageClass
Instance details Defined in GHC.Types.Error Methods json :: MessageClass -> JsonDoc #

data MsgEnvelope e #

An envelope for GHC's facts about a running program, parameterised over the domain-specific (i.e. parsing, typecheck-renaming, etc) diagnostics.

To say things differently, GHC emits diagnostics about the running program, each of which is wrapped into a MsgEnvelope that carries specific information like where the error happened, etc. Finally, multiple MsgEnvelopes are aggregated into Messages that are returned to the user.

Instances

Instances details

Functor MsgEnvelope
Instance details Defined in GHC.Types.Error Methods fmap :: (a -> b) -> MsgEnvelope a -> MsgEnvelope b # (<$) :: a -> MsgEnvelope b -> MsgEnvelope a #
Foldable MsgEnvelope
Instance details Defined in GHC.Types.Error Methods fold :: Monoid m => MsgEnvelope m -> m # foldMap :: Monoid m => (a -> m) -> MsgEnvelope a -> m # foldMap' :: Monoid m => (a -> m) -> MsgEnvelope a -> m # foldr :: (a -> b -> b) -> b -> MsgEnvelope a -> b # foldr' :: (a -> b -> b) -> b -> MsgEnvelope a -> b # foldl :: (b -> a -> b) -> b -> MsgEnvelope a -> b # foldl' :: (b -> a -> b) -> b -> MsgEnvelope a -> b # foldr1 :: (a -> a -> a) -> MsgEnvelope a -> a # foldl1 :: (a -> a -> a) -> MsgEnvelope a -> a # toList :: MsgEnvelope a -> [a] # null :: MsgEnvelope a -> Bool # length :: MsgEnvelope a -> Int # elem :: Eq a => a -> MsgEnvelope a -> Bool # maximum :: Ord a => MsgEnvelope a -> a # minimum :: Ord a => MsgEnvelope a -> a # sum :: Num a => MsgEnvelope a -> a # product :: Num a => MsgEnvelope a -> a #
Traversable MsgEnvelope
Instance details Defined in GHC.Types.Error Methods traverse :: Applicative f => (a -> f b) -> MsgEnvelope a -> f (MsgEnvelope b) # sequenceA :: Applicative f => MsgEnvelope (f a) -> f (MsgEnvelope a) # mapM :: Monad m => (a -> m b) -> MsgEnvelope a -> m (MsgEnvelope b) # sequence :: Monad m => MsgEnvelope (m a) -> m (MsgEnvelope a) #
Diagnostic e => ToJson (MsgEnvelope e)
Instance details Defined in GHC.Types.Error Methods json :: MsgEnvelope e -> JsonDoc #
Show (MsgEnvelope DiagnosticMessage)
Instance details Defined in GHC.Types.Error Methods showsPrec :: Int -> MsgEnvelope DiagnosticMessage -> ShowS # show :: MsgEnvelope DiagnosticMessage -> String # showList :: [MsgEnvelope DiagnosticMessage] -> ShowS #

newtype ResolvedDiagnosticReason #

Like a DiagnosticReason, but resolved against a specific set of DynFlags to work out which warning flag actually enabled this warning.

Constructors

ResolvedDiagnosticReason DiagnosticReason

Instances

Instances details

Outputable ResolvedDiagnosticReason
Instance details Defined in GHC.Types.Error Methods ppr :: ResolvedDiagnosticReason -> SDoc #

data DiagnosticReason #

The reason why a Diagnostic was emitted in the first place. Diagnostic messages are born within GHC with a very precise reason, which can be completely statically-computed (i.e. this is an error or a warning no matter what), or influenced by the specific state of the DynFlags at the moment of the creation of a new Diagnostic. For example, a parsing error is always going to be an error, whereas a 'WarningWithoutFlag Opt_WarnUnusedImports' might turn into an error due to '-Werror' or '-Werror=warn-unused-imports'. Interpreting a DiagnosticReason together with its associated Severity gives us the full picture.

Constructors

WarningWithoutFlag

Born as a warning.

Instances

Instances details

Outputable DiagnosticReason
Instance details Defined in GHC.Types.Error Methods ppr :: DiagnosticReason -> SDoc #
Show DiagnosticReason
Instance details Defined in GHC.Types.Error Methods showsPrec :: Int -> DiagnosticReason -> ShowS # show :: DiagnosticReason -> String # showList :: [DiagnosticReason] -> ShowS #
Eq DiagnosticReason
Instance details Defined in GHC.Types.Error Methods (==) :: DiagnosticReason -> DiagnosticReason -> Bool # (/=) :: DiagnosticReason -> DiagnosticReason -> Bool #

class HasDefaultDiagnosticOpts (DiagnosticOpts a) => Diagnostic a #

A class identifying a diagnostic. Dictionary.com defines a diagnostic as:

"a message output by a computer diagnosing an error in a computer program, computer system, or component device".

A Diagnostic carries the actual description of the message (which, in GHC's case, it can be an error or a warning) and the reason why such message was generated in the first place.

Minimal complete definition

diagnosticMessage, diagnosticReason, diagnosticHints, diagnosticCode

Instances

Instances details

Diagnostic DiagnosticMessage

Instance details

Defined in GHC.Types.Error

Associated Types

type DiagnosticOpts DiagnosticMessage
Instance details Defined in GHC.Types.Error type DiagnosticOpts DiagnosticMessage = NoDiagnosticOpts

Methods

diagnosticMessage :: DiagnosticOpts DiagnosticMessage -> DiagnosticMessage -> DecoratedSDoc #

diagnosticReason :: DiagnosticMessage -> DiagnosticReason #

diagnosticHints :: DiagnosticMessage -> [GhcHint] #

diagnosticCode :: DiagnosticMessage -> Maybe DiagnosticCode #

HasDefaultDiagnosticOpts opts => Diagnostic (UnknownDiagnostic opts)

Instance details

Defined in GHC.Types.Error

Associated Types

type DiagnosticOpts (UnknownDiagnostic opts)
Instance details Defined in GHC.Types.Error type DiagnosticOpts (UnknownDiagnostic opts) = opts

Methods

diagnosticMessage :: DiagnosticOpts (UnknownDiagnostic opts) -> UnknownDiagnostic opts -> DecoratedSDoc #

diagnosticReason :: UnknownDiagnostic opts -> DiagnosticReason #

diagnosticHints :: UnknownDiagnostic opts -> [GhcHint] #

diagnosticCode :: UnknownDiagnostic opts -> Maybe DiagnosticCode #

data Messages e #

A collection of messages emitted by GHC during error reporting. A diagnostic message is typically a warning or an error. See Note [Messages].

INVARIANT: All the messages in this collection must be relevant, i.e. their Severity should not be SevIgnore. The smart constructor mkMessages will filter out any message which Severity is SevIgnore.

Instances

Instances details

Functor Messages
Instance details Defined in GHC.Types.Error Methods fmap :: (a -> b) -> Messages a -> Messages b # (<$) :: a -> Messages b -> Messages a #
Foldable Messages
Instance details Defined in GHC.Types.Error Methods fold :: Monoid m => Messages m -> m # foldMap :: Monoid m => (a -> m) -> Messages a -> m # foldMap' :: Monoid m => (a -> m) -> Messages a -> m # foldr :: (a -> b -> b) -> b -> Messages a -> b # foldr' :: (a -> b -> b) -> b -> Messages a -> b # foldl :: (b -> a -> b) -> b -> Messages a -> b # foldl' :: (b -> a -> b) -> b -> Messages a -> b # foldr1 :: (a -> a -> a) -> Messages a -> a # foldl1 :: (a -> a -> a) -> Messages a -> a # toList :: Messages a -> [a] # null :: Messages a -> Bool # length :: Messages a -> Int # elem :: Eq a => a -> Messages a -> Bool # maximum :: Ord a => Messages a -> a # minimum :: Ord a => Messages a -> a # sum :: Num a => Messages a -> a # product :: Num a => Messages a -> a #
Traversable Messages
Instance details Defined in GHC.Types.Error Methods traverse :: Applicative f => (a -> f b) -> Messages a -> f (Messages b) # sequenceA :: Applicative f => Messages (f a) -> f (Messages a) # mapM :: Monad m => (a -> m b) -> Messages a -> m (Messages b) # sequence :: Monad m => Messages (m a) -> m (Messages a) #
Diagnostic e => ToJson (Messages e)
Instance details Defined in GHC.Types.Error Methods json :: Messages e -> JsonDoc #
Diagnostic e => Outputable (Messages e)
Instance details Defined in GHC.Types.Error Methods ppr :: Messages e -> SDoc #
Monoid (Messages e)
Instance details Defined in GHC.Types.Error Methods mempty :: Messages e # mappend :: Messages e -> Messages e -> Messages e # mconcat :: [Messages e] -> Messages e #
Semigroup (Messages e)
Instance details Defined in GHC.Types.Error Methods (<>) :: Messages e -> Messages e -> Messages e # sconcat :: NonEmpty (Messages e) -> Messages e # stimes :: Integral b => b -> Messages e -> Messages e #

defaultDiagnosticOpts :: HasDefaultDiagnosticOpts (DiagnosticOpts opts) => DiagnosticOpts opts #

mkPlainError :: [GhcHint] -> SDoc -> DiagnosticMessage #

Create an error DiagnosticMessage holding just a single SDoc

errorsOrFatalWarningsFound :: Messages e -> Bool #

Are there any errors or -Werror warnings here?

getLogger :: HasLogger m => m Logger #

data Logger #

putLogMsg :: Logger -> LogAction #

Log something

pprLocMsgEnvelope :: Diagnostic e => DiagnosticOpts e -> MsgEnvelope e -> SDoc #

withTiming #

Arguments

:: MonadIO m
=> Logger
-> SDoc	The name of the phase
-> (a -> ())	A function to force the result (often either `const ()` or `rnf`)
-> m a	The body of the phase to be timed
-> m a

Time a compilation phase.

When timings are enabled (e.g. with the -v2 flag), the allocations and CPU time used by the phase will be reported to stderr. Consider a typical usage: withTiming getDynFlags (text "simplify") force PrintTimings pass. When timings are enabled the following costs are included in the produced accounting,

The cost of executing pass to a result r in WHNF
The cost of evaluating force r to WHNF (e.g. ())

The choice of the force function depends upon the amount of forcing desired; the goal here is to ensure that the cost of evaluating the result is, to the greatest extent possible, included in the accounting provided by withTiming. Often the pass already sufficiently forces its result during construction; in this case const () is a reasonable choice. In other cases, it is necessary to evaluate the result to normal form, in which case something like Control.DeepSeq.rnf is appropriate.

To avoid adversely affecting compiler performance when timings are not requested, the result is only forced when timings are enabled.

See Note [withTiming] for more.

interpreterBackend :: Backend #

The ByteCode interpreter.

Produce ByteCode objects (BCO, see GHC.ByteCode) that can be interpreted. It is used by GHCi.

Currently some extensions are not supported (foreign primops).

See GHC.StgToByteCode

data GhcLink #

What to do in the link step, if there is one.

Constructors

LinkInMemory

Use the in-memory dynamic linker (works for both bytecode and object code).

Instances

Instances details

Show GhcLink
Instance details Defined in GHC.Driver.DynFlags Methods showsPrec :: Int -> GhcLink -> ShowS # show :: GhcLink -> String # showList :: [GhcLink] -> ShowS #
Eq GhcLink
Instance details Defined in GHC.Driver.DynFlags Methods (==) :: GhcLink -> GhcLink -> Bool # (/=) :: GhcLink -> GhcLink -> Bool #

getDynFlags :: HasDynFlags m => m DynFlags #

gopt :: GeneralFlag -> DynFlags -> Bool #

Test whether a GeneralFlag is set

Note that dynamicNow (i.e., dynamic objects built with `-dynamic-too`) always implicitly enables Opt_PIC, Opt_ExternalDynamicRefs, and disables Opt_SplitSections.

gopt_set :: DynFlags -> GeneralFlag -> DynFlags #

Set a GeneralFlag

gopt_unset :: DynFlags -> GeneralFlag -> DynFlags #

Unset a GeneralFlag

xopt_set :: DynFlags -> Extension -> DynFlags #

Set a Extension

data ImportAvails #

ImportAvails summarises what was imported from where, irrespective of whether the imported things are actually used or not. It is used:

when processing the export list,
when constructing usage info for the interface file,
to identify the list of directly imported modules for initialisation purposes and for optimised overlap checking of family instances,
when figuring out what things are really unused

data HsParsedModule #

Constructors

HsParsedModule
Fields hpm_module :: Located (HsModule GhcPs) hpm_src_files :: [FilePath] extra source files (e.g. from #includes). The lexer collects these from '# file line' pragmas, which the C preprocessor leaves behind. These files and their timestamps are stored in the .hi file, so that we can force recompilation if any of them change (#3589)

lexprCtOrigin :: LHsExpr GhcRn -> CtOrigin #

Extract a suitable CtOrigin from a HsExpr

data ModIface_ (phase :: ModIfacePhase) #

A ModIface plus a ModDetails summarises everything we know about a compiled module. The ModIface is the stuff *before* linking, and can be written out to an interface file. The 'ModDetails is after linking and can be completely recovered from just the ModIface.

When we read an interface file, we also construct a ModIface from it, except that we explicitly make the mi_decls and a few other fields empty; as when reading we consolidate the declarations etc. into a number of indexed maps and environments in the ExternalPackageState.

See Note [Strictness in ModIface] to learn about why some fields are strict and others are not.

Instances

Instances details

Binary ModIface
Instance details Defined in GHC.Unit.Module.ModIface Methods put_ :: BinHandle -> ModIface -> IO () # put :: BinHandle -> ModIface -> IO (Bin ModIface) # get :: BinHandle -> IO ModIface #
(NFData (IfaceBackendExts phase), NFData (IfaceDeclExts phase)) => NFData (ModIface_ phase)
Instance details Defined in GHC.Unit.Module.ModIface Methods rnf :: ModIface_ phase -> () #

mkTcRnUnknownMessage :: (Diagnostic a, Typeable a, DiagnosticOpts a ~ NoDiagnosticOpts) => a -> TcRnMessage #

data NameCache #

The NameCache makes sure that there is just one Unique assigned for each original name; i.e. (module-name, occ-name) pair and provides something of a lookup mechanism for those names.

type TypeEnv = NameEnv TyThing #

A map from Names to TyThings, constructed by typechecking local declarations or interface files

mkTypeEnv :: [TyThing] -> TypeEnv #

lookupTypeEnv :: TypeEnv -> Name -> Maybe TyThing #

plusTypeEnv :: TypeEnv -> TypeEnv -> TypeEnv #

isNumericClass :: Class -> Bool #

data FindResult #

The result of searching for an imported module.

NB: FindResult manages both user source-import lookups (which can result in Module) as well as direct imports for interfaces (which always result in InstalledModule).

Constructors

Found ModLocation Module	The module was found
NoPackage Unit	The requested unit was not found
FoundMultiple [(Module, ModuleOrigin)]	_Error_: both in multiple packages
NotFound [FilePath] (Maybe Unit) [Unit] [Unit] [UnusableUnit] [ModuleSuggestion]	Not found

lookupName :: GhcMonad m => Name -> m (Maybe TyThing) #

Returns the TyThing for a Name. The Name may refer to any entity known to GHC, including Names defined using runStmt.

data ModGuts #

A ModGuts is carried through the compiler, accumulating stuff as it goes There is only one ModGuts at any time, the one for the module being compiled right now. Once it is compiled, a ModIface and ModDetails are extracted and the ModGuts is discarded.

type HomePackageTable = DModuleNameEnv HomeModInfo #

Helps us find information about modules in the home package

data HomeModInfo #

Information about modules in the package being compiled

lookupHpt :: HomePackageTable -> ModuleName -> Maybe HomeModInfo #

data ModSummary #

Data for a module node in a ModuleGraph. Module nodes of the module graph are one of:

A regular Haskell source module
A hi-boot source module

Instances

Instances details

Outputable ModSummary
Instance details Defined in GHC.Unit.Module.ModSummary Methods ppr :: ModSummary -> SDoc #

ms_mod_name :: ModSummary -> ModuleName #

showSDoc :: DynFlags -> SDoc -> String #

Show a SDoc as a String with the default user style

showPpr :: Outputable a => DynFlags -> a -> String #

data ExternalPackageState #

Information about other packages that we have slurped in by reading their interface files

data ExternalUnitCache #

Information about the currently loaded external packages. This is mutable because packages will be demand-loaded during a compilation run as required.

data UnitEnv #

ue_hpt :: HasDebugCallStack => UnitEnv -> HomePackageTable #

missingInterfaceErrorDiagnostic :: IfaceMessageOpts -> MissingInterfaceError -> SDoc #

srcErrorMessages :: SourceError -> Messages GhcMessage #

printMessages :: Diagnostic a => Logger -> DiagnosticOpts a -> DiagOpts -> Messages a -> IO () #

initDiagOpts :: DynFlags -> DiagOpts #

Initialise the general configuration for printing diagnostic messages For example, this configuration controls things like whether warnings are treated like errors.

initDsMessageOpts :: DynFlags -> DiagnosticOpts DsMessage #

initIfaceMessageOpts :: DynFlags -> DiagnosticOpts IfaceMessage #

failM :: IOEnv env a #

updEnv :: (env -> env') -> IOEnv env' a -> IOEnv env a #

Perform a computation with an altered environment

emptyPlugins :: Plugins #

data HscEnv #

HscEnv is like Session, except that some of the fields are immutable. An HscEnv is used to compile a single module from plain Haskell source code (after preprocessing) to either C, assembly or C--. It's also used to store the dynamic linker state to allow for multiple linkers in the same address space. Things like the module graph don't change during a single compilation.

Historical note: "hsc" used to be the name of the compiler binary, when there was a separate driver and compiler. To compile a single module, the driver would invoke hsc on the source code... so nowadays we think of hsc as the layer of the compiler that deals with compiling a single module.

Instances

Instances details

ContainsDynFlags HscEnv
Instance details Defined in GHC.Driver.Env.Types Methods extractDynFlags :: HscEnv -> DynFlags #

hscUpdateFlags :: (DynFlags -> DynFlags) -> HscEnv -> HscEnv #

Update Flags

hscSetFlags :: HasDebugCallStack => DynFlags -> HscEnv -> HscEnv #

Set Flags

data Ghc a #

A minimal implementation of a GhcMonad. If you need a custom monad, e.g., to maintain additional state consider wrapping this monad or using GhcT.

Instances

Instances details

MonadIO Ghc
Instance details Defined in GHC.Driver.Monad Methods liftIO :: IO a -> Ghc a #
MonadCatch Ghc
Instance details Defined in GHC.Driver.Monad Methods catch :: (HasCallStack, Exception e) => Ghc a -> (e -> Ghc a) -> Ghc a #
MonadMask Ghc
Instance details Defined in GHC.Driver.Monad Methods mask :: HasCallStack => ((forall a. Ghc a -> Ghc a) -> Ghc b) -> Ghc b # uninterruptibleMask :: HasCallStack => ((forall a. Ghc a -> Ghc a) -> Ghc b) -> Ghc b # generalBracket :: HasCallStack => Ghc a -> (a -> ExitCase b -> Ghc c) -> (a -> Ghc b) -> Ghc (b, c) #
MonadThrow Ghc
Instance details Defined in GHC.Driver.Monad Methods throwM :: (HasCallStack, Exception e) => e -> Ghc a #
HasDynFlags Ghc
Instance details Defined in GHC.Driver.Monad Methods getDynFlags :: Ghc DynFlags #
GhcMonad Ghc
Instance details Defined in GHC.Driver.Monad Methods getSession :: Ghc HscEnv # setSession :: HscEnv -> Ghc () #
HasLogger Ghc
Instance details Defined in GHC.Driver.Monad Methods getLogger :: Ghc Logger #
Applicative Ghc
Instance details Defined in GHC.Driver.Monad Methods pure :: a -> Ghc a # (<>) :: Ghc (a -> b) -> Ghc a -> Ghc b # liftA2 :: (a -> b -> c) -> Ghc a -> Ghc b -> Ghc c # (>) :: Ghc a -> Ghc b -> Ghc b # (<*) :: Ghc a -> Ghc b -> Ghc a #
Functor Ghc
Instance details Defined in GHC.Driver.Monad Methods fmap :: (a -> b) -> Ghc a -> Ghc b # (<$) :: a -> Ghc b -> Ghc a #
Monad Ghc
Instance details Defined in GHC.Driver.Monad Methods (>>=) :: Ghc a -> (a -> Ghc b) -> Ghc b # (>>) :: Ghc a -> Ghc b -> Ghc b # return :: a -> Ghc a #
MonadFail Ghc
Instance details Defined in GHC.Driver.Monad Methods fail :: String -> Ghc a #
MonadFix Ghc
Instance details Defined in GHC.Driver.Monad Methods mfix :: (a -> Ghc a) -> Ghc a #

class (Functor m, ExceptionMonad m, HasDynFlags m, HasLogger m) => GhcMonad (m :: Type -> Type) where #

A monad that has all the features needed by GHC API calls.

In short, a GHC monad

allows embedding of IO actions,
can log warnings,
allows handling of (extensible) exceptions, and
maintains a current session.

If you do not use Ghc or GhcT, make sure to call initGhcMonad before any call to the GHC API functions can occur.

Minimal complete definition

getSession, setSession

Methods

getSession :: m HscEnv #

Instances

Instances details

GhcMonad BkpM
Instance details Defined in GHC.Driver.Backpack Methods getSession :: BkpM HscEnv # setSession :: HscEnv -> BkpM () #
GhcMonad Ghc
Instance details Defined in GHC.Driver.Monad Methods getSession :: Ghc HscEnv # setSession :: HscEnv -> Ghc () #
ExceptionMonad m => GhcMonad (GhcT m)
Instance details Defined in GHC.Driver.Monad Methods getSession :: GhcT m HscEnv # setSession :: HscEnv -> GhcT m () #

withSession :: GhcMonad m => (HscEnv -> m a) -> m a #

Call the argument with the current session.

reflectGhc :: Ghc a -> Session -> IO a #

Reflect a computation in the Ghc monad into the IO monad.

You can use this to call functions returning an action in the Ghc monad inside an IO action. This is needed for some (too restrictive) callback arguments of some library functions:

libFunc :: String -> (Int -> IO a) -> IO a
ghcFunc :: Int -> Ghc a

ghcFuncUsingLibFunc :: String -> Ghc a -> Ghc a
ghcFuncUsingLibFunc str =
  reifyGhc $ \s ->
    libFunc $ \i -> do
      reflectGhc (ghcFunc i) s

type TcM = TcRn #

Historical "type-checking monad" (now it's just TcRn).

type TcRn = TcRnIf TcGblEnv TcLclEnv #

data ParsedResult #

Result of running the parser and the parser plugin

Constructors

ParsedResult
Fields parsedResultModule :: HsParsedModule Parsed module, potentially modified by a plugin parsedResultMessages :: PsMessages Warnings and errors from parser, potentially modified by a plugin

type CommandLineOption = String #

Command line options gathered from the -PModule.Name:stuff syntax are given to you as this type

purePlugin :: [CommandLineOption] -> IO PluginRecompile #

defaultPlugin :: Plugin #

Default plugin: does nothing at all, except for marking that safe inference has failed unless -fplugin-trustworthy is passed. For compatibility reason you should base all your plugin definitions on this default value.

findImportedModule :: HscEnv -> ModuleName -> PkgQual -> IO FindResult #

Locate a module that was imported by the user. We have the module's name, and possibly a package name. Without a package name, this function will use the search path and the known exposed packages to find the module, if a package is specified then only that package is searched for the module.

findExposedPackageModule :: FinderCache -> FinderOpts -> UnitState -> ModuleName -> PkgQual -> IO FindResult #

cannotFindModule :: HscEnv -> ModuleName -> FindResult -> MissingInterfaceError #

updOptLevel :: Int -> DynFlags -> DynFlags #

Sets the DynFlags to be appropriate to the optimisation level

type DsM = TcRnIf DsGblEnv DsLclEnv #

Desugaring monad. See also TcM.

getTopEnv :: TcRnIf gbl lcl HscEnv #

updTopEnv :: (HscEnv -> HscEnv) -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a #

getGblEnv :: TcRnIf gbl lcl gbl #

setGblEnv :: gbl' -> TcRnIf gbl' lcl a -> TcRnIf gbl lcl a #

addErrAt :: SrcSpan -> TcRnMessage -> TcRn () #

addErrs :: [(SrcSpan, TcRnMessage)] -> TcRn () #

reportDiagnostics :: [MsgEnvelope TcRnMessage] -> TcM () #

reportDiagnostic :: MsgEnvelope TcRnMessage -> TcRn () #

failIfErrsM :: TcRn () #

captureConstraints :: TcM a -> TcM (a, WantedConstraints) #

failWithTc :: TcRnMessage -> TcM a #

discardConstraints :: TcM a -> TcM a #

Throw out any constraints emitted by the thing_inside

pushTcLevelM :: TcM a -> TcM (TcLevel, a) #

initIfaceTcRn :: IfG a -> TcRn a #

Run an IfG (top-level interface monad) computation inside an existing TcRn (typecheck-renaming monad) computation by initializing an IfGblEnv based on TcGblEnv.

data TraceBinIFace #

Constructors

QuietBinIFace

getWithUserData :: Binary a => NameCache -> BinHandle -> IO a #

This performs a get action after reading the dictionary and symbol table. It is necessary to run this before trying to deserialise any Names or FastStrings.

putWithUserData :: Binary a => TraceBinIFace -> BinHandle -> a -> IO () #

Put a piece of data with an initialised UserData field. This is necessary if you want to serialise Names or FastStrings. It also writes a symbol table and the dictionary. This segment should be read using getWithUserData.

data WhereFrom #

Reason for loading an interface file

Used to figure out whether we want to consider loading hi-boot files or not.

Constructors

ImportBySystem

Instances

Instances details

Outputable WhereFrom
Instance details Defined in GHC.Iface.Load Methods ppr :: WhereFrom -> SDoc #

loadInterface :: SDoc -> Module -> WhereFrom -> IfM lcl (MaybeErr MissingInterfaceError ModIface) #

initDsTc :: DsM a -> TcM (Messages DsMessage, Maybe a) #

Run a DsM action inside the TcM monad.

initDsWithModGuts :: HscEnv -> ModGuts -> DsM a -> IO (Messages DsMessage, Maybe a) #

Run a DsM action in the context of an existing ModGuts

dsLExpr :: LHsExpr GhcTc -> DsM CoreExpr #

Desugar a located typechecked expression.

rnLExpr :: LHsExpr GhcPs -> RnM (LHsExpr GhcRn, FreeVars) #

tcInferRho :: LHsExpr GhcRn -> TcM (LHsExpr GhcTc, TcRhoType) #

tcGetInstEnvs :: TcM InstEnvs #

zonkTopLExpr :: LHsExpr GhcTc -> TcM (LHsExpr GhcTc) #

renamePkgQual :: UnitEnv -> ModuleName -> Maybe FastString -> PkgQual #

Rename raw package imports

data InferMode #

How should we choose which constraints to quantify over?

Constructors

NoRestrictions

Quantify over any constraint that satisfies pickQuantifiablePreds

Instances

Instances details

Outputable InferMode
Instance details Defined in GHC.Tc.Solver Methods ppr :: InferMode -> SDoc #

captureTopConstraints :: TcM a -> TcM (a, WantedConstraints) #

simplifyInteractive :: WantedConstraints -> TcM (Bag EvBind) #

tcValBinds :: TopLevelFlag -> [(RecFlag, LHsBinds GhcRn)] -> [LSig GhcRn] -> TcM thing -> TcM ([(RecFlag, LHsBinds GhcTc)], HsWrapper, thing) #

tcInferSigma :: Bool -> LHsExpr GhcRn -> TcM TcSigmaType #

hscDesugar :: HscEnv -> ModSummary -> TcGblEnv -> IO ModGuts #

Convert a typechecked module to Core

compileFile :: HscEnv -> StopPhase -> (FilePath, Maybe Phase) -> IO (Maybe FilePath) #

data DesugaredModule #

The result of successful desugaring (i.e., translation to core). Also contains all the information of a typechecked module.

Constructors

DesugaredModule
Fields dm_typechecked_module :: TypecheckedModule dm_core_module :: ModGuts

Instances

Instances details

DesugaredMod DesugaredModule
Instance details Defined in GHC Methods coreModule :: DesugaredModule -> ModGuts #
ParsedMod DesugaredModule
Instance details Defined in GHC Methods modSummary :: DesugaredModule -> ModSummary parsedSource :: DesugaredModule -> ParsedSource #
TypecheckedMod DesugaredModule
Instance details Defined in GHC Methods renamedSource :: DesugaredModule -> Maybe RenamedSource # typecheckedSource :: DesugaredModule -> TypecheckedSource # moduleInfo :: DesugaredModule -> ModuleInfo # tm_internals :: DesugaredModule -> (TcGblEnv, ModDetails)

data TypecheckedModule #

The result of successful typechecking. It also contains the parser result.

Instances

Instances details

ParsedMod TypecheckedModule
Instance details Defined in GHC Methods modSummary :: TypecheckedModule -> ModSummary parsedSource :: TypecheckedModule -> ParsedSource #
TypecheckedMod TypecheckedModule
Instance details Defined in GHC Methods renamedSource :: TypecheckedModule -> Maybe RenamedSource # typecheckedSource :: TypecheckedModule -> TypecheckedSource # moduleInfo :: TypecheckedModule -> ModuleInfo # tm_internals :: TypecheckedModule -> (TcGblEnv, ModDetails)

data ParsedModule #

The result of successful parsing.

Constructors

ParsedModule
Fields pm_mod_summary :: ModSummary pm_parsed_source :: ParsedSource pm_extra_src_files :: [FilePath]

Instances

Instances details

ParsedMod ParsedModule
Instance details Defined in GHC Methods modSummary :: ParsedModule -> ModSummary parsedSource :: ParsedModule -> ParsedSource #

coreModule :: DesugaredMod m => m -> ModGuts #

typecheckModule :: GhcMonad m => ParsedModule -> m TypecheckedModule #

Typecheck and rename a parsed module.

Throws a SourceError if either fails.

desugarModule :: GhcMonad m => TypecheckedModule -> m DesugaredModule #

Desugar a typechecked module.

modInfoTopLevelScope :: ModuleInfo -> Maybe [Name] #

isDictonaryId :: Id -> Bool #

deserializeWithData :: Data a => [Word8] -> a #

Use a Data instance to implement a deserialization scheme dual to that of serializeWithData

fromSerialized :: Typeable a => ([Word8] -> a) -> Serialized -> Maybe a #

If the Serialized value contains something of the given type, then use the specified deserializer to return Just that. Otherwise return Nothing.

toSerialized :: Typeable a => (a -> [Word8]) -> a -> Serialized #

Put a Typeable value that we are able to actually turn into bytes into a Serialized value ready for deserialization later

data Serialized #

Represents a serialized value of a particular type. Attempts can be made to deserialize it at certain types

Constructors

Serialized TypeRep [Word8]

Instances

Instances details

Outputable Serialized
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Serialized -> SDoc #