ghc

• GHC
• GHC.Builtin.Names
• GHC.Builtin.Names.TH
• GHC.Builtin.PrimOps
• GHC.Builtin.PrimOps.Casts
• GHC.Builtin.PrimOps.IdsPrimOp's Ids
• GHC.Builtin.TypesThis module is about types that can be defined in Haskell, but which
• GHC.Builtin.Types.Literals
• GHC.Builtin.Types.PrimThis module defines TyCons that can't be expressed in Haskell.
• GHC.Builtin.UniquesThis is where we define a mapping from Uniques to their associated
• GHC.Builtin.UtilsThe GHC.Builtin.Utils interface to the compiler's prelude knowledge. This module serves as the central gathering point for names which the
• GHC.ByteCode.AsmBytecode assembler and linker
• GHC.ByteCode.Binary
• GHC.ByteCode.BreakpointsBreakpoint information constructed during ByteCode generation. Specifically, code-generation breakpoints are referred to as "internal
• GHC.ByteCode.InfoTableGenerate infotables for interpreter-made bytecodes
• GHC.ByteCode.InstrBytecode instruction definitions
• GHC.ByteCode.LinkerBytecode assembler and linker
• GHC.ByteCode.Recomp.Binary
• GHC.ByteCode.SerializeThis module implements the serialization of bytecode objects to and from disk.
• GHC.ByteCode.TypesBytecode assembler types
• GHC.Cmm
• GHC.Cmm.BlockId
• GHC.Cmm.CLabel
• GHC.Cmm.CallConv
• GHC.Cmm.CommonBlockElim
• GHC.Cmm.ConfigCmm compilation configuration
• GHC.Cmm.ContFlowOpt
• GHC.Cmm.Dataflow
• GHC.Cmm.Dataflow.Block
• GHC.Cmm.Dataflow.Graph
• GHC.Cmm.Dataflow.Label
• GHC.Cmm.DebugBlock
• GHC.Cmm.Dominators
• GHC.Cmm.Expr
• GHC.Cmm.GenericOpt
• GHC.Cmm.Graph
• GHC.Cmm.Info
• GHC.Cmm.Info.Build
• GHC.Cmm.InitFiniUtilities for dealing with constructors/destructors.
• GHC.Cmm.LRegSet
• GHC.Cmm.LayoutStack
• GHC.Cmm.Lexer
• GHC.Cmm.Lint
• GHC.Cmm.Liveness
• GHC.Cmm.MachOp
• GHC.Cmm.Node
• GHC.Cmm.Opt
• GHC.Cmm.Parser
• GHC.Cmm.Parser.Config
• GHC.Cmm.Parser.Monad
• GHC.Cmm.Pipeline
• GHC.Cmm.ProcPoint
• GHC.Cmm.ReducibilityTest a Cmm control-flow graph for reducibility. And provide a
• GHC.Cmm.Reg
• GHC.Cmm.Sink
• GHC.Cmm.Switch
• GHC.Cmm.Switch.Implement
• GHC.Cmm.ThreadSanitizerAnnotate a CmmGraph with ThreadSanitizer instrumentation calls.
• GHC.Cmm.Type
• GHC.Cmm.UniqueRenamer
• GHC.Cmm.Utils
• GHC.CmmToAsmNote [Native code generator]
• GHC.CmmToAsm.AArch64Native code generator for AArch64 architectures
• GHC.CmmToAsm.AArch64.CodeGen
• GHC.CmmToAsm.AArch64.Cond
• GHC.CmmToAsm.AArch64.Instr
• GHC.CmmToAsm.AArch64.Ppr
• GHC.CmmToAsm.AArch64.RegInfo
• GHC.CmmToAsm.AArch64.Regs
• GHC.CmmToAsm.BlockLayout
• GHC.CmmToAsm.CFG
• GHC.CmmToAsm.CFG.DominatorsThe Lengauer-Tarjan graph dominators algorithm. 1 Lengauer, Tarjan,
• GHC.CmmToAsm.CFG.Weight
• GHC.CmmToAsm.CPrimGenerating C symbol names emitted by the compiler.
• GHC.CmmToAsm.ConfigNative code generator configuration
• GHC.CmmToAsm.Dwarf
• GHC.CmmToAsm.Dwarf.ConstantsConstants describing the DWARF format. Most of this simply
• GHC.CmmToAsm.Dwarf.Types
• GHC.CmmToAsm.FormatFormats on this architecture
• GHC.CmmToAsm.Instr
• GHC.CmmToAsm.LA64Native code generator for LoongArch64 architectures
• GHC.CmmToAsm.LA64.CodeGen
• GHC.CmmToAsm.LA64.Cond
• GHC.CmmToAsm.LA64.Instr
• GHC.CmmToAsm.LA64.Ppr
• GHC.CmmToAsm.LA64.RegInfo
• GHC.CmmToAsm.LA64.Regs
• GHC.CmmToAsm.Monad
• GHC.CmmToAsm.PIC
• GHC.CmmToAsm.PPCNative code generator for PPC architectures
• GHC.CmmToAsm.PPC.CodeGen
• GHC.CmmToAsm.PPC.Cond
• GHC.CmmToAsm.PPC.Instr
• GHC.CmmToAsm.PPC.Ppr
• GHC.CmmToAsm.PPC.RegInfo
• GHC.CmmToAsm.PPC.Regs
• GHC.CmmToAsm.Ppr
• GHC.CmmToAsm.RV64Native code generator for RiscV64 architectures
• GHC.CmmToAsm.RV64.CodeGen
• GHC.CmmToAsm.RV64.Cond
• GHC.CmmToAsm.RV64.Instr
• GHC.CmmToAsm.RV64.Ppr
• GHC.CmmToAsm.RV64.RegInfoMinimum viable implementation of jump short-cutting: No short-cutting. The functions here simply implement the no-short-cutting case. Imp…
• GHC.CmmToAsm.RV64.Regs
• GHC.CmmToAsm.Reg.GraphGraph coloring register allocator.
• GHC.CmmToAsm.Reg.Graph.BaseUtils for calculating general worst, bound, squeese and free, functions. as per: "A Generalized Algorithm for Graph-Coloring Register All…
• GHC.CmmToAsm.Reg.Graph.CoalesceRegister coalescing.
• GHC.CmmToAsm.Reg.Graph.SpillWhen there aren't enough registers to hold all the vregs we have to spill
• GHC.CmmToAsm.Reg.Graph.SpillCleanClean out unneeded spill/reload instructions. Handling of join points
• GHC.CmmToAsm.Reg.Graph.SpillCost
• GHC.CmmToAsm.Reg.Graph.StatsCarries interesting info for debugging / profiling of the
• GHC.CmmToAsm.Reg.Graph.TrivColorable
• GHC.CmmToAsm.Reg.Graph.X86A description of the register set of the X86. This isn't used directly in GHC proper. See RegArchBase.hs for the reference.
• GHC.CmmToAsm.Reg.Linear
• GHC.CmmToAsm.Reg.Linear.AArch64
• GHC.CmmToAsm.Reg.Linear.BasePut common type definitions here to break recursive module dependencies.
• GHC.CmmToAsm.Reg.Linear.FreeRegs
• GHC.CmmToAsm.Reg.Linear.JoinToTargetsHandles joining of a jump instruction to its targets.
• GHC.CmmToAsm.Reg.Linear.LA64
• GHC.CmmToAsm.Reg.Linear.PPCFree regs map for PowerPC
• GHC.CmmToAsm.Reg.Linear.RV64Functions to implement the FR (as in "free regs") type class. For LLVM GHC calling convention (used registers), see
• GHC.CmmToAsm.Reg.Linear.StackMapThe assignment of virtual registers to stack slots
• GHC.CmmToAsm.Reg.Linear.StateState monad for the linear register allocator.
• GHC.CmmToAsm.Reg.Linear.Stats
• GHC.CmmToAsm.Reg.Linear.X86Free regs map for i386
• GHC.CmmToAsm.Reg.Linear.X86_64Free regs map for x86_64
• GHC.CmmToAsm.Reg.Liveness
• GHC.CmmToAsm.Reg.Regs
• GHC.CmmToAsm.Reg.TargetHard wired things related to registers.
• GHC.CmmToAsm.Reg.Utils
• GHC.CmmToAsm.Types
• GHC.CmmToAsm.Utils
• GHC.CmmToAsm.Wasm
• GHC.CmmToAsm.Wasm.Asm
• GHC.CmmToAsm.Wasm.FromCmm
• GHC.CmmToAsm.Wasm.Types
• GHC.CmmToAsm.Wasm.Utils
• GHC.CmmToAsm.X86Native code generator for x86 and x86-64 architectures
• GHC.CmmToAsm.X86.CodeGen
• GHC.CmmToAsm.X86.Cond
• GHC.CmmToAsm.X86.Instr
• GHC.CmmToAsm.X86.Ppr
• GHC.CmmToAsm.X86.RegInfo
• GHC.CmmToAsm.X86.Regs
• GHC.CmmToC
• GHC.CmmToLlvmThis is the top-level module in the LLVM code generator.
• GHC.CmmToLlvm.BaseBase LLVM Code Generation module Contains functions useful through out the code generator.
• GHC.CmmToLlvm.CodeGenHandle conversion of CmmProc to LLVM code.
• GHC.CmmToLlvm.ConfigLlvm code generator configuration
• GHC.CmmToLlvm.DataHandle conversion of CmmData to LLVM code.
• GHC.CmmToLlvm.ManglerGHC LLVM Mangler This script processes the assembly produced by LLVM, rewriting all symbols
• GHC.CmmToLlvm.PprPretty print helpers for the LLVM Code generator.
• GHC.CmmToLlvm.RegsDeal with Cmm registers
• GHC.CmmToLlvm.Version
• GHC.CmmToLlvm.Version.Bounds
• GHC.CmmToLlvm.Version.Type
• GHC.CoreGHC.Core holds all the main data types for use by for the Glasgow Haskell Compiler midsection
• GHC.Core.Class
• GHC.Core.CoercionModule for (a) type kinds and (b) type coercions,
• GHC.Core.Coercion.AxiomModule for coercion axioms, used to represent type family instances
• GHC.Core.Coercion.Opt
• GHC.Core.ConLike
• GHC.Core.DataCon
• GHC.Core.FVsA module concerned with finding the free variables of an expression.
• GHC.Core.FamInstEnv
• GHC.Core.InstEnv
• GHC.Core.LateCCAdds cost-centers after the core pipline has run.
• GHC.Core.LateCC.OverloadedCalls
• GHC.Core.LateCC.TopLevelBinds
• GHC.Core.LateCC.TypesTypes related to late cost center insertion
• GHC.Core.LateCC.Utils
• GHC.Core.Lint
• GHC.Core.Lint.Interactive
• GHC.Core.MakeHandy functions for creating much Core syntax
• GHC.Core.Map.Expr
• GHC.Core.Map.Type
• GHC.Core.MultiplicityThis module defines the semi-ring of multiplicities, and associated functions.
• GHC.Core.Opt.ArityArity and eta expansion
• GHC.Core.Opt.CSE
• GHC.Core.Opt.CallArity
• GHC.Core.Opt.CallerCCAdds cost-centers to call sites selected with the -fprof-caller=...
• GHC.Core.Opt.CallerCC.Types
• GHC.Core.Opt.ConstantFoldConstant Folder
• GHC.Core.Opt.CprAnalConstructed Product Result analysis. Identifies functions that surely
• GHC.Core.Opt.DmdAnal
• GHC.Core.Opt.Exitify
• GHC.Core.Opt.FloatIn
• GHC.Core.Opt.FloatOut
• GHC.Core.Opt.LiberateCase
• GHC.Core.Opt.Monad
• GHC.Core.Opt.OccurAnal
• GHC.Core.Opt.Pipeline
• GHC.Core.Opt.Pipeline.Types
• GHC.Core.Opt.RangeRange analysis See Note [Value range analysis]
• GHC.Core.Opt.SetLevels
• GHC.Core.Opt.Simplify
• GHC.Core.Opt.Simplify.Env
• GHC.Core.Opt.Simplify.Inline
• GHC.Core.Opt.Simplify.Iteration
• GHC.Core.Opt.Simplify.Monad
• GHC.Core.Opt.Simplify.Utils
• GHC.Core.Opt.SpecConstr
• GHC.Core.Opt.Specialise
• GHC.Core.Opt.StaticArgs
• GHC.Core.Opt.Stats
• GHC.Core.Opt.WorkWrap
• GHC.Core.Opt.WorkWrap.Utils
• GHC.Core.PatSyn
• GHC.Core.Ppr
• GHC.Core.Predicate
• GHC.Core.Reduction
• GHC.Core.RoughMapRoughMap is an approximate finite map data structure keyed on
• GHC.Core.RulesFunctions for collecting together and applying rewrite rules to a module.
• GHC.Core.Rules.Config
• GHC.Core.SeqVarious utilities for forcing Core structures It can often be useful to force various parts of the AST. This module
• GHC.Core.SimpleOpt
• GHC.Core.StatsFunctions to computing the statistics reflective of the "size"
• GHC.Core.Subst
• GHC.Core.Tidy
• GHC.Core.TyCo.CompareType equality and comparison
• GHC.Core.TyCo.FVs
• GHC.Core.TyCo.PprPretty-printing types and coercions.
• GHC.Core.TyCo.SubstSubstitution into types and coercions.
• GHC.Core.TyCo.TidyTidying types and coercions for printing in error messages.
• GHC.Core.TyCon
• GHC.Core.TyCon.Env
• GHC.Core.TyCon.RecWalk
• GHC.Core.TyCon.Set
• GHC.Core.TypeMain functions for manipulating types and type-related things
• GHC.Core.Unfold
• GHC.Core.Unfold.MakeUnfolding creation
• GHC.Core.Unify
• GHC.Core.UsageEnv
• GHC.Core.UtilsCommonly useful utilities for manipulating the Core language
• GHC.CoreToIfaceFunctions for converting Core things to interface file things.
• GHC.CoreToStg
• GHC.CoreToStg.AddImplicitBinds
• GHC.CoreToStg.Prep
• GHC.Data.Bag
• GHC.Data.Bitmap
• GHC.Data.Bool
• GHC.Data.BooleanFormulaBoolean formulas without quantifiers and without negation.
• GHC.Data.EnumSetA tiny wrapper around IntSet for representing sets of Enum
• GHC.Data.FastMutInt
• GHC.Data.FastStringThere are two principal string types used internally by GHC: FastString A compact, hash-consed, representation of character strings. Gen…
• GHC.Data.FastString.Env
• GHC.Data.FiniteMap
• GHC.Data.FlatBag
• GHC.Data.Graph.BaseTypes for the general graph colorer.
• GHC.Data.Graph.Collapse
• GHC.Data.Graph.ColorGraph Coloring.
• GHC.Data.Graph.Directed
• GHC.Data.Graph.Directed.ReachabilityAn abstract interface for a fast reachability data structure constructed
• GHC.Data.Graph.Inductive.GraphStatic and Dynamic Inductive Graphs Code is from Hackage fgl package version 5.7.0.3
• GHC.Data.Graph.Inductive.PatriciaTreeAn efficient implementation of Data.Graph.Inductive.Graph.Graph
• GHC.Data.Graph.OpsBasic operations on graphs.
• GHC.Data.Graph.PprPretty printing of graphs.
• GHC.Data.Graph.UnVar
• GHC.Data.IOEnvThe IO Monad with an environment The environment is passed around as a Reader monad but
• GHC.Data.List
• GHC.Data.List.Infinite
• GHC.Data.List.NonEmpty
• GHC.Data.List.SetOpsSet-like operations on lists Avoid using them as much as possible
• GHC.Data.Maybe
• GHC.Data.OrdListProvide trees (of instructions), so that lists of instructions can be
• GHC.Data.OsPath
• GHC.Data.Pair
• GHC.Data.StreamMonadic streams
• GHC.Data.Strict
• GHC.Data.StringBuffer
• GHC.Data.TrieMap
• GHC.Data.Unboxed
• GHC.Data.UnionFind
• GHC.Data.Word64MapAn efficient implementation of maps from integer keys to values
• GHC.Data.Word64Map.LazyFinite Word64 Maps (lazy interface) The Word64Map v type represents a finite map (sometimes called a dictionary)
• GHC.Data.Word64Map.StrictFinite Word64 Maps (strict interface) The Word64Map v type represents a finite map (sometimes called a dictionary)
• GHC.Data.Word64SetFinite Int Sets The Word64Set type represents a set of elements of type Int. For a walkthrough of the most commonly used functions see their
• GHC.Driver.BackendThis module exports the Backend type and all the available values
• GHC.Driver.BackpackThis is the driver for the 'ghc --backpack' mode, which
• GHC.Driver.Backpack.SyntaxThis is the syntax for bkp files which are parsed in 'ghc --backpack'
• GHC.Driver.ByteCode
• GHC.Driver.CmdLineCommand-line parser This is an abstract command-line parser used by DynFlags. (c) The University of Glasgow 2005
• GHC.Driver.CodeOutput
• GHC.Driver.ConfigSubsystem configuration
• GHC.Driver.Config.Cmm
• GHC.Driver.Config.Cmm.Parser
• GHC.Driver.Config.CmmToAsm
• GHC.Driver.Config.CmmToLlvm
• GHC.Driver.Config.Core.Lint
• GHC.Driver.Config.Core.Lint.Interactive
• GHC.Driver.Config.Core.Opt.Arity
• GHC.Driver.Config.Core.Opt.LiberateCase
• GHC.Driver.Config.Core.Opt.Simplify
• GHC.Driver.Config.Core.Opt.WorkWrap
• GHC.Driver.Config.Core.Rules
• GHC.Driver.Config.CoreToStg
• GHC.Driver.Config.CoreToStg.Prep
• GHC.Driver.Config.DiagnosticFunctions for initialising error message printing configuration from the
• GHC.Driver.Config.Finder
• GHC.Driver.Config.HsToCore
• GHC.Driver.Config.HsToCore.Ticks
• GHC.Driver.Config.HsToCore.Usage
• GHC.Driver.Config.Interpreter
• GHC.Driver.Config.Linker
• GHC.Driver.Config.Logger
• GHC.Driver.Config.Parser
• GHC.Driver.Config.Stg.Debug
• GHC.Driver.Config.Stg.Lift
• GHC.Driver.Config.Stg.Pipeline
• GHC.Driver.Config.Stg.Ppr
• GHC.Driver.Config.StgToCmm
• GHC.Driver.Config.StgToJS
• GHC.Driver.Config.Tidy
• GHC.Driver.Downsweep
• GHC.Driver.DynFlags
• GHC.Driver.Env
• GHC.Driver.Env.KnotVarsThis data structure holds an updateable environment which is used
• GHC.Driver.Env.Types
• GHC.Driver.Errors
• GHC.Driver.Errors.Ppr
• GHC.Driver.Errors.Types
• GHC.Driver.Flags
• GHC.Driver.GenerateCgIPEStub
• GHC.Driver.Hooks
• GHC.Driver.IncludeSpecs
• GHC.Driver.LlvmConfigCacheLLVM config cache
• GHC.Driver.MainMain API for compiling plain Haskell source code. This module implements compilation of a Haskell source. It is
• GHC.Driver.Make
• GHC.Driver.MakeAction
• GHC.Driver.MakeFile
• GHC.Driver.MakeSemImplementation of a jobserver using system semaphores.
• GHC.Driver.Messager
• GHC.Driver.Monad
• GHC.Driver.Phases
• GHC.Driver.Pipeline
• GHC.Driver.Pipeline.Execute
• GHC.Driver.Pipeline.LogQueue
• GHC.Driver.Pipeline.MonadThe TPipelineClass and MonadUse classes and associated types
• GHC.Driver.Pipeline.Phases
• GHC.Driver.PluginsDefinitions for writing plugins for GHC. Plugins can hook into
• GHC.Driver.Plugins.ExternalExternal plugins GHC supports two kinds of "static" plugins:
• GHC.Driver.PprPrinting related functions that depend on session state (DynFlags)
• GHC.Driver.SessionDynamic flags Most flags are dynamic flags, which means they can change from compilation
• GHC.Driver.Session.InspectGHC API utilities for inspecting the GHC session
• GHC.Driver.Session.Units
• GHC.Hs
• GHC.Hs.BasicFixity
• GHC.Hs.Binds
• GHC.Hs.DeclsAbstract syntax of global declarations. Definitions for: SynDecl and ConDecl, ClassDecl,
• GHC.Hs.Decls.OverlapData-types describing the overlap annotations for instances as well as
• GHC.Hs.DocTypes and functions for raw and lexed docstrings.
• GHC.Hs.DocStringAn exactprintable structure for docstrings
• GHC.Hs.DumpContains a debug function to dump parts of the GHC.Hs AST. It uses a syb
• GHC.Hs.ExprAbstract Haskell syntax for expressions.
• GHC.Hs.Extension
• GHC.Hs.ImpExp
• GHC.Hs.Instances
• GHC.Hs.LitSource-language literals
• GHC.Hs.Pat
• GHC.Hs.Specificity
• GHC.Hs.StatsStatistics for per-module compilations (c) The GRASP/AQUA Project, Glasgow University, 1993-1998
• GHC.Hs.Syn.TypeCompute the Type of an HsExpr GhcTc in a pure fashion. Note that this does not currently support the use case of annotating
• GHC.Hs.Type
• GHC.Hs.UtilsHere we collect a variety of helper functions that construct or
• GHC.HsToCore
• GHC.HsToCore.Arrows
• GHC.HsToCore.Binds
• GHC.HsToCore.BreakpointsInformation attached to Breakpoints generated from Ticks The breakpoint information stored in ModBreaks is generated during
• GHC.HsToCore.Breakpoints.TypesInformation attached to Breakpoints generated from Ticks The breakpoint information stored in ModBreaks is generated during
• GHC.HsToCore.Coverage
• GHC.HsToCore.DocsExtract docs from the renamer output so they can be serialized.
• GHC.HsToCore.Errors.Ppr
• GHC.HsToCore.Errors.Types
• GHC.HsToCore.Expr
• GHC.HsToCore.Foreign.CHandling of C foreign imports/exports
• GHC.HsToCore.Foreign.Call
• GHC.HsToCore.Foreign.DeclDesugaring foreign declarations
• GHC.HsToCore.Foreign.JavaScriptHandling of JavaScript foreign imports/exports
• GHC.HsToCore.Foreign.PrimForeign primitive calls This is for `foreign import prim' declarations. Currently, at the core level we pretend that these primitive call…
• GHC.HsToCore.Foreign.Utils
• GHC.HsToCore.Foreign.Wasm
• GHC.HsToCore.GuardedRHSs
• GHC.HsToCore.ListComp
• GHC.HsToCore.Match
• GHC.HsToCore.Match.Constructor
• GHC.HsToCore.Match.Literal
• GHC.HsToCore.Monad
• GHC.HsToCore.PmcThis module coverage checks pattern matches. It finds Uncovered patterns, certifying non-exhaustivity Redundant equations Equations wit…
• GHC.HsToCore.Pmc.CheckCoverage checking step of the
• GHC.HsToCore.Pmc.DesugarDesugaring step of the
• GHC.HsToCore.Pmc.PprProvides facilities for pretty-printing Nablas in a way appropriate for
• GHC.HsToCore.Pmc.SolverModel refinements type as per the
• GHC.HsToCore.Pmc.Solver.TypesDomain types used in GHC.HsToCore.Pmc.Solver.
• GHC.HsToCore.Pmc.TypesTypes used through-out pattern match checking. This module is mostly there
• GHC.HsToCore.Pmc.UtilsUtility module for the pattern-match coverage checker.
• GHC.HsToCore.Quote
• GHC.HsToCore.Ticks
• GHC.HsToCore.TypesVarious types used during desugaring.
• GHC.HsToCore.Usage
• GHC.HsToCore.UtilsUtility functions for constructing Core syntax, principally for desugaring
• GHC.Iface.BinaryBinary interface file support.
• GHC.Iface.DeclModule for constructing interface declaration values
• GHC.Iface.Env
• GHC.Iface.Errors
• GHC.Iface.Errors.Ppr
• GHC.Iface.Errors.Types
• GHC.Iface.Ext.Ast
• GHC.Iface.Ext.Binary
• GHC.Iface.Ext.Debug
• GHC.Iface.Ext.Fields
• GHC.Iface.Ext.Types
• GHC.Iface.Ext.Utils
• GHC.Iface.FlagsDatatype definitions for the flag representation stored in interface files
• GHC.Iface.LoadLoading interface files
• GHC.Iface.MakeModule for constructing ModIface values (interface files),
• GHC.Iface.RecompModule for detecting if recompilation is required
• GHC.Iface.Recomp.BinaryComputing fingerprints of values serializable with GHC's "Binary" module.
• GHC.Iface.Recomp.FlagsThis module manages storing the various GHC option flags in a modules
• GHC.Iface.Recomp.Types
• GHC.Iface.RenameThis module implements interface renaming, which is
• GHC.Iface.Syntax
• GHC.Iface.TidyTidying up Core This module's purpose is to prepare the Core program for two distinct purposes:
• GHC.Iface.Tidy.StaticPtrTableCode generation for the Static Pointer Table (c) 2014 I/O Tweag Each module that uses static keyword declares an initialization function of
• GHC.Iface.Type
• GHC.Iface.Warnings
• GHC.IfaceToCore
• GHC.JS.IdentDomain and Purpose GHC.JS.Ident defines identifiers for the JS backend. We keep this module
• GHC.JS.JStg.MonadDomain and Purpose GHC.JS.JStg.Monad defines the computational environment for the eDSL that
• GHC.JS.JStg.SyntaxDomain and Purpose GHC.JS.JStg.Syntax defines the eDSL that the JS backend's runtime system
• GHC.JS.MakeDomain and Purpose GHC.JS.Make defines helper functions to ease the creation of JavaScript
• GHC.JS.Opt.ExprThis module contains a simple expression optimizer that performs constant
• GHC.JS.Opt.SimpleSimple optimizer for the JavaScript IR This is a simple optimizer for the JavaScript IR. It is intended to be
• GHC.JS.OptimizerDomain and Purpose GHC.JS.Optimizer is a shallow embedding of a peephole optimizer. That is,
• GHC.JS.PprDomain and Purpose GHC.JS.Ppr defines the code generation facilities for the JavaScript
• GHC.JS.SyntaxDomain and Purpose GHC.JS.Syntax defines the Syntax for the JS backend in GHC. It comports
• GHC.JS.Transform
• GHC.Linker.ByteCode
• GHC.Linker.ConfigLinker configuration
• GHC.Linker.Deps
• GHC.Linker.DynamicDynamic linker
• GHC.Linker.ExecutableLinking executables
• GHC.Linker.ExternalExternal ("system") linker
• GHC.Linker.LoaderThe loader This module deals with the top-level issues of dynamic linking (loading),
• GHC.Linker.MacOS
• GHC.Linker.Static
• GHC.Linker.Static.Utils
• GHC.Linker.Types
• GHC.Linker.UnitLinking Haskell units
• GHC.Linker.Windows
• GHC.LlvmThis module supplies bindings to generate Llvm IR from Haskell
• GHC.Llvm.MetaData
• GHC.Llvm.PprPretty print LLVM IR Code.
• GHC.Llvm.SyntaxThe LLVM abstract syntax.
• GHC.Llvm.TypesThe LLVM Type System.
• GHC.ParserThis module provides the generated Happy parser for Haskell. It exports
• GHC.Parser.Annotation
• GHC.Parser.CharClass
• GHC.Parser.Errors.Basic
• GHC.Parser.Errors.Ppr
• GHC.Parser.Errors.Types
• GHC.Parser.HaddockLex
• GHC.Parser.HeaderParsing the top of a Haskell source file to get its module name,
• GHC.Parser.Lexer
• GHC.Parser.Lexer.InterfaceThis module defines the types and functions necessary for an Alex-generated
• GHC.Parser.Lexer.StringThis module defines lex states for strings. This needs to be separate from the normal lexer because the normal lexer
• GHC.Parser.PostProcess
• GHC.Parser.PostProcess.HaddockThis module implements addHaddockToModule, which inserts Haddock
• GHC.Parser.String
• GHC.Parser.Types
• GHC.Parser.Utils
• GHC.PlatformPlatform description
• GHC.Platform.AArch64
• GHC.Platform.ARM
• GHC.Platform.Constants
• GHC.Platform.LA64
• GHC.Platform.NoRegs
• GHC.Platform.PPC
• GHC.Platform.ProfilePlatform profiles
• GHC.Platform.RISCV64
• GHC.Platform.RegAn architecture independent description of a register.
• GHC.Platform.Reg.Class
• GHC.Platform.Reg.Class.NoVectorsRegister classes for architectures which don't have any vector registers.
• GHC.Platform.Reg.Class.SeparateRegister classes for architectures which have registers
• GHC.Platform.Reg.Class.UnifiedRegister classes for architectures which don't have separate registers
• GHC.Platform.Regs
• GHC.Platform.S390X
• GHC.Platform.TagDynamic pointer tagging See Note [Data constructor dynamic tags]
• GHC.Platform.Wasm32
• GHC.Platform.WaysWays The central concept of a "way" is that all objects in a given
• GHC.Platform.X86
• GHC.Platform.X86_64
• GHC.PluginsThis module is not used by GHC itself. Rather, it exports all of
• GHC.Rename.Bind
• GHC.Rename.Doc
• GHC.Rename.Env
• GHC.Rename.Expr
• GHC.Rename.Fixity
• GHC.Rename.HsType
• GHC.Rename.Lit
• GHC.Rename.Module
• GHC.Rename.Names
• GHC.Rename.Pat
• GHC.Rename.Splice
• GHC.Rename.Unbound
• GHC.Rename.Utils
• GHC.Runtime.Context
• GHC.Runtime.Debugger
• GHC.Runtime.Debugger.BreakpointsGHC API debugger module for finding and setting breakpoints. This module is user facing and is at least used by GHCi and `ghc-debugger`
• GHC.Runtime.Eval
• GHC.Runtime.Eval.Types
• GHC.Runtime.Eval.Utils
• GHC.Runtime.Heap.Inspect
• GHC.Runtime.Heap.Layout
• GHC.Runtime.InterpreterInteracting with the iserv interpreter, whether it is running on an
• GHC.Runtime.Interpreter.CExternal interpreter program
• GHC.Runtime.Interpreter.Init
• GHC.Runtime.Interpreter.JSJavaScript interpreter See Note [The JS interpreter]
• GHC.Runtime.Interpreter.Process
• GHC.Runtime.Interpreter.TypesTypes used by the runtime interpreter
• GHC.Runtime.Interpreter.Types.SymbolCacheThe SymbolCache is used to cache lookups for specific symbols when using
• GHC.Runtime.Interpreter.Wasm
• GHC.Runtime.LoaderDynamically lookup up values from modules and loading them.
• GHC.Runtime.Utils
• GHC.SettingsRun-time settings
• GHC.Settings.Config
• GHC.Settings.ConstantsCompile-time settings
• GHC.Settings.IO
• GHC.Stg.BcPrepPrepare the STG for bytecode generation: Ensure that all breakpoints are directly under
• GHC.Stg.CSENote [CSE for Stg]
• GHC.Stg.Debug
• GHC.Stg.Debug.Types
• GHC.Stg.EnforceEpt
• GHC.Stg.EnforceEpt.Rewrite
• GHC.Stg.EnforceEpt.TagSig
• GHC.Stg.EnforceEpt.Types
• GHC.Stg.FVsNon-global free variable analysis on STG terms. This pass annotates
• GHC.Stg.LiftImplements a selective lambda lifter, running late in the optimisation
• GHC.Stg.Lift.AnalysisProvides the heuristics for when it's beneficial to lambda lift bindings.
• GHC.Stg.Lift.ConfigConfiguration options for Lift the lambda lifter.
• GHC.Stg.Lift.MonadHides away distracting bookkeeping while lambda lifting into a LiftM
• GHC.Stg.Lift.Types
• GHC.Stg.Lint(c) The GRASP/AQUA Project, Glasgow University, 1993-1998 A lint pass to check basic STG invariants: Variables should be defined before u…
• GHC.Stg.Make
• GHC.Stg.Pipeline
• GHC.Stg.Stats
• GHC.Stg.Subst
• GHC.Stg.Syntax
• GHC.Stg.Unarise
• GHC.Stg.Utils
• GHC.StgToByteCodeGHC.StgToByteCode: Generate bytecode from STG
• GHC.StgToCmm
• GHC.StgToCmm.ArgRep
• GHC.StgToCmm.Bind
• GHC.StgToCmm.CgUtils
• GHC.StgToCmm.Closure
• GHC.StgToCmm.ConfigThe stg to cmm code generator configuration
• GHC.StgToCmm.DataCon
• GHC.StgToCmm.Env
• GHC.StgToCmm.Expr
• GHC.StgToCmm.ExtCodeOur extended FCode monad.
• GHC.StgToCmm.Foreign
• GHC.StgToCmm.Heap
• GHC.StgToCmm.Hpc
• GHC.StgToCmm.InfoTableProv
• GHC.StgToCmm.Layout
• GHC.StgToCmm.Lit
• GHC.StgToCmm.Monad
• GHC.StgToCmm.Prim
• GHC.StgToCmm.Prof
• GHC.StgToCmm.Sequel
• GHC.StgToCmm.TagCheck
• GHC.StgToCmm.Ticky
• GHC.StgToCmm.Types
• GHC.StgToCmm.Utils
• GHC.StgToJS
• GHC.StgToJS.ApplyModule that deals with expression application in JavaScript. In some cases we
• GHC.StgToJS.ArgCode generation of application arguments
• GHC.StgToJS.Closure
• GHC.StgToJS.CodeGenJavaScript code generator
• GHC.StgToJS.DataConCode generation of data constructors
• GHC.StgToJS.DepsModule to calculate the transitive dependencies of a module
• GHC.StgToJS.ExprCode generation of Expressions
• GHC.StgToJS.ExprCtx
• GHC.StgToJS.FFI
• GHC.StgToJS.Heap
• GHC.StgToJS.IdsModule to deal with JS identifiers
• GHC.StgToJS.Linker.LinkerGHCJS linker, collects dependencies from the object files
• GHC.StgToJS.Linker.OptOptimization pass at link time
• GHC.StgToJS.Linker.Types
• GHC.StgToJS.Linker.UtilsVarious utilies used in the JS Linker
• GHC.StgToJS.Literal
• GHC.StgToJS.MonadJS codegen state monad
• GHC.StgToJS.ObjectSerialization/deserialization of binary .o files for the JavaScript backend
• GHC.StgToJS.Prim
• GHC.StgToJS.Profiling
• GHC.StgToJS.Regs
• GHC.StgToJS.Rts.RtsTop level driver of the JavaScript Backend RTS. This file is an
• GHC.StgToJS.Rts.TypesTypes and utility functions used in the JS RTS.
• GHC.StgToJS.Sinker.Collect
• GHC.StgToJS.Sinker.Sinker
• GHC.StgToJS.Sinker.StringsUnfloat
• GHC.StgToJS.StackUtilities and wrappers for Stack manipulation in JS Land. In general, functions suffixed with a tick do the actual work, functions
• GHC.StgToJS.StaticPtr
• GHC.StgToJS.SymbolsJS symbol generation
• GHC.StgToJS.TypesModule that holds the Types required for the StgToJS pass
• GHC.StgToJS.Utils
• GHC.SysTools
• GHC.SysTools.Ar
• GHC.SysTools.BaseDir
• GHC.SysTools.Cpp
• GHC.SysTools.Elf
• GHC.SysTools.Process
• GHC.SysTools.Tasks
• GHC.SysTools.Terminal
• GHC.Tc.DerivHandles deriving clauses on data declarations.
• GHC.Tc.Deriv.FunctorThe deriving code for the Functor, Foldable, and Traversable classes
• GHC.Tc.Deriv.GenerateGenerating derived instance declarations This module is nominally `subordinate' to GHC.Tc.Deriv, which is the
• GHC.Tc.Deriv.GenericsThe deriving code for the Generic class
• GHC.Tc.Deriv.InferFunctions for inferring (and simplifying) the context for derived instances.
• GHC.Tc.Deriv.UtilsError-checking and other utilities for deriving clauses or declarations.
• GHC.Tc.Errors
• GHC.Tc.Errors.Hole
• GHC.Tc.Errors.Hole.FitTypes
• GHC.Tc.Errors.Hole.Plugin
• GHC.Tc.Errors.Ppr
• GHC.Tc.Errors.Types
• GHC.Tc.Errors.Types.PromotionErr
• GHC.Tc.Gen.AnnotationTypechecking annotations
• GHC.Tc.Gen.App
• GHC.Tc.Gen.ArrowTypecheck arrow notation
• GHC.Tc.Gen.Bind
• GHC.Tc.Gen.DefaultTypechecking default declarations
• GHC.Tc.Gen.DoExpand Do block statements into (>>=), (>>) and lets
• GHC.Tc.Gen.Expand
• GHC.Tc.Gen.Export
• GHC.Tc.Gen.Expr
• GHC.Tc.Gen.ForeignTypechecking foreign declarations A foreign declaration is used to either give an externally
• GHC.Tc.Gen.Head
• GHC.Tc.Gen.HsTypeTypechecking user-specified MonoTypes
• GHC.Tc.Gen.MatchTypecheck some Matches
• GHC.Tc.Gen.PatTypechecking patterns
• GHC.Tc.Gen.Sig
• GHC.Tc.Gen.SpliceTemplate Haskell splices
• GHC.Tc.Instance.Class
• GHC.Tc.Instance.FamilyThe FamInst type: family instance heads
• GHC.Tc.Instance.FunDepsFunctional dependencies It's better to read it as: "if we know these, then we're going to know these"
• GHC.Tc.Instance.Typeable
• GHC.Tc.ModuleTypechecking a whole module https://gitlab.haskell.org/ghc/ghc/wikis/commentary/compiler/type-checker
• GHC.Tc.PluginThis module provides an interface for typechecker plugins to
• GHC.Tc.Solver
• GHC.Tc.Solver.Default
• GHC.Tc.Solver.DictSolving Class constraints CDictCan
• GHC.Tc.Solver.Equality
• GHC.Tc.Solver.FunDepsSolving Class constraints CDictCan
• GHC.Tc.Solver.InertSet
• GHC.Tc.Solver.Irred
• GHC.Tc.Solver.MonadMonadic definitions for the constraint solver
• GHC.Tc.Solver.Rewrite
• GHC.Tc.Solver.Solve
• GHC.Tc.Solver.TypesUtility types used within the constraint solver
• GHC.Tc.TyClTypecheck type and class declarations
• GHC.Tc.TyCl.Build
• GHC.Tc.TyCl.ClassTypechecking class declarations
• GHC.Tc.TyCl.InstanceTypechecking instance declarations
• GHC.Tc.TyCl.PatSynTypechecking pattern synonym declarations
• GHC.Tc.TyCl.UtilsAnalysis functions over data types. Specifically, detecting recursive types. This stuff is only used for source-code decls; it's recorded…
• GHC.Tc.TypesVarious types used during typechecking. Please see GHC.Tc.Utils.Monad as well for operations on these types. You probably
• GHC.Tc.Types.BasicTypes
• GHC.Tc.Types.ConstraintThis module defines types and simple operations over constraints, as used
• GHC.Tc.Types.CtLoc
• GHC.Tc.Types.ErrCtxt
• GHC.Tc.Types.Evidence
• GHC.Tc.Types.LclEnv
• GHC.Tc.Types.OriginDescribes the provenance of types as they flow through the type-checker.
• GHC.Tc.Types.Rank
• GHC.Tc.Types.TH
• GHC.Tc.Types.TcRef
• GHC.Tc.Utils.Backpack
• GHC.Tc.Utils.ConcreteChecking for representation-polymorphism using the Concrete mechanism. This module contains the logic for enforcing the representation-po…
• GHC.Tc.Utils.Env
• GHC.Tc.Utils.Instantiate
• GHC.Tc.Utils.MonadFunctions for working with the typechecker environment (setters,
• GHC.Tc.Utils.TcMTypeMonadic type operations This module contains monadic operations over types that contain mutable type
• GHC.Tc.Utils.TcTypeTypes used in the typechecker This module provides the Type interface for front-end parts of the
• GHC.Tc.Utils.UnifyType subsumption and unification
• GHC.Tc.Validity
• GHC.Tc.Zonk.EnvThe ZonkEnv zonking environment, and the ZonkT and ZonkBndrT
• GHC.Tc.Zonk.MonadThe ZonkM monad, a stripped down TcM, used when zonking within
• GHC.Tc.Zonk.TcTypeZonking types within the typechecker. Distinct from the final zonking pass in GHC.Tc.Zonk.Type;
• GHC.Tc.Zonk.TypeFinal zonking to Type. See Note [Zonking to Type]. Distinct from the intra-typechecker zonking in GHC.Tc.Zonk.TcType;
• GHC.ThToHs
• GHC.Types.AnnotationsSupport for source code annotation feature of GHC. That is the ANN pragma. (c) The University of Glasgow 2006
• GHC.Types.Arity
• GHC.Types.Avail
• GHC.Types.Basic
• GHC.Types.CompleteMatchCOMPLETE signature
• GHC.Types.CostCentre
• GHC.Types.CostCentre.State
• GHC.Types.CprTypes for the Constructed Product Result lattice.
• GHC.Types.DefaultEnv
• GHC.Types.DemandA language to express the evaluation context of an expression as a
• GHC.Types.Error
• GHC.Types.Error.CodesDefines diagnostic codes for the diagnostics emitted by GHC. A diagnostic code is a numeric unique identifier for a diagnostic.
• GHC.Types.FieldLabel
• GHC.Types.FixityFixity
• GHC.Types.Fixity.Env
• GHC.Types.ForeignCall
• GHC.Types.ForeignStubsForeign export stubs
• GHC.Types.GREInfoRenamer-level information about Names. Renamer equivalent of TyThing.
• GHC.Types.Hint
• GHC.Types.Hint.Ppr
• GHC.Types.HpcInfoHaskell Program Coverage (HPC) support
• GHC.Types.IPE
• GHC.Types.Id
• GHC.Types.Id.Info
• GHC.Types.Id.Make
• GHC.Types.InlinePragma
• GHC.Types.LiteralCore literals
• GHC.Types.Literal.Floating
• GHC.Types.MetaMetaprogramming types
• GHC.Types.Name
• GHC.Types.Name.CacheThe Name Cache
• GHC.Types.Name.Env
• GHC.Types.Name.Occurrence
• GHC.Types.Name.Ppr
• GHC.Types.Name.Reader
• GHC.Types.Name.Set
• GHC.Types.Name.Shape
• GHC.Types.PkgQual
• GHC.Types.ProfAuto
• GHC.Types.RepType
• GHC.Types.SafeHaskellThis stuff here is related to supporting the Safe Haskell extension,
• GHC.Types.SaneDoubleDouble datatype with saner instances
• GHC.Types.SourceErrorSource errors
• GHC.Types.SourceFile
• GHC.Types.SourceTextSource text Keeping Source Text for source to source conversions
• GHC.Types.SptEntry
• GHC.Types.SrcLocThis module contains types that relate to the positions of things
• GHC.Types.Target
• GHC.Types.ThLevelIndex
• GHC.Types.Tickish
• GHC.Types.TyThingA global typecheckable-thing, essentially anything that has a name.
• GHC.Types.TyThing.Ppr
• GHC.Types.TypeEnv
• GHC.Types.Unique
• GHC.Types.Unique.DFM
• GHC.Types.Unique.DSM
• GHC.Types.Unique.DSetSpecialised deterministic sets, for things with Uniques Based on UniqDFMs (as you would expect).
• GHC.Types.Unique.FM
• GHC.Types.Unique.Map
• GHC.Types.Unique.MemoFun
• GHC.Types.Unique.SDFMLike a UniqDFM, but maintains equivalence classes of keys sharing the
• GHC.Types.Unique.Set
• GHC.Types.Unique.Supply
• GHC.Types.Var
• GHC.Types.Var.Env
• GHC.Types.Var.FVUtilities for efficiently and deterministically computing free variables.
• GHC.Types.Var.Set
• GHC.UnitUnits are library components from Cabal packages compiled and installed in
• GHC.Unit.EnvA UnitEnv provides the complete interface into everything that is loaded
• GHC.Unit.External
• GHC.Unit.External.Database
• GHC.Unit.External.IndexThe UnitIndex is a UnitEnv wide data structure that shares
• GHC.Unit.External.ModuleOrigin
• GHC.Unit.External.Providers
• GHC.Unit.External.Query
• GHC.Unit.External.Substitution
• GHC.Unit.External.Validate
• GHC.Unit.External.Visibility
• GHC.Unit.External.Wired
• GHC.Unit.FinderModule finder
• GHC.Unit.Finder.Types
• GHC.Unit.HomeThe home unit is the unit (i.e. compiled package) that contains the module
• GHC.Unit.Home.GraphA HomeUnitGraph (HUG) collects information about all the home units.
• GHC.Unit.Home.ModInfoInfo about modules in the "home" unit.
• GHC.Unit.Home.PackageTableThe HomePackageTable (HPT) contains information about all modules that are part
• GHC.Unit.InfoInfo about installed units (compiled libraries)
• GHC.Unit.Module
• GHC.Unit.Module.DepsDependencies and Usage of a module
• GHC.Unit.Module.EnvModule environment
• GHC.Unit.Module.GraphA module graph should be constructed once and never change from there onwards. The only operations should be for building the ModuleGraph
• GHC.Unit.Module.Imported
• GHC.Unit.Module.LocationModule location
• GHC.Unit.Module.ModDetails
• GHC.Unit.Module.ModGuts
• GHC.Unit.Module.ModIface
• GHC.Unit.Module.ModNodeKey
• GHC.Unit.Module.ModSummaryA ModSummary is a node in the compilation manager's dependency graph
• GHC.Unit.Module.Stage
• GHC.Unit.Module.Status
• GHC.Unit.Module.WarningsWarnings for a module
• GHC.Unit.Module.WholeCoreBindings
• GHC.Unit.ParserParsers for unit/module identifiers
• GHC.Unit.PprUnit identifier pretty-printing
• GHC.Unit.StateUnit manipulation
• GHC.Unit.TypesUnit & Module types This module is used to resolve the loops between Unit and Module types
• GHC.Utils.AsmVarious utilities used in generating assembler. These are used not only by the native code generator, but also by the
• GHC.Utils.Binary
• GHC.Utils.Binary.TypeableOrphan Binary instances for Data.Typeable stuff
• GHC.Utils.BufHandle
• GHC.Utils.CliOption
• GHC.Utils.Constants
• GHC.Utils.EndoOSOne-shot endomorphisms
• GHC.Utils.Error
• GHC.Utils.Exception
• GHC.Utils.Fingerprint
• GHC.Utils.GlobalVarsDo not use global variables! Global variables are a hack. Do not use them if you can help it.
• GHC.Utils.IO.Unsafe
• GHC.Utils.Json
• GHC.Utils.Lexeme
• GHC.Utils.LoggerLogger The Logger is an configurable entity that is used by the compiler to output
• GHC.Utils.MiscHighly random utility functions
• GHC.Utils.MonadUtilities related to Monad and Applicative classes
• GHC.Utils.Monad.Codensity
• GHC.Utils.Monad.State.StrictA state monad which is strict in its state.
• GHC.Utils.OutputableThis module defines classes and functions for pretty-printing. It also
• GHC.Utils.PanicDefines basic functions for printing error messages. It's hard to put these functions anywhere else without causing
• GHC.Utils.Panic.PlainDefines a simple exception type and utilities to throw it. The
• GHC.Utils.PprJohn Hughes's and Simon Peyton Jones's Pretty Printer Combinators Based on The Design of a Pretty-printing Library
• GHC.Utils.Ppr.Colour
• GHC.Utils.TmpFsTemporary file-system management
• GHC.Utils.Touch
• GHC.Utils.TraceTracing utilities
• GHC.Utils.Unique
• GHC.Utils.Word64
• GHC.Wasm.ControlFlow
• GHC.Wasm.ControlFlow.FromCmm
• Language.Haskell.Syntax
• Language.Haskell.Syntax.Basic
• Language.Haskell.Syntax.Binds
• Language.Haskell.Syntax.Binds.InlinePragma
• Language.Haskell.Syntax.BooleanFormula
• Language.Haskell.Syntax.DeclsAbstract syntax of global declarations. Definitions for: SynDecl and ConDecl, ClassDecl,
• Language.Haskell.Syntax.Decls.ForeignAbstract syntax of foreign function interface declarations.
• Language.Haskell.Syntax.Decls.OverlapData-type describing the overlap annotations for instances.
• Language.Haskell.Syntax.ExprAbstract Haskell syntax for expressions.
• Language.Haskell.Syntax.Extension
• Language.Haskell.Syntax.ImpExp
• Language.Haskell.Syntax.ImpExp.IsBoot
• Language.Haskell.Syntax.LitSource-language literals
• Language.Haskell.Syntax.Module.Name
• Language.Haskell.Syntax.Pat
• Language.Haskell.Syntax.Specificity
• Language.Haskell.Syntax.Type

• array-0.5.8.0with GHC
• base-4.23.0.0with GHC
• binary-0.8.9.3with GHC
• bytestring-0.12.2.0with GHC
• containers-0.8with GHC
• deepseq-1.5.2.0with GHC
• directory-1.3.11.0with GHC
• exceptions-0.10.12with GHC
• filepath-1.5.5.0with GHC
• ghc-boot-10.0.0.20260917with GHC
• ghc-boot-th-10.0.0.20260917with GHC
• ghc-heap-10.0.0.20260917with GHC
• ghc-internal-10.0.0with GHC
• ghc-toolchain-0.1.0.0with GHC
• ghci-10.0.0.20260917with GHC
• hpc-0.7.0.2with GHC
• os-string-2.0.11with GHC
• process-1.6.30.0with GHC
• semaphore-compat-2.0.1with GHC
• stm-2.5.3.1with GHC
• text-2.1.4with GHC
• time-1.16.0.1with GHC
• transformers-0.6.3.0with GHC
• unix-2.8.8.0with GHC

Used by in this set · 9

• doctest-0.25.0.2
• ghc-tcplugins-extra-0.5
• haddock-api-2.34.0
• hint-0.9.0.9
• inspection-testing-0.6.3
• polysemy-plugin-0.4.5.3
• tasty-inspection-testing-0.2.1
• vortex-elab-0.2.2
• werrorwolf-plugin-0.2.0.0