h$b      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z{|} ~       !!!!!!!!"""""""""""""""""""""""""""""""###########################################$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%&''''''''''''((((((((((((((((((((((((((((((((((((((())))))))))))))))))))))***++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,---.........................../////////////////////////////////////////////////////////////////////////////////////////////////000000000000000000000000000000000000111111111111112222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222333333333333333333333333333344444444444444444444444444444444555566777777777777777777777777777777777777777777 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9                  : : : : : : : : : : : : : : : : ; ; < < < < < < = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = > ? @ @ A A A A A A A A A A A A A A A A B B B B B B B B B B B B B B B B B B B C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C D D D D D D D D D D D D D D D D D D D D D D D D D D D E E E E E E E F F F F F F F F F F F F 1 1 1 1 1 1 1 1 1 1 1 1 1 1 111111111111111111111111GGGGGGGGGGGGGGGGGGGGGGGGGHHHHIJJKKKKKKKLMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNOPQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTU@@@@@@@@@@@@@@@@@@@@@@@@@@@@@VVVVVVVVVVWWWWWWWXXXXXXXXXXXXYYYYYYYYYNone8'UVWXYVWUXY None>'\Cabal2Applying module substitutions to semantic objects.\]\]ZNone567+ CabalAn 4, annotated with where it came from in a Cabal file.CabalDescription of where a module participating in mixin linking came from.CabalINVARIANT: entries for ModuleName m, have msrc_module is OpenModuleVar mCabalEvery Module in scope at a  is annotated with the  it comes from.CabalA  describes the modules and requirements that are in-scope as we are processing a Cabal package. Unlike a  ModuleShape6, there may be multiple modules in scope at the same ; this is only an error if we attempt to use those modules to fill a requirement. A  can influence the  ModuleShape via a reexport.Cabal An empty . None38,dCabalA d describes the provisions and requirements of a library. We can extract a d from an .hCabalThe default module shape, with no provisions and no requirements.defghidefghi[None.sCabalStripped down version of LinkedComponent0 for things we don't need to know how to build.Cabal7The actual name of the package. This may DISAGREE with pc_pkgid9 for internal dependencies: e.g., an internal component lib may be munged to  z-pkg-z-lib+, but we still want to use it when we see lib in  build-dependsCabal!The actual name of the component.Cabal Convert an  into a *, which was brought into scope under the 0 (important for a package qualified reference.)  None38.pqrstuvpqrstuv\None36CabalThe exception thrown by  to terminate a thread.CabalAsync, but based on , as we don't depend on stm.Cabal Returns the " of the thread running the given .CabalSpawn an asynchronous action in a separate thread, and pass its Async handle to the supplied function. When the function returns or throws an exception,  is called on the Async. withAsync action inner = mask $ \restore -> do a <- async (restore action) restore (inner a) `finally` uninterruptibleCancel aThis is a useful variant of async that ensures an Async( is never left running unintentionally.Note: a reference to the child thread is kept alive until the call to  returns, so nesting many  calls requires linear memory.CabalWait for an asynchronous action to complete, and return its value. If the asynchronous action threw an exception, then the exception is re-thrown by . wait = atomically . waitSTMCabalWait for an asynchronous action to complete, and return either Left e# if the action raised an exception e, or Right a if it returned a value a. %waitCatch = atomically . waitCatchSTMCabal.Cancel an asynchronous action by throwing the AsyncCancelled' exception to it, and waiting for the ' thread to quit. Has no effect if the  has already completed. cancel a = throwTo (asyncThreadId a) AsyncCancelled <* waitCatch a Note that ) will not terminate until the thread the , refers to has terminated. This means that  will block for as long said thread blocks when receiving an asynchronous exception.For example, it could block if:It's executing a foreign call, and thus cannot receive the asynchronous exception;It's executing some cleanup handler after having received the exception, and the handler is blocking.CabalCancel an asynchronous actionThis is a variant of , but it is not interruptible.  Safe-Inferred70TT Safe-Inferred7YOPQPQO Safe-Inferred7RSSR]cabal-devel@haskell.org Windows-only Safe-Inferred7^ Safe-Inferred8z_ Safe-Inferred9Cabal:Copies a file to a new destination. Often you should use  instead.CabalLike , but does not touch the target if source and destination are already byte-identical. This is recommended as it is useful for time-stamp based recompilation avoidance.CabalChecks if two files are byte-identical. Returns False if either of the files do not exist or if files are of different size.{|` Safe-Inferred: IK  Safe-InferredB,}CabalEnable process jobs to ensure accurate determination of process completion in the presence of exec(3) on Windows.9Unfortunately the process job support is badly broken in process releases prior to 1.6.9, so we disable it in these versions, despite the fact that this means we may see sporadic build failures without jobs.On Windows 7 or before the jobs are disabled due to the fact that processes on these systems can only have one job. This prevents spawned process from assigning jobs to its own children. Suppose process A spawns process B. The B process has a job assigned (call it J1) and when it tries to spawn a new process C the C automatically inherits the job. But at it also tries to assign a new job J2 to C since it doesn@t have access J1. This fails on Windows 7 or before.~Cabalab2 with process jobs enabled when appropriate. See }.Cabalac2 with process jobs enabled when appropriate. See }.Cabalad2 with process jobs enabled when appropriate. See }.Cabal Filename of the executable (see  RawCommand for details)Cabal#Arguments to pass to the executableCabal&Optional path to the working directoryCabal(Optional environment (otherwise inherit)}~~}  Safe-Inferred?BbeBSD3cabal-dev@haskell.org experimentalportable Safe-InferredB Safe-InferredECabalGive the *parent* of the person who invoked this; so it's most suitable for being called from a utility function. You probably want to call this using L; otherwise it's not very useful. We didn't implement this for base-4.8.1 because we cannot rely on freezing to have taken place.CabalThis function is for when you *really* want to add a call stack to raised IO, but you don't have a #f so you can't use g. If you have a  Verbosity$, please use that function instead.LMNLMNh Safe-Inferred?F CabalsetEnv name value, sets the specified environment variable to value.Throws ij if either name or value1 is the empty string or contains an equals sign.k(c) Sven Panne 2002-2005/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgportable Safe-Inferred%Ke CabalDescribes whether an option takes an argument or not, and if so how the argument is parsed to a value of type a.=Compared to System.Console.GetOpt, we allow for parse errors.Cabalno argument expectedCabaloption requires argumentCabaloptional argumentCabal-What to do with options following non-optionsCabal+no option processing after first non-optionCabal*freely intersperse options and non-optionsCabalReturn a string describing the usage of a command, derived from the header (first argument) and the options described by the second argument.CabalProcess the command-line, and return the list of values that matched (and those that didn't). The arguments are:The order requirements (see )The option descriptions (see )9The actual command line arguments (presumably got from lm). returns a triple consisting of the option arguments, a list of non-options, and a list of error messages.CabalThis is almost the same as , but returns a quadruple consisting of the option arguments, a list of non-options, a list of unrecognized options, and a list of error messages. nBen Gamari 2015-2019cabal-devel@haskell.orgportable Safe-InferredKJose Iborra 2008BSD3cabal-devel@haskell.orgportable Safe-InferredLkCabal"Parser with simple error reportingNoneTCabalDesugar a "build-tools" entry into proper a executable dependency if possible.*An entry can be so desugared in two cases: The name in build-tools matches a locally defined executable. The executable dependency produced is on that exe in the current package.The name in build-tools matches a hard-coded set of known tools. For now, the executable dependency produced is one an executable in a package of the same, but the hard-coding could just as well be per-key.The first cases matches first.CabalGet everything from "build-tool-depends", along with entries from "build-tools" that we know how to desugar.This should almost always be used instead of just accessing the  field directly.CabalDoes the given executable dependency map to this current package?8This is a tiny function, but used in a number of places.'This function is only sound to call on s from the given package description. This is because it just filters the package names of each dependency, and does not check whether version bounds in fact exclude the current package, or the referenced components in fact exist in the current package.This is OK because when a package is loaded, it is checked (in op) that dependencies matching internal components do indeed have version bounds accepting the current package, and any depended-on component in the current package actually exists. In fact this check is performed by gathering the internal tool dependencies of each component of the package according to this module, and ensuring those properties on each so-gathered dependency.version bounds and components of the package are unchecked. This is because we sanitize exe deps so that the matching name implies these other conditions.CabalGet internal "build-tool-depends", along with internal "build-tools"This is a tiny function, but used in a number of places. The same restrictions that apply to  also apply to this function.2011, Dan Knappcabal-devel@haskell.orgportable Safe-InferredWCabalRepresents a dialect of C. The Monoid instance expresses backward compatibility, in the sense that 'mappend a b' is the least inclusive dialect which both a and b! can be correctly interpreted as.CabalA list of all file extensions which are recognized as possibly containing some dialect of C code. Note that this list is only for source files, not for header files.CabalTakes a dialect of C and whether code is intended to be passed through the preprocessor, and returns a filename extension for containing that code.CabalInfers from a filename's extension the dialect of C which it contains, and whether it is intended to be passed through the preprocessor.8Isaac Jones 2003-2004 Duncan Coutts 2007BSD3cabal-devel@haskell.orgportable Safe-Inferred38?ZwCabal#Types that represent boolean flags.Cabal1All flags are monoids, they come in two flavours:  list flags eg !--ghc-option=foo --ghc-option=bar&gives us all the values ["foo", "bar"] singular value flags, eg: --enable-foo --disable-foogives us Just False So this Flag type is for the latter singular kind of flag. Its monoid instance gives us the behaviour where it starts out as ' and later flags override earlier ones.Cabal   Safe-Inferred38_}CabalThe $prefix path variableCabalThe $bindir path variableCabalThe $libdir path variableCabalThe  $libsubdir path variableCabalThe  $dynlibdir path variableCabalThe $datadir path variableCabalThe  $datasubdir path variableCabalThe $docdir path variableCabalThe $htmldir path variableCabalThe $pkg package name path variableCabalThe $version package version path variableCabalThe $pkgid package Id path variable, eg foo-1.0CabalThe $libname path variableCabal"The compiler name and version, eg  ghc-6.6.1CabalThe operating system name, eg windows or linuxCabalThe CPU architecture name, eg i386 or x86_64CabalThe compiler's ABI identifier,Cabal%The optional ABI tag for the compilerCabal+The executable name; used in shell wrappersCabal$The name of the test suite being runCabal,The result of the test suite being run, eg pass, fail, or error.Cabal#The name of the benchmark being runIsaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone358?lz CabalAn abstract path, possibly containing variables that need to be substituted for to get a real .CabalThe location prefix for the copy command.Cabalwhen using the ${pkgroot} as prefix. The CopyToDb will adjust the paths to be relative to the provided package database when copying / installing.Cabal)The installation directories in terms of s that contain variables.The defaults for most of the directories are relative to each other, in particular they are all relative to a single prefix. This makes it convenient for the user to override the default installation directory by only having to specify --prefix=... rather than overriding each individually. This is done by allowing $-style variables in the dirs. These are expanded by textual substitution (see ).A few of these installation directories are split into two components, the dir and subdir. The full installation path is formed by combining the two together with /. The reason for this is compatibility with other Unix build systems which also support --libdir and  --datadir/. We would like users to be able to configure --libdir=/usr/lib64 for example but because by default we want to support installing multiple versions of packages and building the same package for multiple compilers we append the libsubdir to get: /usr/lib64/$libname/$compiler.An additional complication is the need to support relocatable packages on systems which support such things, like Windows.Cabal9The directories where we will install files for packages.We have several different directories for different types of files since many systems have conventions whereby different types of files in a package are installed in different directories. This is particularly the case on Unix style systems.Cabalforeign librariesCabal5Substitute the install dir templates into each other.To prevent cyclic substitutions, only some variables are allowed in particular dir templates. If out of scope vars are present, they are not substituted for. Checking for any remaining unsubstituted vars can be done as a subsequent operation.-The reason it is done this way is so that in  we can replace  with the  and get resulting s that still have the  in them. Doing this makes it each to check which paths are relative to the $prefix.CabalConvert from abstract install directories to actual absolute ones by substituting for all the variables in the abstract paths, to get real absolute path.CabalCheck which of the paths are relative to the installation $prefix.If any of the paths are not relative, ie they are absolute paths, then it prevents us from making a relocatable package (also known as a "prefix independent" package).Cabal Convert a  to a  including any template vars.Cabal7Convert back to a path, any remaining vars are includedCabal=The initial environment has all the static stuff but no paths...cabal-devel@haskell.orgportable Safe-Inferredn{CabalNo unliteration.Cabal takes a filename (for error reports), and transforms the given string, to eliminate the literate comments from the program text.cabal-devel@haskell.orgportable Safe-Inferredp/CabalExtract the version number from the output of 'strip --version'.Invoking "strip --version" gives very inconsistent results. We ignore everything in parentheses (see #2497), look for the first word that starts with a number, and try parsing out the first two components of it. Non-GNU strip' doesn't appear to have a version flag.Thomas Tuegel 2010BSD3cabal-devel@haskell.orgportable Safe-Inferred?tCabalIf true, then children of this group may be run in parallel. Note that this setting is not inherited by children. In particular, consider a group F with "concurrently = False" that has some children, including a group T with "concurrently = True". The children of group T may be run concurrently with each other, as long as none are run at the same time as any of the direct children of group F.CabalA human-readable description of the option to guide the user setting it.CabalPerform the test.Cabal1A name for the test, unique within a test suite.Cabal0Users can select groups of tests by their tags.Cabal5Descriptions of the options recognized by this test.CabalTry to set the named option to the given value. Returns an error message if the option is not supported or the value could not be correctly parsed; otherwise, a 5 with the option set to the given value is returned.CabalCreate a named group of tests, which are assumed to be safe to run in parallel.++Nonev{CabalAn  is a , , etc. which is annotated with some other useful information that is useful for printing to users, etc.Invariant: if ann_id x == ann_id y, then ann_pid x == ann_pid y and ann_cname x == ann_cname yNonew]CabalDid this come from an entry in mixins", or was implicitly generated by  build-depends?CabalThis should always return % or  CSubLibNameNone38N Cabal?The first five fields are common across all algebraic variants.CabalIt would be very convenient to store the literal Library here, but if we do that, it will get serialized (via the Binary) instance twice. So instead we just provide the ComponentName, which can be used to find the Component in the PackageDescription. NB: eventually, this will NOT uniquely identify the ComponentLocalBuildInfo.Cabal The computed  of this component.Cabal The computed = which uniquely identifies this component. Might be hashed.Cabal:Is this an indefinite component (i.e. has unfilled holes)?Cabal"How the component was instantiatedCabalResolved internal and external package dependencies for this component. The  BuildInfo specifies a set of build dependencies that must be satisfied in terms of version ranges. This field fixes those dependencies to the specific versions available on this machine for this compiler.CabalThe set of packages that are brought into scope during compilation, including a  which may used to hide or rename modules. This is what gets translated into  -package-id. arguments. This is a modernized version of ', which is kept around for BC purposes.Cabal7The internal dependencies which induce a graph on the 0 of this package. This does NOT coincide with  because it ALSO records 'build-tool' dependencies on executables. Maybe one day  cabal-install& will also handle these correctly too!CabalCompatibility "package key" that we pass to older versions of GHC.CabalCompatibility "package name" that we register this component as.CabalA list of exposed modules (either defined in this component, or reexported from another component.)CabalConvenience field, specifying whether or not this is the "public library" that has the same name as the package. Safe-Inferred38None38CabalA  represents a library depended on and explicitly specified by the user/client with  --dependencyIt enables Cabal to know which  to associate with a libraryNoneCabalUsed as a placeholder in $Distribution.Backpack.ReadyComponentCabalUsed by cabal new-repl,  cabal new-run and cabal new-buildCabalUsed by  cabal new-run and cabal new-buildCabal with .NoneJCabalThe  contains all the information necessary to build a specific target (e.g., componentmodule4file) in a package. In principle, one can get the  from a  and LocalBuildInfo, but it is much more convenient to have the component in hand. Safe-Inferred'(4CabalCabalCabal Wrapper for Note$: This operation uses lazy I/O. Use  to force all data to be read and consequently the internal file handle to be closed.CabalRepresents either textual or binary data passed via I/O functions which support binary/text modeCabal2How Text gets encoded is usually locale-dependent.Cabal2Raw binary which gets read/written in binary mode.Cabal Test whether  is emptyCabal Wrapper for  and This is the dual operation ot ., and consequently the handle is closed with hClose.Note: this performs lazy-IO.   Safe-Inferred pCabal Convert a  into a  ByteStringCabalA shorthand for building up s >>> JsonObject [ "a" .= JsonNumber 42, "b" .= JsonBool True ] JsonObject [("a",JsonNumber 42),("b",JsonBool True)]    Safe-InferredCabalMonadic variant of  mapAccumL.! Safe-Inferred5.CabalA type to represent the unfolding of an expensive long running calculation that may fail (or maybe not expensive, but complicated!) We may get intermediate steps before the final result which may be used to indicate progress and/or logging messages.TODO: Apply Codensity to avoid left-associativity problem. See  4http://comonad.com/reader/2011/free-monads-for-less/ and http://blog.ezyang.com/2012/01/problem-set-the-codensity-transformation/CabalEmit a step and then continue.CabalFail the computation.Cabal Consume a  calculation. Much like  for lists but with two base cases, one for a final result and one for failure.Eg to convert into a simple  result use: $foldProgress (flip const) Left Rightq Safe-Inferred8CabalA variable which can be unified; alternately, this can be thought of as an equivalence class with a distinguished representative.Cabal2Create a fresh equivalence class with one element.Cabal6Return the canonical element of an equivalence class .CabalUnify two equivalence classes, so that they share a canonical element. Keeps the descriptor of point2.Cabal5Test if two points are in the same equivalence class." Safe-Inferred38{Cabal  #Ian Lynagh 2007BSD3cabal-devel@haskell.orgportable Safe-Inferred38*CabalIn  mode, we should not print anything unless an error occurs.Cabal&Print stuff we want to see by default.Cabal&Be more verbose about what's going on.CabalNot only are we verbose ourselves (perhaps even noisier than when being 3), but we tell everything we run to be verbose too.Cabal#Increase verbosity level, but stay  if we are.Cabal#Decrease verbosity level, but stay  if we are.CabalCombinator for transforming verbosity level while retaining the original hidden state.*For instance, the following property holdsisVerboseNoWrap (modifyVerbosity (max verbose) v) == isVerboseNoWrap vNote: you can use modifyVerbosity (const v1) v0 to overwrite v1's flags with v0 's flags.CabalNumeric verbosity level 0..3: 0 is , 3 is .Cabal/Turn on verbose call-site printing when we log.Cabal0Turn on verbose call-stack printing when we log.CabalTurn on -----BEGIN CABAL OUTPUT----- markers for output from Cabal (as opposed to GHC, or system dependent).CabalTurn off marking; useful for suppressing nondeterministic output.Cabal'Disable line-wrapping for log messages.Cabal$Turn on timestamps for log messages.Cabal%Turn off timestamps for log messages.CabalSwitch logging to stderr.CabalSwitch logging to stdout.Cabal#Turn off warnings for log messages.CabalTurn off all flags.Cabal0Test if we should output call sites when we log.Cabal1Test if we should output call stacks when we log.Cabal!Test if we should output markets.Cabal3Test if line-wrapping is disabled for log messages.CabalTest if we had called  on the verbosity.Cabal0Test if we should output timestamps when we log.CabalTest if we should output to stderr when we log.Cabal.Test if we should output warnings when we log.CabalParser verbosity-explicitEitherParsec parsecVerbosity "normal"Right (Verbosity {vLevel = Normal, vFlags = fromList [], vQuiet = False})6explicitEitherParsec parsecVerbosity "normal+nowrap "Right (Verbosity {vLevel = Normal, vFlags = fromList [VNoWrap], vQuiet = False})explicitEitherParsec parsecVerbosity "normal+nowrap +markoutput"Right (Verbosity {vLevel = Normal, vFlags = fromList [VNoWrap,VMarkOutput], vQuiet = False})explicitEitherParsec parsecVerbosity "normal +nowrap +markoutput"Right (Verbosity {vLevel = Normal, vFlags = fromList [VNoWrap,VMarkOutput], vQuiet = False})?explicitEitherParsec parsecVerbosity "normal+nowrap+markoutput"Right (Verbosity {vLevel = Normal, vFlags = fromList [VNoWrap,VMarkOutput], vQuiet = False})explicitEitherParsec parsecVerbosity "deafening+nowrap+stdout+stderr+callsite+callstack"Right (Verbosity {vLevel = Deafening, vFlags = fromList [VCallStack,VCallSite,VNoWrap,VStderr], vQuiet = False})Note:& this parser will eat trailing spaces.  rNoneXCabalThe mutable counterpart of .CabalThe mutable counterpart of a  ModuleSubst (not defined here).CabalA mutable version of # which can be imperatively unified.CabalA mutable version of # which can be imperatively unified.CabalContents of a mutable  reference.CabalContents of a mutable  reference.CabalThe unification environment.Cabal%A supply of unique integers to label  cells. This is used to determine loops in unit identifiers (which can happen with mutual recursion.)CabalThe set of requirements in scope. When a provision is brought into scope, we unify with the requirement at the same module name to fill it. This mapping grows monotonically.CabalComponent id of the unit we're linking. We use this to detect if we fill a requirement with a local module, which in principle should be OK but is not currently supported by GHC.Cabal'How verbose the error message should beCabalThe error reporting contextCabal0The package index for expanding unit identifiersCabalAccumulated errorsCabalThe unification monad, this monad encapsulates imperative unification.Cabal+Run a computation in the unification monad.CabalLift a computation from  monad to  monad. Internal use only.Cabal(Get the current unification environment.Cabal)Add a fixed message to the error context.CabalAdd a message to the error context. It may make monadic queries.CabalConversion of  ModuleSubst to CabalConversion of  to  ModuleSubstCabal An empty .Cabal Convert a d into a ", so we can do unification on it.Cabal Convert a  to a .Cabal Convert a  to a Cabal Convert a  to a )sNoneCabalGiven to scopes of provisions and requirements, link them together.tNone;+uNone8ivNone8w Safe-Inferred #Isaac Jones, Simon Marlow 2003-2004=BSD3 portions Copyright (c) 2007, Galois Inc.cabal-devel@haskell.orgportableNone '(8?;CabalAdvanced options for  and .CabalKeep temporary files?CabalGiven a block of IO code that may raise an exception, annotate it with the metadata from the current scope. Use this as close to external code that raises IO exceptions as possible, since this function unconditionally wraps the error message with a trace (so it is NOT idempotent.)CabalNon fatal conditions that may be indicative of an error or problem.We display these at the  verbosity level.CabalUseful status messages.We display these at the  verbosity level.This is for the ordinary helpful status messages that users see. Just enough information to know that things are working but not floods of detail.CabalDisplay a message at ( verbosity level, but without wrapping.CabalPretty-print a  status message at : verbosity level. Use this if you need fancy formatting.CabalDisplay a "setup status message". Prefer using setupMessage' if possible.Cabal,More detail on the operation of some action.6We display these messages when the verbosity level is Cabal'Detailed internal debugging information6We display these messages when the verbosity level is Cabal A variant of  that doesn't perform the automatic line wrapping. Produces better output in some cases.CabalPerform an IO action, catching any IO exceptions and printing an error if one occurs.Cabal!Run an IO computation, returning e- if it raises a "file does not exist" error.CabalWrap output with a marker if  +markoutput verbosity flag is set.NB: Why is markoutput done with start/end markers, and not prefixes? Markers are more convenient to add (if we want to add prefixes, we have to  and then ; here's it's just some concatenates). Note that even in the prefix case, we can't guarantee that the markers are unambiguous, because some of Cabal's output comes straight from external programs, where we don't have the ability to interpose on the output.This is used by Cabal$Run a command and return its output.8The output is assumed to be text in the locale encoding.CabalRun a command and return its output, errors and exit status. Optionally also supply some input. Also provides control over whether the binary/text mode of the input and output.Cabal#Ignore SIGPIPE in a subcomputation.CabalLook for a program and try to find it's version number. It can accept either an absolute path or the name of a program binary, in which case we will look for the program on the path.CabalLike the Unix xargs program. Useful for when we've got very long command lines that might overflow an OS limit on command line length and so you need to invoke a command multiple times to get all the args in.Use it with either of the rawSystem variants above. For example: xargs (32*1024) (rawSystemExit verbosity) prog fixedArgs bigArgsCabalFind a file by looking in a search path. The file path must match exactly.CabalFind a file by looking in a search path. The file path must match exactly.CabalFind a file by looking in a search path with one of a list of possible file extensions. The file base name should be given and it will be tried with each of the extensions in each element of the search path.CabalCabalCabalLike  but returns which element of the search path the file was found in, and the file path relative to that base directory.CabalFinds the files corresponding to a list of Haskell module names.As findModuleFile but for a list of module names.Cabal5Find the file corresponding to a Haskell module name.This is similar to  but specialised to a module name. The function fails if the file corresponding to the module is missing.Cabal9List all the files in a directory and all subdirectories.The order places files in sub-directories after all the files in their parent directories. The list is generated lazily so is not well defined if the source directory structure changes before the list is used.Cabal,Is this directory in the system search path?CabalCompare the modification times of two files to see if the first is newer than the second. The first file must exist but the second need not. The expected use case is when the second file is generated using the first. In this use case, if the result is True then the second file is out of date.CabalLike -, but also checks that the first file exists.CabalSame as createDirectoryIfMissing% but logs at higher verbosity levels.CabalCopies a file without copying file permissions. The target file is created with default permissions. Any existing target file is replaced.3At higher verbosity levels it logs an info message.CabalInstall an ordinary file. This is like a file copy but the permissions are set appropriately for an installed file. On Unix it is "-rw-r--r--" while on Windows it uses the default permissions for the target directory.CabalInstall an executable file. This is like a file copy but the permissions are set appropriately for an installed file. On Unix it is "-rwxr-xr-x" while on Windows it uses the default permissions for the target directory.CabalInstall a file that may or not be executable, preserving permissions.CabalGiven a relative path to a file, copy it to the given directory, preserving the relative path and creating the parent directories if needed.CabalCopies a bunch of files to a target directory, preserving the directory structure in the target location. The target directories are created if they do not exist.The files are identified by a pair of base directory and a path relative to that base. It is only the relative part that is preserved in the destination. For example: copyFiles normal "dist/src" [("", "src/Foo.hs"), ("dist/build/", "src/Bar.hs")]This would copy "src/Foo.hs" to "dist/src/src/Foo.hs" and copy "dist/build/src/Bar.hs" to "dist/src/src/Bar.hs".This operation is not atomic. Any IO failure during the copy (including any missing source files) leaves the target in an unknown state so it is best to use it with a freshly created directory so that it can be simply deleted if anything goes wrong.Cabal This is like  but uses .Cabal This is like  but uses .Cabal This is like  but uses .CabalThis installs all the files in a directory to a target location, preserving the directory layout. All the files are assumed to be ordinary rather than executable files.Cabal?Recursively copy the contents of one directory to another path.CabalLike ., but also checks that the file is executable.Cabal4Use a temporary filename that doesn't already exist.Cabal A version of  that additionally takes a  argument.Cabal%Create and use a temporary directory.Creates a new temporary directory inside the given directory, making use of the template. The temp directory is deleted after use. For example: >withTempDirectory verbosity "src" "sdist." $ \tmpDir -> do ...The tmpDir: will be a new subdirectory of the given directory, e.g.  src/sdist.342.Cabal A version of  that additionally takes a  argument.CabalWrite a file but only if it would have new content. If we would be writing the same as the existing content then leave the file as is so that we do not update the file's modification time.NB: Before Cabal-3.0 the file content was assumed to be ASCII-representable. Since Cabal-3.0 the file is assumed to be UTF-8 encoded.CabalSame as  but for  ByteStrings.CabalThe path name that represents the current directory. In Unix, it's ".", but this is system-specific. (E.g. AmigaOS uses the empty string "" for the current directory.)Cabal"Drop the extension if it's one of  , or return the path unchanged.CabalList of possible executable file extensions on the current build platform.CabalPackage description file (pkgname.cabal)CabalFind a package description file in the given directory. Looks for .cabal files.CabalCabalLike  , but calls die in case of error.CabalLike  , but calls die in case of error.CabalFind auxiliary package information in the given directory. Looks for  .buildinfo files.Cabal.a description of the action we were attemptingCabalthe action itselfCabalNew working dir or inheritCabalNew environment or inheritCabalstdinCabalstdoutCabalstderrCabalNew working dir or inheritCabalNew environment or inheritCabal7action to perform after process is created, but before .CabalstdinCabalstdoutCabalstderrCabalNew working dir or inheritCabalNew environment or inheritCabalstdinCabalstdoutCabalstderrCabal7Any handles created for stdin, stdout, or stderr with  CreateProcess, and a handle to the process.CabalProgram locationCabal ArgumentsCabalNew working dir or inheritCabalNew environment or inheritCabalinput text and binary modeCabaliodata mode, acts as proxyCabaloutput, errors, exitCabal version argsCabal8function to select version number from program outputCaballocationCabalcwdCabalrelative search locationCabal File NameCabalsearch locationsCabal File NameCabalcwdCabal extensionsCabalrelative search locationsCabalbasenameCabal"build prefix (location of objects)Cabalsearch suffixesCabalmodulesCabal"build prefix (location of objects)Cabalsearch suffixesCabalmoduleCabalCreate its parents too?CabalTemp dir to create the file inCabalFile name template. See .CabalTemp dir to create the file inCabalFile name template. See .Cabal Where to lookCabal pkgname.cabalCabal project rootCabalrelative directoryCabal pkgname#.cabal relative to the project rootCabalDirectory to searchCabaldir/pkgname .buildinfo , if present,-./0123456789:;<=>?@ABCDEFGHIJKz{|{|zFEDCBA?>=<@;:0IJK/759864321.HG-,$None38նCabal%NubListR : A right-biased version of  . That is +toNubListR ["-XNoFoo", "-XFoo", "-XNoFoo"] will result in ["-XFoo", "-XNoFoo"], unlike the normal ), which is left-biased. Built on top of 6 and 5.CabalNubList : A de-duplicated list that maintains the original order.Cabal'Smart constructor for the NubList type.Cabal7Lift a function over lists to a function over NubLists.Cabal(Smart constructor for the NubListR type.Cabal8Lift a function over lists to a function over NubListRs.Cabal>Binary instance for 'NubList a' is the same as for '[a]'. For 6, we just pull off constructor and put the list. For , we get the list and make a  out of it using .CabalMonoid operations on NubLists. For a valid Monoid instance we need to satisfy the required monoid laws; identity, associativity and closure.'Identity : by inspection: mempty  NubList xs == NubList xs  mempty1Associativity : by inspection: (NubList xs  NubList ys)  NubList zs == NubList xs  (NubList ys  NubList zs)Closure : appending two lists of type a and removing duplicates obviously does not change the type.%None?דCabalThe 4 monad with specialized logging and error messages.CabalRun !, outputting traces according to , die if there is an error.Cabal"Output a warning trace message in .Cabal)Output an informational trace message in .Cabal+Fail the computation with an error message.Cabal+Add a message to the error/warning context.&(c) Sergey Vinokurov 2017 BSD3-stylecabal-devel@haskell.orgNone?Cabal-Working directory to create response file in.Cabal Template for response file name.Cabal+Encoding to use for response file contents.Cabal$Arguments to put into response file.'Duncan Coutts 2013cabal-devel@haskell.orgportableNone38?CabalA specific dirCabalThe system defaultCabalA search path to use when locating executables. This is analogous to the unix $PATH or win32 %PATH% but with the ability to use the system default method for finding executables () which on unix is simply looking on the $PATH* but on win32 is a bit more complicated).The default to use is [ProgSearchPathDefault] but you can add extra dirs either before, after or instead of the default, e.g. here we add an extra dir to search after the usual ones. 8['ProgramSearchPathDefault', 'ProgramSearchPathDir' dir]Cabal Interpret a  to construct a new $PATH env var. Note that this is close but not perfect because on Windows the search algorithm looks at more than just the %PATH%.Cabal=Get the system search path. On Unix systems this is just the $PATH6 env var, but on windows it's a bit more complicated.()Isaac Jones 2006, Duncan Coutts 2007-2009cabal-devel@haskell.orgportableNone38?nCabalWhere a program was found. Also tells us whether it's specified by user or not. This includes not just the path, but the program as well.CabalThe user gave the path to this program, eg. --ghc-path=/usr/bin/ghc-6.6Cabal$The program was found automatically.CabalRepresents a program which has been configured and is thus ready to be run.(These are usually made by configuring a =, but if you have to construct one directly then start with  and override any extra fields.CabalJust the name againCabal,The version of this program, if it is known.CabalDefault command-line args for this program. These flags will appear first on the command line, so they can be overridden by subsequent flags.CabalOverride command-line args for this program. These flags will appear last on the command line, so they override all earlier flags.CabalOverride environment variables for this program. These env vars will extend/override the prevailing environment of the current to form the environment for the new process.CabalA key-value map listing various properties of the program, useful for feature detection. Populated during the configuration step, key names depend on the specific program.CabalLocation of the program. eg. /usr/bin/ghc-6.4CabalIn addition to the  where the program was found, these are additional locations that were looked at. The combination of ths found location and these not-found locations can be used to monitor to detect when the re-configuring the program might give a different result (e.g. found in a different location).Cabal-Represents a program which can be configured.9Note: rather than constructing this directly, start with  and override any extra fields.Cabal'The simple name of the program, eg. ghcCabalA function to search for the program if its location was not specified by the user. Usually this will just be a call to .It is supplied with the prevailing search path which will typically just be used as-is, but can be extended or ignored as needed.For the purpose of change monitoring, in addition to the location where the program was found, it returns all the other places that were tried.CabalTry to find the version of the program. For many programs this is not possible or is not necessary so it's OK to return Nothing.CabalA function to do any additional configuration after we have located the program (and perhaps identified its version). For example it could add args, or environment vars.CabalA function that filters any arguments that don't impact the output from a commandline. Used to limit the volatility of dependency hashes when using new-build.Cabal&The full path of a configured program.Cabal/Suppress any extra arguments added by the user.CabalMake a simple named program.By default we'll just search for it in the path and not try to find the version name. You can override these behaviours if necessary, eg: (simpleProgram "foo") { programFindLocation = ... , programFindVersion ... }CabalMake a simple . 2simpleConfiguredProgram "foo" (FoundOnSystem path))Duncan Coutts 2009cabal-devel@haskell.orgportableNone'(?MCabal7Represents a specific invocation of a specific program.This is used as an intermediate type between deciding how to call a program and actually doing it. This provides the opportunity to the caller to adjust how the program will be called. These invocations can either be run directly or turned into shell or batch scripts.Cabal6TODO: remove this, make user decide when constructing .CabalReturn the current environment extended with the given overrides. If an entry is specified twice in  overrides%, the second entry takes precedence.CabalLike the unix xargs program. Useful for when we've got very long command lines that might overflow an OS limit on command line length and so you need to invoke a command multiple times to get all the args in.It takes four template invocations corresponding to the simple, initial, middle and last invocations. If the number of args given is small enough that we can get away with just a single invocation then the simple one is used:  $ simple argsIf the number of args given means that we need to use multiple invocations then the templates for the initial, middle and last invocations are used: $ initial args_0 $ middle args_1 $ middle args_2 ... $ final args_n*Duncan Coutts 2009cabal-devel@haskell.orgportableNone'(CabalGenerate a system script, either POSIX shell script or Windows batch file as appropriate for the given system.Cabal5Generate a POSIX shell script that invokes a program.Cabal5Generate a Windows batch file that invokes a program.+Thomas Tuegel 2011cabal-devel@haskell.orgportableNone?Cabal%Invoke hpc with the given parameters.Prior to HPC version 0.7 (packaged with GHC 7.8), hpc did not handle multiple .mix paths correctly, so we print a warning, and only pass it the first path in the list. This means that e.g. test suites that import their library as a dependency can still work, but those that include the library modules directly (in other-modules) don't.CabalPath to .tix fileCabalPaths to .mix file directoriesCabal(Path where html output should be locatedCabal(List of modules to include in the reportCabalPaths to .tix filesCabalPath to resultant .tix fileCabal%List of modules to exclude from union,(c) David Himmelstrup 2005, Bjorn Bringert 2007, Duncan Coutts 2008-2009cabal-devel@haskell.orgportableNone38>? Cabal)The default package index which contains InstalledPackageInfo. Normally use this.Cabal>The collection of information about packages from one or more  PackageDB8s. These packages generally should have an instance of -Packages are uniquely identified in by their , they can also be efficiently looked up by package name or by name and version.Cabal*Build an index out of a bunch of packages.If there are duplicates by $ then later ones mask earlier ones.CabalMerge two indexes.Packages from the second mask packages from the first if they have the exact same ."For packages with the same source , packages from the second are "preferred" over those from the first. Being preferred means they are top result when we do a lookup by source . This is the mechanism we use to prefer user packages over global packages.Cabal(Inserts a single package into the index.8This is equivalent to (but slightly quicker than) using  or  with a singleton index.Cabal2Removes a single installed package from the index.Cabal&Removes all packages with this source  from the index.CabalRemoves all packages with this (case-sensitive) name from the index.9NB: Does NOT delete internal libraries from this package.Cabal$Get all the packages from the index.Cabal$Get all the packages from the index.4They are grouped by package name (case-sensitively).$(Doesn't include private libraries.)Cabal$Get all the packages from the index.They are grouped by source package id (package name and version).#(Doesn't include private libraries)Cabal$Get all the packages from the index.7They are grouped by source package id and library name.%This DOES include internal libraries.Cabal!Does a lookup by unit identifier..Since multiple package DBs mask each other by (, then we get back at most one package.CabalDoes a lookup by component identifier. In the absence of Backpack, this is just a .Cabal4Does a lookup by source package id (name & version).>There can be multiple installed packages with the same source  but different . They are returned in order of preference, with the most preferred first.CabalConvenient alias of 0, but assuming only one package per package ID.Cabal%Does a lookup by source package name.Cabal=Does a lookup by source package name and a range of versions.We get back any number of versions of the specified package name, all satisfying the version range constraint.This does NOT work for internal dependencies, DO NOT use this function on those; use  instead.INVARIANT: List of eligible  is non-empty.Cabal=Does a lookup by source package name and a range of versions.We get back any number of versions of the specified package name, all satisfying the version range constraint.INVARIANT: List of eligible  is non-empty.Cabal/Does a case-insensitive search by package name.If there is only one package that compares case-insensitively to this name then the search is unambiguous and we get back all versions of that package. If several match case-insensitively but one matches exactly then it is also unambiguous.If however several match case-insensitively and none match exactly then we have an ambiguous result, and we get back all the versions of all the packages. The list of ambiguous results is split by exact package name. So it is a non-empty list of non-empty lists.Cabal9Does a case-insensitive substring search by package name.That is, all packages that contain the given string in their name.CabalCabalFind if there are any cycles in the dependency graph. If there are no cycles the result is [].This actually computes the strongly connected components. So it gives us a list of groups of packages where within each group they all depend on each other, directly or indirectly.CabalAll packages that have immediate dependencies that are not in the index.Returns such packages along with the dependencies that they're missing.CabalTries to take the transitive closure of the package dependencies.If the transitive closure is complete then it returns that subset of the index. Otherwise it returns the broken packages as in .Note that if the result is Right []3 it is because at least one of the original given s do not occur in the index.CabalTakes the transitive closure of the packages reverse dependencies. The given s must be in the index.Cabal+Builds a graph of the package dependencies.Dependencies on other packages that are not in the index are discarded. You can check if there are any such dependencies with .CabalGiven a package index where we assume we want to use all the packages (use  if you need to get such a index subset) find out if the dependencies within it use consistent versions of each package. Return all cases where multiple packages depend on different versions of some other package.Each element in the result is a package name along with the packages that depend on it and the versions they require. These are guaranteed to be distinct.Cabal7A rough approximation of GHC's module finder, takes a  and turns it into a map from module names to their source packages. It's used to initialize the  build-deps field in  cabal init.##-Isaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone @Cabal#File contents to final value parserCabalVerbosity levelCabal File name.#Isaac Jones, Simon Marlow 2003-2004=BSD3 portions Copyright (c) 2007, Galois Inc.cabal-devel@haskell.orgportableNone5?Cabal$The glob matched the value supplied.CabalThe glob did not match the value supplied because the cabal-version is too low and the extensions on the file did not precisely match the glob's extensions, but rather the glob was a proper suffix of the file's extensions; i.e., if not for the low cabal-version, it would have matched.CabalThe glob couldn't match because the directory named doesn't exist. The directory will be as it appears in the glob (i.e., relative to the directory passed to 4, and, for 'data-files', relative to 'data-dir').CabalReturns % if the glob didn't match at all, or  the result if the glob matched (or would have matched with a higher cabal-version).Cabal This will  when the glob matches no files, or if the glob refers to a missing directory, or if the glob fails to parse.The Version argument must be the spec version of the package description being processed, as globs behave slightly differently in different spec versions. The first  argument is the directory that the glob is relative to. It must be a valid directory (and hence it can't be the empty string). The returned values will not include this prefix. The second  is the glob itself.CabalLike  but with customizable dieCabal?Match files against a pre-parsed glob, starting in a directory.The Version argument must be the spec version of the package description being processed, as globs behave slightly differently in different spec versions.The  argument is the directory that the glob is relative to. It must be a valid directory (and hence it can't be the empty string). The returned values will not include this prefix./Isaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone38%CabalSome compilers (notably GHC) support profiling and can instrument programs so the system can account costs to different functions. There are different levels of detail that can be used for this accounting. For compilers that do not support this notion or the particular detail levels, this is either ignored or just capped to some similar level they do support.CabalSome compilers support emitting debug info. Some have different levels. For compilers that do not the level is just capped to the level they do support.CabalSome compilers support optimising. Some have different levels. For compilers that do not the level is just capped to the level they do support.CabalWe typically get packages from several databases, and stack them together. This type lets us be explicit about that stacking. For example typical stacks include: [GlobalPackageDB] [GlobalPackageDB, UserPackageDB] [GlobalPackageDB, SpecificPackageDB "package.conf.inplace"]Note that the  is invariably at the bottom since it contains the rts, base and other special compiler-specific packages.We are not restricted to using just the above combinations. In particular we can use several custom package dbs and the user package db together.>When it comes to writing, the top most (last) package is used.CabalSome compilers have a notion of a database of available packages. For some there is just one global db of packages, other compilers support a per-user or an arbitrary db specified at some location in the file system. This can be used to build isolated environments of packages, for example to build a collection of related packages without installing them globally.CabalCompiler flavour and version.CabalTag for distinguishing incompatible ABI's on the same architecture/os.CabalOther implementations that this compiler claims to be compatible with.CabalSupported language standards.CabalSupported extensions.Cabal?A key-value map for properties not covered by the above fields.CabalIs this compiler compatible with the compiler flavour we're interested in?For example this checks if the compiler is actually GHC or is another compiler that claims to be compatible with some version of GHC, e.g. GHCJS. 6if compilerCompatFlavor GHC compiler then ... else ...CabalIs this compiler compatible with the compiler flavour we're interested in, and if so what version does it claim to be compatible with.For example this checks if the compiler is actually GHC-7.x or is another compiler that claims to be compatible with some GHC-7.x version. case compilerCompatVersion GHC compiler of Just (Version (7:_)) -> ... _ -> ...CabalReturn the package that we should register into. This is the package db at the top of the stack.CabalMake package paths absoluteCabalFor the given compiler, return the extensions it does not support.CabalFor the given compiler, return the flags for the supported extensions.Cabal0Does this compiler support parallel --make mode?Cabal.Does this compiler support reexported-modules?Cabal>Does this compiler support thinning/renaming on package flags?Cabal:Does this compiler have unified IPIDs (so no package keys)Cabal(Does this compiler support package keys?Cabal$Does this compiler support unit IDs?Cabal$Does this compiler support Backpack?CabalDoes this compiler support a package database entry with: "dynamic-library-dirs"?CabalDoes this compiler's "ar" command supports response file arguments (i.e. @file-style arguments).CabalDoes this compiler's "ar" command support llvm-ar's -L flag, which compels the archiver to add an input archive's members rather than adding the archive itself.Cabal4Does this compiler support Haskell program coverage?Cabal%Does this compiler support profiling?CabalDoes this compiler support a package database entry with: "visibility"?>0Duncan Coutts 2009, 2013cabal-devel@haskell.orgportableNone ?1\Cabal+Additional variations in the behaviour for .Cabal7Allows re-registering / overwriting an existing packageCabalInsist on the ability to register multiple instances of a single version of a single package. This will fail if the hc-pkg does not support it, see  and .CabalRequire that no checks are performed on the existence of package files mentioned in the registration info. This must be used if registering prior to putting the files in their final place. This will fail if the hc-pkg does not support it, see .Cabal6Information about the features and capabilities of an hc-pkg program.Cabalno package DB stack supportedCabal'hc-pkg does not support verbosity flagsCabal-use package-conf option instead of package-dbCabal*supports directory style package databasesCabal*requires directory style package databasesCabal%supports --enable-multi-instance flagCabal#supports multi-instance via recacheCabal$supports --force-files or equivalentCabalCall hc-pkg9 to initialise a package database at the location {path}. hc-pkg init {path}CabalRun hc-pkg using a given package DB stack, directly forwarding the provided command-line arguments to it.Cabal Defaults are True, False and FalseCabalCall hc-pkg to register a package. hc-pkg register {filename | -} [--user | --global | --package-db]CabalCall hc-pkg to unregister a package = 7.6 uses the '-package-db' flag. See  0https://gitlab.haskell.org/ghc/ghc/-/issues/5977.3)Isaac Jones 2006, Duncan Coutts 2007-2009cabal-devel@haskell.orgportableNoneO-CabalThe default list of programs. These programs are typically used internally to Cabal.4)Isaac Jones 2006, Duncan Coutts 2007-2009cabal-devel@haskell.orgportableNone3?bCabalThe configuration is a collection of information about programs. It contains information both about configured programs and also about programs that we are yet to configure.The idea is that we start from a collection of unconfigured programs and one by one we try to configure them at which point we move them into the configured collection. For unconfigured programs we record not just the  but also any user-provided arguments and location for the program.CabalThe / and 1 instances do not preserve all the unconfigured Programs because  is not in / because it contains functions. So to fully restore a deserialised . use this function to add back all the known s.It does not add the default programs, but you probably want them, use ) in addition to any extra you might need.Cabal/Add a known program that we may configure laterCabalGet the current  used by the . This is the default list of locations where programs are looked for when configuring them. This can be overridden for specific programs (with ), and specific known programs can modify or ignore this search path in their own configuration code.CabalChange the current  used by the . This will affect programs that are configured from here on, so you should usually set it before configuring any programs.CabalModify the current  used by the . This will affect programs that are configured from here on, so you should usually modify it before configuring any programs.CabalUser-specify this path. Basically override any path information for this program in the configuration. If it's not a known program ignore it.CabalUser-specify the arguments for this program. Basically override any args information for this program in the configuration. If it's not a known program, ignore it..CabalLike ) but for a list of progs and their paths.CabalLike ( but for a list of progs and their args.CabalGet any extra args that have been previously specified for a program.Cabal Try to find a configured programCabal,Update a configured program in the database.CabalList all configured programs.CabalTry to configure a specific program. If the program is already included in the collection of unconfigured programs then we use any user-supplied location and arguments. If the program gets configured successfully it gets added to the configured collection.Note that it is not a failure if the program cannot be configured. It's only a failure if the user supplied a location and the program could not be found at that location.The reason for it not being a failure at this stage is that we don't know up front all the programs we will need, so we try to configure them all. To verify that a program was actually successfully configured use .CabalUnconfigure a program. This is basically a hack and you shouldn't use it, but it can be handy for making sure a  actually reconfigures.CabalTry to configure all the known programs that have not yet been configured.Cabalreconfigure a bunch of programs given new user-specified args. It takes the same inputs as  and - and for all progs with a new path it calls .Cabal;Check that a program is configured and available to be run.It raises an exception if the program could not be configured, otherwise it returns the configured program.Cabal;Check that a program is configured and available to be run. It returns 9 if the program couldn't be configured, or is not found.Cabal;Check that a program is configured and available to be run.Additionally check that the program version number is suitable and return it. For example you could require  AnyVersion or  (+ [1,0] [])It returns the configured program, its version number and a possibly updated . If the program could not be configured or the version is unsuitable, it returns an error value.CabalLike , but raises an exception in case of error instead of returning 'Left errMsg'.Cabal4Note that this instance does not preserve the known s. See  for details.Cabal4Note that this instance does not preserve the known s. See  for details.Cabal4Note that this instance does not preserve the known s. See  for details.Cabal Program nameCabal"user-specified path to the programCabal Program nameCabaluser-specified args5)Isaac Jones 2006, Duncan Coutts 2007-2009cabal-devel@haskell.orgportableNone?fuCabal"Runs the given configured program.Cabal6Runs the given configured program and gets the output.Cabal?Looks up the given program in the program database and runs it.Cabal?Looks up the given program in the program database and runs it.Cabal VerbosityCabalThe program to runCabalAny extra arguments to addCabal VerbosityCabalThe program to runCabalAny extra arguments to addCabal verbosityCabalThe program to runCaballook up the program hereCabalAny extra arguments to addCabal verbosityCabalThe program to runCaballook up the program hereCabalAny extra arguments to add6cabal-devel@haskell.orgportableNone?hR7Duncan Coutts 2007BSD3cabal-devel@haskell.org(non-portable (ExistentialQuantification)None?tCabalwraps a  CommandUI/ together with a function that turns it into a Command. By hiding the type of flags for the UI allows construction of a list of all UIs at the top level of the program. That list can then be used for generation of manual page as well as for executing the selected command.Cabal Long command line option stringsCabal!Short command line option stringsCabalAn OptionField takes one or more OptDescrs, describing the command line interface for the field.CabalWe usually have a data type for storing configuration values, where every field stores a configuration option, and the user sets the value either via command line flags or a configuration file. An individual OptionField models such a field, and we usually build a list of options associated to a configuration data type.CabalThe name of the command as it would be entered on the command line. For example "build".CabalA short, one line description of the command to use in help texts.CabalA function that maps a program name to a usage summary for this command.Cabal;Additional explanation of the command to use in help texts.Cabal+Post-Usage notes and examples in help textsCabalInitial / empty flagsCabal&All the Option fields for this commandCabalCreate an option taking a single OptDescr. No explicit Name is given for the Option, the name is the first LFlag given.CabalCreate an option taking several OptDescrs. You will have to give the flags and description individually to the OptDescr constructor.Cabal.Create a string-valued command line interface. CabalCreate a string-valued command line interface with a default value. Cabal!(String -> a) variant of "reqArg" Cabal!(String -> a) variant of "optArg" Cabalcreate a Choice option Cabalcreate a Choice option out of an enumeration type. As long flags, the Show output is used. As short flags, the first character which does not conflict with a previous one is used. Cabal Cabal:Show flags in the standard long option command line format Cabal0Default "usage" documentation text for commands. CabalCreate "usage" documentation from a list of parameter configurations. CabalMake a Command from standard GetOpt options. Cabal'Parse a bunch of command line arguments CabalMark command as hidden. Hidden commands don't show up in the 'progname help' or 'progname --help' output. CabalUtility function, many commands do not accept additional flags. This action fails with a helpful error message if the user supplies any extra. Cabal6Helper function for creating globalCommand descriptionCabalMkOptDescr constructors partially applied to flags and description. CabalnameCabalsynopsisCabalusage alternativesCabalinitial/empty flagsCabaloptions Cabal&Is the command a global or subcommand?        88Isaac Jones 2003-2004 Duncan Coutts 2007BSD3cabal-devel@haskell.orgportableNone38? Cabal9When we build haddock documentation, there are two cases: We build haddocks only for the current development version, intended for local use and not for distribution. In this case, we store the generated documentation in  distdochtml/ packagename.We build haddocks for intended for uploading them to hackage. In this case, we need to follow the layout that hackage expects from documentation tarballs, and we might also want to use different flags than for development builds, so in this case we store the generated documentation in  distdochtml/ packageid-docs. Cabal Flags to register and  unregister2: (user package, gen-script, in-place, verbosity) Cabal Flags to sdist: (snapshot, verbosity) Cabal Flags to install: (package db, verbosity) Cabal Flags to copy6: (destdir, copy-prefix (backwards compat), verbosity) Cabal Flags to  configure command.+IMPORTANT: every time a new flag is added, yz should be updated. IMPORTANT: every time a new flag is added, it should be added to the Eq instance CabalAll programs that cabal may run Cabaluser specified programs paths Cabaluser specified programs args CabalExtend the $PATH Cabal(The "flavor" of the compiler, e.g. GHC. Cabalgiven compiler location Cabalgiven hc-pkg location CabalEnable vanilla library CabalEnable profiling in the library CabalBuild shared library CabalBuild static library Cabal+Enable dynamic linking of the executables. Cabal0Enable fully static linking of the executables. Cabal%Enable profiling in the executables. Cabal1Enable profiling in the library and executables. Cabal8Profiling detail level in the library and executables. Cabal'Profiling detail level in the library CabalExtra arguments to  configure CabalEnable optimization. CabalInstalled executable prefix. CabalInstalled executable suffix. CabalInstallation paths Cabal"path to search for extra libraries Cabalpath to search for extra libraries when linking fully static executables Cabal0path to search for extra frameworks (OS X only) Cabalpath to search for header files Cabalexplicit IPID to be used Cabalexplicit CID to be used Cabalbe as deterministic as possible (e.g., invariant over GHC, database, etc). Used by the test suite Cabal "dist" prefix CabalCabal file to use Cabalverbosity level CabalThe --user/--global flag CabalWhich package DBs to use Cabal!Enable compiling library for GHCi CabalEnable -split-sections with GHC CabalEnable -split-objs with GHC CabalEnable executable stripping CabalEnable library stripping Cabal)Additional constraints for dependencies. CabalThe packages depended on. CabalThe requested Backpack instantiation. If empty, either this package does not use Backpack, or we just want to typecheck the indefinite package. CabalEnable test suite compilation CabalEnable benchmark compilation CabalEnable program coverage Cabal$Enable program coverage (deprecated) CabalAll direct dependencies and flags are provided on the command line by the user via the '--dependency' and '--flags' options. CabalHalt and show an error message indicating an error in flag assignment Cabal Enable relocatable package built CabalEmit debug info. CabalShould we dump available build information on build? Dump build information to disk before attempting to build, tooling can parse these files and use them to compile the source files themselves. CabalWhether to use response files at all. They're used for such tools as haddock, or ld. CabalAllow depending on private sublibraries. This is used by external tools (like cabal-install) so they can add multiple-public-libraries compatibility to older ghcs by checking visibility externally. Cabal:Flags that apply at the top level, not to any sub-command. CabalMore convenient version of  . Results in an # if internal invariant is violated. CabalParse a PackageDB stack entry CabalShow a PackageDB stack entry CabalLike *, but allows to customise the option name. CabalFor each known program PROG in progDb , produce a  PROG-options . CabalArguments to pass to a  configure script, e.g. generated by autoconf. CabalHelper function to split a string into a list of arguments. It's supposed to handle quoted things sensibly, eg: splitArgs "--foo=\"C:/Program Files/Bar/" --baz" = ["--foo=C:/Program Files/Bar", "--baz"] splitArgs "\"-DMSGSTR=\\\"foo bar\\\"\" --baz" = ["-DMSGSTR=\"foo bar\"","--baz"]     9None38?0 Cabal1Data cached after configuration step. See also  . CabalOptions passed to the configuration step. Needed to re-run configuration when .cabal is out of date Cabal9The final set of flags which were picked for this package Cabal;What components were enabled during configuration, and why. CabalExtra args on the command line for the configuration step. Needed to re-run configuration when .cabal is out of date CabalThe installation directories for the various different kinds of files TODO: inplaceDirTemplates :: InstallDirs FilePath Cabal The compiler we're building with CabalThe platform we're building for CabalWhere to build the package. Cabal6Path to the cabal file, if given during configuration. CabalAll the components to build, ordered by topological sort, and with their INTERNAL dependencies over the intrapackage dependency graph. TODO: this is assumed to be short; otherwise we want some sort of ordered map. CabalA map from component name to all matching components. These coincide with  CabalAll the info about the installed packages that the current package depends on (directly or indirectly). The copy saved on disk does NOT include internal dependencies (because we just don't have enough information at this point to have an InstalledPackageInfo for an internal dep), but we will often update it with the internal dependencies; see for example W{<. (This admonition doesn't apply for per-component builds.) Cabal5the filename containing the .cabal file, if available CabalWARNING WARNING WARNING Be VERY careful about using this function; we haven't deprecated it but using it could introduce subtle bugs related to .In principle, this is supposed to contain the resolved package description, that does not contain any conditionals. However, it MAY NOT contain the description with a  applied to it; see  for the whole sordid saga. As much as possible, Cabal library should avoid using this parameter. Cabal"Location and args for all programs Cabal)What package database to use, global/user CabalWhether to build normal libs. Cabal,Whether to build profiling versions of libs. Cabal)Whether to build shared versions of libs. CabalWhether to build static versions of libs (with all other libs rolled in) Cabal'Whether to link executables dynamically Cabal,Whether to link executables fully statically Cabal+Whether to build executables for profiling. Cabal"Level of automatic profile detail. Cabal"Level of automatic profile detail. Cabal2Whether to build with optimization (if available). Cabal*Whether to emit debug info (if available). Cabal1Whether to build libs suitable for use with GHCi. Cabal*Use -split-sections with GHC, if available Cabal&Use -split-objs with GHC, if available Cabal+Whether to strip executables during install Cabal)Whether to strip libraries during install Cabal-Whether to enable executable program coverage Cabal*Whether to enable library program coverage Cabal/Prefix to be prepended to installed executables Cabal.Suffix to be appended to installed executables Cabal Extract the ) from the public library component of a   if it exists, or make a fake component ID based on the package ID. Cabal Extract the  of a  . This is a "safe" use of  Cabal Extract the " from the library component of a  ? if it exists, or make a fake unit ID based on the package ID. CabalExtract the compatibility package key from the public library component of a   if it exists, or make a fake package key based on the package ID. Cabal Return all s associated with &. In the presence of Backpack there may be more than one! Has a prime because it takes a # argument which may disagree with   in  . Cabal Return all s associated with &:. In the presence of Backpack there may be more than one! CabalReturn the list of default s associated with a configured package, in the order they need to be built. Has a prime because it takes a # argument which may disagree with   in  . CabalExecute f for every  in the package, respecting the build dependency order. (TODO: We should use Shake!) Has a prime because it takes a # argument which may disagree with   in  . Cabal3Return the list of all targets needed to build the uids, in the order they need to be built. Has a prime because it takes a # argument which may disagree with   in  . CabalExecute f for every  needed to build uids, respecting the build dependency order. Has a prime because it takes a # argument which may disagree with   in  . CabalIs coverage enabled for test suites? In practice, this requires library and executable profiling to be enabled.9 9 Isaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone8?> Cabal#Perform the action on each enabled & in the package description with the . Cabal#Perform the action on each enabled 3 in the package description. Extended version of + that also gives corresponding build info. Cabal#Perform the action on each enabled  in the package description. Cabal%Perform the action on each buildable  or  (Component) in the PackageDescription, subject to the build order specified by the compBuildOrder field of the given  CabalDetermine the directories containing the dynamic libraries of the transitive dependencies of the component we are building.When wanted, and possible, returns paths relative to the installDirs  CabalGet all module names that needed to be built by GHC; i.e., all of these s have interface files associated with them that need to be installed. CabalBackwards compatibility function which computes the InstallDirs assuming that $libname points to the public library (or some fake package identifier if there is no public library.) IF AT ALL POSSIBLE, please use   instead. CabalSee . CabalBackwards compatibility function which computes the InstallDirs assuming that $libname points to the public library (or some fake package identifier if there is no public library.) IF AT ALL POSSIBLE, please use   instead. CabalSee  CabalBuilding for inplace?Cabal&Generate prefix-relative library pathsCabalComponent that is being built  &%$#"!'*)(   &%$#"!*)('    :Thomas Tuegel 2011BSD3cabal-devel@haskell.orgportableNone?b Cabal?Path to the .tix file containing a test suite's sum statistics. CabalAttempt to guess the way the test suites in this package were compiled and linked with the library so the correct module interfaces are found. Cabal*Generate the HTML markup for a test suite. CabalDuncan Coutts 2009cabal-devel@haskell.orgportableNone?a CabalCall ld -r* to link a bunch of object files together.  ?Duncan Coutts 2009cabal-devel@haskell.orgportableNone ? CabalCall ar: to create a library archive from a bunch of object files.  |None> Cabal.This method computes a default, "good enough"  for a package. The intent is that cabal-install (or the user) will specify a more detailed IPID via the --ipid flag if necessary. CabalIn GHC 8.0, the string we pass to GHC to use for symbol names for a package can be an arbitrary, IPID-compatible string. However, prior to GHC 8.0 there are some restrictions on what format this string can be (due to how ghc-pkg parsed the key): In GHC 7.10, the string had either be of the form foo_ABCD, where foo is a non-semantic alphanumeric/hyphenated prefix and ABCD is two base-64 encoded 64-bit integers, or a GHC 7.8 style identifier.In GHC 7.8, the string had to be a valid package identifier like foo-0.1.So, the problem is that Cabal, in general, has a general IPID, but needs to figure out a package key / package ID that the old ghc-pkg will actually accept. But there's an EVERY WORSE problem: if ghc-pkg decides to parse an identifier foo-0.1-xxx as if it were a package identifier, which means it will SILENTLY DROP the "xxx" (because it's a tag, and Cabal does not allow tags.) So we must CONNIVE to ensure that we don't pick something that looks like this.So this function attempts to define a mapping into the old formats.#The mapping for GHC 7.8 and before:We use the *compatibility* package name and version. For public libraries this is just the package identifier; for internal libraries, it's something like "z-pkgname-z-libname-0.1". See computeCompatPackageName for more details.The mapping for GHC 7.10:For CLibName: If the IPID is of the form foo-0.1-ABCDEF where foo_ABCDEF would validly parse as a package key, we pass ABCDEF. (NB: not all hashes parse this way, because GHC 7.10 mandated that these hashes be two base-62 encoded 64 bit integers), but hashes that Cabal generated using  , are guaranteed to have this form.If it is not of this form, we rehash the IPID into the correct form and pass that.For sub-components, we rehash the IPID into the correct format and pass that. ANoneȕ Cabal1A configured component, we know exactly what its  is, and the s of the things it depends on. Cabal7Unique identifier of component, plus extra useful info. CabalThe fragment of syntax from the Cabal file describing this component. CabalIs this the public library component of the package? (If we invoke Setup with an instantiation, this is the component the instantiation applies to.) Note that in one-component configure mode, this is always True, because any component is the "public" one.) Cabal!Dependencies on executables from  build-tools and build-tool-depends. Cabal?The mixins of this package, including both explicit (from the mixins field) and implicit (from  build-depends). Not mix-in linked yet; component configuration only looks at s. Cabal+Uniquely identifies a configured component. Cabal%The package this component came from. CabalThe & of a component; this uniquely identifies a fragment of syntax within a specified Cabal file describing the component. CabalPretty-print a  .  BNoneά CabalA linked component is a component that has been mix-in linked, at which point we have determined how all the dependencies of the component are explicitly instantiated (in the form of an OpenUnitId).   is mix-in linked into  #, which is then instantiated into ReadyComponent. Cabal$Uniquely identifies linked component CabalCorresponds to  . Cabal build-tools and build-tool-depends dependencies. Corresponds to  . Cabal:Is this the public library of a package? Corresponds to  . CabalCorresponds to  , but (1) this does not contain includes of signature packages (packages with no exports), and (2) the  for requirements (stored in +) has been removed, as it is reflected in .) CabalLike  , but this specifies includes on signature packages which have no exports. CabalThe module shape computed by mix-in linking. This is newly computed from  CabalUniquely identifies a  . Corresponds to  . CabalCorresponds to  . CabalThe = of this component in the "default" instantiation. See also  .  -s cannot be instantiated (e.g., there is no ModSubst instance for them). CabalThe instantiation of  ; this always has the invariant that it is a mapping from a module name A to  A (the hole A).  C(c) Duncan Coutts 2012BSD-likeduncan@community.haskell.orgNone8? Cabal expected thing(actually got) Cabal (no such thing, actually got) CabalA fully resolved build target. CabalA specific component Cabal.A specific module within a specific component. Cabal,A specific file within a specific component. Cabal4Various ways that a user may specify a build target. CabalTake a list of 9 build targets, and parse and validate them into actual  s to be built registered whatever. CabalRead a list of user-supplied build target strings and resolve them to  s according to a . If there are problems with any of the targets e.g. they don't exist or are misformatted, throw an . CabalUnambiguously render a  ., so that it can be parsed in all situations. CabalGiven a bunch of user-specified targets, try to resolve what it is they refer to.  D9Isaac Jones 2003-2004, Duncan Coutts 2008BSD3cabal-devel@haskell.orgportableNone?K Cabal.Build info json file, generated in every build CabalThis is the name of the directory in which the generated haddocks should be stored. It does not include the  distdochtml prefix. CabalThe directory to which generated haddock documentation should be written. CabalThe directory in which we put auto-generated modules for EVERY component in the package. CabalThe directory in which we put auto-generated modules for a particular component. CabalThe name of the auto-generated Paths_* module associated with a package Cabal:The directory where we put build results for an executable Cabal>The directory where we put build results for a foreign library CabalCreate a library name for a static library from a given name. Prepends lib+ and appends the static library extension (.a). CabalCreate a library name for a shared library from a given name. Prepends lib and appends the #-* as well as the shared library extension. CabalCreate a library name for a bundled shared library from a given name. This matches the naming convention for shared libraries as implemented in GHC's packageHsLibs function in the Packages module. If the given name is prefixed with HS, then this prepends lib and appends the compiler flavour/version and shared library extension e.g.: "HSrts-1.0" -> "libHSrts-1.0-ghc8.7.20190109.so" Otherwise the given name should be prefixed with C, then this strips the C , prepends lib5 and appends the shared library extension e.g.: Cffi -> "libffi.so" CabalDefault extension for executable files on the current platform. (typically "" on Unix and "exe" on Windows or OS/2) Cabal5Extension for object files. For GHC the extension is "o". CabalExtension for dynamically linked (or shared) libraries (typically "so" on Unix and "dll" on Windows) CabalExtension for static librariesTODO: Here, as well as in dllExtension, it's really the target OS that we're interested in, not the build OS.  EAndres Loeh 2009BSD3cabal-devel@haskell.orgportableNone?  FNone?ݽ Cabalinstall locationCabal&install location for dynamic librariesCabalBuild location }Isaac Jones 2003-2007cabal-devel@haskell.orgportableNone? Cabal'The kinds of entries we can stick in a .ghc.environment file. Cabal  -- a comment Cabal package-id foo-1.0-4fe301a... Cabalglobal-package-db, user-package-db or package-db blahpackage.conf.d Cabal clear-package-dbCabal/Adjust the way we find and configure gcc and ldCabal.Strip out flags that are not supported in ghciCabal&GHC's rendering of its host or target  as used in its platform strings and certain file locations (such as user package db location).Cabal&GHC's rendering of its host or target  as used in its platform strings and certain file locations (such as user package db location). CabalGHC's rendering of its platform and compiler version string as used in certain file locations (such as user package db location). For example x86_64-linux-7.10.4 Cabal3Make entries for a GHC environment file based on a $ and a bunch of package (unit) ids.If you need to do anything more complicated then either use this as a basis and add more entries, or just make all the entries directly. CabalWrite a .ghc.environment-$arch-$os-$ver file in the given directory.The  and GHC +% are needed as part of the file name.%Returns the name of the file written.CabalThe .ghc.environment-$arch-$os-$ver file name Cabal.Render a bunch of GHC environment file entriesCabal/Render an individual GHC environment file entry Cabaldirectory in which to put itCabalthe GHC target platformCabalthe GHC versionCabal the content   ~None#$3?& 1None? Cabal9Given a single package DB, return all installed packages.Cabal8Given a package DB stack, return all installed packages.Cabal Return the $ to the global GHC package database.Cabal:Get the packages from specific PackageDBs, not cumulative.Cabal.Start a REPL without loading any source files.CabalBuild a foreign libraryCabalBuild an executable with GHC.CabalExtracts a String representing a hash of the ABI of a built library. It can fail if the library has not yet been built.CabalInstall executables for GHCJS.Cabal Install foreign library for GHC.Cabal6Install for ghc, .hi, .a and, if --with-ghci given, .oCabalGet the JavaScript file name and command and arguments to run a program compiled by GHCJS the exe should be the base program name without exe extensionCabalWhere to copy the files toCabalBuild locationCabalExecutable (prefix,suffix)Cabalinstall locationCabalBuild locationCabalinstall locationCabal&install location for dynamic librariesCabalBuild location4 4  GIsaac Jones 2003-2007BSD3cabal-devel@haskell.orgportableNone? Cabal9Given a single package DB, return all installed packages.Cabal8Given a package DB stack, return all installed packages.Cabal Return the ' to the GHC application data directory.Cabal Return the $ to the global GHC package database.Cabal.Start a REPL without loading any source files.CabalBuild a foreign libraryCabalBuild an executable with GHC.CabalExtracts a String representing a hash of the ABI of a built library. It can fail if the library has not yet been built.CabalInstall executables for GHC.Cabal Install foreign library for GHC.Cabal6Install for ghc, .hi, .a and, if --with-ghci given, .oCabalWhere to copy the files toCabalBuild locationCabalExecutable (prefix,suffix)Cabalinstall locationCabalBuild locationCabalinstall locationCabal&install location for dynamic librariesCabalBuild location4 4 HNone !CabalConstruct a JSON document describing the build information for a package.Cabal A variant of  if you need to call  and  yourself.If you change the format or any name in the output json, don't forget to update the schema at (/doc/json-schemas/build-info.schema.json and the docs of --enable-build-info/--disable-build-info.Cabal#The source directory of the packageCabal'Mostly information from the .cabal fileCabalConfiguration informationCabal#Flags that the user passed to buildCabalCompiler information. Needs to be passed explicitly, as we can't extract that information here without some partial function.Cabal=Json representation of buildinfo alongside generated warningsCabalThe  from CabalThe  from IIsaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone?Cabal Perform the "./setup install" and " ./setup copy" actions. Move files into place based on the prefix argument.2This does NOT register libraries, you should call register to do that.Cabal information from the .cabal fileCabal#information from the configure stepCabalflags sent to copy or installJIsaac Jones 2003-2005, Ross Paterson 2006, Duncan Coutts 2007-2008cabal-devel@haskell.orgportableNoneCabalGenerates the name of the environment variable controlling the path component of interest.Note: The format of these strings is part of Cabal's public API; changing this function constitutes a *backwards-compatibility* break.Cabalpath component; one of "bindir", "libdir", -- "datadir", "libexecdir", or "sysconfdir"Cabalenvironment variable nameKNone?hCabal:The name of the stub executable associated with a library  TestSuite.CabalThe filename of the source file for the stub executable associated with a library  TestSuite.Cabal$Write the source file for a library  TestSuite stub executable.Cabal2Source code for library test suite stub executableCabalMain function for test stubs. Once, it was written directly into the stub, but minimizing the amount of code actually in the stub maximizes the number of detectable errors when Cabal is compiled.CabalFrom a test stub, write the  : to temporary file for the calling Cabal process to read.Caballibrary  TestSuite# for which a stub is being createdCabal6path to directory where stub source should be locatedLNone?MLennart Kolmodin 2008BSD3cabal-devel@haskell.orgportableNone CabalA record of operations needed to check the contents of packages. Used by .Cabal-Results of some kind of failed package check.There are a range of severities, from merely dubious to totally insane. All of them come with a human readable explanation. In future we may augment them with more machine readable explanations, for example to help an IDE suggest automatic corrections.CabalThis package description is no good. There's no way it's going to build sensibly. This should give an error at configure time.CabalA problem that is likely to affect building the package, or an issue that we'd like every package author to be aware of, even if the package is never distributed.CabalAn issue that might not be a problem for the package author but might be annoying or detrimental when the package is distributed to users. We should encourage distributed packages to be free from these issues, but occasionally there are justifiable reasons so we cannot ban them entirely.CabalLike PackageDistSuspicious but will only display warnings rather than causing abnormal exit when you run 'cabal check'.CabalAn issue that is OK in the author's environment but is almost certain to be a portability problem for other environments. We can quite legitimately refuse to publicly distribute packages with these problems.Cabal?Check for common mistakes and problems in package descriptions.This is the standard collection of checks covering all aspects except for checks that require looking at files within the package. For those see .It requires the  and optionally a particular configuration of that package. If you pass  then we just check a version of the generic description using .CabalSanity check things that requires IO. It looks at the files in the package and expects to find the package unpacked in at the given file path.CabalSanity check things that requires looking at files in the package. This is a generalised version of 7 that can work in any monad for which you can provide  operations.The point of this extra generality is to allow doing checks in some virtual file system, for example a tarball in memory.CabalCheck the names of all files in a package for portability problems. This should be done for example when creating or validating a package tarball.Martin Sjögren 2004BSD3cabal-devel@haskell.orgportableNone?J++NNone38? CabalAn opaque type representing a file's modification time, represented internally as a 64-bit unsigned integer in the Windows UTC format.CabalReturn modification time of the given file. Works around the low clock resolution problem that  has on GHC < 7.8.This is a modified version of the code originally written for Shake by Neil Mitchell. See module Development.Shake.FileInfo.Cabal!Convert POSIX seconds to ModTime.Cabal!Return age of given file in days.CabalReturn the current time as .Cabal7Based on code written by Neil Mitchell for Shake. See sleepFileTimeCalibrate in . Returns a pair of microsecond values: first, the maximum delay seen, and the recommended delay to use before testing for file modification change. The returned delay is never smaller than 10 ms, but never larger than 1 second.NoneXCabalAn > is a library with requirements which we will typecheck only.Cabal The requirements of the library.Cabal0The modules exported/reexported by this library.CabalThe dependencies which need to be passed to the compiler to bring modules into scope. These are > because these may refer to partially instantiated libraries.CabalAn  is a library which is fully instantiated (or, possibly, has no requirements at all.)Cabal"How this library was instantiated.CabalDependencies induced by . These are recorded here because there isn't a convenient way otherwise to get the  we need to fill componentPackageDeps as needed.Cabal0The modules exported/reexported by this library.CabalThe dependencies which need to be passed to the compiler to bring modules into scope. These always refer to installed fully instantiated libraries.CabalA  is one that we can actually generate build products for. We have a ready component for the typecheck-only products of every indefinite package, as well as a ready component for every way these packages can be fully instantiated.CabalThe  for this package. At the moment, this is used in only one case, which is to determine if an export is of a module from this library (indefinite libraries record these exports as ); 9 can be conveniently used to test for equality, whereas % cannot always be used in this case.CabalCorresponds to  . Invariant: if  records a , it coincides with this one.CabalCorresponds to  .CabalCorresponds to  . Build-tools don't participate in mix-in linking. (but what if they could?)CabalCorresponds to  .CabalExtra metadata depending on whether or not this is an indefinite library (typechecked only) or an instantiated component (can be compiled).CabalThe final, string  that will uniquely identify the compilation products of this component.CabalCorresponds to  .CabalCompute the dependencies of a ! that should be recorded in the depends field of InstalledPackageInfo.CabalGiven a list of  s, expand the module graph so that we have an instantiated graph containing all of the instantiated components we need to build.:Instantiation intuitively follows the following algorithm:instantiate a definite unit id p[S]: recursively instantiate each module M in S recursively instantiate modules exported by this unit recursively instantiate dependencies substituted by SThe implementation is a bit more involved to memoize instantiation if we have done it already. We also call  improveUnitId during this process, so that fully instantiated components are given  HashedUnitId.ONone  #$3PNone?ECabalPrint a Setup message stating (1) what operation we are doing, for (2) which component (with enough details to uniquely identify the build in question.)Cabal'Operation being done (capitalized), on:CabalPackageCabalComponent nameCabal3Instantiation, if available. Polymorphic to take  OpenModule or ModuleQIsaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone?Cabal Compute the $ of a library that we built inplace.Cabal5Create an empty package DB at the specified location.CabalRun hc-pkg using a given package DB stack, directly forwarding the provided command-line arguments to it.Cabal Construct  for a library in a package, given a set of installation directories.Cabal Construct 3 for a library that is in place in the build tree.:This function knows about the layout of in place packages.Cabal Construct 6 for the final install location of a library package.;This function knows about the layout of installed packages.Cabal(Install in the user's database?; verboseCabal8Translate relative include dir paths to absolute paths.Cabaltop of the build treeCaballocation of the dist treeR+(c) 2003-2005, Isaac Jones, Malcolm WallaceBSD3cabal-devel@haskell.orgportableNone?&CabalA preprocessor for turning non-Haskell files with the given extension into plain Haskell source files.CabalThe interface to a preprocessor, which may be implemented using an external program, but need not be. The arguments are the name of the input file, the name of the output file and a verbosity level. Here is a simple example that merely prepends a comment to the given source file: ppTestHandler :: PreProcessor ppTestHandler = PreProcessor { platformIndependent = True, runPreProcessor = mkSimplePreProcessor $ \inFile outFile verbosity -> do info verbosity (inFile++" has been preprocessed to "++outFile) stuff <- readFile inFile writeFile outFile ("-- preprocessed as a test\n\n" ++ stuff) return ExitSuccessWe split the input and output file names into a base directory and the rest of the file name. The input base dir is the path in the list of search dirs that this file was found in. The output base dir is the build dir where all the generated source files are put.The reason for splitting it up this way is that some pre-processors don't simply generate one output .hs file from one input file but have dependencies on other generated files (notably c2hs, where building one .hs file may require reading other .chi files, and then compiling the .hs file may require reading a generated .h file). In these cases the generated files need to embed relative path names to each other (eg the generated .hs file mentions the .h file in the FFI imports). This path must be relative to the base directory where the generated files are located, it cannot be relative to the top level of the build tree because the compilers do not look for .h files relative to there, ie we do not use "-I .", instead we use "-I dist/build" (or whatever dist dir has been set by the user)Most pre-processors do not care of course, so mkSimplePreProcessor and runSimplePreProcessor functions handle the simple case.CabalThis function can reorder all modules, not just those that the require the preprocessor in question. As such, this function should be well-behaved and not reorder modules it doesn't have dominion over!CabalJust present the modules in the order given; this is the default and it is appropriate for preprocessors which do not have any sort of dependencies between modules.Cabal(Apply preprocessors to the sources from 2 for a given component (lib, exe, or test suite).XXX: This is terribleCabal>Convenience function; get the suffixes of these preprocessors.CabalStandard preprocessors: GreenCard, c2hs, hsc2hs, happy, alex and cpphs.CabalFind any extra C sources generated by preprocessing that need to be added to the component (addresses issue #238).SIsaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone?3)CabalHooks allow authors to add specific functionality before and after a command is run, and also to specify additional preprocessors.WARNING: The hooks interface is under rather constant flux as we try to understand users needs. Setup files that depend on this interface may break in future releases.CabalRead the description fileCabal3Custom preprocessors in addition to and overriding .CabalThese programs are detected at configure time. Arguments for them are added to the configure command.Cabal$Hook to run before configure commandCabal?Over-ride this hook to get different behavior during configure.Cabal#Hook to run after configure commandCabalHook to run before build command. Second arg indicates verbosity level.Cabal;Over-ride this hook to get different behavior during build.CabalHook to run after build command. Second arg indicates verbosity level.CabalHook to run before repl command. Second arg indicates verbosity level.CabalOver-ride this hook to get different behavior during interpretation.CabalHook to run after repl command. Second arg indicates verbosity level.CabalHook to run before clean command. Second arg indicates verbosity level.Cabal;Over-ride this hook to get different behavior during clean.CabalHook to run after clean command. Second arg indicates verbosity level.CabalHook to run before copy commandCabal:Over-ride this hook to get different behavior during copy.CabalHook to run after copy commandCabal"Hook to run before install commandCabal=Over-ride this hook to get different behavior during install.CabalHook to run after install command. postInst should be run on the target, not on the build machine.Cabal#Hook to run before register commandCabalOver-ride this hook to get different behavior during registration.Cabal"Hook to run after register commandCabal%Hook to run before unregister commandCabalOver-ride this hook to get different behavior during unregistration.Cabal$Hook to run after unregister commandCabalHook to run before hscolour command. Second arg indicates verbosity level.Cabal>Over-ride this hook to get different behavior during hscolour.CabalHook to run after hscolour command. Second arg indicates verbosity level.CabalHook to run before haddock command. Second arg indicates verbosity level.Cabal=Over-ride this hook to get different behavior during haddock.CabalHook to run after haddock command. Second arg indicates verbosity level.Cabal Hook to run before test command.Cabal:Over-ride this hook to get different behavior during test.CabalHook to run after test command.Cabal!Hook to run before bench command.Cabal;Over-ride this hook to get different behavior during bench.Cabal Hook to run after bench command.CabalEmpty  which do nothing.++TThomas Tuegel 2010BSD3cabal-devel@haskell.orgportableNone?5yCabal Perform the " ./setup test " action.Cabal!positional command-line argumentsCabal information from the .cabal fileCabal#information from the configure stepCabalflags sent to testUJohan Tibell 2011BSD3cabal-devel@haskell.orgportableNone?6Cabal Perform the " ./setup bench " action.Cabal!positional command-line argumentsCabal information from the .cabal fileCabal#information from the configure stepCabalflags sent to benchmark@Isaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone #$3?ICabal/The errors that can be thrown when reading the  setup-config file.CabalNo header found.CabalIncorrect header.CabalCannot parse file contents.CabalNo file!CabalMismatched version.Cabal Read the . Throw an exception if the file is missing, if the file cannot be read, or if the file was created by an older version of Cabal.Cabal Read the 5, returning either an error or the local build info.CabalTry to read the .Cabal Read the . Throw an exception if the file is missing, if the file cannot be read, or if the file was created by an older version of Cabal.CabalTry to read the .Cabal$After running configure, output the   to the .CabalCheck that localBuildInfoFile is up-to-date with respect to the .cabal file.CabalGet the path of dist/setup-config.CabalReturn the "dist/" prefix, or the default prefix. The prefix is taken from (in order of highest to lowest preference) the override prefix, the "CABAL_BUILDDIR" environment variable, or the default prefix.CabalReturn the "dist/" prefix, or the default prefix. The prefix is taken from (in order of highest to lowest preference) the override prefix, the "CABAL_BUILDDIR" environment variable, or  + is used. Call this function to resolve a  *DistPref0 flag whenever it is not known to be set. (The  *DistPref; flags are always set to a definite value before invoking  UserHooks.)Cabal Perform the "./setup configure" action. Returns the  .setup-config file.CabalCreate a PackageIndex that makes *any libraries that might be* defined internally to this package look like installed packages, in case an executable should refer to any of them as dependencies.It must be *any libraries that might be* defined rather than the actual definitions, because these depend on conditionals in the .cabal file, and we haven't resolved them yet. finalizePD does the resolution of conditionals, and it takes internalPackageSet as part of its input.Cabal4Compute the effective value of the profiling flags --enable-library-profiling and --enable-executable-profiling from the specified  . This may be useful for external Cabal tools which need to interact with Setup in a backwards-compatible way: the most predictable mechanism for enabling profiling across many legacy versions is to NOT use --enable-profiling! and use those two flags instead. Note that --enable-executable-profiling also affects profiling of benchmarks and (non-detailed) test suites.CabalList all installed packages in the given package databases. Non-existent package databases do not cause errors, they just get skipped with a warning and treated as empty ones, since technically they do not contain any package.CabalLike , but for a single package DB.,NB: Why isn't this always a fall through to ? That is because  performs some sanity checks on the package database stack in question. However, when sandboxes are involved these sanity checks are not desirable.CabalA set of files (or directories) that can be monitored to detect when there might have been a change in the installed packages.CabalThe user interface specifies the package dbs to use with a combination of --global, --user and $--package-db=global|user|clear|$file. This function combines the global/user flag and interprets the package-db flag into a single package db stack.CabalMakes a " from C compiler and linker flags.This can be used with the output from configuration programs like pkg-config and similar package-specific programs like mysql-config, freealut-config etc. For example: ccflags <- getDbProgramOutput verbosity prog progdb ["--cflags"] ldflags <- getDbProgramOutput verbosity prog progdb ["--libs"] ldflags_static <- getDbProgramOutput verbosity prog progdb ["--libs", "--static"] return (ccldOptionsBuildInfo (words ccflags) (words ldflags) (words ldflags_static)) CabalThe file path of the  setup-config file.CabalThe file path of the  setup-config file.CabalThe dist directory path.CabalThe dist directory path.CabalThe dist directory path.CabalThe dist directory path.CabalThe   to write.CabalThe dist directory path.Cabaldefault "dist" prefixCabaloverride "dist" prefixCabaloverride "dist" prefixCabalThe stack of package databases.  VSimon Marlow 2004BSD3cabal-devel@haskell.orgportableNone?St CabalCreate a source distribution.Cabal#List all source files of a package.Since  Cabal-3.4 returns a single list. There shouldn't be any executable files, they are hardly portable.Cabal A variant of  with configurable die.Note: may still die/ directly. For example on missing include file.Since @3.4.0.0Cabal)Prepare a directory tree of source files.CabalPrepare a directory tree of source files for a snapshot version. It is expected that the appropriate snapshot version has already been set in the package description, eg using  or .Cabal Modifies a  by appending a snapshot number corresponding to the given date.Cabal Modifies a + by appending a snapshot number corresponding to the given date.CabalGiven a date produce a corresponding integer representation. For example given a date 18032008 produce the number 20080318.CabalCreate an archive from a tree of source files, and clean up the tree.CabalNote: must be called with the CWD set to the directory containing the '.cabal' file.Cabalinformation from the tarballCabalverbosity & snapshotCabalbuild prefix (temp dir)Cabal'extra preprocessors (includes suffixes)Cabal verbosityCabaldirectory with cabal fileCabalinfo from the cabal fileCabal&extra preprocessors (include suffixes)Cabalrelative pathsCabal verbosityCabal alternative. Since ! prefixes the error message with  errorPrefix, whatever is passed in here and wants to die should do the same. See issue #7331.Cabaldirectory with cabal fileCabalinfo from the cabal fileCabal&extra preprocessors (include suffixes)Cabalrelative pathsCabal verbosityCabalinfo from the cabal fileCabalsource tree to populateCabal'extra preprocessors (includes suffixes)Cabal verbosityCabalinfo from the cabal fileCabalsource tree to populateCabal'extra preprocessors (includes suffixes)Cabal verbosityCabalinfo from cabal fileCabalsource tree to archiveCabalname of archive to create  WIsaac Jones 2003-2005, Ross Paterson 2006, Duncan Coutts 2007-2008, 2012BSD3cabal-devel@haskell.orgportableNone?XCabal4Build the libraries and executables in this package.Cabal7Start an interpreter without loading any package files.CabalInitialize a new package db file for libraries defined internally to the package.CabalRuns  on every configured component.CabalCreates the autogenerated files for a particular configured component.Cabal!Generate and write out the Paths_ pkg.hs and cabal_macros.h filesCabal'Mostly information from the .cabal fileCabalConfiguration informationCabal#Flags that the user passed to buildCabal%preprocessors to run before compilingCabal'Mostly information from the .cabal fileCabalConfiguration informationCabal#Flags that the user passed to buildCabal%preprocessors to run before compilingCabal "dist" prefixCabal'mostly information from the .cabal fileCabalConfiguration informationCabalThe verbosity to useCabal "dist" prefixCabal'mostly information from the .cabal fileCabalConfiguration informationCabalThe verbosity to useXIsaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone8?YCabalGiven a list of s, return a list of interfaces and HTML paths, and an optional warning for packages with missing documentation.YIsaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone?^ CabalA simple implementation of main for a Cabal setup script. It reads the package description file using IO, and performs the action specified on the command line.Cabal A version of  that is passed the command line arguments, rather than getting them from the environment.CabalA customizable version of .CabalA customizable version of - that also takes the command line arguments.CabalLike , but accepts the package description as input rather than using IO to read it.CabalA customizable version of .CabalA customizable version of - that also takes the command line arguments.CabalHooks that correspond to a plain instantiation of the "simple" build systemCabalBasic autoconf : runs  ./configure , if present.the pre-hooks , , , ,  and + read additional build information from package .buildinfo , if present.Thus  configure/ can use local system information to generate package .buildinfo and possibly other files.+4                              ^__  b c d    !!!!!!!!"""""""""""""""""""""""""""""""#f##########################################g$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%&''''''''''''((((((((((((((((((((((((((((((((((((((())))))))))))))))))))))***++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,---.........................../////////////////////////////////////////////////////////////////////////////////////////////////000000000000000000000000000000000000xxxxxxxxxxxxxx2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222 2 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 5 5 5 5 6 6 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 77 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9               : : : : : : : : : : : : : : : : ; ; < < < < < < = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = > ? | | A A A A A A A A A A A A A A A A B B B B B B B B B B B B B B B B B B B C C C C C C C C C C C C C C C C C C C C C CCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDEEEEEEEFFFFFFFFFFFF}}}}}}}}}~~~~1111111111111111111111111GGGGGGGGGGGGGGGGGGGGGGGGGHHHHIJJKKKKKKKLMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNOPQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTU@@@@@@@@@@@@@@@@@@@@@@@@@@@@@VVVVVVVVVVW{WWWWWWXXXXXXXXXXXXYYYYYYYYYZZZZZZZZZZZZZZZZZZZ[[[[[[[[[[\\\\\\\\\\\]^______jeeehllhkkk k kkkkkk kknqqqqqrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrstttuuuuuuuuuuuuuuuuuuuuuvvvvvvvvvvvvvvvvvvvvvvvvvwwwwwwwwa'oxx8}}}}}}}}}}}}}}}}}}}}}}}ooooooooooo$Cabal-3.8.1.0-B0R5uDiDOgc9Mcr4OAtXboDistribution.Compat.Stack"Distribution.Simple.LocalBuildInfoDistribution.MakeDistribution.Simple.UtilsDistribution.Compat.DirectoryDistribution.Compat.FilePathDistribution.Compat.CreatePipe Distribution.Backpack.FullUnitIdDistribution.Backpack.ModSubst!Distribution.Backpack.ModuleShape$Distribution.Backpack.PreModuleShapeDistribution.Compat.Process Distribution.Compat.ResponseFileDistribution.ReadE$Distribution.Simple.BuildToolDependsDistribution.Simple.CCompilerDistribution.Simple.Flag(Distribution.Simple.InstallDirs.InternalDistribution.Simple.InstallDirs$Distribution.Simple.PreProcess.Unlit$Distribution.Simple.Program.InternalDistribution.TestSuiteDistribution.Types.AnnotatedId#Distribution.Types.ComponentInclude*Distribution.Types.ComponentLocalBuildInfo Distribution.Types.DumpBuildInfo!Distribution.Types.GivenComponent$Distribution.Types.PackageName.MagicDistribution.Types.TargetInfoDistribution.Utils.IODataDistribution.Utils.JsonDistribution.Utils.MapAccumDistribution.Utils.ProgressDistribution.Verbosity.InternalDistribution.VerbosityDistribution.Utils.NubListDistribution.Utils.LogProgress(Distribution.Simple.Program.ResponseFile Distribution.Simple.Program.Find!Distribution.Simple.Program.TypesDistribution.Simple.Program.Run"Distribution.Simple.Program.ScriptDistribution.Simple.Program.Hpc Distribution.Simple.PackageIndex&Distribution.Simple.PackageDescriptionDistribution.Simple.GlobDistribution.Simple.Compiler!Distribution.Simple.Program.HcPkgDistribution.Simple.GHCJSDistribution.Simple.Program.GHC#Distribution.Simple.Program.BuiltinDistribution.Simple.Program.DbDistribution.Simple.Program!Distribution.Simple.Program.StripDistribution.Simple.CommandDistribution.Simple.Setup!Distribution.Types.LocalBuildInfoDistribution.Simple.Hpc Distribution.Simple.Build.Macros%Distribution.Backpack.ComponentsGraphDistribution.Simple.Test.LogDistribution.Simple.Program.LdDistribution.Simple.Program.ArDistribution.Simple.Configure)Distribution.Backpack.ConfiguredComponent%Distribution.Backpack.LinkedComponentDistribution.Simple.BuildTargetDistribution.Simple.BuildPathsDistribution.Simple.UHC Distribution.Simple.HaskellSuiteDistribution.Simple.GHC!Distribution.Simple.ShowBuildInfoDistribution.Simple.Install%Distribution.Simple.Build.PathsModuleDistribution.Simple.Test.LibV09Distribution.Simple.Test.ExeV10%Distribution.PackageDescription.CheckDistribution.Compat.TimeDistribution.Backpack.Configure$Distribution.Backpack.DescribeUnitIdDistribution.Simple.RegisterDistribution.Simple.PreProcessDistribution.Simple.UserHooksDistribution.Simple.TestDistribution.Simple.BenchDistribution.Simple.SrcDistDistribution.Simple.BuildDistribution.Simple.HaddockDistribution.Simple!Distribution.Backpack.ModuleScope*Distribution.Backpack.PreExistingComponentDistribution.Compat.Async$Distribution.Compat.GetShortPathName%Distribution.Compat.Internal.TempFileDistribution.Compat.CopyFile$Distribution.Compat.Prelude.InternalSystem.Process createProcess rawSystemrunInteractiveProcessDistribution.Compat.SnocList Verbosity annotateIODistribution.Compat.EnvironmentControl.Exception IOExceptionDistribution.GetOptSystem.EnvironmentgetArgsDistribution.LexDistribution.PackageCheckDistribution.Utils.UnionFindDistribution.Backpack.UnifyMDistribution.Backpack.MixLinkDistribution.ZinzaPrelude'Distribution.Simple.Build.PathsModule.Z"Distribution.Simple.Build.Macros.Z Paths_Cabal Distribution.Simple.GHC.ImplInfo D.C.SetupfilterConfigureFlagsbuildDistribution.Backpack.Id Distribution.Simple.GHC.Internal)Distribution.Simple.GHC.EnvironmentParserTestType$Distribution.Backpack.ReadyComponentbaseGHC.Stack.Types CallStack+Cabal-syntax-3.8.1.0-3wqkBKyVQKyGg3OBBvtt1F%Distribution.Types.PackageDescription getComponentlookupComponentpkgBuildableComponents pkgComponentsDistribution.Types.Component componentNamecomponentBuildablecomponentBuildInfo foldComponentCBenchCTestCExeCFLibCLib ComponentDistribution.LicenseUnknownLicense OtherLicenseUnspecifiedLicenseAllRightsReserved PublicDomainApacheMPLISCMITBSD4BSD3BSD2LGPLAGPLGPLLicense Distribution.Types.ComponentNamecomponentNameStringshowComponentName CBenchName CTestNameCExeName CFLibNameCLibName ComponentNameDistribution.Types.LibraryNamedefaultLibName LSubLibName LMainLibName LibraryNameDistribution.Types.VersionVersionDistribution.Utils.GenericisRelativeOnAnyPlatformisAbsoluteOnAnyPlatform unintersperse lowercaseequatingsafeInitsafeLastsafeTailsafeHeadlistUnionRight ordNubRight listUnionordNubByordNubtakeWhileEndLEdropWhileEndLEnormaliseLineEndings writeUTF8FilewithUTF8FileContents readUTF8File ignoreBOM toUTF8LBStoUTF8BS fromUTF8LBS fromUTF8BSwriteFileAtomicwithFileContentswrapLinewrapTextData.Ord comparing Data.OldList isInfixOf intercalate GHC.StackwithFrozenCallStack callStack GHC.ExceptionprettyCallStackdirectory-1.3.6.0System.Directory doesPathExist listDirectory makeAbsolutefilepath-1.4.2.1System.FilePath.PosixstripExtension isExtensionOf'process-1.6.15.0-KLHm6qyFI1i1N285xDypJ0System.Process.Internals createPipeFullDb FullUnitIdexpandOpenUnitId expandUnitId$fShowFullUnitId$fGenericFullUnitIdModSubstmodSubst $fModSubst(,) $fModSubst[] $fModSubstMap $fModSubstSet$fModSubstOpenUnitId$fModSubstOpenModule ModuleShapemodShapeProvidesmodShapeRequiresemptyModuleShapeshapeInstalledPackage$fModSubstModuleShape$fStructuredModuleShape$fBinaryModuleShape$fEqModuleShape$fShowModuleShape$fGenericModuleShapePreModuleShapepreModShapeProvidespreModShapeRequirestoPreModuleShaperenamePreModuleShapemixLinkPreModuleShape$fEqPreModuleShape$fShowPreModuleShape$fGenericPreModuleShapecreateTempDirectorysetFileOrdinarysetFileExecutableenableProcessJobsexpandResponse WithCallStackparentSrcLocPrefixwithLexicalCallStackannotateCallStackIOReadErunReadE succeedReadE failReadE parsecToReadEparsecToReadEErrunexpectMsgString$fFunctorReadEdesugarBuildToolgetAllToolDependencies isInternalgetAllInternalToolDependenciesCDialectC ObjectiveC CPlusPlusObjectiveCPlusPluscSourceExtensionscDialectFilenameExtensionfilenameCDialect$fSemigroupCDialect$fMonoidCDialect $fEqCDialect$fShowCDialect BooleanFlagasBoolFlagNoFlagtoFlagfromFlagfromFlagOrDefault flagToMaybeflagElim flagToListallFlags maybeToFlag $fEnumFlag $fBoundedFlag$fSemigroupFlag $fMonoidFlag$fApplicativeFlag $fFunctorFlag$fStructuredFlag $fBinaryFlag$fBooleanFlagBool$fEqFlag $fGenericFlag $fShowFlag $fReadFlagPathTemplateVariable PrefixVar BindirVar LibdirVar LibsubdirVar DynlibdirVar DatadirVar DatasubdirVar DocdirVar HtmldirVar PkgNameVar PkgVerVarPkgIdVar LibNameVar CompilerVarOSVarArchVarAbiVar AbiTagVarExecutableNameVarTestSuiteNameVarTestSuiteResultVarBenchmarkNameVar PathComponentOrdinaryVariable$fReadPathTemplateVariable$fShowPathTemplateVariable $fStructuredPathTemplateVariable$fBinaryPathTemplateVariable$fReadPathComponent$fShowPathComponent$fStructuredPathComponent$fBinaryPathComponent$fEqPathComponent$fOrdPathComponent$fGenericPathComponent$fEqPathTemplateVariable$fOrdPathTemplateVariable$fGenericPathTemplateVariablePathTemplateEnv PathTemplateCopyDest NoCopyDestCopyToCopyToDbInstallDirTemplates InstallDirsprefixbindirlibdir libsubdir dynlibdirflibdir libexecdir libexecsubdir includedirdatadir datasubdirdocdirmandirhtmldir haddockdir sysconfdircombineInstallDirsdefaultInstallDirsdefaultInstallDirs'substituteInstallDirTemplatesabsoluteInstallDirsprefixRelativeInstallDirstoPathTemplatefromPathTemplatecombinePathTemplatesubstPathTemplateinitialPathTemplateEnvpackageTemplateEnvcompilerTemplateEnvplatformTemplateEnvabiTemplateEnvinstallDirsTemplateEnv$fSemigroupInstallDirs$fMonoidInstallDirs$fStructuredInstallDirs$fBinaryInstallDirs$fBinaryCopyDest$fReadPathTemplate$fShowPathTemplate$fStructuredPathTemplate$fBinaryPathTemplate$fEqPathTemplate$fOrdPathTemplate$fGenericPathTemplate $fEqCopyDest$fShowCopyDest$fGenericCopyDest$fEqInstallDirs$fReadInstallDirs$fShowInstallDirs$fFunctorInstallDirs$fGenericInstallDirsplainunlitstripExtractVersionResultPassFailErrorProgressFinishedOptionsGroup ExtraOptions groupName concurrently groupTests OptionType OptionFile OptionString OptionNumber OptionBool OptionEnum OptionSet OptionRngSeedoptionFileMustExistoptionFileIsDiroptionFileExtensionsoptionStringMultilineoptionNumberIsIntoptionNumberBounds OptionDescr optionNameoptionDescription optionType optionDefault TestInstancerunnametagsoptions setOption testGroup $fEqResult $fReadResult $fShowResult$fEqOptionDescr$fReadOptionDescr$fShowOptionDescr$fEqOptionType$fReadOptionType$fShowOptionType AnnotatedIdann_pid ann_cnameann_id$fFunctorAnnotatedId$fPackageAnnotatedId$fOrdAnnotatedId$fEqAnnotatedId$fShowAnnotatedIdComponentInclude ci_ann_id ci_renaming ci_implicitci_idci_pkgidci_cnameComponentLocalBuildInfoLibComponentLocalBuildInfoFLibComponentLocalBuildInfoExeComponentLocalBuildInfoTestComponentLocalBuildInfoBenchComponentLocalBuildInfocomponentLocalNamecomponentComponentIdcomponentUnitIdcomponentIsIndefinite_componentInstantiatedWithcomponentPackageDepscomponentIncludescomponentExeDepscomponentInternalDepscomponentCompatPackageKeycomponentCompatPackageNamecomponentExposedModulescomponentIsPubliccomponentIsIndefinitemaybeComponentInstantiatedWith$fIsNodeComponentLocalBuildInfo#$fStructuredComponentLocalBuildInfo$fBinaryComponentLocalBuildInfo $fGenericComponentLocalBuildInfo$fReadComponentLocalBuildInfo$fShowComponentLocalBuildInfo DumpBuildInfoNoDumpBuildInfo$fStructuredDumpBuildInfo$fBinaryDumpBuildInfo$fReadDumpBuildInfo$fShowDumpBuildInfo$fEqDumpBuildInfo$fOrdDumpBuildInfo$fEnumDumpBuildInfo$fBoundedDumpBuildInfo$fGenericDumpBuildInfoGivenComponentgivenComponentPackagegivenComponentNamegivenComponentId$fStructuredGivenComponent$fBinaryGivenComponent$fGenericGivenComponent$fReadGivenComponent$fShowGivenComponent$fEqGivenComponent nonExistentPackageThisIsCabalBugfakePackageNamefakePackageCabalFileName fakePackageId TargetInfo targetCLBItargetComponent$fIsNodeTargetInfo IODataModeIODataModeTextIODataModeBinaryKnownIODataModehGetIODataContentstoIOData iodataModeIOData IODataText IODataBinary withIODatanull hPutContents$fNFDataIOData$fKnownIODataModeByteString$fKnownIODataMode[]Json JsonArrayJsonBoolJsonNull JsonNumber JsonObject JsonString renderJson.= $fShowJson mapAccumM$fApplicativeStateM$fFunctorStateM stepProgress failProgress foldProgress$fAlternativeProgress$fApplicativeProgress$fMonadProgress$fFunctorProgress VerbosityFlag VCallStack VCallSiteVNoWrap VMarkOutput VTimestampVStderrVNoWarnVerbosityLevelSilentNormalVerbose Deafening$fStructuredVerbosityLevel$fBinaryVerbosityLevel$fStructuredVerbosityFlag$fBinaryVerbosityFlag$fGenericVerbosityFlag$fShowVerbosityFlag$fReadVerbosityFlag$fEqVerbosityFlag$fOrdVerbosityFlag$fEnumVerbosityFlag$fBoundedVerbosityFlag$fGenericVerbosityLevel$fShowVerbosityLevel$fReadVerbosityLevel$fEqVerbosityLevel$fOrdVerbosityLevel$fEnumVerbosityLevel$fBoundedVerbosityLevelsilentnormalverbose deafening moreVerbose lessVerbosemodifyVerbosityintToVerbosityflagToVerbosity showForCabal showForGHCverboseCallSiteverboseCallStackverboseMarkOutputverboseUnmarkOutput verboseNoWrapverboseTimestampverboseNoTimestamp verboseStderrverboseNoStderr verboseNoWarnverboseNoFlagsverboseHasFlagsisVerboseCallSiteisVerboseCallStackisVerboseMarkOutputisVerboseNoWrapisVerboseQuietisVerboseTimestampisVerboseStderrisVerboseNoWarn$fPrettyVerbosity$fParsecVerbosity$fStructuredVerbosity$fBinaryVerbosity$fBoundedVerbosity$fEnumVerbosity$fOrdVerbosity $fEqVerbosity$fGenericVerbosity$fShowVerbosity$fReadVerbosityTempFileOptionsoptKeepTempFiles cabalVersiondieNoVerbositydieWithLocation'die' dieNoWraptopHandlerWith topHandlerwarnnotice noticeNoWrap noticeDoc setupMessageinfo infoNoWrapdebug debugNoWrap chattyTryhandleDoesNotExistwithOutputMarker maybeExitprintRawCommandAndArgsprintRawCommandAndArgsAndEnv rawSystemExitrawSystemExitCoderawSystemExitWithEnvrawSystemIOWithEnvrawSystemIOWithEnvAndActioncreateProcessWithEnvrawSystemStdoutrawSystemStdInOut ignoreSigPipefindProgramVersionxargs findFileCwd findFileExfindFileWithExtensionfindFileCwdWithExtensionfindAllFilesCwdWithExtensionfindAllFilesWithExtensionfindFileWithExtension' findFirstFilefindModuleFilesExfindModuleFileExgetDirectoryContentsRecursiveisInSearchPathaddLibraryPathmoreRecentFileexistsAndIsMoreRecentThancreateDirectoryIfMissingVerbosecopyFileVerboseinstallOrdinaryFileinstallExecutableFileinstallMaybeExecutableFile copyFileTo copyFilesinstallOrdinaryFilesinstallExecutableFilesinstallMaybeExecutableFilesinstallDirectoryContentscopyDirectoryRecursivedoesExecutableExistdefaultTempFileOptions withTempFilewithTempFileExwithTempDirectorywithTempDirectoryEx rewriteFileExrewriteFileLBS currentDirshortRelativePathdropExeExtension exeExtensionsdefaultPackageDescfindPackageDescfindPackageDescCwdtryFindPackageDesctryFindPackageDescCwdfindHookedPackageDesc $fEqTraceWhenNubListR fromNubListRNubList fromNubList toNubList overNubList toNubListR overNubListR$fStructuredNubList$fBinaryNubList $fReadNubList $fShowNubList$fSemigroupNubList$fMonoidNubList$fReadNubListR$fShowNubListR$fSemigroupNubListR$fMonoidNubListR $fEqNubListR $fEqNubList$fGenericNubList LogProgressrunLogProgress warnProgress infoProgress dieProgressaddProgressCtx$fMonadLogProgress$fApplicativeLogProgress$fFunctorLogProgresswithResponseFileProgramSearchPathEntryProgramSearchPathDirProgramSearchPathDefaultProgramSearchPathdefaultProgramSearchPathfindProgramOnSearchPathprogramSearchPathAsPATHVargetSystemSearchPath"$fStructuredProgramSearchPathEntry$fBinaryProgramSearchPathEntry$fEqProgramSearchPathEntry$fGenericProgramSearchPathEntryProgramLocation UserSpecified FoundOnSystem locationPathConfiguredProgram programIdprogramVersionprogramDefaultArgsprogramOverrideArgsprogramOverrideEnvprogramPropertiesprogramLocationprogramMonitorFilesProgArgProgram programNameprogramFindLocationprogramFindVersionprogramPostConfprogramNormaliseArgs programPathsuppressOverrideArgs simpleProgramsimpleConfiguredProgram$fStructuredProgramLocation$fBinaryProgramLocation$fStructuredConfiguredProgram$fBinaryConfiguredProgram $fShowProgram$fEqConfiguredProgram$fGenericConfiguredProgram$fReadConfiguredProgram$fShowConfiguredProgram$fEqProgramLocation$fGenericProgramLocation$fReadProgramLocation$fShowProgramLocation IOEncodingIOEncodingTextIOEncodingUTF8ProgramInvocationprogInvokePathprogInvokeArgs progInvokeEnvprogInvokePathEnv progInvokeCwdprogInvokeInputprogInvokeInputEncodingprogInvokeOutputEncodingemptyProgramInvocationsimpleProgramInvocationprogramInvocationrunProgramInvocationgetProgramInvocationOutputgetProgramInvocationLBS#getProgramInvocationOutputAndErrorsgetEffectiveEnvironmentmultiStageProgramInvocationinvocationAsSystemScriptinvocationAsShellScriptinvocationAsBatchFilemarkupunion SearchResultNone Unambiguous AmbiguousInstalledPackageIndex PackageIndexfromListmergeinsert deleteUnitIddeleteSourcePackageIddeletePackageName allPackagesallPackagesByNameallPackagesBySourcePackageId&allPackagesBySourcePackageIdAndLibName lookupUnitIdlookupComponentIdlookupSourcePackageIdlookupPackageIdlookupPackageNamelookupDependencylookupInternalDependency searchByNamesearchByNameSubstringsearchWithPredicatedependencyCyclesbrokenPackagesdependencyClosurereverseDependencyClosuretopologicalOrderreverseTopologicalOrderdependencyGraphdependencyInconsistenciesmoduleNameIndex$fSemigroupPackageIndex$fMonoidPackageIndex$fStructuredPackageIndex$fBinaryPackageIndex$fEqPackageIndex$fGenericPackageIndex$fShowPackageIndex$fReadPackageIndexreadGenericPackageDescriptionreadHookedBuildInfo parseStringGlobGlobSyntaxErrorStarInDirectoryStarInFileNameStarInExtensionNoExtensionOnStar EmptyGlobLiteralFileNameGlobStarVersionDoesNotSupportGlobStarVersionDoesNotSupportGlob GlobResult GlobMatchGlobWarnMultiDotGlobMissingDirectoryexplainGlobSyntaxErrorfileGlobMatches parseFileGlobmatchDirFileGlobmatchDirFileGlobWithDierunDirFileGlob$fEqIsRecursive$fEqGlobSyntaxError$fShowGlobSyntaxError$fShowGlobResult$fEqGlobResult$fOrdGlobResult$fFunctorGlobResultProfDetailLevelProfDetailNoneProfDetailDefaultProfDetailExportedFunctionsProfDetailToplevelFunctionsProfDetailAllFunctionsProfDetailOther CompilerFlagDebugInfoLevel NoDebugInfoMinimalDebugInfoNormalDebugInfoMaximalDebugInfoOptimisationLevelNoOptimisationNormalOptimisationMaximumOptimisationPackageDBStack PackageDBGlobalPackageDB UserPackageDBSpecificPackageDBCompiler compilerIdcompilerAbiTagcompilerCompatcompilerLanguagescompilerExtensionscompilerPropertiesshowCompilerIdshowCompilerIdWithAbicompilerFlavorcompilerVersioncompilerCompatFlavorcompilerCompatVersion compilerInforegistrationPackageDBabsolutePackageDBPathsabsolutePackageDBPathflagToOptimisationLevelflagToDebugInfoLevelunsupportedLanguageslanguageToFlagsunsupportedExtensionsextensionsToFlagsparmakeSupportedreexportedModulesSupportedrenamingPackageFlagsSupportedunifiedIPIDRequiredpackageKeySupportedunitIdSupportedbackpackSupportedlibraryDynDirSupportedarResponseFilesSupportedarDashLSupportedcoverageSupportedprofilingSupportedlibraryVisibilitySupportedflagToProfDetailLevelknownProfDetailLevelsshowProfDetailLevel$fStructuredPackageDB$fBinaryPackageDB$fStructuredOptimisationLevel$fBinaryOptimisationLevel$fStructuredDebugInfoLevel$fBinaryDebugInfoLevel$fStructuredCompiler$fBinaryCompiler$fStructuredProfDetailLevel$fBinaryProfDetailLevel$fEqProfDetailLevel$fGenericProfDetailLevel$fReadProfDetailLevel$fShowProfDetailLevel $fEqCompiler$fGenericCompiler$fShowCompiler$fReadCompiler$fBoundedDebugInfoLevel$fEnumDebugInfoLevel$fEqDebugInfoLevel$fGenericDebugInfoLevel$fReadDebugInfoLevel$fShowDebugInfoLevel$fBoundedOptimisationLevel$fEnumOptimisationLevel$fEqOptimisationLevel$fGenericOptimisationLevel$fReadOptimisationLevel$fShowOptimisationLevel $fEqPackageDB$fGenericPackageDB$fOrdPackageDB$fShowPackageDB$fReadPackageDBRegisterOptionsregisterAllowOverwriteregisterMultiInstanceregisterSuppressFilesCheck HcPkgInfo hcPkgProgram noPkgDbStack noVerboseFlagflagPackageConfsupportsDirDbsrequiresDirDbsnativeMultiInstancerecacheMultiInstancesuppressFilesCheckinitinvokedefaultRegisterOptionsregister unregisterrecacheexposedescribehidedumplistinitInvocationregisterInvocationunregisterInvocationrecacheInvocationexposeInvocationdescribeInvocationhideInvocationdumpInvocationlistInvocation GhcImplInfosupportsHaskell2010supportsGHC2021 reportsNoExtalwaysNondecIndentflagGhciScript flagProfAuto flagDebugInfosupportsDebugLevelssupportsPkgEnvFilesflagWarnMissingHomeModules getImplInfo GhcProfAutoGhcProfAutoAllGhcProfAutoToplevelGhcProfAutoExportedGhcDynLinkMode GhcStaticOnlyGhcDynamicOnlyGhcStaticAndDynamicGhcOptimisationGhcNoOptimisationGhcNormalOptimisationGhcMaximumOptimisationGhcSpecialOptimisationGhcModeGhcModeCompile GhcModeLink GhcModeMakeGhcModeInteractiveGhcModeAbiHash GhcOptions ghcOptMode ghcOptExtraghcOptExtraDefaultghcOptInputFilesghcOptInputScriptsghcOptInputModulesghcOptOutputFileghcOptOutputDynFileghcOptSourcePathClearghcOptSourcePathghcOptThisUnitIdghcOptThisComponentIdghcOptInstantiatedWith ghcOptNoCodeghcOptPackageDBsghcOptPackagesghcOptHideAllPackagesghcOptWarnMissingHomeModulesghcOptNoAutoLinkPackagesghcOptLinkLibsghcOptLinkLibPathghcOptLinkOptionsghcOptLinkFrameworksghcOptLinkFrameworkDirs ghcOptLinkRts ghcOptNoLinkghcOptLinkNoHsMainghcOptLinkModDefFilesghcOptCcOptionsghcOptCxxOptionsghcOptAsmOptionsghcOptCppOptionsghcOptCppIncludePathghcOptCppIncludesghcOptFfiIncludesghcOptCcProgramghcOptLanguageghcOptExtensionsghcOptExtensionMapghcOptOptimisationghcOptDebugInfoghcOptProfilingModeghcOptProfilingAutoghcOptSplitSectionsghcOptSplitObjs ghcOptNumJobs ghcOptHPCDirghcOptGHCiScriptsghcOptHiSuffixghcOptObjSuffixghcOptDynHiSuffixghcOptDynObjSuffix ghcOptHiDir ghcOptObjDirghcOptOutputDir ghcOptStubDirghcOptDynLinkModeghcOptStaticLib ghcOptShared ghcOptFPicghcOptDylibName ghcOptRPathsghcOptVerbosityghcOptExtraPath ghcOptCabalnormaliseGhcArgsrunGHC ghcInvocationrenderGhcOptionspackageDbArgsDb$fSemigroupGhcOptions$fMonoidGhcOptions$fShowGhcOptions$fGenericGhcOptions$fShowGhcProfAuto$fEqGhcProfAuto$fShowGhcDynLinkMode$fEqGhcDynLinkMode$fShowGhcOptimisation$fEqGhcOptimisation $fShowGhcMode $fEqGhcModebuiltinPrograms ghcProgram runghcProgram ghcPkgProgram ghcjsProgramghcjsPkgProgram hmakeProgram jhcProgram uhcProgram hpcProgramhaskellSuiteProgramhaskellSuitePkgProgram happyProgram alexProgram gccProgram arProgram stripProgram hsc2hsProgram c2hsProgram cpphsProgramhscolourProgramdoctestProgramhaddockProgramgreencardProgram ldProgram tarProgram cppProgrampkgConfigProgram ProgramDbemptyProgramDbdefaultProgramDbrestoreProgramDbaddKnownProgramaddKnownProgramslookupKnownProgram knownProgramsgetProgramSearchPathsetProgramSearchPathmodifyProgramSearchPathuserSpecifyPathuserMaybeSpecifyPathuserSpecifyArgsuserSpecifyPathsuserSpecifyArgssuserSpecifiedArgs lookupProgram updateProgramconfiguredProgramsconfigureProgramunconfigureProgramconfigureAllKnownProgramsreconfigureProgramsrequireProgram needProgramlookupProgramVersionrequireProgramVersion$fStructuredProgramDb$fBinaryProgramDb$fReadProgramDb$fShowProgramDb runProgramgetProgramOutput runDbProgramgetDbProgramOutputstripExestripLib CommandSpecCommand CommandType NormalCommand HiddenCommand CommandParse CommandHelp CommandList CommandErrorsCommandReadyToGo MkOptDescrArgPlaceHolderOptFlagsLFlagsSFlagsOptDescrReqArgOptArg ChoiceOptBoolOpt OptionField optionDescr DescriptionNameShowOrParseArgsShowArgs ParseArgs CommandUI commandNamecommandSynopsis commandUsagecommandDescription commandNotescommandDefaultFlagscommandOptionsoption multiOptionreqArgoptArgreqArg'optArg'noArgboolOptboolOpt' choiceOptchoiceOptFromEnum liftOption liftOptionLcommandShowOptions usageDefaultusageAlternatives mkCommandUIcommandParseArgs hiddenCommandcommandAddAction commandsRun noExtraFlagsgetNormalCommandDescriptions helpCommandUIcommandFromSpec$fFunctorCommandParseBenchmarkFlagsbenchmarkDistPrefbenchmarkVerbositybenchmarkOptions TestFlags testDistPref testVerbosity testHumanLogtestMachineLogtestShowDetails testKeepTix testWrappertestFailWhenNoTestSuites testOptionsTestShowDetailsNeverFailuresAlways StreamingDirect ReplFlagsreplProgramPathsreplProgramArgs replDistPref replVerbosity replReloadreplReplOptions ReplOptionsreplOptionsFlagsreplOptionsNoLoad BuildFlagsbuildProgramPathsbuildProgramArgs buildDistPrefbuildVerbosity buildNumJobs buildArgsbuildCabalFilePath CleanFlags cleanSaveConf cleanDistPrefcleanVerbositycleanCabalFilePath HaddockFlagshaddockProgramPathshaddockProgramArgs haddockHoogle haddockHtmlhaddockHtmlLocationhaddockForHackagehaddockExecutableshaddockTestSuiteshaddockBenchmarkshaddockForeignLibshaddockInternal haddockCsshaddockLinkedSourcehaddockQuickJumphaddockHscolourCsshaddockContentshaddockDistPrefhaddockKeepTempFileshaddockVerbosityhaddockCabalFilePath haddockArgs HaddockTarget ForHackageForDevelopment HscolourFlags hscolourCSShscolourExecutableshscolourTestSuiteshscolourBenchmarkshscolourForeignLibshscolourDistPrefhscolourVerbosityhscolourCabalFilePath RegisterFlags regPackageDB regGenScript regGenPkgConf regInPlace regDistPref regPrintId regVerbosityregArgsregCabalFilePath SDistFlags sDistSnapshotsDistDirectory sDistDistPrefsDistListSourcessDistVerbosity InstallFlagsinstallPackageDB installDestinstallDistPrefinstallUseWrapperinstallInPlaceinstallVerbosityinstallCabalFilePath CopyFlagscopyDest copyDistPref copyVerbositycopyArgscopyCabalFilePath ConfigFlags configArgsconfigPrograms_configProgramPathsconfigProgramArgsconfigProgramPathExtraconfigHcFlavor configHcPath configHcPkgconfigVanillaLib configProfLibconfigSharedLibconfigStaticLib configDynExeconfigFullyStaticExe configProfExe configProfconfigProfDetailconfigProfLibDetailconfigConfigureArgsconfigOptimizationconfigProgPrefixconfigProgSuffixconfigInstallDirsconfigScratchDirconfigExtraLibDirsconfigExtraLibDirsStaticconfigExtraFrameworkDirsconfigExtraIncludeDirs configIPID configCIDconfigDeterministicconfigDistPrefconfigCabalFilePathconfigVerbosityconfigUserInstallconfigPackageDBs configGHCiLibconfigSplitSectionsconfigSplitObjsconfigStripExesconfigStripLibsconfigConstraintsconfigDependenciesconfigInstantiateWithconfigConfigurationsFlags configTestsconfigBenchmarksconfigCoverageconfigLibCoverageconfigExactConfigurationconfigFlagErrorconfigRelocatableconfigDebugInfoconfigDumpBuildInfoconfigUseResponseFiles!configAllowDependingOnPrivateLibs GlobalFlags globalVersionglobalNumericVersiondefaultDistPrefdefaultGlobalFlags globalCommandemptyGlobalFlagsconfigProgramsconfigAbsolutePathsdefaultConfigFlagsconfigureCommandconfigureOptionsreadPackageDbList readPackageDbshowPackageDbList showPackageDbinstallDirsOptionsemptyConfigFlagsdefaultCopyFlags copyCommandemptyCopyFlagsdefaultInstallFlagsinstallCommandemptyInstallFlagsdefaultSDistFlags sdistCommandemptySDistFlagsdefaultRegisterFlagsregisterCommandunregisterCommandemptyRegisterFlagsemptyHscolourFlagsdefaultHscolourFlagshscolourCommanddefaultHaddockFlagshaddockCommandhaddockOptionsemptyHaddockFlagsdefaultCleanFlags cleanCommandemptyCleanFlagsdefaultBuildFlags buildCommand buildOptionsemptyBuildFlagsdefaultReplFlags replCommand replOptionsdefaultTestFlags testCommand testOptions'emptyTestFlagsdefaultBenchmarkFlagsbenchmarkCommandbenchmarkOptions'emptyBenchmarkFlagsprogramFlagsDescriptionprogramDbPaths'programDbOptionstrueArgfalseArgoptionDistPrefoptionVerbosity optionNumJobs configureArgsconfigureCCompilerconfigureLinker splitArgs$fSemigroupGlobalFlags$fMonoidGlobalFlags$fSemigroupConfigFlags$fMonoidConfigFlags$fEqConfigFlags$fStructuredConfigFlags$fBinaryConfigFlags$fSemigroupCopyFlags$fMonoidCopyFlags$fSemigroupInstallFlags$fMonoidInstallFlags$fSemigroupSDistFlags$fMonoidSDistFlags$fSemigroupRegisterFlags$fMonoidRegisterFlags$fSemigroupHscolourFlags$fMonoidHscolourFlags$fParsecHaddockTarget$fPrettyHaddockTarget$fStructuredHaddockTarget$fBinaryHaddockTarget$fSemigroupHaddockFlags$fMonoidHaddockFlags$fSemigroupCleanFlags$fMonoidCleanFlags$fSemigroupBuildFlags$fMonoidBuildFlags$fSemigroupReplOptions$fMonoidReplOptions$fStructuredReplOptions$fBinaryReplOptions$fSemigroupReplFlags$fMonoidReplFlags$fSemigroupTestShowDetails$fMonoidTestShowDetails$fParsecTestShowDetails$fPrettyTestShowDetails$fStructuredTestShowDetails$fBinaryTestShowDetails$fSemigroupTestFlags$fMonoidTestFlags$fSemigroupBenchmarkFlags$fMonoidBenchmarkFlags$fShowBenchmarkFlags$fGenericBenchmarkFlags$fShowTestFlags$fGenericTestFlags$fEqTestShowDetails$fOrdTestShowDetails$fEnumTestShowDetails$fBoundedTestShowDetails$fGenericTestShowDetails$fShowTestShowDetails$fShowReplFlags$fGenericReplFlags$fShowReplOptions$fGenericReplOptions$fReadBuildFlags$fShowBuildFlags$fGenericBuildFlags$fShowCleanFlags$fGenericCleanFlags$fShowHaddockFlags$fGenericHaddockFlags$fEqHaddockTarget$fShowHaddockTarget$fGenericHaddockTarget$fShowHscolourFlags$fGenericHscolourFlags$fShowRegisterFlags$fGenericRegisterFlags$fShowSDistFlags$fGenericSDistFlags$fShowInstallFlags$fGenericInstallFlags$fShowCopyFlags$fGenericCopyFlags$fGenericConfigFlags$fReadConfigFlags$fShowConfigFlags$fGenericGlobalFlagsLocalBuildInfo configFlagsflagAssignmentcomponentEnabledSpecextraConfigArgsinstallDirTemplatescompiler hostPlatformbuildDir cabalFilePathcomponentGraphcomponentNameMap installedPkgs pkgDescrFile localPkgDescr withPrograms withPackageDBwithVanillaLib withProfLib withSharedLib withStaticLib withDynExewithFullyStaticExe withProfExewithProfLibDetailwithProfExeDetailwithOptimization withDebugInfo withGHCiLib splitSections splitObjs stripExes stripLibs exeCoverage libCoverage progPrefix progSuffix relocatablelocalComponentId localPackage localUnitIdlocalCompatPackageKeycomponentNameTargets' unitIdTarget'componentNameCLBIsallTargetsInBuildOrder'withAllTargetsInBuildOrder'neededTargetsInBuildOrder'withNeededTargetsInBuildOrder' testCoveragecomponentNameTargets unitIdTargetallTargetsInBuildOrderwithAllTargetsInBuildOrderneededTargetsInBuildOrderwithNeededTargetsInBuildOrder$fStructuredLocalBuildInfo$fBinaryLocalBuildInfo$fGenericLocalBuildInfo$fReadLocalBuildInfo$fShowLocalBuildInfocomponentBuildDir withLibLBI withExeLBI withBenchLBI withTestLBIenabledTestLBIsenabledBenchLBIswithAllComponentsInBuildOrderallComponentsInBuildOrderdepLibraryPaths allLibModulesabsoluteComponentInstallDirsabsoluteInstallCommandDirs"prefixRelativeComponentInstallDirsWayVanillaProfDynmixDirtixDir tixFilePathhtmlDirguessWay markupTest markupPackage $fBoundedWay $fEnumWay$fEqWay $fReadWay $fShowWaygenerateCabalMacrosHeadergeneratePackageVersionMacrosComponentsWithDepsComponentsGraphdispComponentsWithDepsmkComponentsGraphcomponentsGraphToListcomponentCycleMsgTestLogsTestLog GroupLogstestNametestOptionsReturned testResult TestSuiteLog testSuiteNametestLogslogFile PackageLogpackageplatform testSuiteslocalPackageLogcountTestResults suitePassed suiteFailed suiteErrortestSuiteLogPathsummarizePackage summarizeTestsummarizeSuiteFinishsummarizeSuiteStart$fReadPackageLog$fShowPackageLog$fEqPackageLog$fReadTestSuiteLog$fShowTestSuiteLog$fEqTestSuiteLog$fReadTestLogs$fShowTestLogs $fEqTestLogscombineObjectFilescreateArLibArchivecomputeComponentIdcomputeCompatPackageKeyConfiguredComponentMapConfiguredComponent cc_ann_id cc_component cc_public cc_exe_deps cc_includescc_cidcc_pkgidcc_namedispConfiguredComponenttoConfiguredComponentextendConfiguredComponentMaptoConfiguredComponentsnewPackageDepsBehaviourLinkedComponentMapLinkedComponent lc_ann_id lc_component lc_exe_deps lc_public lc_includeslc_sig_includeslc_shapelc_cidlc_pkgidlc_uidlc_instsdispLinkedComponenttoLinkedComponenttoLinkedComponentsextendLinkedComponentMap$fPackageLinkedComponent QualLevelQL1QL2QL3BuildTargetProblemBuildTargetExpectedBuildTargetNoSuchBuildTargetAmbiguousUserBuildTargetProblemUserBuildTargetUnrecognised BuildTargetBuildTargetComponentBuildTargetModuleBuildTargetFileUserBuildTargetreadTargetInfosbuildTargetComponentNamereadBuildTargetsreadUserBuildTargetsreportUserBuildTargetProblemsshowUserBuildTargetshowBuildTargetresolveBuildTargetsreportBuildTargetProblems$fBinaryBuildTarget $fMonadMatch$fApplicativeMatch$fFunctorMatch$fMonadPlusMatch$fAlternativeMatch$fShowMaybeAmbiguous $fShowMatch$fShowMatchError$fEqMatchError$fEqComponentKind$fOrdComponentKind$fShowComponentKind$fEnumComponentKind$fBoundedComponentKind$fEnumQualLevel$fShowQualLevel$fShowBuildTargetProblem$fShowUserBuildTargetProblem$fEqBuildTarget$fShowBuildTarget$fGenericBuildTarget$fShowUserBuildTarget$fEqUserBuildTarget$fOrdUserBuildTargetsrcPref hscolourPref buildInfoPrefhaddockDirName haddockPrefautogenPackageModulesDirautogenComponentModulesDir cppHeaderNameautogenPathsModuleName haddockNamegetLibSourceFilesgetExeSourceFilesgetFLibSourceFilesgetSourceFiles exeBuildDir flibBuildDirmkGenericStaticLibName mkLibName mkProfLibNamemkGenericSharedLibNamemkSharedLibNamemkStaticLibNamemkGenericSharedBundledLibName exeExtension objExtension dllExtensionstaticLibExtension configuregetInstalledPackagesbuildLibbuildExe installLibregisterPackageinplacePackageDbPath hstoolVersionnumericVersiongetCompilerVersion getExtensions getLanguages initPackageDB packageDbOptGhcEnvironmentFileEntryGhcEnvFileCommentGhcEnvFilePackageIdGhcEnvFilePackageDbGhcEnvFileClearPackageDbStackghcPlatformAndVersionStringsimpleGhcEnvironmentFilewriteGhcEnvironmentFilerenderGhcEnvironmentFile ParseErrorExcparseGhcEnvironmentFilereadGhcEnvironmentFile getGhcInfogetPackageDBContents getLibDirgetGlobalPackageDB getInstalledPackagesMonitorFilesreplLibstartInterpreter buildFLibreplFLibreplExe libAbiHashcomponentGhcOptionscomponentCcGhcOptions installExe installFLib isDynamic hcPkgInfopkgRootrunCmd getGhcAppDir mkBuildInfo mkBuildInfo'mkCompilerInfomkComponentInfoinstallgeneratePathsModule pkgPathEnvVarrunTeststubName stubFilePathwriteSimpleTestStubsimpleTestStubstubMain stubWriteLogCheckPackageContentOps doesFileExistdoesDirectoryExistgetDirectoryContentsgetFileContents PackageCheckPackageBuildImpossiblePackageBuildWarningPackageDistSuspiciousPackageDistSuspiciousWarnPackageDistInexcusable explanation checkPackagecheckConfiguredPackagecheckPackageFilescheckPackageContentcheckPackageFileNames$fShowPackageCheck $fEqPathKind$fEqPackageCheck$fOrdPackageCheck defaultMaindefaultMainArgsModTime getModTimeposixSecondsToModTime getFileAge getCurTimecalibrateMtimeChangeDelay $fReadModTime $fShowModTime$fStructuredModTime$fBinaryModTime$fGenericModTime$fBoundedModTime $fEqModTime $fOrdModTime!configureComponentLocalBuildInfos setupMessage'generateRegistrationInfoabiHashcreatePackageDBdoesPackageDBExistdeletePackageDB invokeHcPkggeneralInstalledPackageInfoinplaceInstalledPackageInfoabsoluteInstalledPackageInfointernalPackageDBPathPPSuffixHandler PreProcessorplatformIndependent ppOrderingrunPreProcessorunsortedmkSimplePreProcessorrunSimplePreProcessorpreprocessComponent ppGreenCardppUnlitppCppppCpp'ppHsc2hsppC2hsplatformDefinesppHappyppAlex ppSuffixesknownSuffixHandlerspreprocessExtras UserHooksreadDeschookedPreProcessorshookedProgramspreConfconfHookpostConfpreBuild buildHook postBuildpreReplreplHookpostReplpreClean cleanHook postCleanpreCopycopyHookpostCopypreInstinstHookpostInstpreRegregHookpostRegpreUnreg unregHook postUnreg preHscolour hscolourHook postHscolour preHaddock haddockHook postHaddockpreTesttestHookpostTestpreBench benchHook postBenchArgsemptyUserHookstestbenchConfigStateFileErrorConfigStateFileNoHeaderConfigStateFileBadHeaderConfigStateFileNoParseConfigStateFileMissingConfigStateFileBadVersiongetConfigStateFiletryGetConfigStateFiletryGetPersistBuildConfiggetPersistBuildConfigmaybeGetPersistBuildConfigwritePersistBuildConfigcheckPersistBuildConfigOutdatedlocalBuildInfoFile findDistPreffindDistPrefOrDefaultgetInternalLibrariescomputeEffectiveProfilinginterpretPackageDbFlagsccLdOptionsBuildInfoconfigCompilerAuxExconfigCompilerExcheckForeignDeps$fExceptionConfigStateFileError$fShowConfigStateFileErrorsdistlistPackageSourceslistPackageSourcesWithDie prepareTreeprepareSnapshotTreesnapshotPackagesnapshotVersiondateToSnapshotNumber createArchiveprintPackageProblemsreplcreateInternalPackageDBinitialBuildStepscomponentInitialBuildStepswriteAutogenFileshaddockhaddockPackagePathshscolour$fSemigroupDirectory$fMonoidDirectory$fSemigroupHaddockArgs$fMonoidHaddockArgs$fGenericHaddockArgs$fReadDirectory$fShowDirectory $fEqDirectory$fOrdDirectorydefaultMainWithHooksdefaultMainWithHooksArgsdefaultMainNoReaddefaultMainWithHooksNoReaddefaultMainWithHooksNoReadArgssimpleUserHooksautoconfUserHooks WithSourceDistribution.Backpack OpenModule ModuleSourceModuleRequiresModuleProvidesDistribution.ModuleName ModuleNameDistribution.Types.PackageName PackageName ModuleScopeemptyModuleScopeModuleWithSource FromMixinsFromBuildDependsFromExposedModulesFromOtherModulesFromSignaturesmodScopeProvidesmodScopeRequiresdispModuleSource unWithSource getSource'Distribution.Types.InstalledPackageInfoInstalledPackageInfoPreExistingComponent pc_pkgname pc_compnameipiToPreExistingComponent pc_munged_idpc_uidpc_cid pc_open_uidpc_shapeAsyncCancelledcancelAsyncMGHC.MVarMVar asyncThreadId GHC.Conc.SyncThreadIdAsync withAsyncuninterruptibleCancelwait waitCatch withAsyncNFgetShortPathName System.IOopenBinaryTempFile openTempFileopenNewBinaryFilecopyFilecopyFileChanged filesEqualcopyOrdinaryFilecopyExecutableFilesetDirOrdinaryGHC.Base++ghc-primGHC.PrimseqGHC.Listfilterzipprint Data.Tuplefstsnd otherwisemap$GHC.Real fromIntegral realToFrac Control.MonadguardjoinGHC.EnumBoundedmaxBoundminBoundEnumsuccpredtoEnumfromEnumenumFromThenTo enumFromToenumFrom enumFromThen GHC.ClassesEq==/= GHC.FloatFloatingpiexplogsqrt**logBasesincostanasinacosatansinhcoshtanhasinhatanhacosh Fractional/ fromRationalrecipIntegralquotremdivmodquotRem toIntegerdivModMonadreturn>>=>> Data.DataDataFunctorfmap<$GHC.NumNum+*abssignumnegate fromInteger-Ordminmax><=<>=compareGHC.ReadReadreadList readsPrecReal toRational RealFloat floatRadix floatDigits floatRange decodeFloat encodeFloatexponent significand scaleFloatisNaN isInfiniteisDenormalizedisNegativeZeroatan2isIEEERealFracproperFractiontruncateroundfloorceilingGHC.ShowShow showsPrecshowListshowData.Typeable.InternalTypeableControl.Monad.Fail MonadFailfail Data.StringIsString fromString Applicative<**><*>pure Data.FoldableFoldablefoldMapfoldrfoldlfoldl'lengthelemmaximumminimumsumtoListproductData.Traversable Traversable sequenceAtraverse GHC.GenericsGeneric Semigroup<>Monoidmconcatmemptymappend GHC.TypesBoolFalseTrueCharDoubleFloatIntGHC.IntInt8Int16Int32Int64integer-wired-inGHC.Integer.TypeInteger GHC.MaybeMaybeNothingJustOrderingGTLTEQRationalIOWordGHC.WordWord8Word16Word32Word64 Data.EitherEitherLeftRightDistribution.Compat.Prelude traceShow traceShowIdtracefoldl1foldr1 genericRnf<<>>Distribution.Compat.NonEmptySet NonEmptySetDistribution.Compat.SemigroupgmemptygmappendDistribution.Utils.Structured StructuredDistribution.Compat.Exception catchExitcatchIOtryIOpretty-1.1.3.6Text.PrettyPrint.HughesPJ<+>deepseq-1.4.4.0Control.DeepSeqNFDatarnfdeepseqforcecontainers-0.6.2.1Data.Set.InternalSetData.Map.InternalMapbinary-0.8.8.0Data.Binary.ClassBinaryputputListgetnot||&&GHC.Exception.Type SomeExceptionGHC.ErrerrorerrorWithoutStackTrace undefinedStringNonEmpty:| MonadPlusmplusmzero Alternativeempty<|>manysome=<<whenliftMliftM2apordidconst.flip$!untilasTypeOfsubtractcurryuncurry Data.Functor<$>void Data.Functionon Data.MaybemaybeisJust isNothing fromMaybe maybeToList listToMaybe catMaybesmapMaybescanlscanl1scanrscanr1iteraterepeat replicatecycle takeWhile dropWhiletakedropsplitAtspanbreakreverselookup!!zip3zipWithzipWith3unzipunzip3ShowSshowsshowChar showString showParenGHC.Charchrevenodd^^^gcdlcm GHC.UnicodeisSpaceisDigitisAlpha isAlphaNumisUppertoLowertoUpperText.ParserCombinators.ReadPReadS readParenlex Data.ProxyProxyeitherpartitionEithers Text.Readreads readMaybe dropWhileEnd isPrefixOf isSuffixOfnubnubBy intersperse partitionsortsortByunfoldrlinesunlineswordsunwords traverse_for_ sequence_concat concatMapandoranyallnotElemfindData.Functor.ConstConstgetConst Data.TypeableTypeReptypeRep Exception toExceptiondisplayException fromExceptionGHC.IO.ExceptionIOError userErrorGHC.IOFilePathcatchthrowIOevaluateExitCode ExitFailure ExitSuccessioErrorputCharputStrputStrLngetChargetLine getContentsinteractreadFile writeFile appendFilereadLnreadIOData.Functor.IdentityIdentity runIdentityforfilterMfoldMunless System.ExitexitWith exitFailure exitSuccessData.List.NonEmptynonEmptyheadtaillast Data.VoidVoidabsurdvacuous Control.ArrowfirstSnocListsnoc runSnocListsetEnvunsetEnv lookupEnvgetEnvironmentArgDescrNoArgArgOrder RequireOrderPermute usageInfogetOptgetOpt'OptiontokenizeQuotedWordsDistribution.Types.BuildInfobuildToolDepends BuildInfoDistribution.Types.ComponentId ComponentIdDistribution.Types.UnitIdUnitId!Distribution.Types.ModuleRenamingModuleRenamingversion0GHC.IO.Handle.Text hGetContentshPutStr GHC.IO.HandlehClosePointfresh equivalent ModuleScopeU ModuleSubstUUnitIdUModuleUDistribution.Types.ModuleModuleUnitIdU'ModuleU'UnifEnv unify_uniq unify_reqsunify_self_cidunify_verbosity unify_ctxunify_db unify_errsUnifyM runUnifyMliftSTGHC.STST getUnifEnv addErrContextaddErrContextMconvertModuleSubstconvertModuleSubstUemptyModuleScopeUconvertIncludeconvertModuleScopeUconvertModuleProvidesModuleProvidesUconvertModuleProvidesUModuleWithSourceU UnitIdThunkU ModuleVarUaddErrfailWith failIfErrstryM convertUnitId convertModuleconvertUnitIdUconvertModuleUmixLinkDistribution.Pretty prettyShowforM_Writer execWritertellZ zPackageNamezVersionDigits zSupportsCppzSupportsNoRebindableSyntax zAbsolute zRelocatable zIsWindowszIsI386zIsX8664zPrefixzBindirzLibdir zDynlibdirzDatadir zLibexecdir zSysconfdirzNotzManglePkgNamerenderZTool ztoolName ztoolVersionztoolXztoolYztoolZZPackagezpkgName zpkgVersionzpkgXzpkgYzpkgZ zPackageszTools zPackageKey zComponentIdzPackageVersionzNotNull zMangleStrversion getBinDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameDoc withMetadatawaitForProcessfindExecutablePackageInstalledDistribution.Types.PackageId PackageIdDistribution.CompilerunknownCompilerInfo abiTagStringperCompilerFlavorToListdefaultCompilerFlavorbuildCompilerIdbuildCompilerFlavorclassifyCompilerFlavorknownCompilerFlavorsCompilerFlavor OtherCompiler HaskellSuiteEtaUHCLHCJHCHeliumHBCHugsYHCNHCGHCGHCJSPerCompilerFlavor CompilerId CompilerInfocompilerInfoExtensionscompilerInfoLanguagescompilerInfoCompatcompilerInfoIdcompilerInfoAbiTagAbiTagNoAbiTagghcjsVersionImplInfoghcVersionImplInfo OpenModuleVar(Distribution.Types.VersionRange.InternalorLaterVersionprogramDbPaths"Distribution.Types.HookedBuildInfoHookedBuildInfoPackageIdentifierPackageDescriptionlibraryDistribution.Types.Executable ExecutablewithExeDistribution.Types.Benchmark BenchmarkDistribution.Types.LibraryLibraryDistribution.Compat.GraphGraph"Distribution.Types.IncludeRenamingIncludeRenaming OpenUnitIdconfigureToolchainfilterGhciFlags ghcArchStringDistribution.SystemArch ghcOsStringOSPlatformghcEnvironmentFileNamerenderGhcEnvironmentFileEntrytargetPlatformcomponentCxxGhcOptionscomponentAsmGhcOptionscomponentCmmGhcOptions mkGHCiLibNamemkGHCiProfLibNameghcLookupPropertygetHaskellObjectsmkGhcOptPackages substTopDircheckPackageDbEnvVarprofDetailLevelFlag,Distribution.Types.GenericPackageDescriptionGenericPackageDescription-Distribution.PackageDescription.ConfigurationflattenPackageDescriptionpackageVersion packageNamemungedVersion' mungedName'Package packageIdHasMungedPackageIdmungedId HasUnitIdinstalledUnitIdinstalledDependsDistribution.Types.DependencysimplifyDependency mainLibSet mkDependency depLibraries depVerRange depPkgName DependencyunsafeMkDefUnitIdgetHSLibraryNamemkLegacyUnitIdnewSimpleUnitIdmkUnitIdunUnitId DefUnitId unDefUnitIdpkgName pkgVersionDistribution.Types.AbiHash mkAbiHash unAbiHashAbiHash unComponentId mkComponentIdmkPackageNameST mkPackageNameunPackageNameST unPackageName Distribution.Types.PkgconfigNamemkPkgconfigNameunPkgconfigName PkgconfigNamegetModificationTimeIndefiniteComponentindefc_requiresindefc_providesindefc_includesInstantiatedComponent instc_instsinstc_insts_depsinstc_providesinstc_includesReadyComponent rc_open_uidrc_cid rc_component rc_exe_deps rc_publicrc_irc_uidrc_pkgid rc_dependstoReadyComponents rc_ann_iddispReadyComponent hsSourceDirsLanguage.Haskell.ExtensionknownExtensionsclassifyExtensiondeprecatedExtensionsclassifyLanguageknownLanguagesLanguageUnknownLanguageGHC2021 Haskell98 Haskell2010 ExtensionUnknownExtensionEnableExtensionDisableExtensionKnownExtension RelaxedLayout!AlternativeLayoutRuleTransitionalAlternativeLayoutRuleUnliftedDatatypesOverloadedRecordUpdateOverloadedRecordDotFieldSelectors LinearTypes QualifiedDoLexicalNegationUnliftedNewtypesStandaloneKindSignaturesImportQualifiedPostCUSKsEmptyDataDeriving StarIsTypeQuantifiedConstraintsNumericUnderscoresBlockArgumentsHexFloatLiterals UnboxedSums DerivingViaDerivingStrategiesTypeFamilyDependenciesOverloadedLabelsTemplateHaskellQuotesMonadFailDesugaringUndecidableSuperClasses TypeInTypeTypeApplicationsDuplicateRecordFields ApplicativeDo StrictDataStaticPointers DeriveLiftDeriveAnyClassNamedWildCardsPartialTypeSignaturesPatternSynonyms JavaScriptFFIAllowAmbiguousTypesExplicitNamespacesNullaryTypeClasses NumDecimalsBinaryLiteralsNegativeLiteralsAutoDeriveTypeable EmptyCaseOverloadedListsRoleAnnotationsParallelArrays DataKinds PolyKindsConstraintKindsUnsafe TrustworthySafe SafeImportsNondecreasingIndentationDeriveFoldableDeriveTraversable DeriveFunctorMonoLocalBindsDatatypeContextsExplicitForAllRebindableSyntax LambdaCase MultiWayIfDoAndIfThenElseNPlusKPatternsGHCForeignImportPrim TupleSectionsRegularPatterns XmlSyntax ViewPatternsMonadComprehensionsTransformListComp QuasiQuotesPostfixOperatorsNewQualifiedOperatorsImpredicativeTypesPackageImportsConstrainedClassMethods InstanceSigsDefaultSignatures DeriveGenericDeriveDataTypeable UnboxedTuplesExtendedDefaultRulesRelaxedPolyRec MonoPatBinds GADTSyntaxGADTsOverloadedStringsTraditionalRecordSyntaxDisambiguateRecordFields RecordPunsRecordWildCards TypeOperatorsLiberalTypeSynonymsCApiFFIInterruptibleFFIUnliftedFFITypes UnicodeSyntaxStandaloneDeriving TypeFamilies MagicHash HereDocumentsRestrictedTypeSynonymsExtensibleRecordsGeneralisedNewtypeDerivingGeneralizedNewtypeDeriving PatternGuardsNamedFieldPunsImplicitPreludeGenericsArrowsForeignFunctionInterfaceTemplateHaskellTypeSynonymInstances BangPatternsKindSignaturesCPPEmptyDataDeclsFlexibleInstancesFlexibleContextsImplicitParamsPatternSignaturesScopedTypeVariablesExistentialQuantificationPolymorphicComponents RankNTypes Rank2TypesFunctionalDependenciesMonomorphismRestrictionMultiParamTypeClassesParallelListComp RecursiveDoDoRecIncoherentInstancesUndecidableInstancesStrictOverlappingInstanceslicenseFromSPDX licenseToSPDX knownLicensesDistribution.VersiontransformCaretLowertransformCaretUppertransformCaretremoveLowerBoundremoveUpperBoundsimplifyVersionRangeisSpecificVersion isNoVersionDistribution.Types.VersionRange hasLowerBound hasUpperBound isAnyVersion withinRangestripParensVersionRangenormaliseVersionRangefoldVersionRange"Distribution.Types.VersionIntervalfromVersionIntervalstoVersionIntervalsasVersionIntervalsunVersionIntervalsVersionIntervalsVersionInterval LowerBound UpperBound NoUpperBoundBoundExclusiveBoundInclusiveBoundwildcardUpperBoundmajorUpperBoundhyloVersionRangeanaVersionRangeembedVersionRangecataVersionRangeprojectVersionRangemajorBoundVersion withinVersionintersectVersionRangesunionVersionRangesorEarlierVersionearlierVersion laterVersionnotThisVersion thisVersion noVersion anyVersion VersionRange VersionRangeFIntersectVersionRangesFUnionVersionRangesFMajorBoundVersionFOrEarlierVersionFEarlierVersionFOrLaterVersionF ThisVersionF LaterVersionF alterVersion nullVersionversionNumbers mkVersion' mkVersion