GHC

Initialisation

defaultErrorHandler :: ExceptionMonad m => FatalMessager -> FlushOut -> m a -> m a

Install some default exception handlers and run the inner computation. Unless you want to handle exceptions yourself, you should wrap this around the top level of your program. The default handlers output the error message(s) to stderr and exit cleanly.

defaultCleanupHandler :: ExceptionMonad m => DynFlags -> m a -> m a

Deprecated: Cleanup is now done by runGhc/runGhcT

This function is no longer necessary, cleanup is now done by runGhc/runGhcT.

prettyPrintGhcErrors :: ExceptionMonad m => Logger -> m a -> m a

withSignalHandlers :: ExceptionMonad m => m a -> m a

Temporarily install standard signal handlers for catching ^C, which just throw an exception in the current thread.

withCleanupSession :: GhcMonad m => m a -> m a

GHC Monad

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

MonadFix Ghc

Defined in GHC.Driver.Monad

Methods

mfix :: (a -> Ghc a) -> Ghc a

MonadIO Ghc

Defined in GHC.Driver.Monad

Methods

liftIO :: IO a -> Ghc a

Applicative Ghc

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

Defined in GHC.Driver.Monad

Methods

fmap :: (a -> b) -> Ghc a -> Ghc b

(<$) :: a -> Ghc b -> Ghc a

Monad Ghc

Defined in GHC.Driver.Monad

Methods

(>>=) :: Ghc a -> (a -> Ghc b) -> Ghc b

(>>) :: Ghc a -> Ghc b -> Ghc b

return :: a -> Ghc a

MonadCatch Ghc

Defined in GHC.Driver.Monad

Methods

catch :: Exception e => Ghc a -> (e -> Ghc a) -> Ghc a

MonadMask Ghc

Defined in GHC.Driver.Monad

Methods

mask :: ((forall a. Ghc a -> Ghc a) -> Ghc b) -> Ghc b

uninterruptibleMask :: ((forall a. Ghc a -> Ghc a) -> Ghc b) -> Ghc b

generalBracket :: Ghc a -> (a -> ExitCase b -> Ghc c) -> (a -> Ghc b) -> Ghc (b, c)

MonadThrow Ghc

Defined in GHC.Driver.Monad

Methods

throwM :: Exception e => e -> Ghc a

GhcMonad Ghc

Defined in GHC.Driver.Monad

Methods

getSession :: Ghc HscEnv

setSession :: HscEnv -> Ghc ()

HasDynFlags Ghc

Defined in GHC.Driver.Monad

Methods

getDynFlags :: Ghc DynFlags

HasLogger Ghc

Defined in GHC.Driver.Monad

Methods

getLogger :: Ghc Logger

data GhcT m a

A monad transformer to add GHC specific features to another monad.

Note that the wrapped monad must support IO and handling of exceptions.

Instances

MonadIO m => MonadIO (GhcT m)

Defined in GHC.Driver.Monad

Methods

liftIO :: IO a -> GhcT m a

Applicative m => Applicative (GhcT m)

Defined in GHC.Driver.Monad

Methods

pure :: a -> GhcT m a

(<*>) :: GhcT m (a -> b) -> GhcT m a -> GhcT m b

liftA2 :: (a -> b -> c) -> GhcT m a -> GhcT m b -> GhcT m c

(*>) :: GhcT m a -> GhcT m b -> GhcT m b

(<*) :: GhcT m a -> GhcT m b -> GhcT m a

Functor m => Functor (GhcT m)

Defined in GHC.Driver.Monad

Methods

fmap :: (a -> b) -> GhcT m a -> GhcT m b

(<$) :: a -> GhcT m b -> GhcT m a

Monad m => Monad (GhcT m)

Defined in GHC.Driver.Monad

Methods

(>>=) :: GhcT m a -> (a -> GhcT m b) -> GhcT m b

(>>) :: GhcT m a -> GhcT m b -> GhcT m b

return :: a -> GhcT m a

MonadCatch m => MonadCatch (GhcT m)

Defined in GHC.Driver.Monad

Methods

catch :: Exception e => GhcT m a -> (e -> GhcT m a) -> GhcT m a

MonadMask m => MonadMask (GhcT m)

Defined in GHC.Driver.Monad

Methods

mask :: ((forall a. GhcT m a -> GhcT m a) -> GhcT m b) -> GhcT m b

uninterruptibleMask :: ((forall a. GhcT m a -> GhcT m a) -> GhcT m b) -> GhcT m b

generalBracket :: GhcT m a -> (a -> ExitCase b -> GhcT m c) -> (a -> GhcT m b) -> GhcT m (b, c)

MonadThrow m => MonadThrow (GhcT m)

Defined in GHC.Driver.Monad

Methods

throwM :: Exception e => e -> GhcT m a

ExceptionMonad m => GhcMonad (GhcT m)

Defined in GHC.Driver.Monad

Methods

getSession :: GhcT m HscEnv

setSession :: HscEnv -> GhcT m ()

MonadIO m => HasDynFlags (GhcT m)

Defined in GHC.Driver.Monad

Methods

getDynFlags :: GhcT m DynFlags

MonadIO m => HasLogger (GhcT m)

Defined in GHC.Driver.Monad

Methods

getLogger :: GhcT m Logger

class (Functor m, ExceptionMonad m, HasDynFlags m, HasLogger m) => GhcMonad m 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.

Methods

getSession :: m HscEnv

setSession :: HscEnv -> m ()

Instances

GhcMonad Ghc

Defined in GHC.Driver.Monad

Methods

getSession :: Ghc HscEnv

setSession :: HscEnv -> Ghc ()

ExceptionMonad m => GhcMonad (GhcT m)

Defined in GHC.Driver.Monad

Methods

getSession :: GhcT m HscEnv

setSession :: HscEnv -> GhcT m ()

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

ContainsDynFlags HscEnv

Defined in GHC.Driver.Env.Types

Methods

extractDynFlags :: HscEnv -> DynFlags

runGhc

Arguments

:: Maybe FilePath

See argument to initGhcMonad.

-> Ghc a

The action to perform.

-> IO a

Run function for the Ghc monad.

It initialises the GHC session and warnings via initGhcMonad. Each call to this function will create a new session which should not be shared among several threads.

Any errors not handled inside the Ghc action are propagated as IO exceptions.

runGhcT

Arguments

:: ExceptionMonad m

=> Maybe FilePath

See argument to initGhcMonad.

-> GhcT m a

The action to perform.

-> m a

Run function for GhcT monad transformer.

It initialises the GHC session and warnings via initGhcMonad. Each call to this function will create a new session which should not be shared among several threads.

initGhcMonad :: GhcMonad m => Maybe FilePath -> m ()

Initialise a GHC session.

If you implement a custom GhcMonad you must call this function in the monad run function. It will initialise the session variable and clear all warnings.

The first argument should point to the directory where GHC's library files reside. More precisely, this should be the output of ghc --print-libdir of the version of GHC the module using this API is compiled with. For portability, you should use the ghc-paths package, available at http://hackage.haskell.org/package/ghc-paths.

printException :: (HasLogger m, MonadIO m, HasDynFlags m) => SourceError -> m ()

Print the all diagnostics in a SourceError. Useful inside exception handlers.

handleSourceError

Arguments

:: MonadCatch m

=> (SourceError -> m a)

exception handler

-> m a

action to perform

-> m a

Perform the given action and call the exception handler if the action throws a SourceError. See SourceError for more information.

Flags and settings

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

Constructors

DynFlags

Fields

• ghcMode :: GhcMode
• ghcLink :: GhcLink
• backend :: !Backend

  The backend to use (if any).

  Whenever you change the backend, also make sure to set ghcLink to something sensible.

  NoBackend can be used to avoid generating any output, however, note that:

  • If a program uses Template Haskell the typechecker may need to run code from an imported module. To facilitate this, code generation is enabled for modules imported by modules that use template haskell, using the default backend for the platform. See Note [-fno-code mode].
• ghcNameVersion :: !GhcNameVersion
• fileSettings :: !FileSettings
• targetPlatform :: Platform
• toolSettings :: !ToolSettings
• platformMisc :: !PlatformMisc
• rawSettings :: [(String, String)]
• tmpDir :: TempDir
• llvmConfig :: LlvmConfig

  N.B. It's important that this field is lazy since we load the LLVM configuration lazily. See Note [LLVM configuration] in GHC.SysTools.

• llvmOptLevel :: Int

  LLVM optimisation level

• verbosity :: Int

  Verbosity level: see Note [Verbosity levels]

• debugLevel :: Int

  How much debug information to produce

• simplPhases :: Int

  Number of simplifier phases

• maxSimplIterations :: Int

  Max simplifier iterations

• ruleCheck :: Maybe String
• strictnessBefore :: [Int]

  Additional demand analysis

• parMakeCount :: Maybe Int

  The number of modules to compile in parallel in --make mode, where Nothing ==> compile as many in parallel as there are CPUs.

• enableTimeStats :: Bool

  Enable RTS timing statistics?

• ghcHeapSize :: Maybe Int

  The heap size to set.

• maxRelevantBinds :: Maybe Int

  Maximum number of bindings from the type envt to show in type error messages

• maxValidHoleFits :: Maybe Int

  Maximum number of hole fits to show in typed hole error messages

• maxRefHoleFits :: Maybe Int

  Maximum number of refinement hole fits to show in typed hole error messages

• refLevelHoleFits :: Maybe Int

  Maximum level of refinement for refinement hole fits in typed hole error messages

• maxUncoveredPatterns :: Int

  Maximum number of unmatched patterns to show in non-exhaustiveness warnings

• maxPmCheckModels :: Int

  Soft limit on the number of models the pattern match checker checks a pattern against. A safe guard against exponential blow-up.

• simplTickFactor :: Int

  Multiplier for simplifier ticks

• dmdUnboxWidth :: !Int

  Whether DmdAnal should optimistically put an Unboxed demand on returned products with at most this number of fields

• specConstrThreshold :: Maybe Int

  Threshold for SpecConstr

• specConstrCount :: Maybe Int

  Max number of specialisations for any one function

• specConstrRecursive :: Int

  Max number of specialisations for recursive types Not optional; otherwise ForceSpecConstr can diverge.

• binBlobThreshold :: Maybe Word

  Binary literals (e.g. strings) whose size is above this threshold will be dumped in a binary file by the assembler code generator. 0 and Nothing disables this feature. See Config.

• liberateCaseThreshold :: Maybe Int

  Threshold for LiberateCase

• floatLamArgs :: Maybe Int

  Arg count for lambda floating See FloatOutSwitches

• liftLamsRecArgs :: Maybe Int

  Maximum number of arguments after lambda lifting a recursive function.

• liftLamsNonRecArgs :: Maybe Int

  Maximum number of arguments after lambda lifting a non-recursive function.

• liftLamsKnown :: Bool

  Lambda lift even when this turns a known call into an unknown call.

• cmmProcAlignment :: Maybe Int

  Align Cmm functions at this boundary or use default.

• historySize :: Int

  Simplification history size

• importPaths :: [FilePath]
• mainModuleNameIs :: ModuleName
• mainFunIs :: Maybe String
• reductionDepth :: IntWithInf

  Typechecker maximum stack depth

• solverIterations :: IntWithInf

  Number of iterations in the constraints solver Typically only 1 is needed

• homeUnitId_ :: UnitId

  Target home unit-id

• homeUnitInstanceOf_ :: Maybe UnitId

  Id of the unit to instantiate

• homeUnitInstantiations_ :: [(ModuleName, Module)]

  Module instantiations

• workingDirectory :: Maybe FilePath
• thisPackageName :: Maybe String

  What the package is called, use with multiple home units

• hiddenModules :: Set ModuleName
• reexportedModules :: Set ModuleName
• targetWays_ :: Ways

  Target way flags from the command line

• splitInfo :: Maybe (String, Int)
• objectDir :: Maybe String
• dylibInstallName :: Maybe String
• hiDir :: Maybe String
• hieDir :: Maybe String
• stubDir :: Maybe String
• dumpDir :: Maybe String
• objectSuf_ :: String
• hcSuf :: String
• hiSuf_ :: String
• hieSuf :: String
• dynObjectSuf_ :: String
• dynHiSuf_ :: String
• outputFile_ :: Maybe String
• dynOutputFile_ :: Maybe String
• outputHi :: Maybe String
• dynOutputHi :: Maybe String
• dynLibLoader :: DynLibLoader
• dynamicNow :: !Bool

  Indicate if we are now generating dynamic output because of -dynamic-too. This predicate is used to query the appropriate fields (outputFile/dynOutputFile, ways, etc.)

• dumpPrefix :: FilePath

  This defaults to 'non-module'. It can be set by setDumpPrefix or 'ghc.GHCi.UI.runStmt' based on where its output is going.

• dumpPrefixForce :: Maybe FilePath

  Override the dumpPrefix set by setDumpPrefix or 'ghc.GHCi.UI.runStmt'. Set by -ddump-file-prefix

• ldInputs :: [Option]
• includePaths :: IncludeSpecs
• libraryPaths :: [String]
• frameworkPaths :: [String]
• cmdlineFrameworks :: [String]
• rtsOpts :: Maybe String
• rtsOptsEnabled :: RtsOptsEnabled
• rtsOptsSuggestions :: Bool
• hpcDir :: String

  Path to store the .mix files

• pluginModNames :: [ModuleName]

  the -fplugin flags given on the command line, in *reverse* order that they're specified on the command line.

• pluginModNameOpts :: [(ModuleName, String)]
• frontendPluginOpts :: [String]

  the -ffrontend-opt flags given on the command line, in *reverse* order that they're specified on the command line.

• depMakefile :: FilePath
• depIncludePkgDeps :: Bool
• depIncludeCppDeps :: Bool
• depExcludeMods :: [ModuleName]
• depSuffixes :: [String]
• packageDBFlags :: [PackageDBFlag]

  The -package-db flags given on the command line, In *reverse* order that they're specified on the command line. This is intended to be applied with the list of "initial" package databases derived from GHC_PACKAGE_PATH; see getUnitDbRefs.

• ignorePackageFlags :: [IgnorePackageFlag]

  The -ignore-package flags from the command line. In *reverse* order that they're specified on the command line.

• packageFlags :: [PackageFlag]

  The -package and -hide-package flags from the command-line. In *reverse* order that they're specified on the command line.

• pluginPackageFlags :: [PackageFlag]

  The -plugin-package-id flags from command line. In *reverse* order that they're specified on the command line.

• trustFlags :: [TrustFlag]

  The -trust and -distrust flags. In *reverse* order that they're specified on the command line.

• packageEnv :: Maybe FilePath

  Filepath to the package environment file (if overriding default)

• dumpFlags :: EnumSet DumpFlag
• generalFlags :: EnumSet GeneralFlag
• warningFlags :: EnumSet WarningFlag
• fatalWarningFlags :: EnumSet WarningFlag
• language :: Maybe Language
• safeHaskell :: SafeHaskellMode

  Safe Haskell mode

• safeInfer :: Bool
• safeInferred :: Bool
• thOnLoc :: SrcSpan
• newDerivOnLoc :: SrcSpan
• deriveViaOnLoc :: SrcSpan
• overlapInstLoc :: SrcSpan
• incoherentOnLoc :: SrcSpan
• pkgTrustOnLoc :: SrcSpan
• warnSafeOnLoc :: SrcSpan
• warnUnsafeOnLoc :: SrcSpan
• trustworthyOnLoc :: SrcSpan
• extensions :: [OnOff Extension]
• extensionFlags :: EnumSet Extension
• unfoldingOpts :: !UnfoldingOpts

  Unfolding control See Note [Discounts and thresholds] in GHC.Core.Unfold

• maxWorkerArgs :: Int
• ghciHistSize :: Int
• flushOut :: FlushOut
• ghcVersionFile :: Maybe FilePath
• haddockOptions :: Maybe String
• ghciScripts :: [String]

  GHCi scripts specified by -ghci-script, in reverse order

• pprUserLength :: Int
• pprCols :: Int
• useUnicode :: Bool
• useColor :: OverridingBool
• canUseColor :: Bool
• colScheme :: Scheme
• profAuto :: ProfAuto

  what kind of {-# SCC #-} to add automatically

• callerCcFilters :: [CallerCcFilter]
• interactivePrint :: Maybe String
• sseVersion :: Maybe SseVersion

  Machine dependent flags (-m<blah> stuff)

• bmiVersion :: Maybe BmiVersion
• avx :: Bool
• avx2 :: Bool
• avx512cd :: Bool
• avx512er :: Bool
• avx512f :: Bool
• avx512pf :: Bool
• rtldInfo :: IORef (Maybe LinkerInfo)

  Run-time linker information (what options we need, etc.)

• rtccInfo :: IORef (Maybe CompilerInfo)

  Run-time C compiler information

• rtasmInfo :: IORef (Maybe CompilerInfo)

  Run-time assembler information

• maxInlineAllocSize :: Int

  Max size, in bytes, of inline array allocations.

• maxInlineMemcpyInsns :: Int

  Only inline memcpy if it generates no more than this many pseudo (roughly: Cmm) instructions.

• maxInlineMemsetInsns :: Int

  Only inline memset if it generates no more than this many pseudo (roughly: Cmm) instructions.

• reverseErrors :: Bool

  Reverse the order of error messages in GHC/GHCi

• maxErrors :: Maybe Int

  Limit the maximum number of errors to show

• initialUnique :: Word

  Unique supply configuration for testing build determinism

• uniqueIncrement :: Int
• cfgWeights :: Weights

  Temporary: CFG Edge weights for fast iterations

data GeneralFlag

Enumerates the simple on-or-off dynamic flags

Constructors

Opt_DumpToFile

Append dump output to files instead of stdout.

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_WarnIsError

Opt_ShowWarnGroups

Opt_HideSourcePaths

Opt_PrintExplicitForalls

Opt_PrintExplicitKinds

Opt_PrintExplicitCoercions

Opt_PrintExplicitRuntimeReps

Opt_PrintEqualityRelations

Opt_PrintAxiomIncomps

Opt_PrintUnicodeSyntax

Opt_PrintExpandedSynonyms

Opt_PrintPotentialInstances

Opt_PrintTypecheckerElaboration

Opt_CallArity

Opt_Exitification

Opt_Strictness

Opt_LateDmdAnal

Opt_KillAbsence

Opt_KillOneShot

Opt_FullLaziness

Opt_FloatIn

Opt_LateSpecialise

Opt_Specialise

Opt_SpecialiseAggressively

Opt_CrossModuleSpecialise

Opt_InlineGenerics

Opt_InlineGenericsAggressively

Opt_StaticArgumentTransformation

Opt_CSE

Opt_StgCSE

Opt_StgLiftLams

Opt_LiberateCase

Opt_SpecConstr

Opt_SpecConstrKeen

Opt_DoLambdaEtaExpansion

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_LlvmTBAA

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_WriteInterface

Opt_WriteHie

Opt_AutoSccsOnIndividualCafs

Opt_ProfCountEntries

Opt_ProfLateInlineCcs

Opt_ProfLateCcs

Opt_ProfManualCcs

Ignore manual SCC annotations

Opt_Pp

Opt_ForceRecomp

Opt_IgnoreOptimChanges

Opt_IgnoreHpcChanges

Opt_ExcessPrecision

Opt_EagerBlackHoling

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_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_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_LinkRts

Opt_ErrorSpans

Opt_DeferDiagnostics

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_SuppressVarKinds

Opt_SuppressModulePrefixes

Opt_SuppressTypeApplications

Opt_SuppressIdInfo

Opt_SuppressUnfoldings

Opt_SuppressTypeSignatures

Opt_SuppressUniques

Opt_SuppressStgExts

Opt_SuppressTicks

Opt_SuppressTimestamps

Suppress timestamps in dumps

Opt_SuppressCoreSizes

Suppress per binding Core size stats in dumps

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_DistrustAllPackages

Opt_PackageTrust

Opt_PluginTrustworthy

Opt_G_NoStateHack

Opt_G_NoOptCoercion

Instances

Enum GeneralFlag

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

Defined in GHC.Driver.Flags

Methods

showsPrec :: Int -> GeneralFlag -> ShowS

show :: GeneralFlag -> String

showList :: [GeneralFlag] -> ShowS

Eq GeneralFlag

Defined in GHC.Driver.Flags

Methods

(==) :: GeneralFlag -> GeneralFlag -> Bool

(/=) :: GeneralFlag -> GeneralFlag -> Bool

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

SevIgnore

Ignore this message, for example in case of suppression of warnings users don't want to see. See Note [Suppressing Messages]

SevWarning

SevError

Instances

Show Severity

Defined in GHC.Types.Error

Methods

showsPrec :: Int -> Severity -> ShowS

show :: Severity -> String

showList :: [Severity] -> ShowS

ToJson Severity

Defined in GHC.Types.Error

Methods

json :: Severity -> JsonDoc

Outputable Severity

Defined in GHC.Types.Error

Methods

ppr :: Severity -> SDoc

Eq Severity

Defined in GHC.Types.Error

Methods

(==) :: Severity -> Severity -> Bool

(/=) :: Severity -> Severity -> Bool

data Backend

Code generation backends.

GHC supports several code generation backends serving different purposes (producing machine code, producing ByteCode for the interpreter) and supporting different platforms.

Constructors

NCG

Native code generator backend.

Compiles Cmm code into textual assembler, then relies on an external assembler toolchain to produce machine code.

Only supports a few platforms (X86, PowerPC, SPARC).

See GHC.CmmToAsm.

LLVM

LLVM backend.

Compiles Cmm code into LLVM textual IR, then relies on LLVM toolchain to produce machine code.

It relies on LLVM support for the calling convention used by the NCG backend to produce code objects ABI compatible with it (see "cc 10" or "ghccc" calling convention in https://llvm.org/docs/LangRef.html#calling-conventions).

Support a few platforms (X86, AArch64, s390x, ARM).

See GHC.CmmToLlvm

ViaC

Via-C backend.

Compiles Cmm code into C code, then relies on a C compiler to produce machine code.

It produces code objects that are *not* ABI compatible with those produced by NCG and LLVM backends.

Produced code is expected to be less efficient than the one produced by NCG and LLVM backends because STG registers are not pinned into real registers. On the other hand, it supports more target platforms (those having a valid C toolchain).

See GHC.CmmToC

Interpreter

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

NoBackend

No code generated.

Use this to disable code generation. It is particularly useful when GHC is used as a library for other purpose than generating code (e.g. to generate documentation with Haddock) or when the user requested it (via -fno-code) for some reason.

Instances

Read Backend

Defined in GHC.Driver.Backend

Methods

readsPrec :: Int -> ReadS Backend

readList :: ReadS [Backend]

readPrec :: ReadPrec Backend

readListPrec :: ReadPrec [Backend]

Show Backend

Defined in GHC.Driver.Backend

Methods

showsPrec :: Int -> Backend -> ShowS

show :: Backend -> String

showList :: [Backend] -> ShowS

Eq Backend

Defined in GHC.Driver.Backend

Methods

(==) :: Backend -> Backend -> Bool

(/=) :: Backend -> Backend -> Bool

Ord Backend

Defined in GHC.Driver.Backend

Methods

compare :: Backend -> Backend -> Ordering

(<) :: Backend -> Backend -> Bool

(<=) :: Backend -> Backend -> Bool

(>) :: Backend -> Backend -> Bool

(>=) :: Backend -> Backend -> Bool

max :: Backend -> Backend -> Backend

min :: Backend -> Backend -> Backend

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.

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.

OneShot

ghc -c Foo.hs

MkDepend

ghc -M, see GHC.Unit.Finder for why we need this

Instances

Outputable GhcMode

Defined in GHC.Driver.Session

Methods

ppr :: GhcMode -> SDoc

Eq GhcMode

Defined in GHC.Driver.Session

Methods

(==) :: GhcMode -> GhcMode -> Bool

(/=) :: GhcMode -> GhcMode -> Bool

data GhcLink

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

Constructors

NoLink

Don't link at all

LinkBinary

Link object code into a binary

LinkInMemory

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

LinkDynLib

Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)

LinkStaticLib

Link objects into a static lib

LinkMergedObj

Link objects into a merged "GHCi object"

Instances

Show GhcLink

Defined in GHC.Driver.Session

Methods

showsPrec :: Int -> GhcLink -> ShowS

show :: GhcLink -> String

showList :: [GhcLink] -> ShowS

Eq GhcLink

Defined in GHC.Driver.Session

Methods

(==) :: GhcLink -> GhcLink -> Bool

(/=) :: GhcLink -> GhcLink -> Bool

parseDynamicFlags :: MonadIO m => Logger -> DynFlags -> [Located String] -> m (DynFlags, [Located String], [Warn])

parseTargetFiles :: DynFlags -> [String] -> (DynFlags, [(String, Maybe Phase)], [String])

Parse command line arguments that look like files. First normalises its arguments and then splits them into source files and object files. A source file can be turned into a Target via guessTarget

getSessionDynFlags :: GhcMonad m => m DynFlags

Grabs the DynFlags from the Session

setTopSessionDynFlags :: GhcMonad m => DynFlags -> m ()

setSessionDynFlags :: (HasCallStack, GhcMonad m) => DynFlags -> m ()

setUnitDynFlags :: GhcMonad m => UnitId -> DynFlags -> m ()

getProgramDynFlags :: GhcMonad m => m DynFlags

Returns the program DynFlags.

setProgramDynFlags :: GhcMonad m => DynFlags -> m Bool

Sets the program DynFlags. Note: this invalidates the internal cached module graph, causing more work to be done the next time load is called.

Returns a boolean indicating if preload units have changed and need to be reloaded.

getInteractiveDynFlags :: GhcMonad m => m DynFlags

Get the DynFlags used to evaluate interactive expressions.

setInteractiveDynFlags :: GhcMonad m => DynFlags -> m ()

Set the DynFlags used to evaluate interactive expressions. Also initialise (load) plugins.

Note: this cannot be used for changes to packages. Use setSessionDynFlags, or setProgramDynFlags and then copy the unitState into the interactive DynFlags.

interpretPackageEnv :: Logger -> DynFlags -> IO DynFlags

Find the package environment (if one exists)

We interpret the package environment as a set of package flags; to be specific, if we find a package environment file like

clear-package-db
global-package-db
package-db blah/package.conf.d
package-id id1
package-id id2

we interpret this as

[ -hide-all-packages
, -clear-package-db
, -global-package-db
, -package-db blah/package.conf.d
, -package-id id1
, -package-id id2
]

There's also an older syntax alias for package-id, which is just an unadorned package id

id1
id2

Logging

data Logger

getLogger :: HasLogger m => m Logger

pushLogHook :: (LogAction -> LogAction) -> Logger -> Logger

Push a log hook

popLogHook :: Logger -> Logger

Pop a log hook

pushLogHookM :: GhcMonad m => (LogAction -> LogAction) -> m ()

Push a log hook on the stack

popLogHookM :: GhcMonad m => m ()

Pop a log hook from the stack

modifyLogger :: GhcMonad m => (Logger -> Logger) -> m ()

Modify the logger

putMsgM :: GhcMonad m => SDoc -> m ()

Put a log message

putLogMsgM :: GhcMonad m => MessageClass -> SrcSpan -> SDoc -> m ()

Put a log message

Targets

data Target

A compilation target.

A target may be supplied with the actual text of the module. If so, use this instead of the file contents (this is for use in an IDE where the file hasn't been saved by the user yet).

These fields are strict because Targets are long lived.

Constructors

Target

Fields

• targetId :: !TargetId

  module or filename

• targetAllowObjCode :: !Bool

  object code allowed?

• targetUnitId :: !UnitId

  id of the unit this target is part of

• targetContents :: !(Maybe (InputFileBuffer, UTCTime))

  Optional in-memory buffer containing the source code GHC should use for this target instead of reading it from disk.

  Since GHC version 8.10 modules which require preprocessors such as Literate Haskell or CPP to run are also supported.

  If a corresponding source file does not exist on disk this will result in a SourceError exception if targetId = TargetModule _ is used. However together with targetId = TargetFile _ GHC will not complain about the file missing.

Instances

Outputable Target

Defined in GHC.Types.Target

Methods

ppr :: Target -> SDoc

data TargetId

Constructors

TargetModule !ModuleName

A module name: search for the file

TargetFile !FilePath !(Maybe Phase)

A filename: preprocess & parse it to find the module name. If specified, the Phase indicates how to compile this file (which phase to start from). Nothing indicates the starting phase should be determined from the suffix of the filename.

Instances

Outputable TargetId

Defined in GHC.Types.Target

Methods

ppr :: TargetId -> SDoc

Eq TargetId

Defined in GHC.Types.Target

Methods

(==) :: TargetId -> TargetId -> Bool

(/=) :: TargetId -> TargetId -> Bool

data Phase

Untyped Phase description

Instances

Show Phase

Defined in GHC.Driver.Phases

Methods

showsPrec :: Int -> Phase -> ShowS

show :: Phase -> String

showList :: [Phase] -> ShowS

Outputable Phase

Defined in GHC.Driver.Phases

Methods

ppr :: Phase -> SDoc

Eq Phase

Defined in GHC.Driver.Phases

Methods

(==) :: Phase -> Phase -> Bool

(/=) :: Phase -> Phase -> Bool

setTargets :: GhcMonad m => [Target] -> m ()

Sets the targets for this session. Each target may be a module name or a filename. The targets correspond to the set of root modules for the program/library. Unloading the current program is achieved by setting the current set of targets to be empty, followed by load.

getTargets :: GhcMonad m => m [Target]

Returns the current set of targets

addTarget :: GhcMonad m => Target -> m ()

Add another target.

removeTarget :: GhcMonad m => TargetId -> m ()

Remove a target

guessTarget :: GhcMonad m => String -> Maybe UnitId -> Maybe Phase -> m Target

Attempts to guess what Target a string refers to. This function implements the --make/GHCi command-line syntax for filenames:

• if the string looks like a Haskell source filename, then interpret it as such
• if adding a .hs or .lhs suffix yields the name of an existing file, then use that
• otherwise interpret the string as a module name

Loading/compiling the program

depanal

Arguments

:: GhcMonad m

=> [ModuleName]

excluded modules

-> Bool

allow duplicate roots

-> m ModuleGraph

Perform a dependency analysis starting from the current targets and update the session with the new module graph.

Dependency analysis entails parsing the import directives and may therefore require running certain preprocessors.

Note that each ModSummary in the module graph caches its DynFlags. These DynFlags are determined by the current session DynFlags and the OPTIONS and LANGUAGE pragmas of the parsed module. Thus if you want changes to the DynFlags to take effect you need to call this function again. In case of errors, just throw them.

depanalE

Arguments

:: GhcMonad m

=> [ModuleName]

excluded modules

-> Bool

allow duplicate roots

-> m (DriverMessages, ModuleGraph)

Perform dependency analysis like in depanal. In case of errors, the errors and an empty module graph are returned.

load :: GhcMonad f => LoadHowMuch -> f SuccessFlag

Try to load the program. See LoadHowMuch for the different modes.

This function implements the core of GHC's --make mode. It preprocesses, compiles and loads the specified modules, avoiding re-compilation wherever possible. Depending on the backend (see backend field) compiling and loading may result in files being created on disk.

Calls the defaultWarnErrLogger after each compiling each module, whether successful or not.

If errors are encountered during dependency analysis, the module depanalE returns together with the errors an empty ModuleGraph. After processing this empty ModuleGraph, the errors of depanalE are thrown. All other errors are reported using the defaultWarnErrLogger.

loadWithCache :: GhcMonad m => Maybe ModIfaceCache -> LoadHowMuch -> m SuccessFlag

data LoadHowMuch

Describes which modules of the module graph need to be loaded.

Constructors

LoadAllTargets

Load all targets and its dependencies.

LoadUpTo HomeUnitModule

Load only the given module and its dependencies.

LoadDependenciesOf HomeUnitModule

Load only the dependencies of the given module, but not the module itself.

data InteractiveImport

Constructors

IIDecl (ImportDecl GhcPs)

Bring the exports of a particular module (filtered by an import decl) into scope

IIModule ModuleName

Bring into scope the entire top-level envt of of this module, including the things imported into it.

Instances

Outputable InteractiveImport

Defined in GHC.Runtime.Context

Methods

ppr :: InteractiveImport -> SDoc

data SuccessFlag

Constructors

Succeeded

Failed

Instances

Semigroup SuccessFlag

Defined in GHC.Types.Basic

Methods

(<>) :: SuccessFlag -> SuccessFlag -> SuccessFlag

sconcat :: NonEmpty SuccessFlag -> SuccessFlag

stimes :: Integral b => b -> SuccessFlag -> SuccessFlag

Outputable SuccessFlag

Defined in GHC.Types.Basic

Methods

ppr :: SuccessFlag -> SDoc

succeeded :: SuccessFlag -> Bool

failed :: SuccessFlag -> Bool

defaultWarnErrLogger :: WarnErrLogger

type WarnErrLogger = forall m. (HasDynFlags m, MonadIO m, HasLogger m) => Maybe SourceError -> m ()

A function called to log warnings and errors.

workingDirectoryChanged :: GhcMonad m => m ()

Inform GHC that the working directory has changed. GHC will flush its cache of module locations, since it may no longer be valid.

Note: Before changing the working directory make sure all threads running in the same session have stopped. If you change the working directory, you should also unload the current program (set targets to empty, followed by load).

parseModule :: GhcMonad m => ModSummary -> m ParsedModule

Parse a module.

Throws a SourceError on parse error.

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.

data ParsedModule

The result of successful parsing.

Constructors

ParsedModule

Fields

• pm_mod_summary :: ModSummary
• pm_parsed_source :: ParsedSource
• pm_extra_src_files :: [FilePath]

Instances

ParsedMod ParsedModule

Defined in GHC

Methods

modSummary :: ParsedModule -> ModSummary

parsedSource :: ParsedModule -> ParsedSource

data TypecheckedModule

The result of successful typechecking. It also contains the parser result.

Constructors

TypecheckedModule

Fields

• tm_parsed_module :: ParsedModule
• tm_renamed_source :: Maybe RenamedSource
• tm_typechecked_source :: TypecheckedSource
• tm_checked_module_info :: ModuleInfo
• tm_internals_ :: (TcGblEnv, ModDetails)

Instances

ParsedMod TypecheckedModule

Defined in GHC

Methods

modSummary :: TypecheckedModule -> ModSummary

parsedSource :: TypecheckedModule -> ParsedSource

TypecheckedMod TypecheckedModule

Defined in GHC

Methods

renamedSource :: TypecheckedModule -> Maybe RenamedSource

typecheckedSource :: TypecheckedModule -> TypecheckedSource

moduleInfo :: TypecheckedModule -> ModuleInfo

tm_internals :: TypecheckedModule -> (TcGblEnv, ModDetails)

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

ParsedMod DesugaredModule

Defined in GHC

Methods

modSummary :: DesugaredModule -> ModSummary

parsedSource :: DesugaredModule -> ParsedSource

TypecheckedMod DesugaredModule

Defined in GHC

Methods

renamedSource :: DesugaredModule -> Maybe RenamedSource

typecheckedSource :: DesugaredModule -> TypecheckedSource

moduleInfo :: DesugaredModule -> ModuleInfo

tm_internals :: DesugaredModule -> (TcGblEnv, ModDetails)

type TypecheckedSource = LHsBinds GhcTc

type ParsedSource = Located HsModule

type RenamedSource = (HsGroup GhcRn, [LImportDecl GhcRn], Maybe [(LIE GhcRn, Avails)], Maybe (LHsDoc GhcRn))

class ParsedMod m => TypecheckedMod m

Minimal complete definition

renamedSource, typecheckedSource, moduleInfo, tm_internals

Instances

TypecheckedMod DesugaredModule

Defined in GHC

Methods

renamedSource :: DesugaredModule -> Maybe RenamedSource

typecheckedSource :: DesugaredModule -> TypecheckedSource

moduleInfo :: DesugaredModule -> ModuleInfo

tm_internals :: DesugaredModule -> (TcGblEnv, ModDetails)

TypecheckedMod TypecheckedModule

Defined in GHC

Methods

renamedSource :: TypecheckedModule -> Maybe RenamedSource

typecheckedSource :: TypecheckedModule -> TypecheckedSource

moduleInfo :: TypecheckedModule -> ModuleInfo

tm_internals :: TypecheckedModule -> (TcGblEnv, ModDetails)

class ParsedMod m

Minimal complete definition

modSummary, parsedSource

Instances

ParsedMod DesugaredModule

Defined in GHC

Methods

modSummary :: DesugaredModule -> ModSummary

parsedSource :: DesugaredModule -> ParsedSource

ParsedMod ParsedModule

Defined in GHC

Methods

modSummary :: ParsedModule -> ModSummary

parsedSource :: ParsedModule -> ParsedSource

ParsedMod TypecheckedModule

Defined in GHC

Methods

modSummary :: TypecheckedModule -> ModSummary

parsedSource :: TypecheckedModule -> ParsedSource

moduleInfo :: TypecheckedMod m => m -> ModuleInfo

renamedSource :: TypecheckedMod m => m -> Maybe RenamedSource

typecheckedSource :: TypecheckedMod m => m -> TypecheckedSource

parsedSource :: ParsedMod m => m -> ParsedSource

coreModule :: DesugaredMod m => m -> ModGuts

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

ThisPkg UnitId

Import from home-unit

OtherPkg UnitId

Import from another unit

Instances

Data PkgQual

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

Outputable PkgQual

Defined in GHC.Types.PkgQual

Methods

ppr :: PkgQual -> SDoc

Eq PkgQual

Defined in GHC.Types.PkgQual

Methods

(==) :: PkgQual -> PkgQual -> Bool

(/=) :: PkgQual -> PkgQual -> Bool

Ord PkgQual

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

Compiling to Core

data CoreModule

A CoreModule consists of just the fields of a ModGuts that are needed for the compileToCoreModule interface.

Constructors

CoreModule

Fields

• cm_module :: !Module

  Module name

• cm_types :: !TypeEnv

  Type environment for types declared in this module

• cm_binds :: CoreProgram

  Declarations

• cm_safe :: SafeHaskellMode

  Safe Haskell mode

Instances

Outputable CoreModule

Defined in GHC

Methods

ppr :: CoreModule -> SDoc

compileToCoreModule :: GhcMonad m => FilePath -> m CoreModule

This is the way to get access to the Core bindings corresponding to a module. compileToCore parses, typechecks, and desugars the module, then returns the resulting Core module (consisting of the module name, type declarations, and function declarations) if successful.

compileToCoreSimplified :: GhcMonad m => FilePath -> m CoreModule

Like compileToCoreModule, but invokes the simplifier, so as to return simplified and tidied Core.

Inspecting the module structure of the program

data ModuleGraph

A 'ModuleGraph' contains all the nodes from the home package (only). See 'ModuleGraphNode' for information about the nodes.

Modules need to be compiled. hs-boots need to be typechecked before the associated "real" module so modules with {-# SOURCE #-} imports can be built. Instantiations also need to be typechecked to ensure that the module fits the signature. Substantiation typechecking is roughly comparable to the check that the module and its hs-boot agree.

The graph is not necessarily stored in topologically-sorted order. Use topSortModuleGraph and flattenSCC to achieve this.

emptyMG :: ModuleGraph

mapMG :: (ModSummary -> ModSummary) -> ModuleGraph -> ModuleGraph

Map a function f over all the ModSummaries. To preserve invariants f can't change the isBoot status.

mkModuleGraph :: [ModuleGraphNode] -> ModuleGraph

mgModSummaries :: ModuleGraph -> [ModSummary]

mgLookupModule :: ModuleGraph -> Module -> Maybe ModSummary

Look up a ModSummary in the ModuleGraph Looks up the non-boot ModSummary Linear in the size of the module graph

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

Constructors

ModSummary

Fields

• ms_mod :: Module

  Identity of the module

• ms_hsc_src :: HscSource

  The module source either plain Haskell, hs-boot, or hsig

• ms_location :: ModLocation

  Location of the various files belonging to the module

• ms_hs_hash :: Fingerprint

  Content hash of source file

• ms_obj_date :: Maybe UTCTime

  Timestamp of object, if we have one

• ms_dyn_obj_date :: !(Maybe UTCTime)

  Timestamp of dynamic object, if we have one

• ms_iface_date :: Maybe UTCTime

  Timestamp of hi file, if we have one See Note [When source is considered modified] and #9243

• ms_hie_date :: Maybe UTCTime

  Timestamp of hie file, if we have one

• ms_srcimps :: [(PkgQual, Located ModuleName)]

  Source imports of the module

• ms_textual_imps :: [(PkgQual, Located ModuleName)]

  Non-source imports of the module from the module *text*

• ms_ghc_prim_import :: !Bool

  Whether the special module GHC.Prim was imported explicitliy

• ms_parsed_mod :: Maybe HsParsedModule

  The parsed, nonrenamed source, if we have it. This is also used to support "inline module syntax" in Backpack files.

• ms_hspp_file :: FilePath

  Filename of preprocessed source file

• ms_hspp_opts :: DynFlags

  Cached flags from OPTIONS, INCLUDE and LANGUAGE pragmas in the modules source code

• ms_hspp_buf :: Maybe StringBuffer

  The actual preprocessed source, if we have it

Instances

Outputable ModSummary

Defined in GHC.Unit.Module.ModSummary

Methods

ppr :: ModSummary -> SDoc

ms_mod_name :: ModSummary -> ModuleName

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.

Constructors

ModLocation

Fields

• ml_hs_file :: Maybe FilePath

  The source file, if we have one. Package modules probably don't have source files.

• ml_hi_file :: FilePath

  Where the .hi file is, whether or not it exists yet. Always of form foo.hi, even if there is an hi-boot file (we add the -boot suffix later)

• ml_dyn_hi_file :: FilePath

  Where the .dyn_hi file is, whether or not it exists yet.

• ml_obj_file :: FilePath

  Where the .o file is, whether or not it exists yet. (might not exist either because the module hasn't been compiled yet, or because it is part of a unit with a .a file)

• ml_dyn_obj_file :: FilePath

  Where the .dy file is, whether or not it exists yet.

• ml_hie_file :: FilePath

  Where the .hie file is, whether or not it exists yet.

Instances

Show ModLocation

Defined in GHC.Unit.Module.Location

Methods

showsPrec :: Int -> ModLocation -> ShowS

show :: ModLocation -> String

showList :: [ModLocation] -> ShowS

Outputable ModLocation

Defined in GHC.Unit.Module.Location

Methods

ppr :: ModLocation -> SDoc

getModSummary :: GhcMonad m => ModuleName -> m ModSummary

Return the ModSummary of a module with the given name.

The module must be part of the module graph (see hsc_mod_graph and ModuleGraph). If this is not the case, this function will throw a GhcApiError.

This function ignores boot modules and requires that there is only one non-boot module with the given name.

getModuleGraph :: GhcMonad m => m ModuleGraph

Get the module dependency graph.

isLoaded :: GhcMonad m => ModuleName -> m Bool

Return True <==> module is loaded.

isLoadedModule :: GhcMonad m => UnitId -> ModuleName -> m Bool

topSortModuleGraph

Arguments

:: Bool

Drop hi-boot nodes? (see below)

-> ModuleGraph

-> Maybe HomeUnitModule

Root module name. If Nothing, use the full graph.

-> [SCC ModuleGraphNode]

Topological sort of the module graph

Calculate SCCs of the module graph, possibly dropping the hi-boot nodes The resulting list of strongly-connected-components is in topologically sorted order, starting with the module(s) at the bottom of the dependency graph (ie compile them first) and ending with the ones at the top.

Drop hi-boot nodes (first boolean arg)?

• False: treat the hi-boot summaries as nodes of the graph, so the graph must be acyclic
• True: eliminate the hi-boot nodes, and instead pretend the a source-import of Foo is an import of Foo The resulting graph has no hi-boot nodes, but can be cyclic

Inspecting modules

data ModuleInfo

Container for information about a GenModule.

getModuleInfo :: GhcMonad m => Module -> m (Maybe ModuleInfo)

Request information about a loaded GenModule

modInfoTyThings :: ModuleInfo -> [TyThing]

The list of top-level entities defined in a module

modInfoTopLevelScope :: ModuleInfo -> Maybe [Name]

modInfoExports :: ModuleInfo -> [Name]

modInfoExportsWithSelectors :: ModuleInfo -> [Name]

modInfoInstances :: ModuleInfo -> [ClsInst]

Returns the instances defined by the specified module. Warning: currently unimplemented for package modules.

modInfoIsExportedName :: ModuleInfo -> Name -> Bool

modInfoLookupName :: GhcMonad m => ModuleInfo -> Name -> m (Maybe TyThing)

modInfoIface :: ModuleInfo -> Maybe ModIface

modInfoRdrEnv :: ModuleInfo -> Maybe GlobalRdrEnv

modInfoSafe :: ModuleInfo -> SafeHaskellMode

Retrieve module safe haskell mode

lookupGlobalName :: GhcMonad m => Name -> m (Maybe TyThing)

Looks up a global name: that is, any top-level name in any visible module. Unlike lookupName, lookupGlobalName does not use the interactive context, and therefore does not require a preceding setContext.

findGlobalAnns :: (GhcMonad m, Typeable a) => ([Word8] -> a) -> AnnTarget Name -> m [a]

mkPrintUnqualifiedForModule :: GhcMonad m => ModuleInfo -> m (Maybe PrintUnqualified)

type ModIface = ModIface_ 'ModIfaceFinal

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.

Constructors

ModIface

Fields

• mi_module :: !Module

  Name of the module we are for

• mi_sig_of :: !(Maybe Module)

  Are we a sig of another mod?

• mi_hsc_src :: !HscSource

  Boot? Signature?

• mi_deps :: Dependencies

  The dependencies of the module. This is consulted for directly-imported modules, but not for anything else (hence lazy)

• mi_usages :: [Usage]

  Usages; kept sorted so that it's easy to decide whether to write a new iface file (changing usages doesn't affect the hash of this module) NOT STRICT! we read this field lazily from the interface file It is *only* consulted by the recompilation checker

• mi_exports :: ![IfaceExport]

  Exports Kept sorted by (mod,occ), to make version comparisons easier Records the modules that are the declaration points for things exported by this module, and the OccNames of those things

• mi_used_th :: !Bool

  Module required TH splices when it was compiled. This disables recompilation avoidance (see #481).

• mi_fixities :: [(OccName, Fixity)]

  Fixities NOT STRICT! we read this field lazily from the interface file

• mi_warns :: Warnings GhcRn

  Warnings NOT STRICT! we read this field lazily from the interface file

• mi_anns :: [IfaceAnnotation]

  Annotations NOT STRICT! we read this field lazily from the interface file

• mi_decls :: [IfaceDeclExts phase]

  Type, class and variable declarations The hash of an Id changes if its fixity or deprecations change (as well as its type of course) Ditto data constructors, class operations, except that the hash of the parent class/tycon changes

• mi_globals :: !(Maybe GlobalRdrEnv)

  Binds all the things defined at the top level in the original source code for this module. which is NOT the same as mi_exports, nor mi_decls (which may contains declarations for things not actually defined by the user). Used for GHCi and for inspecting the contents of modules via the GHC API only.

  (We need the source file to figure out the top-level environment, if we didn't compile this module from source then this field contains Nothing).

  Strictly speaking this field should live in the HomeModInfo, but that leads to more plumbing.

• mi_insts :: [IfaceClsInst]

  Sorted class instance

• mi_fam_insts :: [IfaceFamInst]

  Sorted family instances

• mi_rules :: [IfaceRule]

  Sorted rules

• mi_hpc :: !AnyHpcUsage

  True if this program uses Hpc at any point in the program.

• mi_trust :: !IfaceTrustInfo

  Safe Haskell Trust information for this module.

• mi_trust_pkg :: !Bool

  Do we require the package this module resides in be trusted to trust this module? This is used for the situation where a module is Safe (so doesn't require the package be trusted itself) but imports some trustworthy modules from its own package (which does require its own package be trusted). See Note [Trust Own Package] in GHC.Rename.Names

• mi_complete_matches :: ![IfaceCompleteMatch]
• mi_docs :: Maybe Docs

  Docstrings and related data for use by haddock, the ghci :doc command, and other tools.

  Just _ = the module was built with -haddock.

• mi_final_exts :: !(IfaceBackendExts phase)

  Either () or ModIfaceBackend for a fully instantiated interface.

• mi_ext_fields :: !ExtensibleFields

  Additional optional fields, where the Map key represents the field name, resulting in a (size, serialized data) pair. Because the data is intended to be serialized through the internal Binary class (increasing compatibility with types using Name and FastString, such as HIE), this format is chosen over ByteStrings.

• mi_src_hash :: !Fingerprint

  Hash of the .hs source, used for recompilation checking.

Instances

Binary ModIface

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)

Defined in GHC.Unit.Module.ModIface

Methods

rnf :: ModIface_ phase -> ()

data SafeHaskellMode

The various Safe Haskell modes

Constructors

Sf_None

inferred unsafe

Sf_Unsafe

declared and checked

Sf_Trustworthy

declared and checked

Sf_Safe

declared and checked

Sf_SafeInferred

inferred as safe

Sf_Ignore

-fno-safe-haskell state

Instances

Show SafeHaskellMode

Defined in GHC.Types.SafeHaskell

Methods

showsPrec :: Int -> SafeHaskellMode -> ShowS

show :: SafeHaskellMode -> String

showList :: [SafeHaskellMode] -> ShowS

Outputable SafeHaskellMode

Defined in GHC.Types.SafeHaskell

Methods

ppr :: SafeHaskellMode -> SDoc

Eq SafeHaskellMode

Defined in GHC.Types.SafeHaskell

Methods

(==) :: SafeHaskellMode -> SafeHaskellMode -> Bool

(/=) :: SafeHaskellMode -> SafeHaskellMode -> Bool

Printing

data PrintUnqualified

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.

alwaysQualify :: PrintUnqualified

Interactive evaluation

Executing statements

execStmt

Arguments

:: GhcMonad m

=> String

a statement (bind or expression)

-> ExecOptions

-> m ExecResult

Run a statement in the current interactive context.

execStmt' :: GhcMonad m => GhciLStmt GhcPs -> String -> ExecOptions -> m ExecResult

Like execStmt, but takes a parsed statement as argument. Useful when doing preprocessing on the AST before execution, e.g. in GHCi (see GHCi.UI.runStmt).

data ExecOptions

Constructors

ExecOptions

Fields

• execSingleStep :: SingleStep

  stepping mode

• execSourceFile :: String

  filename (for errors)

• execLineNumber :: Int

  line number (for errors)

• execWrap :: ForeignHValue -> EvalExpr ForeignHValue

execOptions :: ExecOptions

default ExecOptions

data ExecResult

Constructors

ExecComplete

Fields

• execResult :: Either SomeException [Name]
• execAllocation :: Word64

ExecBreak

Fields

• breakNames :: [Name]
• breakInfo :: Maybe BreakInfo

resumeExec :: GhcMonad m => (SrcSpan -> Bool) -> SingleStep -> Maybe Int -> m ExecResult

Adding new declarations

runDecls :: GhcMonad m => String -> m [Name]

runDeclsWithLocation :: GhcMonad m => String -> Int -> String -> m [Name]

Run some declarations and return any user-visible names that were brought into scope.

runParsedDecls :: GhcMonad m => [LHsDecl GhcPs] -> m [Name]

Like runDeclsWithLocation, but takes parsed declarations as argument. Useful when doing preprocessing on the AST before execution, e.g. in GHCi (see GHCi.UI.runStmt).

Get/set the current context

parseImportDecl :: GhcMonad m => String -> m (ImportDecl GhcPs)

setContext :: GhcMonad m => [InteractiveImport] -> m ()

Set the interactive evaluation context.

(setContext imports) sets the ic_imports field (which in turn determines what is in scope at the prompt) to imports, and updates the icReaderEnv environment to reflect it.

We retain in scope all the things defined at the prompt, and kept in ic_tythings. (Indeed, they shadow stuff from ic_imports.)

getContext :: GhcMonad m => m [InteractiveImport]

Get the interactive evaluation context, consisting of a pair of the set of modules from which we take the full top-level scope, and the set of modules from which we take just the exports respectively.

setGHCiMonad :: GhcMonad m => String -> m ()

Set the monad GHCi lifts user statements into.

Checks that a type (in string form) is an instance of the GHC.GHCi.GHCiSandboxIO type class. Sets it to be the GHCi monad if it is, throws an error otherwise.

getGHCiMonad :: GhcMonad m => m Name

Get the monad GHCi lifts user statements into.

Inspecting the current context

getBindings :: GhcMonad m => m [TyThing]

Return the bindings for the current interactive session.

getInsts :: GhcMonad m => m ([ClsInst], [FamInst])

Return the instances for the current interactive session.

getPrintUnqual :: GhcMonad m => m PrintUnqualified

findModule :: GhcMonad m => ModuleName -> Maybe FastString -> m Module

Takes a ModuleName and possibly a UnitId, and consults the filesystem and package database to find the corresponding GenModule, using the algorithm that is used for an import declaration.

lookupModule :: GhcMonad m => ModuleName -> Maybe FastString -> m Module

Like findModule, but differs slightly when the module refers to a source file, and the file has not been loaded via load. In this case, findModule will throw an error (module not loaded), but lookupModule will check to see whether the module can also be found in a package, and if so, that package GenModule will be returned. If not, the usual module-not-found error will be thrown.

findQualifiedModule :: GhcMonad m => PkgQual -> ModuleName -> m Module

lookupQualifiedModule :: GhcMonad m => PkgQual -> ModuleName -> m Module

renamePkgQualM :: GhcMonad m => ModuleName -> Maybe FastString -> m PkgQual

renameRawPkgQualM :: GhcMonad m => ModuleName -> RawPkgQual -> m PkgQual

isModuleTrusted :: GhcMonad m => Module -> m Bool

Check that a module is safe to import (according to Safe Haskell).

We return True to indicate the import is safe and False otherwise although in the False case an error may be thrown first.

moduleTrustReqs :: GhcMonad m => Module -> m (Bool, Set UnitId)

Return if a module is trusted and the pkgs it depends on to be trusted.

getNamesInScope :: GhcMonad m => m [Name]

Returns all names in scope in the current interactive context

getRdrNamesInScope :: GhcMonad m => m [RdrName]

Returns all RdrNames in scope in the current interactive context, excluding any that are internally-generated.

getGRE :: GhcMonad m => m GlobalRdrEnv

get the GlobalRdrEnv for a session

moduleIsInterpreted :: GhcMonad m => Module -> m Bool

Returns True if the specified module is interpreted, and hence has its full top-level scope available.

getInfo :: GhcMonad m => Bool -> Name -> m (Maybe (TyThing, Fixity, [ClsInst], [FamInst], SDoc))

Looks up an identifier in the current interactive context (for :info) Filter the instances by the ones whose tycons (or clases resp) are in scope (qualified or otherwise). Otherwise we list a whole lot too many! The exact choice of which ones to show, and which to hide, is a judgement call. (see #1581)

showModule :: GhcMonad m => ModSummary -> m String

moduleIsBootOrNotObjectLinkable :: GhcMonad m => ModSummary -> m Bool

getNameToInstancesIndex

Arguments

:: GhcMonad m

=> [Module]

visible modules. An orphan instance will be returned if it is visible from at least one module in the list.

-> Maybe [Module]

modules to load. If this is not specified, we load modules for everything that is in scope unqualified.

-> m (Messages TcRnMessage, Maybe (NameEnv ([ClsInst], [FamInst])))

Retrieve all type and family instances in the environment, indexed by Name. Each name's lists will contain every instance in which that name is mentioned in the instance head.

Inspecting types and kinds

exprType :: GhcMonad m => TcRnExprMode -> String -> m Type

Get the type of an expression Returns the type as described by TcRnExprMode

data TcRnExprMode

How should we infer a type? See Note [TcRnExprMode]

Constructors

TM_Inst

Instantiate inferred quantifiers only (:type)

TM_Default

Instantiate all quantifiers, and do eager defaulting (:type +d)

typeKind :: GhcMonad m => Bool -> String -> m (Type, Kind)

Get the kind of a type

Looking up a Name

parseName :: GhcMonad m => String -> m [Name]

Parses a string as an identifier, and returns the list of Names that the identifier can refer to in the current interactive context.

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.

Compiling expressions

data HValue

Instances

Show HValue

Defined in GHCi.RemoteTypes

Methods

showsPrec :: Int -> HValue -> ShowS

show :: HValue -> String

showList :: [HValue] -> ShowS

parseExpr :: GhcMonad m => String -> m (LHsExpr GhcPs)

Parse an expression, the parsed expression can be further processed and passed to compileParsedExpr.

compileParsedExpr :: GhcMonad m => LHsExpr GhcPs -> m HValue

compileExpr :: GhcMonad m => String -> m HValue

Compile an expression, run it, and deliver the resulting HValue.

dynCompileExpr :: GhcMonad m => String -> m Dynamic

Compile an expression, run it and return the result as a Dynamic.

type ForeignHValue = ForeignRef HValue

compileExprRemote :: GhcMonad m => String -> m ForeignHValue

Compile an expression, run it, and deliver the resulting HValue.

compileParsedExprRemote :: GhcMonad m => LHsExpr GhcPs -> m ForeignHValue

Compile a parsed expression (before renaming), run it, and deliver the resulting HValue.

Docs

getDocs :: GhcMonad m => Name -> m (Either GetDocsFailure (Maybe [HsDoc GhcRn], IntMap (HsDoc GhcRn)))

data GetDocsFailure

Failure modes for getDocs.

Constructors

NameHasNoModule Name

nameModule_maybe returned Nothing.

NoDocsInIface

The module was loaded without -haddock,

Fields

• Module
• Bool

  True: The module was compiled. False: The module was :loaded.

InteractiveName

The Name was defined interactively.

Instances

Outputable GetDocsFailure

Defined in GHC.Runtime.Eval

Methods

ppr :: GetDocsFailure -> SDoc

Other

runTcInteractive :: HscEnv -> TcRn a -> IO (Messages TcRnMessage, Maybe a)

isStmt :: ParserOpts -> String -> Bool

Returns True if passed string is a statement.

hasImport :: ParserOpts -> String -> Bool

Returns True if passed string has an import declaration.

isImport :: ParserOpts -> String -> Bool

Returns True if passed string is an import declaration.

isDecl :: ParserOpts -> String -> Bool

Returns True if passed string is a declaration but not a splice.

The debugger

data SingleStep

Constructors

RunToCompletion

SingleStep

RunAndLogSteps

data Resume

Constructors

Resume

Fields

• resumeStmt :: String
• resumeContext :: ForeignRef (ResumeContext [HValueRef])
• resumeBindings :: ResumeBindings
• resumeFinalIds :: [Id]
• resumeApStack :: ForeignHValue
• resumeBreakInfo :: Maybe BreakInfo
• resumeSpan :: SrcSpan
• resumeDecl :: String
• resumeCCS :: RemotePtr CostCentreStack
• resumeHistory :: [History]
• resumeHistoryIx :: Int

data History

getHistorySpan :: GhcMonad m => History -> m SrcSpan

getHistoryModule :: History -> Module

abandon :: GhcMonad m => m Bool

abandonAll :: GhcMonad m => m Bool

getResumeContext :: GhcMonad m => m [Resume]

obtainTermFromId :: GhcMonad m => Int -> Bool -> Id -> m Term

obtainTermFromVal :: GhcMonad m => Int -> Bool -> Type -> a -> m Term

reconstructType :: HscEnv -> Int -> Id -> IO (Maybe Type)

modInfoModBreaks :: ModuleInfo -> ModBreaks

data ModBreaks

All the information about the breakpoints for a module

Constructors

ModBreaks

Fields

• modBreaks_flags :: ForeignRef BreakArray

  The array of flags, one per breakpoint, indicating which breakpoints are enabled.

• modBreaks_locs :: !(Array BreakIndex SrcSpan)

  An array giving the source span of each breakpoint.

• modBreaks_vars :: !(Array BreakIndex [OccName])

  An array giving the names of the free variables at each breakpoint.

• modBreaks_decls :: !(Array BreakIndex [String])

  An array giving the names of the declarations enclosing each breakpoint. See Note [Field modBreaks_decls]

• modBreaks_ccs :: !(Array BreakIndex (RemotePtr CostCentre))

  Array pointing to cost centre for each breakpoint

• modBreaks_breakInfo :: IntMap CgBreakInfo

  info about each breakpoint from the bytecode generator

type BreakIndex = Int

Breakpoint index

data BreakInfo

Constructors

BreakInfo

Fields

• breakInfo_module :: Module
• breakInfo_number :: Int

back :: GhcMonad m => Int -> m ([Name], Int, SrcSpan, String)

forward :: GhcMonad m => Int -> m ([Name], Int, SrcSpan, String)

setupBreakpoint :: GhcMonad m => HscEnv -> BreakInfo -> Int -> m ()

Abstract syntax elements

Units

type Unit = GenUnit UnitId

Modules

type Module = GenModule Unit

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

mkModule :: u -> ModuleName -> GenModule u

pprModule :: Module -> SDoc

moduleName :: GenModule unit -> ModuleName

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

moduleUnit :: GenModule unit -> unit

Unit the module belongs to

data ModuleName

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

Instances

Data ModuleName

Defined in GHC.Unit.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

Defined in GHC.Unit.Module.Name

Methods

showsPrec :: Int -> ModuleName -> ShowS

show :: ModuleName -> String

showList :: [ModuleName] -> ShowS

NFData ModuleName

Defined in GHC.Unit.Module.Name

Methods

rnf :: ModuleName -> ()

Uniquable ModuleName

Defined in GHC.Unit.Module.Name

Methods

getUnique :: ModuleName -> Unique

Binary ModuleName

Defined in GHC.Unit.Module.Name

Methods

put_ :: BinHandle -> ModuleName -> IO ()

put :: BinHandle -> ModuleName -> IO (Bin ModuleName)

get :: BinHandle -> IO ModuleName

Outputable ModuleName

Defined in GHC.Unit.Module.Name

Methods

ppr :: ModuleName -> SDoc

Eq ModuleName

Defined in GHC.Unit.Module.Name

Methods

(==) :: ModuleName -> ModuleName -> Bool

(/=) :: ModuleName -> ModuleName -> Bool

Ord ModuleName

Defined in GHC.Unit.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

type Anno ModuleName

Defined in GHC.Hs.ImpExp

type Anno ModuleName = SrcSpanAnnA

mkModuleName :: String -> ModuleName

moduleNameString :: ModuleName -> String

Names

data Name

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

Instances

Data Name

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

NFData Name

Defined in GHC.Types.Name

Methods

rnf :: Name -> ()

NamedThing Name

Defined in GHC.Types.Name

Methods

getOccName :: Name -> OccName

getName :: Name -> Name

HasOccName Name

Defined in GHC.Types.Name

Methods

occName :: Name -> OccName

Uniquable Name

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 Names. See UserData for the rationale for this distinction.

Defined in GHC.Types.Name

Methods

put_ :: BinHandle -> Name -> IO ()

put :: BinHandle -> Name -> IO (Bin Name)

get :: BinHandle -> IO Name

Outputable Name

Defined in GHC.Types.Name

Methods

ppr :: Name -> SDoc

OutputableBndr Name

Defined in GHC.Types.Name

Methods

pprBndr :: BindingSite -> Name -> SDoc

pprPrefixOcc :: Name -> SDoc

pprInfixOcc :: Name -> SDoc

bndrIsJoin_maybe :: Name -> Maybe Int

Eq Name

The same comments as for Name's Ord instance apply.

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 trac #15240 for a bug caused by improper use of this instance.

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

type Anno Name

Defined in GHC.Hs.Extension

type Anno Name = SrcSpanAnnN

type Anno (LocatedN Name)

Defined in GHC.Hs.Binds

type Anno (LocatedN Name) = SrcSpan

type Anno [LocatedN Name]

Defined in GHC.Hs.Binds

type Anno [LocatedN Name] = SrcSpan

isExternalName :: Name -> Bool

nameModule :: HasDebugCallStack => Name -> Module

pprParenSymName :: NamedThing a => a -> SDoc

print a NamedThing, adding parentheses if the name is an operator.

nameSrcSpan :: Name -> SrcSpan

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

NamedThing Class

Defined in GHC.Core.Class

Methods

getOccName :: Class -> OccName

getName :: Class -> Name

NamedThing ConLike

Defined in GHC.Core.ConLike

Methods

getOccName :: ConLike -> OccName

getName :: ConLike -> Name

NamedThing DataCon

Defined in GHC.Core.DataCon

Methods

getOccName :: DataCon -> OccName

getName :: DataCon -> Name

NamedThing FamInst

Defined in GHC.Core.FamInstEnv

Methods

getOccName :: FamInst -> OccName

getName :: FamInst -> Name

NamedThing ClsInst

Defined in GHC.Core.InstEnv

Methods

getOccName :: ClsInst -> OccName

getName :: ClsInst -> Name

NamedThing PatSyn

Defined in GHC.Core.PatSyn

Methods

getOccName :: PatSyn -> OccName

getName :: PatSyn -> Name

NamedThing TyCon

Defined in GHC.Core.TyCon

Methods

getOccName :: TyCon -> OccName

getName :: TyCon -> Name

NamedThing IfaceClassOp

Defined in GHC.Iface.Syntax

Methods

getOccName :: IfaceClassOp -> OccName

getName :: IfaceClassOp -> Name

NamedThing IfaceConDecl

Defined in GHC.Iface.Syntax

Methods

getOccName :: IfaceConDecl -> OccName

getName :: IfaceConDecl -> Name

NamedThing IfaceDecl

Defined in GHC.Iface.Syntax

Methods

getOccName :: IfaceDecl -> OccName

getName :: IfaceDecl -> Name

NamedThing HoleFitCandidate

Defined in GHC.Tc.Errors.Hole.FitTypes

Methods

getOccName :: HoleFitCandidate -> OccName

getName :: HoleFitCandidate -> Name

NamedThing Name

Defined in GHC.Types.Name

Methods

getOccName :: Name -> OccName

getName :: Name -> Name

NamedThing TyThing

Defined in GHC.Types.TyThing

Methods

getOccName :: TyThing -> OccName

getName :: TyThing -> Name

NamedThing Var

Defined in GHC.Types.Var

Methods

getOccName :: Var -> OccName

getName :: Var -> Name

NamedThing (CoAxiom br)

Defined in GHC.Core.Coercion.Axiom

Methods

getOccName :: CoAxiom br -> OccName

getName :: CoAxiom br -> Name

NamedThing e => NamedThing (Located e)

Defined in GHC.Types.Name

Methods

getOccName :: Located e -> OccName

getName :: Located e -> Name

NamedThing (Located a) => NamedThing (LocatedAn an a)

Defined in GHC.Parser.Annotation

Methods

getOccName :: LocatedAn an a -> OccName

getName :: LocatedAn an a -> Name

NamedThing tv => NamedThing (VarBndr tv flag)

Defined in GHC.Types.Var

Methods

getOccName :: VarBndr tv flag -> OccName

getName :: VarBndr tv flag -> Name

NamedThing (HsTyVarBndr flag GhcRn)

Defined in GHC.Hs.Type

Methods

getOccName :: HsTyVarBndr flag GhcRn -> OccName

getName :: HsTyVarBndr flag GhcRn -> Name

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,

Constructors

Unqual OccName

Unqualified name

Used for ordinary, unqualified occurrences, e.g. x, y or Foo. Create such a RdrName with mkRdrUnqual

Qual ModuleName OccName

Qualified name

A qualified name written by the user in source code. The module isn't necessarily the module where the thing is defined; just the one from which it is imported. Examples are Bar.x, Bar.y or Bar.Foo. Create such a RdrName with mkRdrQual

Instances

Data RdrName

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

DisambInfixOp RdrName

Defined in GHC.Parser.PostProcess

Methods

mkHsVarOpPV :: LocatedN RdrName -> PV (LocatedN RdrName)

mkHsConOpPV :: LocatedN RdrName -> PV (LocatedN RdrName)

mkHsInfixHolePV :: SrcSpan -> (EpAnnComments -> EpAnn EpAnnUnboundVar) -> PV (Located RdrName)

HasOccName RdrName

Defined in GHC.Types.Name.Reader

Methods

occName :: RdrName -> OccName

Outputable RdrName

Defined in GHC.Types.Name.Reader

Methods

ppr :: RdrName -> SDoc

OutputableBndr RdrName

Defined in GHC.Types.Name.Reader

Methods

pprBndr :: BindingSite -> RdrName -> SDoc

pprPrefixOcc :: RdrName -> SDoc

pprInfixOcc :: RdrName -> SDoc

bndrIsJoin_maybe :: RdrName -> Maybe Int

Eq RdrName

Defined in GHC.Types.Name.Reader

Methods

(==) :: RdrName -> RdrName -> Bool

(/=) :: RdrName -> RdrName -> Bool

Ord RdrName

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

Defined in GHC.Hs.Extension

type Anno RdrName = SrcSpanAnnN

type Anno (LocatedN RdrName)

Defined in GHC.Hs.Binds

type Anno (LocatedN RdrName) = SrcSpan

type Anno [LocatedN RdrName]

Defined in GHC.Hs.Binds

type Anno [LocatedN RdrName] = SrcSpan

Identifiers

type Id = Var

Identifier

idType :: Id -> Kind

isImplicitId :: Id -> Bool

isImplicitId tells whether an Ids info is implied by other declarations, so we don't need to put its signature in an interface file, even if it's mentioned in some other interface unfolding.

isDeadBinder :: Id -> Bool

isExportedId :: Var -> Bool

isExportedIdVar means "don't throw this away"

isLocalId :: Var -> Bool

isGlobalId :: Var -> Bool

isRecordSelector :: Id -> Bool

isPrimOpId :: Id -> Bool

isFCallId :: Id -> Bool

isClassOpId_maybe :: Id -> Maybe Class

isDataConWorkId :: 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

isDeadEndId :: Var -> Bool

Returns true if an application to n args diverges or throws an exception See Note [Dead ends] in GHC.Types.Demand.

isDictonaryId :: Id -> Bool

recordSelectorTyCon :: Id -> RecSelParent

If the Id is that for a record selector, extract the sel_tycon. Panic otherwise.

Type constructors

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 *

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

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

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

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

Instances

Data TyCon

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

NamedThing TyCon

Defined in GHC.Core.TyCon

Methods

getOccName :: TyCon -> OccName

getName :: TyCon -> Name

Uniquable TyCon

Defined in GHC.Core.TyCon

Methods

getUnique :: TyCon -> Unique

Outputable TyCon

Defined in GHC.Core.TyCon

Methods

ppr :: TyCon -> SDoc

Eq TyCon

Defined in GHC.Core.TyCon

Methods

(==) :: TyCon -> TyCon -> Bool

(/=) :: TyCon -> TyCon -> Bool

tyConTyVars :: TyCon -> [TyVar]

TyVar binders

tyConDataCons :: TyCon -> [DataCon]

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

tyConArity :: TyCon -> Arity

Arity

isClassTyCon :: TyCon -> Bool

Is this TyCon that for a class instance?

isTypeSynonymTyCon :: TyCon -> Bool

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

isTypeFamilyTyCon :: TyCon -> Bool

Is this a synonym TyCon that can have may have further instances appear?

isNewTyCon :: TyCon -> Bool

Is this TyCon that for a newtype

isPrimTyCon :: TyCon -> Bool

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

isFunTyCon :: TyCon -> Bool

isFamilyTyCon :: TyCon -> Bool

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

isOpenFamilyTyCon :: TyCon -> Bool

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

isOpenTypeFamilyTyCon :: TyCon -> Bool

Is this an open type family TyCon?

tyConClass_maybe :: TyCon -> Maybe Class

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

synTyConRhs_maybe :: TyCon -> Maybe Type

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

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

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

tyConKind :: TyCon -> Kind

Kind of this TyCon

Type variables

type TyVar = Var

Type or kind Variable

alphaTyVars :: [TyVar]

Data constructors

data DataCon

A data constructor

• AnnKeywordId : AnnOpen, AnnClose,AnnComma

Instances

Data DataCon

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

NamedThing DataCon

Defined in GHC.Core.DataCon

Methods

getOccName :: DataCon -> OccName

getName :: DataCon -> Name

Uniquable DataCon

Defined in GHC.Core.DataCon

Methods

getUnique :: DataCon -> Unique

Outputable DataCon

Defined in GHC.Core.DataCon

Methods

ppr :: DataCon -> SDoc

OutputableBndr DataCon

Defined in GHC.Core.DataCon

Methods

pprBndr :: BindingSite -> DataCon -> SDoc

pprPrefixOcc :: DataCon -> SDoc

pprInfixOcc :: DataCon -> SDoc

bndrIsJoin_maybe :: DataCon -> Maybe Int

Eq DataCon

Defined in GHC.Core.DataCon

Methods

(==) :: DataCon -> DataCon -> Bool

(/=) :: DataCon -> DataCon -> Bool

dataConType :: DataCon -> Type

dataConTyCon :: DataCon -> TyCon

The type constructor that we are building via this data constructor

dataConFieldLabels :: DataCon -> [FieldLabel]

The labels for the fields of this particular DataCon

dataConIsInfix :: DataCon -> Bool

Should the DataCon be presented infix?

isVanillaDataCon :: DataCon -> Bool

Vanilla DataCons are those that are nice boring Haskell 98 constructors

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.

dataConSrcBangs :: DataCon -> [HsSrcBang]

Strictness/unpack annotations, from user; or, for imported DataCons, from the interface file The list is in one-to-one correspondence with the arity of the DataCon

data StrictnessMark

Constructors

MarkedStrict

NotMarkedStrict

Instances

Binary StrictnessMark

Defined in GHC.Core.DataCon

Methods

put_ :: BinHandle -> StrictnessMark -> IO ()

put :: BinHandle -> StrictnessMark -> IO (Bin StrictnessMark)

get :: BinHandle -> IO StrictnessMark

Outputable StrictnessMark

Defined in GHC.Core.DataCon

Methods

ppr :: StrictnessMark -> SDoc

Eq StrictnessMark

Defined in GHC.Core.DataCon

Methods

(==) :: StrictnessMark -> StrictnessMark -> Bool

(/=) :: StrictnessMark -> StrictnessMark -> Bool

isMarkedStrict :: StrictnessMark -> Bool

Classes

data Class

Instances

Data Class

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

NamedThing Class

Defined in GHC.Core.Class

Methods

getOccName :: Class -> OccName

getName :: Class -> Name

Uniquable Class

Defined in GHC.Core.Class

Methods

getUnique :: Class -> Unique

Outputable Class

Defined in GHC.Core.Class

Methods

ppr :: Class -> SDoc

Eq Class

Defined in GHC.Core.Class

Methods

(==) :: Class -> Class -> Bool

(/=) :: Class -> Class -> Bool

classMethods :: Class -> [Id]

classSCTheta :: Class -> [PredType]

classTvsFds :: Class -> ([TyVar], [FunDep TyVar])

classATs :: Class -> [TyCon]

pprFundeps :: Outputable a => [FunDep a] -> SDoc

Instances

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

Data ClsInst

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

NamedThing ClsInst

Defined in GHC.Core.InstEnv

Methods

getOccName :: ClsInst -> OccName

getName :: ClsInst -> Name

Outputable ClsInst

Defined in GHC.Core.InstEnv

Methods

ppr :: ClsInst -> SDoc

instanceDFunId :: ClsInst -> DFunId

pprInstance :: ClsInst -> SDoc

pprInstanceHdr :: ClsInst -> SDoc

pprFamInst :: FamInst -> SDoc

Pretty-prints a FamInst (type/data family instance) with its defining location.

data FamInst

Instances

NamedThing FamInst

Defined in GHC.Core.FamInstEnv

Methods

getOccName :: FamInst -> OccName

getName :: FamInst -> Name

Outputable FamInst

Defined in GHC.Core.FamInstEnv

Methods

ppr :: FamInst -> SDoc

Types and Kinds

data Type

Instances

Data Type

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

Outputable Type

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: Type -> SDoc

Eq (DeBruijn Type)

Defined in GHC.Core.Map.Type

Methods

(==) :: DeBruijn Type -> DeBruijn Type -> Bool

(/=) :: DeBruijn Type -> DeBruijn Type -> Bool

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.

funResultTy :: Type -> Type

Extract the function result type and panic if that is not possible

pprParendType :: Type -> SDoc

pprTypeApp :: TyCon -> [Type] -> SDoc

type Kind = Type

The key type representing kinds in the compiler.

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"

type ThetaType = [PredType]

A collection of PredTypes

pprForAll :: [TyCoVarBinder] -> SDoc

pprThetaArrowTy :: ThetaType -> SDoc

parseInstanceHead :: GhcMonad m => String -> m Type

getInstancesForType :: GhcMonad m => Type -> m [ClsInst]

Entities

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

ACoAxiom (CoAxiom Branched)

Instances

NamedThing TyThing

Defined in GHC.Types.TyThing

Methods

getOccName :: TyThing -> OccName

getName :: TyThing -> Name

Outputable TyThing

Defined in GHC.Types.TyThing

Methods

ppr :: TyThing -> SDoc

Syntax

module GHC.Hs

Fixities

data FixityDirection

Constructors

InfixL

InfixR

InfixN

Instances

Data FixityDirection

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

Binary FixityDirection

Defined in GHC.Types.Fixity

Methods

put_ :: BinHandle -> FixityDirection -> IO ()

put :: BinHandle -> FixityDirection -> IO (Bin FixityDirection)

get :: BinHandle -> IO FixityDirection

Outputable FixityDirection

Defined in GHC.Types.Fixity

Methods

ppr :: FixityDirection -> SDoc

Eq FixityDirection

Defined in GHC.Types.Fixity

Methods

(==) :: FixityDirection -> FixityDirection -> Bool

(/=) :: FixityDirection -> FixityDirection -> Bool

defaultFixity :: Fixity

maxPrecedence :: Int

negateFixity :: Fixity

compareFixity :: Fixity -> Fixity -> (Bool, 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

Infix

Instances

Data LexicalFixity

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

Outputable LexicalFixity

Defined in GHC.Types.Fixity

Methods

ppr :: LexicalFixity -> SDoc

Eq LexicalFixity

Defined in GHC.Types.Fixity

Methods

(==) :: LexicalFixity -> LexicalFixity -> Bool

(/=) :: LexicalFixity -> LexicalFixity -> Bool

Source locations

data SrcLoc

Source Location

Constructors

RealSrcLoc !RealSrcLoc !(Maybe BufPos)

UnhelpfulLoc !FastString

Instances

Show SrcLoc

Defined in GHC.Types.SrcLoc

Methods

showsPrec :: Int -> SrcLoc -> ShowS

show :: SrcLoc -> String

showList :: [SrcLoc] -> ShowS

Outputable SrcLoc

Defined in GHC.Types.SrcLoc

Methods

ppr :: SrcLoc -> SDoc

Eq SrcLoc

Defined in GHC.Types.SrcLoc

Methods

(==) :: SrcLoc -> SrcLoc -> Bool

(/=) :: SrcLoc -> SrcLoc -> Bool

data RealSrcLoc

Real Source Location

Represents a single point within a file

Instances

Show RealSrcLoc

Defined in GHC.Types.SrcLoc

Methods

showsPrec :: Int -> RealSrcLoc -> ShowS

show :: RealSrcLoc -> String

showList :: [RealSrcLoc] -> ShowS

Outputable RealSrcLoc

Defined in GHC.Types.SrcLoc

Methods

ppr :: RealSrcLoc -> SDoc

Eq RealSrcLoc

Defined in GHC.Types.SrcLoc

Methods

(==) :: RealSrcLoc -> RealSrcLoc -> Bool

(/=) :: RealSrcLoc -> RealSrcLoc -> Bool

Ord RealSrcLoc

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

noSrcLoc :: SrcLoc

Built-in "bad" RealSrcLoc values for particular locations

srcLocFile :: RealSrcLoc -> FastString

Gives the filename of the RealSrcLoc

srcLocLine :: RealSrcLoc -> Int

Raises an error when used on a "bad" RealSrcLoc

srcLocCol :: RealSrcLoc -> Int

Raises an error when used on a "bad" RealSrcLoc

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

Data SrcSpan

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

Defined in GHC.Types.SrcLoc

Methods

showsPrec :: Int -> SrcSpan -> ShowS

show :: SrcSpan -> String

showList :: [SrcSpan] -> ShowS

NFData SrcSpan

Defined in GHC.Types.SrcLoc

Methods

rnf :: SrcSpan -> ()

Binary SrcSpan

Defined in GHC.Utils.Binary

Methods

put_ :: BinHandle -> SrcSpan -> IO ()

put :: BinHandle -> SrcSpan -> IO (Bin SrcSpan)

get :: BinHandle -> IO SrcSpan

ToJson SrcSpan

Defined in GHC.Types.SrcLoc

Methods

json :: SrcSpan -> JsonDoc

Outputable SrcSpan

Defined in GHC.Types.SrcLoc

Methods

ppr :: SrcSpan -> SDoc

Eq SrcSpan

Defined in GHC.Types.SrcLoc

Methods

(==) :: SrcSpan -> SrcSpan -> Bool

(/=) :: SrcSpan -> SrcSpan -> Bool

NamedThing e => NamedThing (Located e)

Defined in GHC.Types.Name

Methods

getOccName :: Located e -> OccName

getName :: Located e -> Name

Binary a => Binary (Located a)

Defined in GHC.Utils.Binary

Methods

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

put :: BinHandle -> Located a -> IO (Bin (Located a))

get :: BinHandle -> IO (Located a)

Outputable e => Outputable (Located e)

Defined in GHC.Types.SrcLoc

Methods

ppr :: Located e -> SDoc

(UnXRec p, Outputable (XRec p FieldLabelString)) => OutputableBndr (Located (FieldLabelStrings p))

Defined in Language.Haskell.Syntax.Expr

Methods

pprBndr :: BindingSite -> Located (FieldLabelStrings p) -> SDoc

pprPrefixOcc :: Located (FieldLabelStrings p) -> SDoc

pprInfixOcc :: Located (FieldLabelStrings p) -> SDoc

bndrIsJoin_maybe :: Located (FieldLabelStrings p) -> Maybe Int

OutputableBndr (Located (AmbiguousFieldOcc (GhcPass p)))

Defined in GHC.Hs.Type

Methods

pprBndr :: BindingSite -> Located (AmbiguousFieldOcc (GhcPass p)) -> SDoc

pprPrefixOcc :: Located (AmbiguousFieldOcc (GhcPass p)) -> SDoc

pprInfixOcc :: Located (AmbiguousFieldOcc (GhcPass p)) -> SDoc

bndrIsJoin_maybe :: Located (AmbiguousFieldOcc (GhcPass p)) -> Maybe Int

(UnXRec pass, OutputableBndr (XRec pass RdrName)) => OutputableBndr (GenLocated SrcSpan (FieldOcc pass))

Defined in Language.Haskell.Syntax.Type

Methods

pprBndr :: BindingSite -> GenLocated SrcSpan (FieldOcc pass) -> SDoc

pprPrefixOcc :: GenLocated SrcSpan (FieldOcc pass) -> SDoc

pprInfixOcc :: GenLocated SrcSpan (FieldOcc pass) -> SDoc

bndrIsJoin_maybe :: GenLocated SrcSpan (FieldOcc pass) -> Maybe Int

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

Data RealSrcSpan

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

Defined in GHC.Types.SrcLoc

Methods

showsPrec :: Int -> RealSrcSpan -> ShowS

show :: RealSrcSpan -> String

showList :: [RealSrcSpan] -> ShowS

Binary RealSrcSpan

Defined in GHC.Utils.Binary

Methods

put_ :: BinHandle -> RealSrcSpan -> IO ()

put :: BinHandle -> RealSrcSpan -> IO (Bin RealSrcSpan)

get :: BinHandle -> IO RealSrcSpan

ToJson RealSrcSpan

Defined in GHC.Types.SrcLoc

Methods

json :: RealSrcSpan -> JsonDoc

Outputable RealSrcSpan

Defined in GHC.Types.SrcLoc

Methods

ppr :: RealSrcSpan -> SDoc

Eq RealSrcSpan

Defined in GHC.Types.SrcLoc

Methods

(==) :: RealSrcSpan -> RealSrcSpan -> Bool

(/=) :: RealSrcSpan -> RealSrcSpan -> Bool

Ord RealSrcSpan

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)

Defined in GHC.Types.SrcLoc

Methods

ppr :: GenLocated RealSrcSpan e -> SDoc

mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan

Create a SrcSpan between two points in a file

srcLocSpan :: SrcLoc -> SrcSpan

Create a SrcSpan corresponding to a single point

isGoodSrcSpan :: SrcSpan -> Bool

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

noSrcSpan :: SrcSpan

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

srcSpanStart :: SrcSpan -> SrcLoc

Returns the location at the start of the SrcSpan or a "bad" SrcSpan if that is unavailable

srcSpanEnd :: SrcSpan -> SrcLoc

Returns the location at the end of the SrcSpan or a "bad" SrcSpan if that is unavailable

srcSpanFile :: RealSrcSpan -> FastString

srcSpanStartLine :: RealSrcSpan -> Int

srcSpanEndLine :: RealSrcSpan -> Int

srcSpanStartCol :: RealSrcSpan -> Int

srcSpanEndCol :: RealSrcSpan -> Int

Located

data GenLocated l e

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

Constructors

L l e

Instances

Foldable (GenLocated l)

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)

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)

Functor (GenLocated l)

Defined in GHC.Types.SrcLoc

Methods

fmap :: (a -> b) -> GenLocated l a -> GenLocated l b

(<$) :: a -> GenLocated l b -> GenLocated l a

NamedThing e => NamedThing (Located e)

Defined in GHC.Types.Name

Methods

getOccName :: Located e -> OccName

getName :: Located e -> Name

Binary a => Binary (LocatedL a)

Defined in GHC.Parser.Annotation

Methods

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

put :: BinHandle -> LocatedL a -> IO (Bin (LocatedL a))

get :: BinHandle -> IO (LocatedL a)

Binary a => Binary (Located a)

Defined in GHC.Utils.Binary

Methods

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

put :: BinHandle -> Located a -> IO (Bin (Located a))

get :: BinHandle -> IO (Located a)

Outputable e => Outputable (Located e)

Defined in GHC.Types.SrcLoc

Methods

ppr :: Located e -> SDoc

(UnXRec p, Outputable (XRec p FieldLabelString)) => OutputableBndr (Located (FieldLabelStrings p))

Defined in Language.Haskell.Syntax.Expr

Methods

pprBndr :: BindingSite -> Located (FieldLabelStrings p) -> SDoc

pprPrefixOcc :: Located (FieldLabelStrings p) -> SDoc

pprInfixOcc :: Located (FieldLabelStrings p) -> SDoc

bndrIsJoin_maybe :: Located (FieldLabelStrings p) -> Maybe Int

OutputableBndr (Located (AmbiguousFieldOcc (GhcPass p)))

Defined in GHC.Hs.Type

Methods

pprBndr :: BindingSite -> Located (AmbiguousFieldOcc (GhcPass p)) -> SDoc

pprPrefixOcc :: Located (AmbiguousFieldOcc (GhcPass p)) -> SDoc

pprInfixOcc :: Located (AmbiguousFieldOcc (GhcPass p)) -> SDoc

bndrIsJoin_maybe :: Located (AmbiguousFieldOcc (GhcPass p)) -> Maybe Int

(Data l, Data e) => Data (GenLocated l e)

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)

Data (GRHS GhcPs (LocatedA (HsCmd GhcPs)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GRHS GhcPs (LocatedA (HsCmd GhcPs)) -> c (GRHS GhcPs (LocatedA (HsCmd GhcPs)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GRHS GhcPs (LocatedA (HsCmd GhcPs)))

toConstr :: GRHS GhcPs (LocatedA (HsCmd GhcPs)) -> Constr

dataTypeOf :: GRHS GhcPs (LocatedA (HsCmd GhcPs)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GRHS GhcPs (LocatedA (HsCmd GhcPs))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GRHS GhcPs (LocatedA (HsCmd GhcPs))))

gmapT :: (forall b. Data b => b -> b) -> GRHS GhcPs (LocatedA (HsCmd GhcPs)) -> GRHS GhcPs (LocatedA (HsCmd GhcPs))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GRHS GhcPs (LocatedA (HsCmd GhcPs)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GRHS GhcPs (LocatedA (HsCmd GhcPs)) -> r

gmapQ :: (forall d. Data d => d -> u) -> GRHS GhcPs (LocatedA (HsCmd GhcPs)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> GRHS GhcPs (LocatedA (HsCmd GhcPs)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GRHS GhcPs (LocatedA (HsCmd GhcPs)) -> m (GRHS GhcPs (LocatedA (HsCmd GhcPs)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHS GhcPs (LocatedA (HsCmd GhcPs)) -> m (GRHS GhcPs (LocatedA (HsCmd GhcPs)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHS GhcPs (LocatedA (HsCmd GhcPs)) -> m (GRHS GhcPs (LocatedA (HsCmd GhcPs)))

Data (GRHS GhcPs (LocatedA (HsExpr GhcPs)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GRHS GhcPs (LocatedA (HsExpr GhcPs)) -> c (GRHS GhcPs (LocatedA (HsExpr GhcPs)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GRHS GhcPs (LocatedA (HsExpr GhcPs)))

toConstr :: GRHS GhcPs (LocatedA (HsExpr GhcPs)) -> Constr

dataTypeOf :: GRHS GhcPs (LocatedA (HsExpr GhcPs)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GRHS GhcPs (LocatedA (HsExpr GhcPs))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GRHS GhcPs (LocatedA (HsExpr GhcPs))))

gmapT :: (forall b. Data b => b -> b) -> GRHS GhcPs (LocatedA (HsExpr GhcPs)) -> GRHS GhcPs (LocatedA (HsExpr GhcPs))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GRHS GhcPs (LocatedA (HsExpr GhcPs)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GRHS GhcPs (LocatedA (HsExpr GhcPs)) -> r

gmapQ :: (forall d. Data d => d -> u) -> GRHS GhcPs (LocatedA (HsExpr GhcPs)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> GRHS GhcPs (LocatedA (HsExpr GhcPs)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GRHS GhcPs (LocatedA (HsExpr GhcPs)) -> m (GRHS GhcPs (LocatedA (HsExpr GhcPs)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHS GhcPs (LocatedA (HsExpr GhcPs)) -> m (GRHS GhcPs (LocatedA (HsExpr GhcPs)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHS GhcPs (LocatedA (HsExpr GhcPs)) -> m (GRHS GhcPs (LocatedA (HsExpr GhcPs)))

Data (GRHS GhcRn (LocatedA (HsCmd GhcRn)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GRHS GhcRn (LocatedA (HsCmd GhcRn)) -> c (GRHS GhcRn (LocatedA (HsCmd GhcRn)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GRHS GhcRn (LocatedA (HsCmd GhcRn)))

toConstr :: GRHS GhcRn (LocatedA (HsCmd GhcRn)) -> Constr

dataTypeOf :: GRHS GhcRn (LocatedA (HsCmd GhcRn)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GRHS GhcRn (LocatedA (HsCmd GhcRn))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GRHS GhcRn (LocatedA (HsCmd GhcRn))))

gmapT :: (forall b. Data b => b -> b) -> GRHS GhcRn (LocatedA (HsCmd GhcRn)) -> GRHS GhcRn (LocatedA (HsCmd GhcRn))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GRHS GhcRn (LocatedA (HsCmd GhcRn)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GRHS GhcRn (LocatedA (HsCmd GhcRn)) -> r

gmapQ :: (forall d. Data d => d -> u) -> GRHS GhcRn (LocatedA (HsCmd GhcRn)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> GRHS GhcRn (LocatedA (HsCmd GhcRn)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GRHS GhcRn (LocatedA (HsCmd GhcRn)) -> m (GRHS GhcRn (LocatedA (HsCmd GhcRn)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHS GhcRn (LocatedA (HsCmd GhcRn)) -> m (GRHS GhcRn (LocatedA (HsCmd GhcRn)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHS GhcRn (LocatedA (HsCmd GhcRn)) -> m (GRHS GhcRn (LocatedA (HsCmd GhcRn)))

Data (GRHS GhcRn (LocatedA (HsExpr GhcRn)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GRHS GhcRn (LocatedA (HsExpr GhcRn)) -> c (GRHS GhcRn (LocatedA (HsExpr GhcRn)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GRHS GhcRn (LocatedA (HsExpr GhcRn)))

toConstr :: GRHS GhcRn (LocatedA (HsExpr GhcRn)) -> Constr

dataTypeOf :: GRHS GhcRn (LocatedA (HsExpr GhcRn)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GRHS GhcRn (LocatedA (HsExpr GhcRn))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GRHS GhcRn (LocatedA (HsExpr GhcRn))))

gmapT :: (forall b. Data b => b -> b) -> GRHS GhcRn (LocatedA (HsExpr GhcRn)) -> GRHS GhcRn (LocatedA (HsExpr GhcRn))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GRHS GhcRn (LocatedA (HsExpr GhcRn)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GRHS GhcRn (LocatedA (HsExpr GhcRn)) -> r

gmapQ :: (forall d. Data d => d -> u) -> GRHS GhcRn (LocatedA (HsExpr GhcRn)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> GRHS GhcRn (LocatedA (HsExpr GhcRn)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GRHS GhcRn (LocatedA (HsExpr GhcRn)) -> m (GRHS GhcRn (LocatedA (HsExpr GhcRn)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHS GhcRn (LocatedA (HsExpr GhcRn)) -> m (GRHS GhcRn (LocatedA (HsExpr GhcRn)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHS GhcRn (LocatedA (HsExpr GhcRn)) -> m (GRHS GhcRn (LocatedA (HsExpr GhcRn)))

Data (GRHS GhcTc (LocatedA (HsCmd GhcTc)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GRHS GhcTc (LocatedA (HsCmd GhcTc)) -> c (GRHS GhcTc (LocatedA (HsCmd GhcTc)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GRHS GhcTc (LocatedA (HsCmd GhcTc)))

toConstr :: GRHS GhcTc (LocatedA (HsCmd GhcTc)) -> Constr

dataTypeOf :: GRHS GhcTc (LocatedA (HsCmd GhcTc)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GRHS GhcTc (LocatedA (HsCmd GhcTc))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GRHS GhcTc (LocatedA (HsCmd GhcTc))))

gmapT :: (forall b. Data b => b -> b) -> GRHS GhcTc (LocatedA (HsCmd GhcTc)) -> GRHS GhcTc (LocatedA (HsCmd GhcTc))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GRHS GhcTc (LocatedA (HsCmd GhcTc)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GRHS GhcTc (LocatedA (HsCmd GhcTc)) -> r

gmapQ :: (forall d. Data d => d -> u) -> GRHS GhcTc (LocatedA (HsCmd GhcTc)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> GRHS GhcTc (LocatedA (HsCmd GhcTc)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GRHS GhcTc (LocatedA (HsCmd GhcTc)) -> m (GRHS GhcTc (LocatedA (HsCmd GhcTc)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHS GhcTc (LocatedA (HsCmd GhcTc)) -> m (GRHS GhcTc (LocatedA (HsCmd GhcTc)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHS GhcTc (LocatedA (HsCmd GhcTc)) -> m (GRHS GhcTc (LocatedA (HsCmd GhcTc)))

Data (GRHS GhcTc (LocatedA (HsExpr GhcTc)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GRHS GhcTc (LocatedA (HsExpr GhcTc)) -> c (GRHS GhcTc (LocatedA (HsExpr GhcTc)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GRHS GhcTc (LocatedA (HsExpr GhcTc)))

toConstr :: GRHS GhcTc (LocatedA (HsExpr GhcTc)) -> Constr

dataTypeOf :: GRHS GhcTc (LocatedA (HsExpr GhcTc)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GRHS GhcTc (LocatedA (HsExpr GhcTc))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GRHS GhcTc (LocatedA (HsExpr GhcTc))))

gmapT :: (forall b. Data b => b -> b) -> GRHS GhcTc (LocatedA (HsExpr GhcTc)) -> GRHS GhcTc (LocatedA (HsExpr GhcTc))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GRHS GhcTc (LocatedA (HsExpr GhcTc)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GRHS GhcTc (LocatedA (HsExpr GhcTc)) -> r

gmapQ :: (forall d. Data d => d -> u) -> GRHS GhcTc (LocatedA (HsExpr GhcTc)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> GRHS GhcTc (LocatedA (HsExpr GhcTc)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GRHS GhcTc (LocatedA (HsExpr GhcTc)) -> m (GRHS GhcTc (LocatedA (HsExpr GhcTc)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHS GhcTc (LocatedA (HsExpr GhcTc)) -> m (GRHS GhcTc (LocatedA (HsExpr GhcTc)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHS GhcTc (LocatedA (HsExpr GhcTc)) -> m (GRHS GhcTc (LocatedA (HsExpr GhcTc)))

Data (GRHSs GhcPs (LocatedA (HsCmd GhcPs)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GRHSs GhcPs (LocatedA (HsCmd GhcPs)) -> c (GRHSs GhcPs (LocatedA (HsCmd GhcPs)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GRHSs GhcPs (LocatedA (HsCmd GhcPs)))

toConstr :: GRHSs GhcPs (LocatedA (HsCmd GhcPs)) -> Constr

dataTypeOf :: GRHSs GhcPs (LocatedA (HsCmd GhcPs)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GRHSs GhcPs (LocatedA (HsCmd GhcPs))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GRHSs GhcPs (LocatedA (HsCmd GhcPs))))

gmapT :: (forall b. Data b => b -> b) -> GRHSs GhcPs (LocatedA (HsCmd GhcPs)) -> GRHSs GhcPs (LocatedA (HsCmd GhcPs))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GRHSs GhcPs (LocatedA (HsCmd GhcPs)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GRHSs GhcPs (LocatedA (HsCmd GhcPs)) -> r

gmapQ :: (forall d. Data d => d -> u) -> GRHSs GhcPs (LocatedA (HsCmd GhcPs)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> GRHSs GhcPs (LocatedA (HsCmd GhcPs)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GRHSs GhcPs (LocatedA (HsCmd GhcPs)) -> m (GRHSs GhcPs (LocatedA (HsCmd GhcPs)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHSs GhcPs (LocatedA (HsCmd GhcPs)) -> m (GRHSs GhcPs (LocatedA (HsCmd GhcPs)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHSs GhcPs (LocatedA (HsCmd GhcPs)) -> m (GRHSs GhcPs (LocatedA (HsCmd GhcPs)))

Data (GRHSs GhcPs (LocatedA (HsExpr GhcPs)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GRHSs GhcPs (LocatedA (HsExpr GhcPs)) -> c (GRHSs GhcPs (LocatedA (HsExpr GhcPs)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GRHSs GhcPs (LocatedA (HsExpr GhcPs)))

toConstr :: GRHSs GhcPs (LocatedA (HsExpr GhcPs)) -> Constr

dataTypeOf :: GRHSs GhcPs (LocatedA (HsExpr GhcPs)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GRHSs GhcPs (LocatedA (HsExpr GhcPs))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GRHSs GhcPs (LocatedA (HsExpr GhcPs))))

gmapT :: (forall b. Data b => b -> b) -> GRHSs GhcPs (LocatedA (HsExpr GhcPs)) -> GRHSs GhcPs (LocatedA (HsExpr GhcPs))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GRHSs GhcPs (LocatedA (HsExpr GhcPs)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GRHSs GhcPs (LocatedA (HsExpr GhcPs)) -> r

gmapQ :: (forall d. Data d => d -> u) -> GRHSs GhcPs (LocatedA (HsExpr GhcPs)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> GRHSs GhcPs (LocatedA (HsExpr GhcPs)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GRHSs GhcPs (LocatedA (HsExpr GhcPs)) -> m (GRHSs GhcPs (LocatedA (HsExpr GhcPs)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHSs GhcPs (LocatedA (HsExpr GhcPs)) -> m (GRHSs GhcPs (LocatedA (HsExpr GhcPs)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHSs GhcPs (LocatedA (HsExpr GhcPs)) -> m (GRHSs GhcPs (LocatedA (HsExpr GhcPs)))

Data (GRHSs GhcRn (LocatedA (HsCmd GhcRn)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GRHSs GhcRn (LocatedA (HsCmd GhcRn)) -> c (GRHSs GhcRn (LocatedA (HsCmd GhcRn)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GRHSs GhcRn (LocatedA (HsCmd GhcRn)))

toConstr :: GRHSs GhcRn (LocatedA (HsCmd GhcRn)) -> Constr

dataTypeOf :: GRHSs GhcRn (LocatedA (HsCmd GhcRn)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GRHSs GhcRn (LocatedA (HsCmd GhcRn))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GRHSs GhcRn (LocatedA (HsCmd GhcRn))))

gmapT :: (forall b. Data b => b -> b) -> GRHSs GhcRn (LocatedA (HsCmd GhcRn)) -> GRHSs GhcRn (LocatedA (HsCmd GhcRn))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GRHSs GhcRn (LocatedA (HsCmd GhcRn)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GRHSs GhcRn (LocatedA (HsCmd GhcRn)) -> r

gmapQ :: (forall d. Data d => d -> u) -> GRHSs GhcRn (LocatedA (HsCmd GhcRn)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> GRHSs GhcRn (LocatedA (HsCmd GhcRn)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GRHSs GhcRn (LocatedA (HsCmd GhcRn)) -> m (GRHSs GhcRn (LocatedA (HsCmd GhcRn)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHSs GhcRn (LocatedA (HsCmd GhcRn)) -> m (GRHSs GhcRn (LocatedA (HsCmd GhcRn)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHSs GhcRn (LocatedA (HsCmd GhcRn)) -> m (GRHSs GhcRn (LocatedA (HsCmd GhcRn)))

Data (GRHSs GhcRn (LocatedA (HsExpr GhcRn)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GRHSs GhcRn (LocatedA (HsExpr GhcRn)) -> c (GRHSs GhcRn (LocatedA (HsExpr GhcRn)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GRHSs GhcRn (LocatedA (HsExpr GhcRn)))

toConstr :: GRHSs GhcRn (LocatedA (HsExpr GhcRn)) -> Constr

dataTypeOf :: GRHSs GhcRn (LocatedA (HsExpr GhcRn)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GRHSs GhcRn (LocatedA (HsExpr GhcRn))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GRHSs GhcRn (LocatedA (HsExpr GhcRn))))

gmapT :: (forall b. Data b => b -> b) -> GRHSs GhcRn (LocatedA (HsExpr GhcRn)) -> GRHSs GhcRn (LocatedA (HsExpr GhcRn))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GRHSs GhcRn (LocatedA (HsExpr GhcRn)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GRHSs GhcRn (LocatedA (HsExpr GhcRn)) -> r

gmapQ :: (forall d. Data d => d -> u) -> GRHSs GhcRn (LocatedA (HsExpr GhcRn)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> GRHSs GhcRn (LocatedA (HsExpr GhcRn)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GRHSs GhcRn (LocatedA (HsExpr GhcRn)) -> m (GRHSs GhcRn (LocatedA (HsExpr GhcRn)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHSs GhcRn (LocatedA (HsExpr GhcRn)) -> m (GRHSs GhcRn (LocatedA (HsExpr GhcRn)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHSs GhcRn (LocatedA (HsExpr GhcRn)) -> m (GRHSs GhcRn (LocatedA (HsExpr GhcRn)))

Data (GRHSs GhcTc (LocatedA (HsCmd GhcTc)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GRHSs GhcTc (LocatedA (HsCmd GhcTc)) -> c (GRHSs GhcTc (LocatedA (HsCmd GhcTc)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GRHSs GhcTc (LocatedA (HsCmd GhcTc)))

toConstr :: GRHSs GhcTc (LocatedA (HsCmd GhcTc)) -> Constr

dataTypeOf :: GRHSs GhcTc (LocatedA (HsCmd GhcTc)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GRHSs GhcTc (LocatedA (HsCmd GhcTc))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GRHSs GhcTc (LocatedA (HsCmd GhcTc))))

gmapT :: (forall b. Data b => b -> b) -> GRHSs GhcTc (LocatedA (HsCmd GhcTc)) -> GRHSs GhcTc (LocatedA (HsCmd GhcTc))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GRHSs GhcTc (LocatedA (HsCmd GhcTc)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GRHSs GhcTc (LocatedA (HsCmd GhcTc)) -> r

gmapQ :: (forall d. Data d => d -> u) -> GRHSs GhcTc (LocatedA (HsCmd GhcTc)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> GRHSs GhcTc (LocatedA (HsCmd GhcTc)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GRHSs GhcTc (LocatedA (HsCmd GhcTc)) -> m (GRHSs GhcTc (LocatedA (HsCmd GhcTc)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHSs GhcTc (LocatedA (HsCmd GhcTc)) -> m (GRHSs GhcTc (LocatedA (HsCmd GhcTc)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHSs GhcTc (LocatedA (HsCmd GhcTc)) -> m (GRHSs GhcTc (LocatedA (HsCmd GhcTc)))

Data (GRHSs GhcTc (LocatedA (HsExpr GhcTc)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GRHSs GhcTc (LocatedA (HsExpr GhcTc)) -> c (GRHSs GhcTc (LocatedA (HsExpr GhcTc)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GRHSs GhcTc (LocatedA (HsExpr GhcTc)))

toConstr :: GRHSs GhcTc (LocatedA (HsExpr GhcTc)) -> Constr

dataTypeOf :: GRHSs GhcTc (LocatedA (HsExpr GhcTc)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GRHSs GhcTc (LocatedA (HsExpr GhcTc))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GRHSs GhcTc (LocatedA (HsExpr GhcTc))))

gmapT :: (forall b. Data b => b -> b) -> GRHSs GhcTc (LocatedA (HsExpr GhcTc)) -> GRHSs GhcTc (LocatedA (HsExpr GhcTc))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GRHSs GhcTc (LocatedA (HsExpr GhcTc)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GRHSs GhcTc (LocatedA (HsExpr GhcTc)) -> r

gmapQ :: (forall d. Data d => d -> u) -> GRHSs GhcTc (LocatedA (HsExpr GhcTc)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> GRHSs GhcTc (LocatedA (HsExpr GhcTc)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GRHSs GhcTc (LocatedA (HsExpr GhcTc)) -> m (GRHSs GhcTc (LocatedA (HsExpr GhcTc)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHSs GhcTc (LocatedA (HsExpr GhcTc)) -> m (GRHSs GhcTc (LocatedA (HsExpr GhcTc)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHSs GhcTc (LocatedA (HsExpr GhcTc)) -> m (GRHSs GhcTc (LocatedA (HsExpr GhcTc)))

Data (Match GhcPs (LocatedA (HsCmd GhcPs)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Match GhcPs (LocatedA (HsCmd GhcPs)) -> c (Match GhcPs (LocatedA (HsCmd GhcPs)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Match GhcPs (LocatedA (HsCmd GhcPs)))

toConstr :: Match GhcPs (LocatedA (HsCmd GhcPs)) -> Constr

dataTypeOf :: Match GhcPs (LocatedA (HsCmd GhcPs)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Match GhcPs (LocatedA (HsCmd GhcPs))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Match GhcPs (LocatedA (HsCmd GhcPs))))

gmapT :: (forall b. Data b => b -> b) -> Match GhcPs (LocatedA (HsCmd GhcPs)) -> Match GhcPs (LocatedA (HsCmd GhcPs))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match GhcPs (LocatedA (HsCmd GhcPs)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match GhcPs (LocatedA (HsCmd GhcPs)) -> r

gmapQ :: (forall d. Data d => d -> u) -> Match GhcPs (LocatedA (HsCmd GhcPs)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Match GhcPs (LocatedA (HsCmd GhcPs)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Match GhcPs (LocatedA (HsCmd GhcPs)) -> m (Match GhcPs (LocatedA (HsCmd GhcPs)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Match GhcPs (LocatedA (HsCmd GhcPs)) -> m (Match GhcPs (LocatedA (HsCmd GhcPs)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Match GhcPs (LocatedA (HsCmd GhcPs)) -> m (Match GhcPs (LocatedA (HsCmd GhcPs)))

Data (Match GhcPs (LocatedA (HsExpr GhcPs)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Match GhcPs (LocatedA (HsExpr GhcPs)) -> c (Match GhcPs (LocatedA (HsExpr GhcPs)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Match GhcPs (LocatedA (HsExpr GhcPs)))

toConstr :: Match GhcPs (LocatedA (HsExpr GhcPs)) -> Constr

dataTypeOf :: Match GhcPs (LocatedA (HsExpr GhcPs)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Match GhcPs (LocatedA (HsExpr GhcPs))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Match GhcPs (LocatedA (HsExpr GhcPs))))

gmapT :: (forall b. Data b => b -> b) -> Match GhcPs (LocatedA (HsExpr GhcPs)) -> Match GhcPs (LocatedA (HsExpr GhcPs))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match GhcPs (LocatedA (HsExpr GhcPs)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match GhcPs (LocatedA (HsExpr GhcPs)) -> r

gmapQ :: (forall d. Data d => d -> u) -> Match GhcPs (LocatedA (HsExpr GhcPs)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Match GhcPs (LocatedA (HsExpr GhcPs)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Match GhcPs (LocatedA (HsExpr GhcPs)) -> m (Match GhcPs (LocatedA (HsExpr GhcPs)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Match GhcPs (LocatedA (HsExpr GhcPs)) -> m (Match GhcPs (LocatedA (HsExpr GhcPs)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Match GhcPs (LocatedA (HsExpr GhcPs)) -> m (Match GhcPs (LocatedA (HsExpr GhcPs)))

Data (Match GhcRn (LocatedA (HsCmd GhcRn)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Match GhcRn (LocatedA (HsCmd GhcRn)) -> c (Match GhcRn (LocatedA (HsCmd GhcRn)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Match GhcRn (LocatedA (HsCmd GhcRn)))

toConstr :: Match GhcRn (LocatedA (HsCmd GhcRn)) -> Constr

dataTypeOf :: Match GhcRn (LocatedA (HsCmd GhcRn)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Match GhcRn (LocatedA (HsCmd GhcRn))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Match GhcRn (LocatedA (HsCmd GhcRn))))

gmapT :: (forall b. Data b => b -> b) -> Match GhcRn (LocatedA (HsCmd GhcRn)) -> Match GhcRn (LocatedA (HsCmd GhcRn))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match GhcRn (LocatedA (HsCmd GhcRn)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match GhcRn (LocatedA (HsCmd GhcRn)) -> r

gmapQ :: (forall d. Data d => d -> u) -> Match GhcRn (LocatedA (HsCmd GhcRn)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Match GhcRn (LocatedA (HsCmd GhcRn)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Match GhcRn (LocatedA (HsCmd GhcRn)) -> m (Match GhcRn (LocatedA (HsCmd GhcRn)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Match GhcRn (LocatedA (HsCmd GhcRn)) -> m (Match GhcRn (LocatedA (HsCmd GhcRn)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Match GhcRn (LocatedA (HsCmd GhcRn)) -> m (Match GhcRn (LocatedA (HsCmd GhcRn)))

Data (Match GhcRn (LocatedA (HsExpr GhcRn)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Match GhcRn (LocatedA (HsExpr GhcRn)) -> c (Match GhcRn (LocatedA (HsExpr GhcRn)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Match GhcRn (LocatedA (HsExpr GhcRn)))

toConstr :: Match GhcRn (LocatedA (HsExpr GhcRn)) -> Constr

dataTypeOf :: Match GhcRn (LocatedA (HsExpr GhcRn)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Match GhcRn (LocatedA (HsExpr GhcRn))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Match GhcRn (LocatedA (HsExpr GhcRn))))

gmapT :: (forall b. Data b => b -> b) -> Match GhcRn (LocatedA (HsExpr GhcRn)) -> Match GhcRn (LocatedA (HsExpr GhcRn))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match GhcRn (LocatedA (HsExpr GhcRn)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match GhcRn (LocatedA (HsExpr GhcRn)) -> r

gmapQ :: (forall d. Data d => d -> u) -> Match GhcRn (LocatedA (HsExpr GhcRn)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Match GhcRn (LocatedA (HsExpr GhcRn)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Match GhcRn (LocatedA (HsExpr GhcRn)) -> m (Match GhcRn (LocatedA (HsExpr GhcRn)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Match GhcRn (LocatedA (HsExpr GhcRn)) -> m (Match GhcRn (LocatedA (HsExpr GhcRn)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Match GhcRn (LocatedA (HsExpr GhcRn)) -> m (Match GhcRn (LocatedA (HsExpr GhcRn)))

Data (Match GhcTc (LocatedA (HsCmd GhcTc)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Match GhcTc (LocatedA (HsCmd GhcTc)) -> c (Match GhcTc (LocatedA (HsCmd GhcTc)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Match GhcTc (LocatedA (HsCmd GhcTc)))

toConstr :: Match GhcTc (LocatedA (HsCmd GhcTc)) -> Constr

dataTypeOf :: Match GhcTc (LocatedA (HsCmd GhcTc)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Match GhcTc (LocatedA (HsCmd GhcTc))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Match GhcTc (LocatedA (HsCmd GhcTc))))

gmapT :: (forall b. Data b => b -> b) -> Match GhcTc (LocatedA (HsCmd GhcTc)) -> Match GhcTc (LocatedA (HsCmd GhcTc))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match GhcTc (LocatedA (HsCmd GhcTc)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match GhcTc (LocatedA (HsCmd GhcTc)) -> r

gmapQ :: (forall d. Data d => d -> u) -> Match GhcTc (LocatedA (HsCmd GhcTc)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Match GhcTc (LocatedA (HsCmd GhcTc)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Match GhcTc (LocatedA (HsCmd GhcTc)) -> m (Match GhcTc (LocatedA (HsCmd GhcTc)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Match GhcTc (LocatedA (HsCmd GhcTc)) -> m (Match GhcTc (LocatedA (HsCmd GhcTc)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Match GhcTc (LocatedA (HsCmd GhcTc)) -> m (Match GhcTc (LocatedA (HsCmd GhcTc)))

Data (Match GhcTc (LocatedA (HsExpr GhcTc)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Match GhcTc (LocatedA (HsExpr GhcTc)) -> c (Match GhcTc (LocatedA (HsExpr GhcTc)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Match GhcTc (LocatedA (HsExpr GhcTc)))

toConstr :: Match GhcTc (LocatedA (HsExpr GhcTc)) -> Constr

dataTypeOf :: Match GhcTc (LocatedA (HsExpr GhcTc)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Match GhcTc (LocatedA (HsExpr GhcTc))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Match GhcTc (LocatedA (HsExpr GhcTc))))

gmapT :: (forall b. Data b => b -> b) -> Match GhcTc (LocatedA (HsExpr GhcTc)) -> Match GhcTc (LocatedA (HsExpr GhcTc))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match GhcTc (LocatedA (HsExpr GhcTc)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match GhcTc (LocatedA (HsExpr GhcTc)) -> r

gmapQ :: (forall d. Data d => d -> u) -> Match GhcTc (LocatedA (HsExpr GhcTc)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Match GhcTc (LocatedA (HsExpr GhcTc)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Match GhcTc (LocatedA (HsExpr GhcTc)) -> m (Match GhcTc (LocatedA (HsExpr GhcTc)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Match GhcTc (LocatedA (HsExpr GhcTc)) -> m (Match GhcTc (LocatedA (HsExpr GhcTc)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Match GhcTc (LocatedA (HsExpr GhcTc)) -> m (Match GhcTc (LocatedA (HsExpr GhcTc)))

Data (MatchGroup GhcPs (LocatedA (HsCmd GhcPs)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MatchGroup GhcPs (LocatedA (HsCmd GhcPs)) -> c (MatchGroup GhcPs (LocatedA (HsCmd GhcPs)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (MatchGroup GhcPs (LocatedA (HsCmd GhcPs)))

toConstr :: MatchGroup GhcPs (LocatedA (HsCmd GhcPs)) -> Constr

dataTypeOf :: MatchGroup GhcPs (LocatedA (HsCmd GhcPs)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (MatchGroup GhcPs (LocatedA (HsCmd GhcPs))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MatchGroup GhcPs (LocatedA (HsCmd GhcPs))))

gmapT :: (forall b. Data b => b -> b) -> MatchGroup GhcPs (LocatedA (HsCmd GhcPs)) -> MatchGroup GhcPs (LocatedA (HsCmd GhcPs))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MatchGroup GhcPs (LocatedA (HsCmd GhcPs)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MatchGroup GhcPs (LocatedA (HsCmd GhcPs)) -> r

gmapQ :: (forall d. Data d => d -> u) -> MatchGroup GhcPs (LocatedA (HsCmd GhcPs)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> MatchGroup GhcPs (LocatedA (HsCmd GhcPs)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MatchGroup GhcPs (LocatedA (HsCmd GhcPs)) -> m (MatchGroup GhcPs (LocatedA (HsCmd GhcPs)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MatchGroup GhcPs (LocatedA (HsCmd GhcPs)) -> m (MatchGroup GhcPs (LocatedA (HsCmd GhcPs)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MatchGroup GhcPs (LocatedA (HsCmd GhcPs)) -> m (MatchGroup GhcPs (LocatedA (HsCmd GhcPs)))

Data (MatchGroup GhcPs (LocatedA (HsExpr GhcPs)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MatchGroup GhcPs (LocatedA (HsExpr GhcPs)) -> c (MatchGroup GhcPs (LocatedA (HsExpr GhcPs)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (MatchGroup GhcPs (LocatedA (HsExpr GhcPs)))

toConstr :: MatchGroup GhcPs (LocatedA (HsExpr GhcPs)) -> Constr

dataTypeOf :: MatchGroup GhcPs (LocatedA (HsExpr GhcPs)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (MatchGroup GhcPs (LocatedA (HsExpr GhcPs))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MatchGroup GhcPs (LocatedA (HsExpr GhcPs))))

gmapT :: (forall b. Data b => b -> b) -> MatchGroup GhcPs (LocatedA (HsExpr GhcPs)) -> MatchGroup GhcPs (LocatedA (HsExpr GhcPs))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MatchGroup GhcPs (LocatedA (HsExpr GhcPs)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MatchGroup GhcPs (LocatedA (HsExpr GhcPs)) -> r

gmapQ :: (forall d. Data d => d -> u) -> MatchGroup GhcPs (LocatedA (HsExpr GhcPs)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> MatchGroup GhcPs (LocatedA (HsExpr GhcPs)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MatchGroup GhcPs (LocatedA (HsExpr GhcPs)) -> m (MatchGroup GhcPs (LocatedA (HsExpr GhcPs)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MatchGroup GhcPs (LocatedA (HsExpr GhcPs)) -> m (MatchGroup GhcPs (LocatedA (HsExpr GhcPs)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MatchGroup GhcPs (LocatedA (HsExpr GhcPs)) -> m (MatchGroup GhcPs (LocatedA (HsExpr GhcPs)))

Data (MatchGroup GhcRn (LocatedA (HsCmd GhcRn)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MatchGroup GhcRn (LocatedA (HsCmd GhcRn)) -> c (MatchGroup GhcRn (LocatedA (HsCmd GhcRn)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (MatchGroup GhcRn (LocatedA (HsCmd GhcRn)))

toConstr :: MatchGroup GhcRn (LocatedA (HsCmd GhcRn)) -> Constr

dataTypeOf :: MatchGroup GhcRn (LocatedA (HsCmd GhcRn)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (MatchGroup GhcRn (LocatedA (HsCmd GhcRn))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MatchGroup GhcRn (LocatedA (HsCmd GhcRn))))

gmapT :: (forall b. Data b => b -> b) -> MatchGroup GhcRn (LocatedA (HsCmd GhcRn)) -> MatchGroup GhcRn (LocatedA (HsCmd GhcRn))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MatchGroup GhcRn (LocatedA (HsCmd GhcRn)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MatchGroup GhcRn (LocatedA (HsCmd GhcRn)) -> r

gmapQ :: (forall d. Data d => d -> u) -> MatchGroup GhcRn (LocatedA (HsCmd GhcRn)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> MatchGroup GhcRn (LocatedA (HsCmd GhcRn)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MatchGroup GhcRn (LocatedA (HsCmd GhcRn)) -> m (MatchGroup GhcRn (LocatedA (HsCmd GhcRn)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MatchGroup GhcRn (LocatedA (HsCmd GhcRn)) -> m (MatchGroup GhcRn (LocatedA (HsCmd GhcRn)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MatchGroup GhcRn (LocatedA (HsCmd GhcRn)) -> m (MatchGroup GhcRn (LocatedA (HsCmd GhcRn)))

Data (MatchGroup GhcRn (LocatedA (HsExpr GhcRn)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MatchGroup GhcRn (LocatedA (HsExpr GhcRn)) -> c (MatchGroup GhcRn (LocatedA (HsExpr GhcRn)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (MatchGroup GhcRn (LocatedA (HsExpr GhcRn)))

toConstr :: MatchGroup GhcRn (LocatedA (HsExpr GhcRn)) -> Constr

dataTypeOf :: MatchGroup GhcRn (LocatedA (HsExpr GhcRn)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (MatchGroup GhcRn (LocatedA (HsExpr GhcRn))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MatchGroup GhcRn (LocatedA (HsExpr GhcRn))))

gmapT :: (forall b. Data b => b -> b) -> MatchGroup GhcRn (LocatedA (HsExpr GhcRn)) -> MatchGroup GhcRn (LocatedA (HsExpr GhcRn))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MatchGroup GhcRn (LocatedA (HsExpr GhcRn)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MatchGroup GhcRn (LocatedA (HsExpr GhcRn)) -> r

gmapQ :: (forall d. Data d => d -> u) -> MatchGroup GhcRn (LocatedA (HsExpr GhcRn)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> MatchGroup GhcRn (LocatedA (HsExpr GhcRn)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MatchGroup GhcRn (LocatedA (HsExpr GhcRn)) -> m (MatchGroup GhcRn (LocatedA (HsExpr GhcRn)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MatchGroup GhcRn (LocatedA (HsExpr GhcRn)) -> m (MatchGroup GhcRn (LocatedA (HsExpr GhcRn)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MatchGroup GhcRn (LocatedA (HsExpr GhcRn)) -> m (MatchGroup GhcRn (LocatedA (HsExpr GhcRn)))

Data (MatchGroup GhcTc (LocatedA (HsCmd GhcTc)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MatchGroup GhcTc (LocatedA (HsCmd GhcTc)) -> c (MatchGroup GhcTc (LocatedA (HsCmd GhcTc)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (MatchGroup GhcTc (LocatedA (HsCmd GhcTc)))

toConstr :: MatchGroup GhcTc (LocatedA (HsCmd GhcTc)) -> Constr

dataTypeOf :: MatchGroup GhcTc (LocatedA (HsCmd GhcTc)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (MatchGroup GhcTc (LocatedA (HsCmd GhcTc))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MatchGroup GhcTc (LocatedA (HsCmd GhcTc))))

gmapT :: (forall b. Data b => b -> b) -> MatchGroup GhcTc (LocatedA (HsCmd GhcTc)) -> MatchGroup GhcTc (LocatedA (HsCmd GhcTc))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MatchGroup GhcTc (LocatedA (HsCmd GhcTc)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MatchGroup GhcTc (LocatedA (HsCmd GhcTc)) -> r

gmapQ :: (forall d. Data d => d -> u) -> MatchGroup GhcTc (LocatedA (HsCmd GhcTc)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> MatchGroup GhcTc (LocatedA (HsCmd GhcTc)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MatchGroup GhcTc (LocatedA (HsCmd GhcTc)) -> m (MatchGroup GhcTc (LocatedA (HsCmd GhcTc)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MatchGroup GhcTc (LocatedA (HsCmd GhcTc)) -> m (MatchGroup GhcTc (LocatedA (HsCmd GhcTc)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MatchGroup GhcTc (LocatedA (HsCmd GhcTc)) -> m (MatchGroup GhcTc (LocatedA (HsCmd GhcTc)))

Data (MatchGroup GhcTc (LocatedA (HsExpr GhcTc)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MatchGroup GhcTc (LocatedA (HsExpr GhcTc)) -> c (MatchGroup GhcTc (LocatedA (HsExpr GhcTc)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (MatchGroup GhcTc (LocatedA (HsExpr GhcTc)))

toConstr :: MatchGroup GhcTc (LocatedA (HsExpr GhcTc)) -> Constr

dataTypeOf :: MatchGroup GhcTc (LocatedA (HsExpr GhcTc)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (MatchGroup GhcTc (LocatedA (HsExpr GhcTc))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MatchGroup GhcTc (LocatedA (HsExpr GhcTc))))

gmapT :: (forall b. Data b => b -> b) -> MatchGroup GhcTc (LocatedA (HsExpr GhcTc)) -> MatchGroup GhcTc (LocatedA (HsExpr GhcTc))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MatchGroup GhcTc (LocatedA (HsExpr GhcTc)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MatchGroup GhcTc (LocatedA (HsExpr GhcTc)) -> r

gmapQ :: (forall d. Data d => d -> u) -> MatchGroup GhcTc (LocatedA (HsExpr GhcTc)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> MatchGroup GhcTc (LocatedA (HsExpr GhcTc)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MatchGroup GhcTc (LocatedA (HsExpr GhcTc)) -> m (MatchGroup GhcTc (LocatedA (HsExpr GhcTc)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MatchGroup GhcTc (LocatedA (HsExpr GhcTc)) -> m (MatchGroup GhcTc (LocatedA (HsExpr GhcTc)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MatchGroup GhcTc (LocatedA (HsExpr GhcTc)) -> m (MatchGroup GhcTc (LocatedA (HsExpr GhcTc)))

(Show l, Show e) => Show (GenLocated l e)

Defined in GHC.Types.SrcLoc

Methods

showsPrec :: Int -> GenLocated l e -> ShowS

show :: GenLocated l e -> String

showList :: [GenLocated l e] -> ShowS

NamedThing (Located a) => NamedThing (LocatedAn an a)

Defined in GHC.Parser.Annotation

Methods

getOccName :: LocatedAn an a -> OccName

getName :: LocatedAn an a -> Name

Outputable (GenLocated Anchor EpaComment)

Defined in GHC.Parser.Annotation

Methods

ppr :: GenLocated Anchor EpaComment -> SDoc

(Outputable a, Outputable e) => Outputable (GenLocated (SrcSpanAnn' a) e)

Defined in GHC.Parser.Annotation

Methods

ppr :: GenLocated (SrcSpanAnn' a) e -> SDoc

Outputable e => Outputable (GenLocated RealSrcSpan e)

Defined in GHC.Types.SrcLoc

Methods

ppr :: GenLocated RealSrcSpan e -> SDoc

(Outputable a, OutputableBndr e) => OutputableBndr (GenLocated (SrcSpanAnn' a) e)

Defined in GHC.Parser.Annotation

Methods

pprBndr :: BindingSite -> GenLocated (SrcSpanAnn' a) e -> SDoc

pprPrefixOcc :: GenLocated (SrcSpanAnn' a) e -> SDoc

pprInfixOcc :: GenLocated (SrcSpanAnn' a) e -> SDoc

bndrIsJoin_maybe :: GenLocated (SrcSpanAnn' a) e -> Maybe Int

(UnXRec pass, OutputableBndr (XRec pass RdrName)) => OutputableBndr (GenLocated SrcSpan (FieldOcc pass))

Defined in Language.Haskell.Syntax.Type

Methods

pprBndr :: BindingSite -> GenLocated SrcSpan (FieldOcc pass) -> SDoc

pprPrefixOcc :: GenLocated SrcSpan (FieldOcc pass) -> SDoc

pprInfixOcc :: GenLocated SrcSpan (FieldOcc pass) -> SDoc

bndrIsJoin_maybe :: GenLocated SrcSpan (FieldOcc pass) -> Maybe Int

(Eq l, Eq e) => Eq (GenLocated l e)

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)

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

Data (StmtLR GhcPs GhcPs (LocatedA (HsCmd GhcPs)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> StmtLR GhcPs GhcPs (LocatedA (HsCmd GhcPs)) -> c (StmtLR GhcPs GhcPs (LocatedA (HsCmd GhcPs)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (StmtLR GhcPs GhcPs (LocatedA (HsCmd GhcPs)))

toConstr :: StmtLR GhcPs GhcPs (LocatedA (HsCmd GhcPs)) -> Constr

dataTypeOf :: StmtLR GhcPs GhcPs (LocatedA (HsCmd GhcPs)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (StmtLR GhcPs GhcPs (LocatedA (HsCmd GhcPs))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (StmtLR GhcPs GhcPs (LocatedA (HsCmd GhcPs))))

gmapT :: (forall b. Data b => b -> b) -> StmtLR GhcPs GhcPs (LocatedA (HsCmd GhcPs)) -> StmtLR GhcPs GhcPs (LocatedA (HsCmd GhcPs))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> StmtLR GhcPs GhcPs (LocatedA (HsCmd GhcPs)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> StmtLR GhcPs GhcPs (LocatedA (HsCmd GhcPs)) -> r

gmapQ :: (forall d. Data d => d -> u) -> StmtLR GhcPs GhcPs (LocatedA (HsCmd GhcPs)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> StmtLR GhcPs GhcPs (LocatedA (HsCmd GhcPs)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> StmtLR GhcPs GhcPs (LocatedA (HsCmd GhcPs)) -> m (StmtLR GhcPs GhcPs (LocatedA (HsCmd GhcPs)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> StmtLR GhcPs GhcPs (LocatedA (HsCmd GhcPs)) -> m (StmtLR GhcPs GhcPs (LocatedA (HsCmd GhcPs)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> StmtLR GhcPs GhcPs (LocatedA (HsCmd GhcPs)) -> m (StmtLR GhcPs GhcPs (LocatedA (HsCmd GhcPs)))

Data (StmtLR GhcPs GhcPs (LocatedA (HsExpr GhcPs)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> StmtLR GhcPs GhcPs (LocatedA (HsExpr GhcPs)) -> c (StmtLR GhcPs GhcPs (LocatedA (HsExpr GhcPs)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (StmtLR GhcPs GhcPs (LocatedA (HsExpr GhcPs)))

toConstr :: StmtLR GhcPs GhcPs (LocatedA (HsExpr GhcPs)) -> Constr

dataTypeOf :: StmtLR GhcPs GhcPs (LocatedA (HsExpr GhcPs)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (StmtLR GhcPs GhcPs (LocatedA (HsExpr GhcPs))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (StmtLR GhcPs GhcPs (LocatedA (HsExpr GhcPs))))

gmapT :: (forall b. Data b => b -> b) -> StmtLR GhcPs GhcPs (LocatedA (HsExpr GhcPs)) -> StmtLR GhcPs GhcPs (LocatedA (HsExpr GhcPs))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> StmtLR GhcPs GhcPs (LocatedA (HsExpr GhcPs)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> StmtLR GhcPs GhcPs (LocatedA (HsExpr GhcPs)) -> r

gmapQ :: (forall d. Data d => d -> u) -> StmtLR GhcPs GhcPs (LocatedA (HsExpr GhcPs)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> StmtLR GhcPs GhcPs (LocatedA (HsExpr GhcPs)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> StmtLR GhcPs GhcPs (LocatedA (HsExpr GhcPs)) -> m (StmtLR GhcPs GhcPs (LocatedA (HsExpr GhcPs)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> StmtLR GhcPs GhcPs (LocatedA (HsExpr GhcPs)) -> m (StmtLR GhcPs GhcPs (LocatedA (HsExpr GhcPs)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> StmtLR GhcPs GhcPs (LocatedA (HsExpr GhcPs)) -> m (StmtLR GhcPs GhcPs (LocatedA (HsExpr GhcPs)))

Data (StmtLR GhcPs GhcRn (LocatedA (HsCmd GhcRn)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> StmtLR GhcPs GhcRn (LocatedA (HsCmd GhcRn)) -> c (StmtLR GhcPs GhcRn (LocatedA (HsCmd GhcRn)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (StmtLR GhcPs GhcRn (LocatedA (HsCmd GhcRn)))

toConstr :: StmtLR GhcPs GhcRn (LocatedA (HsCmd GhcRn)) -> Constr

dataTypeOf :: StmtLR GhcPs GhcRn (LocatedA (HsCmd GhcRn)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (StmtLR GhcPs GhcRn (LocatedA (HsCmd GhcRn))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (StmtLR GhcPs GhcRn (LocatedA (HsCmd GhcRn))))

gmapT :: (forall b. Data b => b -> b) -> StmtLR GhcPs GhcRn (LocatedA (HsCmd GhcRn)) -> StmtLR GhcPs GhcRn (LocatedA (HsCmd GhcRn))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> StmtLR GhcPs GhcRn (LocatedA (HsCmd GhcRn)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> StmtLR GhcPs GhcRn (LocatedA (HsCmd GhcRn)) -> r

gmapQ :: (forall d. Data d => d -> u) -> StmtLR GhcPs GhcRn (LocatedA (HsCmd GhcRn)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> StmtLR GhcPs GhcRn (LocatedA (HsCmd GhcRn)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> StmtLR GhcPs GhcRn (LocatedA (HsCmd GhcRn)) -> m (StmtLR GhcPs GhcRn (LocatedA (HsCmd GhcRn)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> StmtLR GhcPs GhcRn (LocatedA (HsCmd GhcRn)) -> m (StmtLR GhcPs GhcRn (LocatedA (HsCmd GhcRn)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> StmtLR GhcPs GhcRn (LocatedA (HsCmd GhcRn)) -> m (StmtLR GhcPs GhcRn (LocatedA (HsCmd GhcRn)))

Data (StmtLR GhcPs GhcRn (LocatedA (HsExpr GhcRn)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> StmtLR GhcPs GhcRn (LocatedA (HsExpr GhcRn)) -> c (StmtLR GhcPs GhcRn (LocatedA (HsExpr GhcRn)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (StmtLR GhcPs GhcRn (LocatedA (HsExpr GhcRn)))

toConstr :: StmtLR GhcPs GhcRn (LocatedA (HsExpr GhcRn)) -> Constr

dataTypeOf :: StmtLR GhcPs GhcRn (LocatedA (HsExpr GhcRn)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (StmtLR GhcPs GhcRn (LocatedA (HsExpr GhcRn))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (StmtLR GhcPs GhcRn (LocatedA (HsExpr GhcRn))))

gmapT :: (forall b. Data b => b -> b) -> StmtLR GhcPs GhcRn (LocatedA (HsExpr GhcRn)) -> StmtLR GhcPs GhcRn (LocatedA (HsExpr GhcRn))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> StmtLR GhcPs GhcRn (LocatedA (HsExpr GhcRn)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> StmtLR GhcPs GhcRn (LocatedA (HsExpr GhcRn)) -> r

gmapQ :: (forall d. Data d => d -> u) -> StmtLR GhcPs GhcRn (LocatedA (HsExpr GhcRn)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> StmtLR GhcPs GhcRn (LocatedA (HsExpr GhcRn)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> StmtLR GhcPs GhcRn (LocatedA (HsExpr GhcRn)) -> m (StmtLR GhcPs GhcRn (LocatedA (HsExpr GhcRn)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> StmtLR GhcPs GhcRn (LocatedA (HsExpr GhcRn)) -> m (StmtLR GhcPs GhcRn (LocatedA (HsExpr GhcRn)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> StmtLR GhcPs GhcRn (LocatedA (HsExpr GhcRn)) -> m (StmtLR GhcPs GhcRn (LocatedA (HsExpr GhcRn)))

Data (StmtLR GhcRn GhcRn (LocatedA (HsCmd GhcRn)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> StmtLR GhcRn GhcRn (LocatedA (HsCmd GhcRn)) -> c (StmtLR GhcRn GhcRn (LocatedA (HsCmd GhcRn)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (StmtLR GhcRn GhcRn (LocatedA (HsCmd GhcRn)))

toConstr :: StmtLR GhcRn GhcRn (LocatedA (HsCmd GhcRn)) -> Constr

dataTypeOf :: StmtLR GhcRn GhcRn (LocatedA (HsCmd GhcRn)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (StmtLR GhcRn GhcRn (LocatedA (HsCmd GhcRn))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (StmtLR GhcRn GhcRn (LocatedA (HsCmd GhcRn))))

gmapT :: (forall b. Data b => b -> b) -> StmtLR GhcRn GhcRn (LocatedA (HsCmd GhcRn)) -> StmtLR GhcRn GhcRn (LocatedA (HsCmd GhcRn))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> StmtLR GhcRn GhcRn (LocatedA (HsCmd GhcRn)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> StmtLR GhcRn GhcRn (LocatedA (HsCmd GhcRn)) -> r

gmapQ :: (forall d. Data d => d -> u) -> StmtLR GhcRn GhcRn (LocatedA (HsCmd GhcRn)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> StmtLR GhcRn GhcRn (LocatedA (HsCmd GhcRn)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> StmtLR GhcRn GhcRn (LocatedA (HsCmd GhcRn)) -> m (StmtLR GhcRn GhcRn (LocatedA (HsCmd GhcRn)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> StmtLR GhcRn GhcRn (LocatedA (HsCmd GhcRn)) -> m (StmtLR GhcRn GhcRn (LocatedA (HsCmd GhcRn)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> StmtLR GhcRn GhcRn (LocatedA (HsCmd GhcRn)) -> m (StmtLR GhcRn GhcRn (LocatedA (HsCmd GhcRn)))

Data (StmtLR GhcRn GhcRn (LocatedA (HsExpr GhcRn)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> StmtLR GhcRn GhcRn (LocatedA (HsExpr GhcRn)) -> c (StmtLR GhcRn GhcRn (LocatedA (HsExpr GhcRn)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (StmtLR GhcRn GhcRn (LocatedA (HsExpr GhcRn)))

toConstr :: StmtLR GhcRn GhcRn (LocatedA (HsExpr GhcRn)) -> Constr

dataTypeOf :: StmtLR GhcRn GhcRn (LocatedA (HsExpr GhcRn)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (StmtLR GhcRn GhcRn (LocatedA (HsExpr GhcRn))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (StmtLR GhcRn GhcRn (LocatedA (HsExpr GhcRn))))

gmapT :: (forall b. Data b => b -> b) -> StmtLR GhcRn GhcRn (LocatedA (HsExpr GhcRn)) -> StmtLR GhcRn GhcRn (LocatedA (HsExpr GhcRn))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> StmtLR GhcRn GhcRn (LocatedA (HsExpr GhcRn)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> StmtLR GhcRn GhcRn (LocatedA (HsExpr GhcRn)) -> r

gmapQ :: (forall d. Data d => d -> u) -> StmtLR GhcRn GhcRn (LocatedA (HsExpr GhcRn)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> StmtLR GhcRn GhcRn (LocatedA (HsExpr GhcRn)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> StmtLR GhcRn GhcRn (LocatedA (HsExpr GhcRn)) -> m (StmtLR GhcRn GhcRn (LocatedA (HsExpr GhcRn)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> StmtLR GhcRn GhcRn (LocatedA (HsExpr GhcRn)) -> m (StmtLR GhcRn GhcRn (LocatedA (HsExpr GhcRn)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> StmtLR GhcRn GhcRn (LocatedA (HsExpr GhcRn)) -> m (StmtLR GhcRn GhcRn (LocatedA (HsExpr GhcRn)))

Data (StmtLR GhcTc GhcTc (LocatedA (HsCmd GhcTc)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> StmtLR GhcTc GhcTc (LocatedA (HsCmd GhcTc)) -> c (StmtLR GhcTc GhcTc (LocatedA (HsCmd GhcTc)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (StmtLR GhcTc GhcTc (LocatedA (HsCmd GhcTc)))

toConstr :: StmtLR GhcTc GhcTc (LocatedA (HsCmd GhcTc)) -> Constr

dataTypeOf :: StmtLR GhcTc GhcTc (LocatedA (HsCmd GhcTc)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (StmtLR GhcTc GhcTc (LocatedA (HsCmd GhcTc))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (StmtLR GhcTc GhcTc (LocatedA (HsCmd GhcTc))))

gmapT :: (forall b. Data b => b -> b) -> StmtLR GhcTc GhcTc (LocatedA (HsCmd GhcTc)) -> StmtLR GhcTc GhcTc (LocatedA (HsCmd GhcTc))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> StmtLR GhcTc GhcTc (LocatedA (HsCmd GhcTc)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> StmtLR GhcTc GhcTc (LocatedA (HsCmd GhcTc)) -> r

gmapQ :: (forall d. Data d => d -> u) -> StmtLR GhcTc GhcTc (LocatedA (HsCmd GhcTc)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> StmtLR GhcTc GhcTc (LocatedA (HsCmd GhcTc)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> StmtLR GhcTc GhcTc (LocatedA (HsCmd GhcTc)) -> m (StmtLR GhcTc GhcTc (LocatedA (HsCmd GhcTc)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> StmtLR GhcTc GhcTc (LocatedA (HsCmd GhcTc)) -> m (StmtLR GhcTc GhcTc (LocatedA (HsCmd GhcTc)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> StmtLR GhcTc GhcTc (LocatedA (HsCmd GhcTc)) -> m (StmtLR GhcTc GhcTc (LocatedA (HsCmd GhcTc)))

Data (StmtLR GhcTc GhcTc (LocatedA (HsExpr GhcTc)))

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> StmtLR GhcTc GhcTc (LocatedA (HsExpr GhcTc)) -> c (StmtLR GhcTc GhcTc (LocatedA (HsExpr GhcTc)))

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (StmtLR GhcTc GhcTc (LocatedA (HsExpr GhcTc)))

toConstr :: StmtLR GhcTc GhcTc (LocatedA (HsExpr GhcTc)) -> Constr

dataTypeOf :: StmtLR GhcTc GhcTc (LocatedA (HsExpr GhcTc)) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (StmtLR GhcTc GhcTc (LocatedA (HsExpr GhcTc))))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (StmtLR GhcTc GhcTc (LocatedA (HsExpr GhcTc))))

gmapT :: (forall b. Data b => b -> b) -> StmtLR GhcTc GhcTc (LocatedA (HsExpr GhcTc)) -> StmtLR GhcTc GhcTc (LocatedA (HsExpr GhcTc))

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> StmtLR GhcTc GhcTc (LocatedA (HsExpr GhcTc)) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> StmtLR GhcTc GhcTc (LocatedA (HsExpr GhcTc)) -> r

gmapQ :: (forall d. Data d => d -> u) -> StmtLR GhcTc GhcTc (LocatedA (HsExpr GhcTc)) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> StmtLR GhcTc GhcTc (LocatedA (HsExpr GhcTc)) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> StmtLR GhcTc GhcTc (LocatedA (HsExpr GhcTc)) -> m (StmtLR GhcTc GhcTc (LocatedA (HsExpr GhcTc)))

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> StmtLR GhcTc GhcTc (LocatedA (HsExpr GhcTc)) -> m (StmtLR GhcTc GhcTc (LocatedA (HsExpr GhcTc)))

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> StmtLR GhcTc GhcTc (LocatedA (HsExpr GhcTc)) -> m (StmtLR GhcTc GhcTc (LocatedA (HsExpr GhcTc)))

type Anno (LocatedA (IE (GhcPass p)))

Defined in GHC.Hs.ImpExp

type Anno (LocatedA (IE (GhcPass p))) = SrcSpanAnnA

type Anno (LocatedN Name)

Defined in GHC.Hs.Binds

type Anno (LocatedN Name) = SrcSpan

type Anno (LocatedN RdrName)

Defined in GHC.Hs.Binds

type Anno (LocatedN RdrName) = SrcSpan

type Anno (LocatedN Id)

Defined in GHC.Hs.Binds

type Anno (LocatedN Id) = SrcSpan

type Anno [LocatedA (IE (GhcPass p))]

Defined in GHC.Hs.ImpExp

type Anno [LocatedA (IE (GhcPass p))] = SrcSpanAnnL

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

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))))]

Defined in GHC.Hs.Expr

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

type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))]

Defined in GHC.Parser.PostProcess

type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL

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

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))))]

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))))]

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))))]

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))))]

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 (HsExpr (GhcPass pr))))]

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))))]

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)))]

Defined in GHC.Parser.Types

type Anno [LocatedA (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL

type Anno [LocatedA (ConDeclField (GhcPass _1))]

Defined in GHC.Hs.Decls

type Anno [LocatedA (ConDeclField (GhcPass _1))] = SrcSpanAnnL

type Anno [LocatedA (HsType (GhcPass p))]

Defined in GHC.Hs.Type

type Anno [LocatedA (HsType (GhcPass p))] = SrcSpanAnnC

type Anno [LocatedN Name]

Defined in GHC.Hs.Binds

type Anno [LocatedN Name] = SrcSpan

type Anno [LocatedN RdrName]

Defined in GHC.Hs.Binds

type Anno [LocatedN RdrName] = SrcSpan

type Anno [LocatedN Id]

Defined in GHC.Hs.Binds

type Anno [LocatedN Id] = SrcSpan

type Anno (FamEqn p (LocatedA (HsType p)))

Defined in GHC.Hs.Decls

type Anno (FamEqn p (LocatedA (HsType p))) = SrcSpanAnnA

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

Defined in GHC.Hs.Expr

type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcAnn NoEpAnns

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

Defined in GHC.Hs.Expr

type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcAnn NoEpAnns

type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs)))

Defined in GHC.Parser.PostProcess

type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs))) = SrcAnn NoEpAnns

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

Defined in GHC.Hs.Expr

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

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

Defined in GHC.Hs.Expr

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

type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs)))

Defined in GHC.Parser.PostProcess

type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))

Defined in GHC.Hs.Expr

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr)))) = SrcSpanAnnA

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

Defined in GHC.Hs.Expr

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr)))) = SrcSpanAnnA

type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))

Defined in GHC.Parser.PostProcess

type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA

type Anno (StmtLR GhcRn GhcRn (LocatedA (body GhcRn)))

Defined in GHC.Hs.Expr

type Anno (StmtLR GhcRn GhcRn (LocatedA (body GhcRn))) = SrcSpanAnnA

type Located = GenLocated SrcSpan

type RealLocated = GenLocated RealSrcSpan

Constructing Located

noLoc :: e -> Located e

mkGeneralLocated :: String -> e -> Located e

Deconstructing Located

getLoc :: GenLocated l e -> l

unLoc :: GenLocated l e -> e

getRealSrcSpan :: RealLocated a -> RealSrcSpan

unRealSrcSpan :: RealLocated a -> a

Combining and comparing Located values

eqLocated :: Eq a => GenLocated l a -> GenLocated l a -> Bool

Tests whether the two located things are equal

cmpLocated :: Ord a => GenLocated l a -> GenLocated l a -> Ordering

Tests the ordering of the two located things

combineLocs :: Located a -> Located b -> SrcSpan

addCLoc :: Located a -> Located b -> c -> Located c

Combine locations from two Located things and add them to a third thing

leftmost_smallest :: SrcSpan -> SrcSpan -> Ordering

Strategies for ordering SrcSpans

leftmost_largest :: SrcSpan -> SrcSpan -> Ordering

Strategies for ordering SrcSpans

rightmost_smallest :: SrcSpan -> SrcSpan -> Ordering

Strategies for ordering SrcSpans

spans :: SrcSpan -> (Int, Int) -> Bool

Determines whether a span encloses a given line and column index

isSubspanOf

Arguments

:: SrcSpan

The span that may be enclosed by the other

-> SrcSpan

The span it may be enclosed by

-> Bool

Determines whether a span is enclosed by another one

Exceptions

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

Signal Int

Some other fatal signal (SIGHUP,SIGTERM)

UsageError String

Prints the short usage msg after the error

CmdLineError String

A problem with the command line arguments, but don't print usage.

Panic String

The impossible happened.

PprPanic String SDoc

Sorry String

The user tickled something that's known not to work yet, but we're not counting it as a bug.

PprSorry String SDoc

InstallationError String

An installation problem.

ProgramError String

An error in the user's code, probably.

PprProgramError String SDoc

Instances

Exception GhcException

Defined in GHC.Utils.Panic

Methods

toException :: GhcException -> SomeException

fromException :: SomeException -> Maybe GhcException

displayException :: GhcException -> String

Show GhcException

Defined in GHC.Utils.Panic

Methods

showsPrec :: Int -> GhcException -> ShowS

show :: GhcException -> String

showList :: [GhcException] -> ShowS

showGhcException :: SDocContext -> GhcException -> ShowS

Append a description of the given exception to this string.

newtype GhcApiError

An error thrown if the GHC API is used in an incorrect fashion.

Constructors

GhcApiError String

Instances

Exception GhcApiError

Defined in GHC

Methods

toException :: GhcApiError -> SomeException

fromException :: SomeException -> Maybe GhcApiError

displayException :: GhcApiError -> String

Show GhcApiError

Defined in GHC

Methods

showsPrec :: Int -> GhcApiError -> ShowS

show :: GhcApiError -> String

showList :: [GhcApiError] -> ShowS

Token stream manipulations

data Token

Instances

Show Token

Defined in GHC.Parser.Lexer

Methods

showsPrec :: Int -> Token -> ShowS

show :: Token -> String

showList :: [Token] -> ShowS

Outputable Token

Defined in GHC.Parser.Lexer

Methods

ppr :: Token -> SDoc

getTokenStream :: ModSummary -> IO [Located Token]

Return module source as token stream, including comments.

A GenModule can be turned into a ModSummary using getModSummary if your session is fully initialised. Throws a SourceError on parse error.

getRichTokenStream :: ModSummary -> IO [(Located Token, String)]

Give even more information on the source than getTokenStream This function allows reconstructing the source completely with showRichTokenStream.

showRichTokenStream :: [(Located Token, String)] -> String

Take a rich token stream such as produced from getRichTokenStream and return source code almost identical to the original code (except for insignificant whitespace.)

addSourceToTokens :: RealSrcLoc -> StringBuffer -> [Located Token] -> [(Located Token, String)]

Given a source location and a StringBuffer corresponding to this location, return a rich token stream with the source associated to the tokens.

Pure interface to the parser

parser

Arguments

:: String

Haskell module source text (full Unicode is supported)

-> DynFlags

the flags

-> FilePath

the filename (for source locations)

-> (WarningMessages, Either ErrorMessages (Located HsModule))

A pure interface to the module parser.

API Annotations

data AnnKeywordId

Exact print annotations exist so that tools can perform source to source conversions of Haskell code. They are used to keep track of the various syntactic keywords that are not otherwise captured in the AST.

The wiki page describing this feature is https://gitlab.haskell.org/ghc/ghc/wikis/api-annotations https://gitlab.haskell.org/ghc/ghc/-/wikis/implementing-trees-that-grow/in-tree-api-annotations

Note: in general the names of these are taken from the corresponding token, unless otherwise noted See Note [exact print annotations] above for details of the usage

Constructors

AnnAnyclass

AnnAs

AnnAt

AnnBang

!

AnnBackquote

'`'

AnnBy

AnnCase

case or lambda case

AnnCases

lambda cases

AnnClass

AnnClose

'#)' or '#-}' etc

AnnCloseB

'|)'

AnnCloseBU

'|)', unicode variant

AnnCloseC

'}'

AnnCloseQ

'|]'

AnnCloseQU

'|]', unicode variant

AnnCloseP

')'

AnnClosePH

'#)'

AnnCloseS

']'

AnnColon

AnnComma

as a list separator

AnnCommaTuple

in a RdrName for a tuple

AnnDarrow

'=>'

AnnDarrowU

'=>', unicode variant

AnnData

AnnDcolon

'::'

AnnDcolonU

'::', unicode variant

AnnDefault

AnnDeriving

AnnDo

AnnDot

.

AnnDotdot

'..'

AnnElse

AnnEqual

AnnExport

AnnFamily

AnnForall

AnnForallU

Unicode variant

AnnForeign

AnnFunId

for function name in matches where there are multiple equations for the function.

AnnGroup

AnnHeader

for CType

AnnHiding

AnnIf

AnnImport

AnnIn

AnnInfix

'infix' or 'infixl' or 'infixr'

AnnInstance

AnnLam

AnnLarrow

'<-'

AnnLarrowU

'<-', unicode variant

AnnLet

AnnLollyU

The ⊸ unicode arrow

AnnMdo

AnnMinus

-

AnnModule

AnnNewtype

AnnName

where a name loses its location in the AST, this carries it

AnnOf

AnnOpen

'{-# DEPRECATED' etc. Opening of pragmas where the capitalisation of the string can be changed by the user. The actual text used is stored in a SourceText on the relevant pragma item.

AnnOpenB

'(|'

AnnOpenBU

'(|', unicode variant

AnnOpenC

'{'

AnnOpenE

'[e|' or '[e||'

AnnOpenEQ

'[|'

AnnOpenEQU

'[|', unicode variant

AnnOpenP

'('

AnnOpenS

'['

AnnOpenPH

'(#'

AnnDollar

prefix $ -- TemplateHaskell

AnnDollarDollar

prefix $$ -- TemplateHaskell

AnnPackageName

AnnPattern

AnnPercent

% -- for HsExplicitMult

AnnPercentOne

'%1' -- for HsLinearArrow

AnnProc

AnnQualified

AnnRarrow

->

AnnRarrowU

->, unicode variant

AnnRec

AnnRole

AnnSafe

AnnSemi

';'

AnnSimpleQuote

'''

AnnSignature

AnnStatic

static

AnnStock

AnnThen

AnnThTyQuote

double '''

AnnTilde

~

AnnType

AnnUnit

() for types

AnnUsing

AnnVal

e.g. INTEGER

AnnValStr

String value, will need quotes when output

AnnVbar

'|'

AnnVia

via

AnnWhere

Annlarrowtail

-<

AnnlarrowtailU

-<, unicode variant

Annrarrowtail

->

AnnrarrowtailU

->, unicode variant

AnnLarrowtail

-<<

AnnLarrowtailU

-<<, unicode variant

AnnRarrowtail

>>-

AnnRarrowtailU

>>-, unicode variant

Instances

Data AnnKeywordId

Defined in GHC.Parser.Annotation

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnKeywordId -> c AnnKeywordId

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnKeywordId

toConstr :: AnnKeywordId -> Constr

dataTypeOf :: AnnKeywordId -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnnKeywordId)

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

gmapT :: (forall b. Data b => b -> b) -> AnnKeywordId -> AnnKeywordId

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnKeywordId -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnKeywordId -> r

gmapQ :: (forall d. Data d => d -> u) -> AnnKeywordId -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnKeywordId -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnKeywordId -> m AnnKeywordId

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnKeywordId -> m AnnKeywordId

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnKeywordId -> m AnnKeywordId

Show AnnKeywordId

Defined in GHC.Parser.Annotation

Methods

showsPrec :: Int -> AnnKeywordId -> ShowS

show :: AnnKeywordId -> String

showList :: [AnnKeywordId] -> ShowS

Outputable AnnKeywordId

Defined in GHC.Parser.Annotation

Methods

ppr :: AnnKeywordId -> SDoc

Eq AnnKeywordId

Defined in GHC.Parser.Annotation

Methods

(==) :: AnnKeywordId -> AnnKeywordId -> Bool

(/=) :: AnnKeywordId -> AnnKeywordId -> Bool

Ord AnnKeywordId

Defined in GHC.Parser.Annotation

Methods

compare :: AnnKeywordId -> AnnKeywordId -> Ordering

(<) :: AnnKeywordId -> AnnKeywordId -> Bool

(<=) :: AnnKeywordId -> AnnKeywordId -> Bool

(>) :: AnnKeywordId -> AnnKeywordId -> Bool

(>=) :: AnnKeywordId -> AnnKeywordId -> Bool

max :: AnnKeywordId -> AnnKeywordId -> AnnKeywordId

min :: AnnKeywordId -> AnnKeywordId -> AnnKeywordId

data EpaComment

Constructors

EpaComment

Fields

• ac_tok :: EpaCommentTok
• ac_prior_tok :: RealSrcSpan

  The location of the prior token, used in exact printing. The EpaComment appears as an LEpaComment containing its location. The difference between the end of the prior token and the start of this location is used for the spacing when exact printing the comment.

Instances

Data EpaComment

Defined in GHC.Parser.Annotation

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> EpaComment -> c EpaComment

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c EpaComment

toConstr :: EpaComment -> Constr

dataTypeOf :: EpaComment -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c EpaComment)

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

gmapT :: (forall b. Data b => b -> b) -> EpaComment -> EpaComment

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EpaComment -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EpaComment -> r

gmapQ :: (forall d. Data d => d -> u) -> EpaComment -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> EpaComment -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> EpaComment -> m EpaComment

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> EpaComment -> m EpaComment

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> EpaComment -> m EpaComment

Show EpaComment

Defined in GHC.Parser.Annotation

Methods

showsPrec :: Int -> EpaComment -> ShowS

show :: EpaComment -> String

showList :: [EpaComment] -> ShowS

Outputable EpaComment

Defined in GHC.Parser.Annotation

Methods

ppr :: EpaComment -> SDoc

Eq EpaComment

Defined in GHC.Parser.Annotation

Methods

(==) :: EpaComment -> EpaComment -> Bool

(/=) :: EpaComment -> EpaComment -> Bool

Outputable (GenLocated Anchor EpaComment)

Defined in GHC.Parser.Annotation

Methods

ppr :: GenLocated Anchor EpaComment -> SDoc

Miscellaneous

cyclicModuleErr :: [ModuleGraphNode] -> SDoc