h-      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\] ^ _ ` a b c d e f ghij k lmnop q r s t u v w x y z { | } ~                                                                                                                                                                       !!!!!!!!!!!!!!!!""""""""""###$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''(((((((((((((((((((((()))))))))))))))))))))))))))))))))))))))))))))))******************+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + , , -                                                                                                       . . . . . . . . . . . . . . . . . . . . . . / / / / / / / / / 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 2 3 3 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 6 6 6 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 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 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 : : : : : : : : : : ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; < < < < < < < < < < < < < < < < < < < < < < < < < = = = = = ==========================================>>>>>>>??@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDEFGGGGGGGGGGGGGGGGGGGGHHIIJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKLLLLLLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPQQQQQQRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTU:::::::::::::U::::::::::::::::::::::::::UUUUUUUUUUUUUUUUUUUUUUUUVVVVWWWXX      YZ[[[[[[[[[[[[[[[[\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII^^^^^^^^^^______________________`aaaaaaaaaaaaaaaabcccccccccccccccccccccccccccd3.18.2.0None?BCDEFEFDBCGeHe None=I2Applying module substitutions to semantic objects.IJIJKf1 1$Lf/ /*Mf Nf# #Of' '#Pf3 3'gNone<=> An empty .Every Module in scope at a  is annotated with the  it comes from.INVARIANT: entries for ModuleName m, have msrc_module is OpenModuleVar mA  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.Description of where a module participating in mixin linking came from.An 4, annotated with where it came from in a Cabal file.hh h /h +None?QThe default module shape, with no provisions and no requirements.SA S describes the provisions and requirements of a library. We can extract a S from an .QRSTUVSTUVQRWi# #Xi! !Yi!!Zi& &[i!!\i$ $ None?]^_`abc`abc_^]dj ejfjkNoneThe exception thrown by  to terminate a thread.Async, but based on , as we don't depend on stm. Returns the " of the thread running the given .Spawn 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.Wait 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 . waitSTMWait 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 . waitCatchSTM.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.Cancel an asynchronous actionThis is a variant of , but it is not interruptible. l "l l mNone:Copies a file to a new destination. Often you should use  instead.Like , 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.Checks if two files are byte-identical. Returns False if either of the files do not exist or if files are of different size.hg Safe-InferredAAn Safe-InferredZsetEnv name value, sets the specified environment variable to value.o Safe-InferredpNoneiq Safe-Inferred  Safe-InferredjEnable 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.krs= with process jobs enabled when appropriate, and defaulting  delegate_ctlc to .jkkj Safe-Inferredl$This is a more elaborate version of tu, which not only substitute @foo with the contents of file foo, but performs such substitution recursively. In doing so we keep closer to the reference implementation of  expandargv in argv.c from binutils, although this additional functionality likely remains unused by Haskell tooling.l@l@ Safe-InferrednGive 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 ="; otherwise it's not very useful.no?>=mm=o?>n  Safe-Inferredpp None?qReturn the current time as t.r!Return age of given file in days.s+Return modification time of the given file.tFile's modification time, represented internally as a 64-bit unsigned integer in the Windows UTC format.Convert  to t.qrsttsrquv vv%wv')xvyv+.zv {v |v w(c) Sven Panne 2002-2005/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgportable Safe-Inferred(8 Process 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 ):The actual command line arguments (presumably got from xy). returns a triple consisting of the option arguments, a list of non-options, and a list of error messages.This 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.Return a string describing the usage of a command, derived from the header (first argument) and the options described by the second argument.Describes 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.no argument expectedoptional argumentoption requires argument-What to do with options following non-options*freely intersperse options and non-options+no option processing after first non-optionPretty printing of long options. * With required arguments can be given as: 3--with-compiler=PATH (but not --with-compiler PATH) This is displayed as: --with-compiler=PATH= * With optional but default arguments can be given as: )--jobs or --jobs=NUM (but not --jobs NUM) This is displayed as:  --jobs[=NUM]Pretty printing of short options. * With required arguments can be given as: #-w PATH or -wPATH (but not -w=PATH) This is displayed as: -w PATH or -wPATH= * With optional but default arguments can be given as: &-j or -jNUM (but not -j=NUM or -j NUM) This is displayed as: -j[NUM] z z: :{Ben Gamari 2015-2019cabal-devel@haskell.orgportable Safe-Inferredu*A simple parser supporting quoted strings.Please be aware that this will only split strings when seeing whitespace outside of quotation marks, i.e, "foo"bar baz"qux quux" will be converted to ["foobar bazqux", "quux"].4This behavior can be useful when parsing text like ,"ghc-options: -Wl,"some option with spaces"", for instance.|Francesco Ariis 2022BSD3cabal-devel@haskell.orgportableNone3b}+Filter Package Check by CheckExplanationID.~*Filter Package Check by Check explanation string.5Would Hackage refuse a package because of this error?A one-word identifier for each CheckExplanation.Pretty printing .Which stanza does  refer to?Explanations of  PackageCheck's errors/warnings.Identifier for the specific . This ensures `--ignore` can output a warning on unrecognised values. L N.B.: should be kept in sync with .-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.This package description is no good. There's no way it's going to build sensibly. This should give an error at configure time.A 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.An 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.An 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.Like PackageDistSuspicious but will only display warnings rather than causing abnormal exit when you run 'cabal check'.:Which language are we referring to in our warning message?Broken  instance (not bijective with Read), alas external packages depend on it.Pretty printing .Pretty printing .Pretty printing .}Original checks. IDs to omit.~Original checks.IDs to omit, in String format.}~}")} } } } } } }}}}}}}}} }Jose Iborra 2008BSD3cabal-devel@haskell.orgportableNone."Parser with simple error reporting~) )None_Desugar a "build-tools" entry into a proper 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.Same as , but requires atomic information (package name, executable names) instead of a whole .Get 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.Get 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.Does 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 ) 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. Safe-InferreddReturns the object extension for the given build way (e.g. "dyn_o" for  on ELF) " &       2011, Dan Knappcabal-devel@haskell.orgportable Safe-InferredTakes a dialect of C and whether code is intended to be passed through the preprocessor, and returns a filename extension for containing that code.A 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.Infers from a filename's extension the dialect of C which it contains, and whether it is intended to be passed through the preprocessor.Represents 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.   8Isaac Jones 2003-2004 Duncan Coutts 2007BSD3cabal-devel@haskell.orgportable Safe-InferredZ #Types that represent boolean flags.1All 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  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.Isomorphic to  a.Wraps a value in .Extracts a value from a , and throws an exception on .Extracts a value from a #, and returns the default value on . Converts a  value to a  value.CabalPushes a function through a & value, and returns a default if the  value is . Converts a  value to a list.Returns  only if every   value is Flag True, else . Converts a  value to a  value.Merge the elements of a list  with another list . #Isaac Jones, Simon Marlow 2003-2004=BSD3 portions Copyright (c) 2007, Galois Inc.cabal-devel@haskell.orgportableNone?a A piece of a globbing pattern A wildcard *A literal string dirABCA union of patterns, e.g. dir {a,*.txt,c}...6A single directory or file component of a globbed path!A filepath specified by globbing.  dirGlob/ glob**/ glob, where ** denotes recursively traversing all directories and matching filenames on  glob.Note that the  glob portion can only match on filenames, not paths, so for example **foo*.txt is not supported. A file glob.Trailing dir; a glob ending in /.   = =< <  - -, ,* *****: :::::None? A description of a file (or set of files) to monitor for changes.Where file paths are relative they are relative to a common directory (e.g. project root), not necessarily the process current directory.e.g. "/", "c:" or result of  takeDriveA file path specified by globbing, relative to some root directory.Monitor a single file for changes, based on its modification time. The monitored file is considered to have changed if it no longer exists or if its modification time has changed.Monitor a single file for changes, based on its modification time and content hash. The monitored file is considered to have changed if it no longer exists or if its modification time and content hash have changed.Monitor a single non-existent file for changes. The monitored file is considered to have changed if it exists.Monitor a single file for existence only. The monitored file is considered to have changed if it no longer exists.Monitor a single directory for changes, based on its modification time. The monitored directory is considered to have changed if it no longer exists or if its modification time has changed.Monitor a single non-existent directory for changes. The monitored directory is considered to have changed if it exists.Monitor a single directory for existence. The monitored directory is considered to have changed only if it no longer exists.Monitor a single file or directory for changes, based on its modification time. The monitored file is considered to have changed if it no longer exists or if its modification time has changed.Monitor a set of files (or directories) identified by a file glob. The monitored glob is considered to have changed if the set of files matching the glob changes (i.e. creations or deletions), or for files if the modification time and content hash of any matching file has changed.Monitor a set of files (or directories) identified by a file glob for existence only. The monitored glob is considered to have changed if the set of files matching the glob changes (i.e. creations or deletions).Creates a list of files to monitor when you search for a file which unsuccessfully looked in notFoundAtPaths before finding it at  foundAtPath. Similar to ?, but also instructs us to monitor the hash of the found file.what the glob is relative tothe glob##   !   < <; ; $  #  $    9 99999  Safe-Inferred?DThe $prefix path variableThe $bindir path variableThe $libdir path variableThe  $libsubdir path variableThe  $dynlibdir path variableThe $bytecodelibdir path variableThe $datadir path variableThe  $datasubdir path variableThe $docdir path variableThe $htmldir path variableThe $pkg package name path variableThe $version package version path variableThe $pkgid package Id path variable, eg foo-1.0The $libname path variable"The compiler name and version, eg  ghc-6.6.1The operating system name, eg windows or linuxThe CPU architecture name, eg i386 or x86_64The compiler's ABI identifier,%The optional ABI tag for the compiler+The executable name; used in shell wrappers$The name of the test suite being run,The result of the test suite being run, eg pass, fail, or error.#The name of the benchmark being run # # ) % %   "    Isaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone#Determine if the parallelism strategy enables parallel builds.Used by Cabal to indicate that we want to use this specific semaphore (created by cabal-install)Used by cabal-install to say we want to create a semaphore with N slots.How to control parallelism, e.g. a fixed number of jobs or by using a system semaphore.Compile in parallel with the given number of jobs (`-jN` or `-j`).No parallelism (neither `-jN` nor `--semaphore`, but could be `-j1`).=`--semaphore`: use a system semaphore to control parallelism. .  None ?!The  contains all the information necessary to build a specific target (e.g., componentmodule4file) in a package. In principle, one can get the 3 from a  and LocalBuildInfo, but it is much more convenient to have the component in hand.! ! $ $" "! Safe-Inferred+,6 Cabal1Phantom-typed GADT representation of the mode of , containing no other data.Cabal 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 mode2How Text gets encoded is usually locale-dependent.2Raw binary which gets read/written in binary mode.$Applies a function polymorphic over  to an  value. Test whether  is emptyCabal Wrapper for  and This is the dual operation to ., and consequently the handle is closed with .Note: this performs lazy-IO.  ) ) ( )" Safe-Inferred#A shorthand for building up s >>> JsonObject [ "a" .= JsonNumber 42, "b" .= JsonBool True ] JsonObject [("a",JsonNumber 42),("b",JsonBool True)] Convert a  into a  ByteString   # Safe-Inferred0Monadic variant of  mapAccumL. - +$ Safe-Inferred<Fail the computation. 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 RightEmit a step and then continue.A 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/ 9? ?* ; ;$ Safe-Inferred0 5Test if two points are in the same equivalence class.6Return the canonical element of an equivalence class .2Create a fresh equivalence class with one element.Unify two equivalence classes, so that they share a canonical element. Keeps the descriptor of point2.A variable which can be unified; alternately, this can be thought of as an equivalence class with a distinguished representative."The internal data structure for a , which either records the representative element of an equivalence class, or a link to the . that actually stores the representative type.Read the current value of .)Flatten any chains of links, returning a 8 which points directly to the canonical representation.Mutable write to a  % Safe-Inferred?Cabal   #   "    "$&)+/18      " $ & ) + / 1 8&Ian Lynagh 2007BSD3cabal-devel@haskell.orgportableNone? %5Verbosity information which can be passed by the CLI.Handles to use for logging (e.g. log to stdout, or log to a file).5Rich verbosity, used for the Cabal library interface."The handle used for normal output. With the +stderr* verbosity flag, this is the error handle.+The verbosity handle used for error output.In  mode, we should not print anything unless an error occurs.&Print stuff we want to see by default.&Be more verbose about what's going on.Not only are we verbose ourselves (perhaps even noisier than when being 3), but we tell everything we run to be verbose too.#Increase verbosity level, but stay  if we are.*Make sure the verbosity level is at least  , but stay  if we are.#Decrease verbosity level, but stay  if we are.Numeric verbosity level 0..3: 0 is , 3 is ./Turn on verbose call-site printing when we log.0Turn on verbose call-stack printing when we log.Turn on -----BEGIN CABAL OUTPUT----- markers for output from Cabal (as opposed to GHC, or system dependent).Turn off marking; useful for suppressing nondeterministic output.'Disable line-wrapping for log messages.Mark the verbosity as quiet.$Turn on timestamps for log messages.%Turn off timestamps for log messages.CabalSwitch logging to .CabalSwitch logging to .#Turn off warnings for log messages.,Helper function for flag enabling functions.-Helper function for flag disabling functions.Turn off all flags.0Test if we should output call sites when we log.1Test if we should output call stacks when we log.!Test if we should output markers.3Test if line-wrapping is disabled for log messages.Test if we had called  on the verbosity.0Test if we should output timestamps when we log.CabalTest if we should output to  when we log..Test if we should output warnings when we log.+Helper function for flag testing functions.Parser verbosity-explicitEitherParsec parsecVerbosity "normal"Right (VerbosityFlags {vLevel = Normal, vFlags = fromList [], vQuiet = False})6explicitEitherParsec parsecVerbosity "normal+nowrap "Right (VerbosityFlags {vLevel = Normal, vFlags = fromList [VNoWrap], vQuiet = False})explicitEitherParsec parsecVerbosity "normal+nowrap +markoutput"Right (VerbosityFlags {vLevel = Normal, vFlags = fromList [VNoWrap,VMarkOutput], vQuiet = False})explicitEitherParsec parsecVerbosity "normal +nowrap +markoutput"Right (VerbosityFlags {vLevel = Normal, vFlags = fromList [VNoWrap,VMarkOutput], vQuiet = False})?explicitEitherParsec parsecVerbosity "normal+nowrap+markoutput"Right (VerbosityFlags {vLevel = Normal, vFlags = fromList [VNoWrap,VMarkOutput], vQuiet = False})explicitEitherParsec parsecVerbosity "deafening+nowrap+stdout+stderr+callsite+callstack"Right (VerbosityFlags {vLevel = Deafening, vFlags = fromList [VCallStack,VCallSite,VNoWrap,VStderr], vQuiet = False})Note:& this parser will eat trailing spaces.66 % !   #       "$'None !+,12359?>#A token constructor used to define = instances on types that involve existential quantification.A wrapper used to pass evidence of a constraint as an explicit value.The rule command together with the result of the (optional) dynamic dependency computation./Only the (optional) dynamic dependency command.Both the rule command and the (optional) dynamic dependency command./The result of a dynamic dependency computation.A dynamic dependency command.A placeholder for a command that has been omitted, e.g. when we don't care about serialising/deserialising one particular command in a datatype.Commands to execute a rule:6for a rule with static dependencies, a single command,for a rule with dynamic dependencies, a command for computing dynamic dependencies, and a command for executing the rule. Prefer using  and , instead of the (internal) constructors of .*A rule with statically-known dependencies.A  for arg. The command to execute the rule.A  for the triple (depsArg,depsRes,arg).The command to execute the rule. It will receive the result of the dynamic dependency computation.A dynamic dependency computation. The resulting dependencies will be injected into the build graph, and the result of the computation will be passed on to the command that executes the rule.>A rule with dynamic dependencies, which consists of two parts:a dynamic dependency computation, that returns additional edges to be added to the build graph together with an additional piece of data,the command to execute the rule itself, which receives the additional piece of data returned by the dependency computation.=Internal datatype used for commands, both for the Hooks API () and for the build system.Static evidence that the argument can be serialised and deserialised.6The (possibly dynamic) argument to pass to the action.)The (statically-known) action to execute.A command consists of a statically-known action together with a (possibly dynamic) argument to that action.For example, the action can consist of running an executable (such as happy or c2hs), while the argument consists of the variable component of the command, e.g. the specific file to run happy on.>A static pointer (in user scope) or its key (in system scope).A collection of s.Use the 1 smart constructor instead of directly using the  constructor.Rules are registered using  registerRule,2Monitored files or directories are declared using addRuleMonitors; a change in these will trigger the recomputation of all rules.The env type parameter represents an extra argument, which usually consists of information known to Cabal such as LocalBuildInfo and ComponentLocalBuildInfo.8Monad transformer for defining rules. Usually wraps the  monad, allowing IO actions to be performed using liftIO.'The environment within the monadic API.Monad for constructing rules.)A reference to an output of another rule.%which particular output of that rule?)which rule's outputs are we referring to?A dependency of a rule.*A dependency on an output of another rule.?A direct dependency on a file at a particular location on disk.This should not be used for files that are generated by other rules; use  instead.A (fully resolved) location of a dependency or result of a rule, consisting of a base directory and of a file path relative to that base directory path.)In practice, this will be something like  dir (moduleNameSymbolicPath mod  . "hs") , where:for a file dependency, dir( is one of the Cabal search directories,for an output, dir is a directory such as autogenComponentModulesDir or componentBuildDir.File path relative to base directory (including file extension).Base directory.A rule consists of:%an action to run to execute the rule,-a description of the rule inputs and outputs.Use  or  to construct a rule, overriding specific fields, rather than directly using the  constructor.Please use the  or  smart constructors instead of this constructor, in order to avoid relying on internal implementation details.Results of this rule.!Static dependencies of this rule.To run this rule, which s should we execute?-s are defined with rich types by the package.The build system only has a limited view of these; most data consists of opaque  ByteStrings.The 9 data-type describes which side of this divide we are on.User space (with rich types)..Build-system space (manipulation of raw data).A unique identifier for a .Internal function: create a  from a . A rule with static dependencies./Prefer using this smart constructor instead of  whenever possible. See also - which adds support for dynamic dependencies.>A rule with dynamic dependencies, which consists of two parts:a dynamic dependency computation, that returns additional edges to be added to the build graph, together with an additional piece of data,the command to execute the rule itself, which receives the additional piece of data returned by the dependency computation./Prefer using this smart constructor instead of  whenever possible.Use - if you do not have any dynamic dependencies.6Get a (relative or absolute) un-interpreted path to a .An empty collection of rules.3Construct a collection of rules with a given label.3A label for the rules can be constructed using the static keyword, using the StaticPointers# extension. NB: separate calls to  should have different labels.Example usage: myRules :: Rules env myRules = rules (static ()) $ \ env -> do { .. } -- use the monadic API here2Internal function to create a collection of rules. API users should go through the  function instead.#Internal function: run the monadic * computations in order to obtain all the  s with their s.Construct a command./Prefer using this smart constructor instead of  whenever possible.Run a .Project out the (optional) dependency computation command, so that it can be serialised without serialising anything else.Obtain the (optional) + action that computes dynamic dependencies.Project out the command for running the rule, passing in the result of the dependency computation if there was one. Obtain the  action that executes a rule.Serialise and deserialise a raw ByteString, leaving it untouched.Serialise/deserialise, always including the length of the payload. Trimmed down % instance, mostly for error messages.Warning: this  instance is not commutative.command to execute the rulestatic dependencies of the rule rule resultsevidence that the result of the dynamic dependency command is serialisabledynamic dependency computation, returning dynamic dependencies and an additional piece of data to be consumed by the main rule commandmain rule command; takes in the piece of data returned by the dyn-deps commandstatic dependencies of the rule rule results)unique label for this collection of rulesthe computation of rulesrule namespacethe computation of rules     #    !  8/-+)+  +  ' )    2 )+029;" #%)""$* ")( ")( ")( ")(,,(?8642-+-(None+,9 AN error involving the Rules in the  SetupHooks0 module of a package with the Hooks build-type.?There are cycles in the dependency graph of fine-grained rules.When executing fine-grained rules compiled into the external hooks executable, we failed to find dependencies of a rule.When executing fine-grained rules compiled into the external hooks executable, a rule failed to generate the outputs it claimed it would.An invalid reference to a rule output, e.g. an out-of-range index. A duplicate ( in the construction of pre-build rules.An error involving the  SetupHooks, module of a package with Hooks build-type.Cannot apply a diff to a component in a per-component configure hook.An error with pre-build rules.missing dependenciesmissing outputsrule dependencyoutputs of dependencythe invalid index+ +  &))Isaac Jones 2006, Duncan Coutts 2007-2009cabal-devel@haskell.orgportableNone?R&The full path of a configured program.Make a simple . 2simpleConfiguredProgram "foo" (FoundOnSystem path)/Suppress any extra arguments added by the user.Represents 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.Default command-line args for this program. These flags will appear first on the command line, so they can be overridden by subsequent flags.Just the name againLocation of the program. eg. /usr/bin/ghc-6.4In addition to the  where the program was found, these are additional locations that were looked at. The combination of this 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).Override command-line args for this program. These flags will appear last on the command line, so they override all earlier flags.Override 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.A 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.,The version of this program, if it is known.-Represents a program which can be configured.9Note: rather than constructing this directly, start with  simpleProgram and override any extra fields.A function to search for the program if its location was not specified by the user. Usually this will just be a call to findProgramOnSearchPath.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.Try 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.'The simple name of the program, eg. ghcA 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.A 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.Where 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.$The program was found automatically.The user gave the path to this program, eg. --ghc-path=/usr/bin/ghc-6.6A 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 (findExecutable) 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]We also use this path to set the environment when running child processes.The  ProgramDb is created with a ProgramSearchPath to which we prependProgramSearchPath to add the ones that come from cli flags and from configurations. Then each of the programs that are configured in the db inherits the same path as part of configureProgram.The system defaultA specific dir "   '   $  $  & $ +*+(c) 2003-2005, Isaac Jones, Malcolm WallaceBSD3cabal-devel@haskell.orgportableNone3? {A suffix (or file extension).Mostly used to decide which preprocessor to use, e.g. files with suffix "y" are usually processed by the "happy" build tool.>A command to run a given preprocessor on a single source file.The input and output file paths are passed in as arguments, as it is the build system and not the package author which chooses the location of source files.The 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, ppOrdering = \_ _ -> return, 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 ()We 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!2Location of the source file relative to a base dir0Output file name, relative to an output base dir      #%-+NoneeNoLibraryFound has been downgraded to a warning, and is therefore no longer emitted.                                                          ) ),...cabal-devel@haskell.orgportableNone No unliteration.   takes a filename (for error reports), and transforms the given string, to eliminate the literate comments from the program text.  None p!)Add a fixed message to the error context.Add a message to the error context. It may make monadic queries. Convert a S into a ", so we can do unification on it. Convert a  to a  Convert a  to a  Convert a  to a .Conversion of  ModuleSubst to Conversion of  to  ModuleSubst An empty .(Get the current unification environment.Lift a computation from  monad to  monad. Internal use only.+Run a computation in the unification monad.The mutable counterpart of .The mutable counterpart of a  ModuleSubst (not defined here).A mutable version of # which can be imperatively unified.Contents of a mutable  reference.The unification environment.The error reporting context0The package index for expanding unit identifiersAccumulated errorsThe 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.Component 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.%A supply of unique integers to label  cells. This is used to determine loops in unit identifiers (which can happen with mutual recursion.)'How verbose the error message should beThe unification monad, this monad encapsulates imperative unification.A mutable version of # which can be imperatively unified.Contents of a mutable  reference.The mutable counterpart of A convenient alias for mutable references in the unification monad.!An integer for uniquely labeling  nodes. We need these labels in order to efficiently serialize s into s (we use the label to check if any parent is the node in question, and if so insert a deBruijn index instead.) These labels must be unique across all s/$s which participate in unification!Returns  if there is no a mutually recursive unit. | Otherwise returns a list of signatures instantiated by given .Imperatively read a .Imperatively write a .)    None1Given to scopes of provisions and requirements, link them together.Link a list of possibly provided modules to a single requirement. This applies a side-condition that all of the provided modules at the same name are *actually* the same module.Imperatively unify two modules.None  # #None?None? -cabal-devel@haskell.orgportableNone  None?Data file location, and package version and installation directories. Safe-InferredThe package version.If the argument is a filename, the result is the name of a corresponding file on the system on which the program is running, if the file were listed in the  data-files field of the package's Cabal package description file. No check is performed that the given filename is listed in that field.3The location of the directory specified by Cabal's --bindir option (where executables that the user might invoke are installed). This can be overridden at runtime using the environment variable Cabal_bindir.3The location of the directory specified by Cabal's --libdir option (where object libraries are installed). This can be overridden at runtime using the environment variable Cabal_libdir.3The location of the directory specified by Cabal's  --dynlibdir option (where dynamic libraries are installed). This can be overridden at runtime using the environment variable Cabal_dynlibdir.3The location of the directory specified by Cabal's  --datadir option (where architecture-independent data files are installed). This can be overridden at runtime using the environment variable Cabal_datadir.3The location of the directory specified by Cabal's  --libexedir option (where executables that are not expected to be invoked directly by the user are installed). This can be overridden at runtime using the environment variable Cabal_libexedir.3The location of the directory specified by Cabal's  --sysconfdir option (where configuration files are installed). This can be overridden at runtime using the environment variable Cabal_sysconfdir.#Isaac Jones, Simon Marlow 2003-2004=BSD3 portions Copyright (c) 2007, Galois Inc.cabal-devel@haskell.orgportableNone+,35= Given 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.) Cabal compiler information, reported by `--version-full` but otherwise unused. Cabal Git information. Only filled in if built in a Git tree in development mode and Template Haskell is available. Perform an IO action, catching any IO exceptions and printing an error if one occurs. ?Recursively copy the contents of one directory to another path. Given a relative path to a file, copy it to the given directory, preserving the relative path and creating the parent directories if needed. Given a relative path to a file, copy it to the given directory, preserving the relative path and creating the parent directories if needed. Copies 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. Copies 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. Same as createDirectoryIfMissing% but logs at higher verbosity levels. 'Detailed internal debugging information6We display these messages when the verbosity level is   A variant of   that doesn't perform the automatic line wrapping. Produces better output in some cases. Package description file (pkgname.cabal$) in the current working directory. Like ., but also checks that the file is executable. "Drop the extension if it's one of   , or return the path unchanged. 7Append a call-site and/or call-stack based on Verbosity /Add all necessary metadata to a logging message List of possible executable file extensions on the current build platform. Like  -, but also checks that the first file exists. Cabal 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. Like   but returns which element of the search path the file was found in, and the file path relative to that base directory. Find a file by looking in a search path. The file path must match exactly. Find 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. Like   but returns which element of the search path the file was found in, and the file path relative to that base directory. Find auxiliary package information in the given directory. Looks for  .buildinfo files. 5Find 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. 5Find 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. Finds the files corresponding to a list of Haskell module names.As   but for a list of module names. Finds the files corresponding to a list of Haskell module names.As findModuleFile but for a list of module names. Find a package description file in the given directory. Looks for .cabal files. Look 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. fromJust for dealing with 'Maybe Handle' values as obtained via r. Creating a pipe using  CreatePipe guarantees a $ value for the corresponding handle. 9List 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. !Run an IO computation, returning e- if it raises a "file does not exist" error. #Ignore SIGPIPE in a subcomputation. ,More detail on the operation of some action.6We display these messages when the verbosity level is  This 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. Install 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.  This is like   but uses  . Install a file that may or not be executable, preserving permissions.  This is like   but uses  . Install 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.  This is like   but uses  . ,Is this directory in the system search path? Check that the type of the exception matches the given user error type. Helper to use with one of the  rawSystem? variants, and exit unless the command completes successfully. Compare 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. Useful 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. Pretty-print a  status message at : verbosity level. Use this if you need fancy formatting. Display a message at ( verbosity level, but without wrapping. Execute the given command with the given arguments, exiting with the same exit code if the command fails. Execute the given command with the given arguments, returning the command's exit code. Execute the given command with the given arguments and environment, exiting with the same exit code if the command fails. Like  ", but setting a working directory. Execute the given command with the given arguments, returning the command's exit code.Optional arguments allow setting working directory, environment and input and output handles. Execute the given command with the given arguments, returning the command's exit code. action is executed while the command is running, and would typically be used to communicate with the process through pipes.Optional arguments allow setting working directory, environment and input and output handles. Execute the given command with the given arguments, returning the command's exit code.!Create the process argument with  s* to ensure consistent options with other  rawSystem functions in this module. Execute the given command with the given arguments, returning the command's exit code. action is executed while the command is running, and would typically be used to communicate with the process through pipes.!Create the process argument with  s* to ensure consistent options with other  rawSystem functions in this module. Execute the given command with the given arguments, returning the command's output, errors and exit code.Optional arguments allow setting working directory, environment and command input.Provides control over the binary/text mode of the input and output. Execute the given command with the given arguments, returning the command's output. Exits if the command exits with error.9Provides control over the binary/text mode of the output. A robust helper to remove an existing file, which does not throw an exception if such file never existed, thus akin to removePathForcibly. Write 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. Same as   but for  ByteStrings. Display a "setup status message". Prefer using setupMessage' if possible. stripCommonPrefix xs ys gives you ys without the common prefix with xs. Like   , but calls die in case of error. Non fatal conditions that may be indicative of an error or problem.We display these at the  verbosity level. Like  , but prepend Error: @ instead of  Warning: @ before the the message. Useful when you want to highlight the condition is an error but do not want to quit the program yet. (Hold an exclusive cross-process lock on lockPath for the duration of action., creating the lock file if it does not exist. Wrap 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  %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: 4withTempDirectory "src" "sdist." $ \tmpDir -> do ...The tmpDir: will be a new subdirectory of the given directory, e.g.  src/sdist.342. %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: 4withTempDirectory "src" "sdist." $ \tmpDir -> do ...The tmpDir: will be a new subdirectory of the given directory, e.g.  src/sdist.342.  A version of   that additionally takes a   argument.  A version of   that additionally takes a   argument. 3Use a temporary filename that doesn't already exist 4Use a temporary filename that doesn't already exist.  A version of   that additionally takes a   argument. Like 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 bigArgs Advanced options for   and  . Keep temporary files?Append a trailing newline to a string if it does not already have a trailing newline./When should we output the marker? Things like die always get marked, but a 5 will only be output if we're not a quiet verbosity.When should we emit the call stack? We always emit for internal errors, emit the trace for errors when we are in verbose mode, and otherwise only emit it if explicitly asked for using the  +callstack# verbosity flag. (At the moment,  is not used.Prefixing a message to indicate that it is a fatal error, if the  is not already present.4A prefix indicating that a message is a fatal error.,Annotate an error string with timestamp and ./Add all necessary metadata to a logging message A version of 5 that is careful to not close the handles stored in .Common implementation of  ,  ,   and  .BC wrapper around .'A lens for the error message inside an . Check if an % should be output verbatim to screen.2A semantic editor for the error message inside an .Tag an = whose error string should be output to the screen verbatim.Log a command execution (that's typically about to happen) at info level, and log working directory and environment overrides at debug level if specified..Prefix an error string with program name from Determine if we should emit a call stack. If we trace, it also emits any prefix we should append. Create a ) whose error text will be output verbatim%Warning message, with a custom label.8Prepend a call-site and/or call-stack based on VerbosityPrepends a timestamp if  +timestamp verbosity flag is setThis is used by Wraps text unless the +nowrap verbosity flag is active .a description of the action we were attemptingthe action itself Create its parents too? working directory extensionsrelative search locationsbasename working directorysearch directories File Name search directories File Name Working directoryDirectory to searchdir/pkgname .buildinfo , if present "build prefix (location of objects)search suffixesmodule "build prefix (location of objects)search suffixesmodule "build prefix (location of objects)search suffixesmodules "build prefix (location of objects)search suffixesmodules package directory  version args8function to select version number from program outputlocation New working dir or inheritNew environment or inheritstdinstdoutstderr  argumentsNew working dir or inheritNew environment or inherit7action to perform after process is created, but before waitForProcess.stdinstdoutstderr Program location ArgumentsNew working dir or inheritNew environment or inheritinput text and binary modeiodata mode, acts as proxyoutput, errors, exit 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  . Monoid 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.1Helper used by NubList/NubListR's Read instances.    1      4 4% 8 8(  &  )  ( > >-  . ; ;$  %  0/None +Add a message to the error/warning context. +Fail the computation with an error message. )Output an informational trace message in  . Run  !, outputting traces according to , die if there is an error. "Output a warning trace message in  . The 4 monad with specialized logging and error messages.:Format a message with context. (Something simple for now.)   & &! # # * *0Duncan Coutts 2009cabal-devel@haskell.orgportableNone+,3 Return the current environment extended with the given overrides. If an entry is specified twice in  overrides%, the second entry takes precedence. getEffectiveEnvironment returns  when there are no overrides. It returns an argument that is suitable to pass directly to  CreateProcess to override the environment. If you need the full environment to manipulate further, even when there are no overrides, then call  . Like  , but when no overrides are specified, returns the full environment instead of . Like 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 7Represents 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. 6TODO: remove this, make user decide when constructing  .  1Duncan Coutts 2009cabal-devel@haskell.orgportableNone+, 5Generate a Windows batch file that invokes a program. 5Generate a POSIX shell script that invokes a program. Generate a system script, either POSIX shell script or Windows batch file as appropriate for the given system.  2(c) Sergey Vinokurov 2017 BSD3-stylecabal-devel@haskell.orgNone3  Template for response file name.+Encoding to use for response file contents.$Arguments to put into response file.  3Thomas Tuegel 2011cabal-devel@haskell.orgportableNone3s %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. Path to .tix filePaths to .mix file directories(Path where html output should be located(List of modules to include in the report Paths to .tix filesPath to resultant .tix file%List of modules to exclude from unionPath to .tix filePaths to .mix file directories)Path where html output should be locatedList of modules to includePaths to .tix filesPath to resultant .tix file%List of modules to exclude from union  4Duncan Coutts 2013cabal-devel@haskell.orgportableNone Adds some paths to the PATH entry in the key-value environment provided or if there is none, looks up $PATH in the real environment. =Get the system search path. On Unix systems this is just the $PATH6 env var, but on windows it's a bit more complicated.  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%. Make 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 ... }   5(c) David Himmelstrup 2005, Bjorn Bringert 2007, Duncan Coutts 2008-2009cabal-devel@haskell.orgportableNone?H! $Get all the packages from the index. $Get all the packages from the index.4They are grouped by package name (case-sensitively).$(Doesn't include private libraries.) $Get all the packages from the index.They are grouped by source package id (package name and version).#(Doesn't include private libraries) $Get all the packages from the index.7They are grouped by source package id and library name.%This DOES include internal libraries. All packages that have immediate dependencies that are not in the index.Returns such packages along with the dependencies that they're missing. Removes all packages with this (case-sensitive) name from the index.9NB: Does NOT delete internal libraries from this package. &Removes all packages with this source  from the index. 2Removes a single installed package from the index. Tries 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. Find 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. +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  . Given 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. Filter a set of installed packages to ones eligible as dependencies.When we select for dependencies, we ONLY want to pick up indefinite packages, or packages with no instantiations. We'll do mix-in linking to improve any such package into an instantiated one later.INVARIANT: List of eligible  is non-empty. *Build an index out of a bunch of packages.If there are duplicates by $ then later ones mask earlier ones. (Inserts a single package into the index.8This is equivalent to (but slightly quicker than) using  or   with a singleton index. Does a lookup by component identifier. In the absence of Backpack, this is just a  . =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. =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. 6Does a lookup by source package name and library name. Also looks up internal packages. Convenient alias of  0, but assuming only one package per package ID. %Does a lookup by source package name. 4Does 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. !Does a lookup by unit identifier..Since multiple package DBs mask each other by (, then we get back at most one package. 2Get eligible dependencies from a list of versions.)This can be used to filter the output of   or  .INVARIANT: List of eligible  is non-empty. Merge 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. 7A 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. Takes the transitive closure of the packages reverse dependencies. The given s must be in the index. /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. 9Does a case-insensitive substring search by package name.That is, all packages that contain the given string in their name. Cabal )The default package index which contains InstalledPackageInfo. Normally use this. >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.(We maintain the invariant that, for any =, there is only one instance of the package in our database.& &   -     8  ;  $   56Isaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone3 Collapse duplicate experimental feature warnings into single warning, with a count of further sites 3Helper combinator to do parsing plumbing for files.Given a parser and a filename, return the parse of the file, after checking if the file exists.:Argument order is chosen to encourage partial application. #File contents to final value parserVerbosity level File name #File contents to final value parserVerbosity levelWorking directory File to read working directory  7#Isaac Jones, Simon Marlow 2003-2004=BSD3 portions Copyright (c) 2007, Galois Inc.cabal-devel@haskell.orgportableNone3< How/does the glob match the given filepath, according to the cabal version? Since this is pure, we don't make a distinction between matching on directories or files (i.e. this function won't return  ) Cabal #Extract the matches from a list of  s.Note: throws away the   results; chances are that you want to check for these and error out if any are present. Is the root of this relative glob path a directory-recursive wildcard, e.g. **/*.txt ?  This will die' 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 die Cabal Match a  against the file system, starting from a given root directory. The results are all relative to the given root. 6Match a globbing pattern against a file path component ?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. $The glob matched the value supplied. Cabal The glob matched a directory when we were looking for files only. It didn't match a file! The 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'). The 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.>Check how the string matches the glob under this cabal version If the glob we are running should care about the cabal spec, and warnings such as  , then this should be the version. If you want to run a glob but don't care about any of the cabal-spec restrictions on globs, use !      #    Francesco Ariis 2022BSD3cabal-devel@haskell.orgportableNone Jask( (from Control.Monad.Reader) for CheckM.0Pure check not requiring IO or other interfaces.Like , except performs the check when our spec version >= the param.Execute a CheckM monad, leaving `m [PackageCheck]` which can be run in the appropriate m environment (IO, pure, @).Adds useful bits to  (as now, whether we are operating under a user off-by-default flag).Lift a monadic action via an interface. Missing interface, no action.local( (from Control.Monad.Reader) for CheckM.Creates a pristing . With pristine we mean everything that can be deduced by GPD but *not* user flags information.As  but always succeeding.Context to perform checks (will be the Reader part in your monad).Which interface to we have available/should we use? (to perform: pure checks, package checks, pre-distribution checks.),Check monad, carrying a context, collecting s. Using Set for writer (automatic sort) is useful for output stability on different platforms. It is nothing more than a monad stack with Reader+Writer. m; is the monad that could be used to do package/file checks. A record of operations needed to check the contents of packages. Abstracted over m< to provide flexibility (could be IO, a .tar.gz file, etc).A record of operations needed to check contents *of the work tree* (compare it with  ). This is still m abstracted in case in the future we can obtain the same infos other than from IO (e.g. a VCS work tree).:A collection os names, shipping tuples around is annoying. collects contextual information on the target we are realising: a buildup of the various slices of the target (a library, executable, etc. @ is a monoid) whether we are under an off-by-default package flag.Most basic check function. You do not want to export this, rather export @smart@ functions (checkP, checkPkg) to enforce relevant properties.As , but - does not depend on the monadic computation.Generalised version for checks that need an interface. We pass a Reader accessor to such interface @i@, a check function.Init names from a GPD.!Lift a monadic computation to CM.4Add a package warning withoutu performing any check. ! #( +Lennart Kolmodin 2008, Francesco Ariis 2023BSD3cabal-devel@haskell.orgportableNoneAA conditional target is a library, exe, benchmark etc., destructured in a CondTree. Traversing method: we render the branches, pass a relevant context, collect checks.Before walking a target , we need to annotate it with information relevant to the checks (read TaraAnn and  doc for more info).7Condvar checking (misspelled OS in if conditions, etc).nf function is needed to appropriately name some targets which need to be spoonfed (otherwise name appears as "").)We @build up@ target from various slices.8Isaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone3<=>?/ Make package paths absolute Does 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. Does this compiler's "ar" command supports response file arguments (i.e. @file-style arguments). $Does this compiler support Backpack? Does the compiler support producing bytecode objects and bytecode libraries? Transform a package db using a FilePath into one using symbolic paths. Is 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 ... Is 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:_)) -> ... _ -> ... 4Does this compiler support Haskell program coverage? 2Is the compiler distributed with dynamic libraries For the given compiler, return the flags for the supported extensions. ,Does this compiler support the -jsem option? 7What semaphore protocol version does this compiler use?Returns Nothing for compilers that don't report a "Semaphore version" field in  ghc --info# (i.e. GHC 9.8@9.14, which use v1). Does this compiler support a package database entry with: "dynamic-library-dirs"? Does this compiler support a package database entry with: "visibility"? (Does this compiler support package keys? 0Does this compiler support parallel --make mode? Does this compiler support thinning/renaming on package flags? :Does this compiler have unified IPIDs (so no package keys) $Does this compiler support unit IDs? For the given compiler, return the extensions it does not support. Tag for distinguishing incompatible ABI's on the same architecture/os. Other implementations that this compiler claims to be compatible with. Supported extensions. Compiler flavour and version. Supported language standards. ?A key-value map for properties not covered by the above fields. s that the compiler doesn't support reinstalling. For instance, when using GHC plugins, one wants to use the exact same version of the ghc6 package as the one the compiler was linked against.  indicates that the compiler hasn't supplied this information and that we should act pessimistically. Some 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. Some compilers support optimising. Some have different levels. For compilers that do not the level is just capped to the level they do support. We 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. Some 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.Abstracted over 6NB: the path might be relative or it might be absolute Some 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.Returns Just if we can certainly determine whether a way is supported if we don't know, return NothingLooks up the flag for a given extension, for a given compiler. Ignores the subtlety of extensions which lack associated flags.Looks up the flag for a given extension, for a given compiler. However, the extension may be valid for the compiler but not have a flag. For example, NondecreasingIndentation is enabled by default on GHC 7.0.4, hence it is considered a supported extension but not an accepted flag.The outer layer of Maybe indicates whether the extensions is supported, while the inner layer indicates whether it has a flag. When building strings, it is often more convenient to use  , which ignores the difference.&Utility function for GHC only features   .      "  -                 4< +2   '  '        "  -       "    $ )- )- %)   /3 /3 #  $    #  &  5  $ >9Duncan Coutts 2009, 2013cabal-devel@haskell.orgportableNone#3\  Defaults are True, False and False Call hc-pkg to retrieve a specific package :hc-pkg describe [pkgid] [--user | --global | --package-db] Call hc-pkg to get all the details of all the packages in the given package database. Call hc-pkg to expose a package. 8hc-pkg expose [pkgid] [--user | --global | --package-db] Call hc-pkg to hide a package. 6hc-pkg hide [pkgid] [--user | --global | --package-db] Call hc-pkg9 to initialise a package database at the location {path}. hc-pkg init {path} Run hc-pkg using a given package DB stack, directly forwarding the provided command-line arguments to it. Call hc-pkg to get the source package Id of all the packages in the given package database.(This is much less information than with  , but also rather quicker. Note in particular that it does not include the UnitId, just the source 3 which is not necessarily unique in any package db. Call hc-pkg$ to recache the registered packages. 1hc-pkg recache [--user | --global | --package-db] Call hc-pkg to register a package. hc-pkg register {filename | -} [--user | --global | --package-db] Call hc-pkg to unregister a package )Isaac Jones 2006, Duncan Coutts 2007-2009cabal-devel@haskell.orgportableNone3~?Looks up the given program in the program database and runs it.?Looks up the given program in the program database and runs it.6Runs the given configured program and gets the output.?Looks up the given program in the program database and runs it.?Looks up the given program in the program database and runs it."Runs the given configured program."Runs the given configured program. verbosityThe program to runlook up the program hereAny extra arguments to add verbosityworking directoryThe program to runlook up the program hereAny extra arguments to add VerbosityThe program to runAny extra arguments to add verbosityThe program to runlook up the program hereAny extra arguments to add verbosityworking directoryThe program to runlook up the program hereAny extra arguments to add VerbosityThe program to runAny extra arguments to add VerbosityWorking directoryThe program to runAny extra arguments to add         ?cabal-devel@haskell.orgportableNone@Duncan Coutts 2007BSD3cabal-devel@haskell.org(non-portable (ExistentialQuantification)Nonecreate a Choice optioncreate 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.'Parse a bunch of command line arguments:Show flags in the standard long option command line format6Helper function for creating globalCommand descriptionMark command as hidden. Hidden commands don't show up in the 'progname help' or 'progname --help' output.CabalMake a Command from standard GetOpt options.Create an option taking several OptDescrs. You will have to give the flags and description individually to the OptDescr constructor.Utility function, many commands do not accept additional flags. This action fails with a helpful error message if the user supplies any extra.Create a string-valued command line interface with a default value.!(String -> a) variant of "optArg"Create an option taking a single OptDescr. No explicit Name is given for the Option, the name is the first LFlag given. Example:  sf lf d get set * sf": Short option name, for example: ['d']. No hyphen permitted. * lf!: Long option name, for example:  ["debug"]. No hyphens permitted. * d: Description of the option, shown to the user in help messages. * get(: Get the current value of the flag. * set: Set the value of the flag. Gets the current value of the flag as a parameter.Create a string-valued command line interface. Usually called in the context of  or . Example:  ad mkflag showflagad&: Placeholder shown to the user, e.g. FILES+ if files are expected parameters.mkflag,: How to parse the argument into the option.showflag: If parsing goes wrong, display a useful error message to the user.!(String -> a) variant of "reqArg"Create "usage" documentation from a list of parameter configurations.0Default "usage" documentation text for commands.wraps 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.Initial / empty flags;Additional explanation of the command to use in help texts.The name of the command as it would be entered on the command line. For example "build".+Post-Usage notes and examples in help texts&All the Option fields for this commandA short, one line description of the command to use in help texts.A function that maps a program name to a usage summary for this command. Long command line option stringsAn OptionField takes one or more OptDescrs, describing the command line interface for the field.We 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.!Short command line option strings(Common flags that apply to every commandThe help text for this command with descriptions of all the options.&Is the command a global or subcommand?namesynopsisusage alternativesinitial/empty flagsoptionsMkOptDescr constructors partially applied to flags and description. 8Isaac Jones 2003-2004 Duncan Coutts 2007BSD3cabal-devel@haskell.orgportableNone3?Get   that respect the  flag.The name of the directory where optional compilation artifacts go, such as ghc plugins and .hie files.For each known program PROG in progDb , produce a  PROG-option .For each known program PROG in progDb , produce a  PROG-options .For each known program PROG in progDb , produce a  with-PROG .Like *, but allows to customise the option name.Helper 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"]Help text for test and bench commands.A datatype that stores common flags for different invocations of a Setup, executable, e.g. configure, build, install."Which Cabal file to use (optional)Build directoryWhen this flag is set, temporary files will be kept after building.Note: Keeping temporary files is important functionality for HLS, which runs  cabal repl with a fake GHC to get CLI arguments. It will need the temporary files (including multi unit repl response files) to stay, even after the  cabal repl command exits.3Which targets is this Setup invocation relative to?TODO: this one should not be here, it's just that the silly UserHooks stop us from passing extra info in other ways VerbosityWorking directory (optional)Either "test" or  "benchmark". Help text.. ! $ ! $ %8Isaac Jones 2003-2004 Duncan Coutts 2007BSD3cabal-devel@haskell.orgportableNone)3? > > <<#<<< <<%<,    #? ? <<   <.<2  $8Isaac Jones 2003-2004 Duncan Coutts 2007BSD3cabal-devel@haskell.orgportableNone)3?8 Flags to sdist: (snapshot, verbosity)88  8 88Isaac Jones 2003-2004 Duncan Coutts 2007BSD3cabal-devel@haskell.orgportableNone)3?   ;;     ; ;  8Isaac Jones 2003-2004 Duncan Coutts 2007BSD3cabal-devel@haskell.orgportableNone)3?l Flags to register and  unregister2: (user package, gen-script, in-place, verbosity)==  != =8Isaac Jones 2003-2004 Duncan Coutts 2007BSD3cabal-devel@haskell.orgportableNone)3?< Flags to install: (package db, verbosity)>>   > >8Isaac Jones 2003-2004 Duncan Coutts 2007BSD3cabal-devel@haskell.orgportableNone)3? 99  !9 9 "8Isaac Jones 2003-2004 Duncan Coutts 2007BSD3cabal-devel@haskell.orgportableNone)3?Toutput directory of combined haddocks, the default is './haddocks'a shortcut option which builds documentation linked to hackage. It implies: * `--html-location=' 7https://hackage.haskell.org/package/$prg-$version/docs' * `--quickjump` * `--gen-index` * `--gen-contents` * `--hyperlinked-source`haddocksInterfaces is inferred by the haddocksAction%; currently not exposed to the user.9When 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.Governs whether modules from a given interface should be visible or hidden in the Haddock generated content page. We don't expose this functionality to the user, but simply use  for only local packages. Visibility of modules is available since haddock-2.26.1.  <>     $ '      ! "8Isaac Jones 2003-2004 Duncan Coutts 2007BSD3cabal-devel@haskell.orgportableNone3?F:Flags that apply at the top level, not to any sub-command. 3 3  8Isaac Jones 2003-2004 Duncan Coutts 2007BSD3cabal-devel@haskell.orgportableNone)3?V Flags to copy6: (destdir, copy-prefix (backwards compat), verbosity)  ::  : : 8Isaac Jones 2003-2004 Duncan Coutts 2007BSD3cabal-devel@haskell.orgportableNone )3?=More convenient version of . Results in an # if internal invariant is violated.Arguments to pass to a  configure script, e.g. generated by autoconf.CabalShow a PackageDB stack entry Flags to  configure command.+IMPORTANT: every time a new flag is added,  should be updated. IMPORTANT: every time a new flag is added, it should be added to the Eq instanceAllow 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.Enable benchmark compilationBuild bytecode libraryexplicit CID to be usedExtra arguments to  configure*Additional constraints for dependencies.Enable program coverageThe list of libraries to be included in the hpc coverage report for testsuites run with --enable-coverage. Notably, this list must exclude indefinite libraries and instantiations because HPC does not support backpack (Nov. 2023).Emit debug info.,The packages depended on which already existbe as deterministic as possible (e.g., invariant over GHC, database, etc). Used by the test suiteShould 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.,Enable dynamic linking of the executables.All direct dependencies and flags are provided on the command line by the user via the '--dependency' and '--flags' options.0path to search for extra frameworks (OS X only)path to search for header files"path to search for extra librariespath to search for extra libraries when linking fully static executablesHalt and show an error message indicating an error in flag assignment1Enable fully static linking of the executables.!Enable compiling library for GHCi)The "flavor" of the compiler, e.g. GHC.given compiler locationgiven hc-pkg locationexplicit IPID to be usedWhen this flag is set, all tools declared in `build-tool`s and `build-tool-depends` will be ignored. This allows a Cabal package with build-tool-dependencies to be built even if the tool is not found.Installation pathsThe requested Backpack instantiation. If empty, either this package does not use Backpack, or we just want to typecheck the indefinite package.$Enable program coverage (deprecated)Enable optimization.Which package DBs to use2Enable profiling in the library and executables.9Profiling detail level in the library and executables.&Enable profiling in the executables.Enable profiling in the library(Profiling detail level in the libraryEnable shared profiling objectsInstalled executable prefix.Installed executable suffix.user specified programs argsExtend the $PATHuser specified programs pathsAll programs that cabal may runThe packages depended on which doesn't yet exist (i.e. promised). Promising dependencies enables us to configure components in parallel, and avoids expensive builds if they are not necessary. For example, in multi-repl mode, we don't want to build dependencies that are loaded into the interactive session, since we have to build them again. Enable relocatable package builtBuild shared libraryEnable -split-objs with GHCEnable -split-sections with GHCBuild static libraryEnable executable strippingEnable library strippingEnable test suite compilationWhether to use response files at all. They're used for such tools as haddock, or ld.The --user/--global flagEnable vanilla library5Pretty-print a single entry of a module substitution. Inverse to .         BNone&'3?U- contains configuration options that can be controlled by the user.-Whether to enable executable program coverage*Whether to enable library program coverage&Whether to build a relocatable package&Use -split-objs with GHC, if available*Use -split-sections with GHC, if available+Whether to strip executables during install)Whether to strip libraries during install*Whether to build bytecode versions of libs*Whether to emit debug info (if available).'Whether to link executables dynamically,Whether to link executables fully statically1Whether to build libs suitable for use with GHCi.2Whether to build with optimization (if available).+Whether to build executables for profiling."Level of automatic profile detail.Whether to build normal libs."Level of automatic profile detail.,Whether to build profiling versions of libs.)Whether to build shared versions of libs.Whether to build static versions of libs (with all other libs rolled in)Whether to build normal libs.Information about individual components in a package, determined after the configure step.All 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.A map from component name to all matching components. These coincide with  There may be more than one matching component because of backpack instantiationsAll 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 _<. (This admonition doesn't apply for per-component builds.)The packages we were promised, but aren't already installed. MP: Perhaps this just needs to be a Set UnitId at this stage. contains options that can be controlled by the user and serve as inputs to the configuration of a package.Extra args on the command line for the configuration step. Needed to re-run configuration when .cabal is out of dateOptions to control the build, e.g. whether to enable profiling or to enable program coverage."Location and args for all programs'LocalBuildDescr ' contains the information Cabal determines after performing package-wide and per-component configuration of a package.;This information can no longer be changed after that point.Information about individual components in the package determined after the configure step.Information that is available after configuring the package itself, before looking at individual components. contains the information Cabal determines after performing package-wide configuration of a package, before doing any per-component configuration. The compiler we're building with;What components were enabled during configuration, and why.Options passed to the configuration step. Needed to re-run configuration when .cabal is out of dateFor per-package builds-only: an extra list of libraries to be included in the hpc coverage report for testsuites run with --enable-coverage. Notably, this list must exclude indefinite libraries and instantiations because HPC does not support backpack (Nov. 2023).9The final set of flags which were picked for this packageThe platform we're building forThe installation directories for the various different kinds of files TODO: inplaceDirTemplates :: InstallDirs FilePathWARNING 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.5the filename containing the .cabal file, if available)What package database to use, global/user33  $ !   "      $     ! ( % $ &CNone &(3? 5Return 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 .Returns a list of ways, in the order which they should be built, and the way we build executable and foreign library components.Ideally all this info should be fixed at configure time and not dependent on additional info but  is per package (not per component) so it's currently not possible to configure components to be built in certain ways. Return all s associated with (:. In the presence of Backpack there may be more than one! 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 .Extract 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. Extract the ) from the public library component of a  if it exists, or make a fake component ID based on the package ID. Extract the  of a . This is a "safe" use of  Extract the " from the library component of a ? if it exists, or make a fake unit ID based on the package ID.3Return 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 .=The (relative or absolute) path to the package root, based onthe working directory flagthe .cabal pathIs coverage enabled for test suites? In practice, this requires library and executable profiling to be enabled.Execute 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 .Execute 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 .1Data cached after configuration step. See also A.This pattern synonym is for backwards compatibility, to adapt to  being split into LocalBuildDescr and LocalBuildConfig.Information about a package configuration that can be modified by the user at configuration time.Information about a package determined by Cabal after the configuration step.+Convenience function to generate a default  from a 0. The idea is to call this once, and then use * everywhere else. Private to this module. Warning: By using this function, you may be introducing a bug where you retrieve a  Component which does not have + applied to it. See the documentation for 1 for an explanation of the issue. If you have a  handy (NOT from the ), try using the primed version of the function, which takes it as an extra argument. Warning: By using this function, you may be introducing a bug where you retrieve a  Component which does not have + applied to it. See the documentation for 1 for an explanation of the issue. If you have a  handy (NOT from the ), try using the primed version of the function, which takes it as an extra argument. Warning: By using this function, you may be introducing a bug where you retrieve a  Component which does not have + applied to it. See the documentation for 1 for an explanation of the issue. If you have a  handy (NOT from the ), try using the primed version of the function, which takes it as an extra argument. Warning: By using this function, you may be introducing a bug where you retrieve a  Component which does not have + applied to it. See the documentation for 1 for an explanation of the issue. If you have a  handy (NOT from the ), try using the primed version of the function, which takes it as an extra argument. Warning: By using this function, you may be introducing a bug where you retrieve a  Component which does not have + applied to it. See the documentation for 1 for an explanation of the issue. If you have a  handy (NOT from the ), try using the primed version of the function, which takes it as an extra argument. Warning: By using this function, you may be introducing a bug where you retrieve a  Component which does not have + applied to it. See the documentation for 1 for an explanation of the issue. If you have a  handy (NOT from the ), try using the primed version of the function, which takes it as an extra argument.    #Isaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone&3 See .Backwards 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./Absolute path to the current working directory.Get 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.Determine 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 Interpret a symbolic path with respect to the working directory stored in .:Use this before directly interacting with the file system.-NB: when invoking external programs (such as GHC), it is preferable to set the working directory of the process rather than calling this function, as this function will turn relative paths into absolute paths if the working directory is an absolute path. This can degrade error messages, or worse, break the behaviour entirely (because the program might expect certain paths to be relative).4See Note [Symbolic paths] in Distribution.Utils.Path,Retrieve an optional working directory from .See Backwards 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.%Perform the action on each buildable  or  (Component) in the PackageDescription, subject to the build order specified by the compBuildOrder field of the given #Perform the action on each enabled  in the package description.#Perform the action on each enabled 3 in the package description. Extended version of + that also gives corresponding build info.#Perform the action on each enabled & in the package description with the .Building for inplace?&Generate prefix-relative library pathsComponent that is being built/012&'"9:;<345678()*+,-.#$%345678()*+,-.)*+.#$%"'&21/0<;:9DNone  >>>>>> >$>&>*HSimon Marlow 2008cabal-devel@haskell.orgportableNoneThe contents of the cabal_macros.h" for the given configured package.(Helper function that generates just the  VERSION_pkg and MIN_VERSION_pkg macros for a list of package ids (usually used with the specific deps of a configured package).NoneIn 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..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.JNonef +Uniquely identifies a configured component.The ( of a component; this uniquely identifies a fragment of syntax within a specified Cabal file describing the component.%The package this component came from.Pretty-print a .1A configured component, we know exactly what its  is, and the s of the things it depends on.7Unique identifier of component, plus extra useful info.The fragment of syntax from the Cabal file describing this component.!Dependencies on executables from  build-tools and build-tool-depends.?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.Is 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.) Construct a , given that the  and library/executable dependencies are known. The primary work this does is handling implicit backpack-include fields.Also computes the , and sets cc_public if necessary. This is Cabal-only; cabal-install won't use this.KNone . Uniquely identifies a . Corresponds to .The instantiation of ; this always has the invariant that it is a mapping from a module name A to  A (the hole A).Corresponds to .The = of this component in the "default" instantiation. See also . -s cannot be instantiated (e.g., there is no ModSubst instance for them).A 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.$Uniquely identifies linked componentCorresponds to . build-tools and build-tool-depends dependencies. Corresponds to .Corresponds 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 .):Is this the public library of a package? Corresponds to .The module shape computed by mix-in linking. This is newly computed from Like , but this specifies includes on signature packages which have no exports.Whether there are any "promised" package dependencies which we won't find already installed.Whether there are any "promised" package dependencies which we won't find already installed. !LNonehError message when there is a cycle; takes the SCC of components.$Given the package description and a  (used to determine if a package name is internal or not), sort the components in dependency order (fewest dependencies first). This is NOT necessarily the build order (although it is in the absence of Backpack.) Pretty-print . Create a  of 3+, or report a cycle if there is a problem.A graph of source-level components by their source-level dependenciesA list of components associated with the source level dependencies between them.8Isaac Jones 2003-2004 Duncan Coutts 2007BSD3cabal-devel@haskell.orgportableNone)3?  55  5 5 8Isaac Jones 2003-2004 Duncan Coutts 2007BSD3cabal-devel@haskell.orgportableNone)3? ==   = === 8Isaac Jones 2003-2004 Duncan Coutts 2007BSD3cabal-devel@haskell.orgportableNone)3? 77  "7 7 #A8Isaac Jones 2003-2004 Duncan Coutts 2007BSD3cabal-devel@haskell.orgportableNone3?,3What kind of build phase are we doing/hooking into?Is this a normal build, or is it perhaps for running an interactive session or Haddock?)Build steps for generating documentation.Build steps for Hscolour.A normal build.'Build steps for an interactive session.     !MNoneY Get the  of the component being built.Get the  for the component being built.Get the  # being used to build the component.Get the 3 being built.Is the 3 being built a Library?Get the 2 from the context the component being built is in.The information required for a build computation which is available right before building each component, i.e. the pre-build component inputs. What kind of build are we doing?Information about the package)Information about an individual componentN(c) Duncan Coutts 2012BSD-likeduncan@community.haskell.orgNone &39?Read 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 .Take a list of 9 build targets, and parse and validate them into actual  s to be built registered whatever.Given a bunch of user-specified targets, try to resolve what it is they refer to.Unambiguously render a ., so that it can be parsed in all situations.A fully resolved build target.A specific component,A specific file within a specific component..A specific module within a specific component. expected thing(actually got) (no such thing, actually got)4Various ways that a user may specify a build target.Combine two matchers. Exact matches are used over inexact matches but if we have multiple exact, or inexact then the we collect all the ambiguous matches.A target specified by a single name. This could be a component module or file. cabal build foo cabal build Data.Foo cabal build Data/Foo.hs Data/Foo.hscA target specified by a qualifier and name. This could be a component name qualified by the component namespace kind, or a module or file qualified by the component name. cabal build lib:foo exe:foo cabal build foo:Data.Foo cabal build foo:Data/Foo.hsA fully qualified target, either a module or file qualified by a component name with the component namespace kind. cabal build lib:foo:Data/Foo.hs exe:foo:Data/Foo.hs cabal build lib:foo:Data.Foo exe:foo:Data.FooCabalCabalA matcher embodies a way to match some input as being some recognised value. In particular it deals with multiple and ambiguous matches.&There are various matcher primitives ( matchExactly, ), ways to combine matchers ( ambiguousWith, shadows;) and finally we can run a matcher against an input using .readUserBuildTarget "comp"$Right (UserBuildTargetSingle "comp")readUserBuildTarget "lib:comp"*Right (UserBuildTargetDouble "lib" "comp")"readUserBuildTarget "pkg:lib:comp"0Right (UserBuildTargetTriple "pkg" "lib" "comp")readUserBuildTarget "\"comp\""$Right (UserBuildTargetSingle "comp")"readUserBuildTarget "lib:\"comp\""*Right (UserBuildTargetDouble "lib" "comp")&readUserBuildTarget "pkg:lib:\"comp\""0Right (UserBuildTargetTriple "pkg" "lib" "comp")'readUserBuildTarget "pkg:lib:comp:more"6Left (UserBuildTargetUnrecognised "pkg:lib:comp:more")&readUserBuildTarget "pkg:\"lib\":comp"5Left (UserBuildTargetUnrecognised "pkg:\"lib\":comp")Given a matcher and a key to look up, use the matcher to find all the possible matches. There may be  , a single  match or you may have an " match with several possibilities.6A primitive matcher that looks up a value in a finite . It checks for an exact or inexact match. We get an inexact match if the match is not exact, but the canonical forms match. It takes a canonicalisation function for this purpose.So for example if we used string case fold as the canonicalisation function, then we would get case insensitive matching (but it will still report an exact match when the case matches too).Check that the given build targets are valid in the current context.)Also swizzle into a more convenient form.)Lift a list of matches to an exact match.)Lift a list of matches to an exact match.)Combine two matchers. This is similar to  ambiguousWith with the difference that an exact match from the left matcher shadows any exact match on the right. Inexact matches are still collected however.Unless you use !, this function is PARTIAL; use  instead.    ")      "!      O9Isaac Jones 2003-2004, Duncan Coutts 2008BSD3cabal-devel@haskell.orgportableNone3 .The directory in which we put auto-generated modules for a particular component.The name of the auto-generated PackageInfo_* module associated with a packageThe directory in which we put auto-generated modules for EVERY component in the package.The name of the auto-generated Paths_* module associated with a package>The directory where we put build results for a benchmark suite.Build info json file, generated in every buildExtension for dynamically linked (or shared) libraries (typically "so" on Unix and "dll" on Windows):The directory where we put build results for an executableDefault extension for executable files on the current platform. (typically "" on Unix and "exe" on Windows or OS/2)>The directory where we put build results for a foreign libraryThis is the name of the directory in which the generated haddocks should be stored. It does not include the  distdochtml prefix.It is also used by `haddock-project` when constructing its output directory.This is the name of the directory in which the generated haddocks for a (sub)library should be stored. It does not include the  distdochtml prefix.It is also used by `haddock-project` when constructing its output directory.)A name of a (sub)library used by haddock.!File path of the ".haddock" file.8A name of a (sub)library used by haddock, in the form ` package: library` if it is a sublibrary, or ` package` if it is the main library.Used by `haddock-project` and c.The directory to which generated haddock documentation should be written.Create 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"Create a library name for a shared library from a given name. Prepends lib and appends the #-* as well as the shared library extension.Create a library name for a static library from a given name. Prepends lib+ and appends the static library extension (.a).5Extension for object files. For GHC the extension is "o".The path to the pre-build rules cache file for a component, used to compute rule staleness across runs.Extension for static librariesTODO: Here, as well as in dllExtension, it's really the target OS that we're interested in, not the build OS.:The name of the stub executable associated with a library .9The directory where we put build results for a test suite,,PAndres Loeh 2009BSD3cabal-devel@haskell.orgportableNone3'The flags for the supported extensions.Hack to add version numbers to UHC-built-in packages. This should sooner or later be fixed on the UHC side.*Name of the installed package config file.Check if a certain dir contains a valid package. Currently, we are looking only for the presence of an installed package configuration. TODO: Actually make use of the information provided in the file.4Create a trivial package info from a directory name.QNone32Source code for library test suite stub executableThe filename of the source file for the stub executable associated with a library  TestSuite.Main 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.From a test stub, write the : to temporary file for the calling Cabal process to read.$Write the source file for a library  TestSuite stub executable. The test runner used in library  TestSuite$ stub executables. Runs a list of s. An executable calling this function is meant to be invoked as the child of a Cabal process during  ./setup test. A , provided by Cabal, is read from the standard input; it supplies the name of the test suite and the location of the machine-readable test suite log file. Human-readable log information is written to the standard output for capture by the calling Cabal process.library  TestSuite# for which a stub is being created6path to directory where stub source should be locatedRNoneSNone&(+,39?a,Run all pre-build rules.6This function should only be called internally within Cabal, as it is used to implement the (legacy) Setup.hs interface. The build tool (e.g.  cabal-install or hls) should instead go through the separate hooks executable, which allows us to only rerun the out-of-date rules (instead of running all of these rules at once).Like , except it can be used when communicating with an external hooks executable.Empty build hooks.Empty configure phase hooks.Empty copy/install hooks.Use this smart constructor to declare an empty set of changes by a per-component pre-configure hook, and override the fields you care about.Use this rather than  to avoid relying on internal implementation details of the latter.Use this smart constructor to declare an empty set of changes by the package-wide pre-configure hook, and override the fields you care about.Use this rather than  to avoid relying on internal implementation details of the latter. Empty hooks.Build-time hooks.Per-component post-build hook.+Per-component fine-grained pre-build rules.A diff to a Cabal 32, that gets combined monoidally into an existing 3.Configure-time hooks.Order of execution:,configure the package,,,configure the components.&Package-wide post-configure hook. See .&Per-component pre-configure hook. See .%Package-wide pre-configure hook. See .A per-component install hook, which can only perform side effects (e.g. copying files).Copy/install hooks.Per-component install hook.!Package-wide post-configure step.Perform side effects. Last opportunity for any package-wide logic; any subsequent hooks work per-component./Inputs to the package-wide post-configure step.-what kind of build phase are we hooking into?information about the package)information about an individual component!Per-component pre-configure step.For each component of the package, this hook can perform side effects, and return a diff to the passed in component, e.g. to declare additional autogenerated modules./Inputs to the per-component pre-configure step.0Outputs of the per-component pre-configure step. Prefer using noPreComponentOutputs and overriding the fields you care about, to avoid depending on implementation details of this datatype..Inputs to the package-wide pre-configure step. Warning: the  in the 3 field will not contain any unconfigured programs./Outputs of the package-wide pre-configure step. Prefer using  and overriding the fields you care about, to avoid depending on implementation details of this datatype.Hooks into the cabal build phases.Usage:In your .cabal file, declare build-type: Hooks (with a  cabal-version greater than or equal to 3.14),In your .cabal file, include a  custom-setup4 stanza which declares the dependencies of your  SetupHooks; module; this will usually contain a dependency on the  Cabal-hooks package. Provide a  SetupHooks.hs module next to your .cabal file; it must export setupHooks :: SetupHooks.Hooks into the build phase.These hooks are relevant to any build-like phase, such as repl or haddock.Hooks into the configure phase."Hooks into the copy/install phase. can be combined monoidally. This is useful to combine setup hooks defined by another package with your own package-specific hooks.Warning: this  instance is not commutative.Collects why certain rules were not demanded (and thus not run), in order to construct an error message to report to the user. The rules that were not demandedRules that generate Haskell files that are not declared as autogenerated modules.Rules that generate files that aren't in the appropriate autogen directory.A newtype to hang off the Semigroup PreConfComponentHook instance.A newtype to hang off the Semigroup PreConfPackageHook instance.!Is the file we depend on missing?;Is the rule up to date (so that we can skip re-running it)?>As per the SetupHooks documentation, a rule must be re-run if:[N] the rule is new, or2[S] the rule matches with an old rule, and either:[S1] an input to the rule has changed (either a file or rule dependency) [S2] the rule itself has changedTraverse the components of a .:The function must preserve the component type, i.e. map a 7 to a 7, a 5 to a 5, etc.working directory!old rules from the previous buildrules that have been re-run!dynamic dependencies of this rule0  / ' ) & ( ' ( % &            "    / 2    - '  3 + - * , + , ) *TNone&'159?Create a hooks executable main given the package's .4The executable expects three command-line arguments: A reference to an input communication handle (to read hook inputs from).A reference to an output communication handle (to write hook outputs to).The hook type to run.The hook reads binary-encoded data from the input handle, runs the requested hook, and writes the binary-encoded result to the output handle.The version of the Hooks API built into this version of the Cabal library.Used for handshake before beginning inter-process communication.Tracks the parts of the Cabal API relevant to its binary interface.Tracks the parts of the Hooks API relevant to its binary interface.$The version of the Hooks API in use.Used for handshake before beginning inter-process communication.Missing hook type argument.0Could not parse a communication handle argument.3Incorrect arguments passed to the hooks executable. Unknown hook type was requested.,Failed to decode the binary input to a hook.8The rule does not have a dynamic dependency computation.An error describing an invalid argument passed to a hooks executable./The verbosity used inside the hooks executable.The hooks executable is always invoked as a separate process, so stdout and stderr are available for verbosity output and can be redirected via the System.Process API.Run a hook by reading its input from a handle, invoking it, and writing its output to another handle. hook name hook input that failed to decode$byte offset at which decoding faileddecoding error message&Input and output communication handles"Hook name (used in error messages)The hook to run  = ")  //Isaac Jones 2003-2007cabal-devel@haskell.orgportableNone3m/Adjust the way we find and configure gcc and ld .Strip out flags that are not supported in ghci &GHC's rendering of its host or target   as used in its platform strings and certain file locations (such as user package db location). The .ghc.environment-$arch-$os-$ver file name &GHC's rendering of its host or target   as used in its platform strings and certain file locations (such as user package db location).GHC'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 Create the required packaged arguments, but filtering out package arguments which aren't yet built, but promised. This filtering is used when compiling CCxxAsm files, and is a hack to avoid passing bogus `-package` arguments to GHC. The assumption being that in 99% of cases we will include the right `-package` so that the C file finds the right headers..Render a bunch of GHC environment file entries /Render an individual GHC environment file entry3Make 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.Write 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.'The kinds of entries we can stick in a .ghc.environment file. clear-package-db  -- a commentglobal-package-db, user-package-db or package-db blahpackage.conf.d package-id foo-1.0-4fe301a...directory in which to put itthe GHC target platformthe GHC version the content$          None . .! , ,None3 * Returns True if the modification date of the given source file is newer than the object file we last compiled for it, or if no object file exists yet. Decode argument to '-main-is'Returns ( if argument set only the function name.This code has been stolen/refactored from GHC's DynFlags.setMainIs function. The logic here is deliberately imperfect as it is intended to be bug-compatible with GHC's parser. See discussion in  https://github.com/haskell/cabal/pull/4539#discussion_r118981753. Main module name when overridden by ghc-options: -main-is ... or  if no -main-is flag could be found. In case of ,  can be assumed. Gets the target name (name of actual executable file) from the name of an executable-like component (, , ). 7Is the extension of the file in the list of extensions? Find the path to the entry point of an executable (typically specified in main-is, and found in hs-source-dirs -- yes, even when main-is is not a Haskell file). #Name for the library when building.If the `lib-version-info` field or the `lib-version-linux` field of a foreign library target is set, we need to incorporate that version into the SONAME field.If a foreign library foo has lib-version-info 5:1:2, it should be built as libfoo.so.3.2.1. We want it to get soname libfoo.so.3. However, GHC does not allow overriding soname by setting linker options, as it sets a soname of its own (namely the output filename), after the user-supplied linker options. Hence, we have to compile the library with the soname as its filename. We rename the compiled binary afterwards.This method allows to adjust the name of the library at build time such that the correct soname can be set. 8Target name for a foreign library (the actual file name)We do not use mkLibName and co here because the naming for foreign libraries is slightly different (we don't use "_p" or compiler version suffices, and we don't want the "lib" prefix on Windows).TODO: We do use  and co here, but really that's wrong: they use the OS used to build cabal to determine which extension to use, rather than the target OS (but this is wrong elsewhere in Cabal as well). 3Finds the object file name of the given source file +Is this a C source file, i.e. ends with .c? Is this file a C++ source file, i.e. ends with .cpp, .cxx, or .c++? *Is this compiler's RTS dynamically linked? -FilePath has a Haskell extension: .hs or .lhs Given the path to a source file (Haskell, C, JS...), return the corresponding object file path (input to the linker). Does this compiler support the  -dynamic-too option =Should we dynamically link the foreign library, based on its  ? The build info of the executable-like component (Exe, Test, Bench) Build directoryThe build info and module path of an executable-like component (Exe, Test, Bench)!The path to the main source file. Package directory Symbolic path to the source fileGHC compilation optionsPath to the object file Objects build directory (-odir)Object file extension'Source file path (relative or absolute)Resulting object file path  None(3. 9Compile the Haskell modules of the component being built. Returns a pair of the main file and Haskell modules of the component being built. The main file is not necessarily a Haskell file. It could also be e.g. a C source, or, a Haskell repl script (that does not necessarily have an extension).String describing the extra sources being built, for printing.Function to determine the  > for the invocation of GHC when compiling these extra sourcesView the extra sources of a component, typically from the build info (e.g.  ,  ).  Executable= components might additionally add the program entry point (main-is file) to the extra sources, if it should be compiled as the rest of them.The GHC configured program#The build directory for this targetNeeded build waysHandles for logging,The context and component being built in it.1Returns the list of extra sources that were built !An optional non-Haskell Main fileThe GHC configured program#The build directory for this targetNeeded build waysLogging handles,The context and component being built in it.1Returns the list of extra sources that were built None3 f 7Extract (and compute) information about the RTS library!TODO: This hardcodes the name as  HSrts-ghc version. I don't know if we can find this information somewhere. We can lookup the  hsLibraries field of  but it will tell us [HSrts, Cffi], which doesn't really help. 7Calculate the RPATHs for the component we are building. Calculates relative RPATHs when  is set. Determine whether the given  is intended to link against the threaded RTS. This is used to determine which RTS to link against when building a foreign library with a GHC without support for  -flink-rts. Link the executable resulting from building this component, be it an executable, test, or benchmark component.  Link a foreign library component Link a library component Links together the object files of the Haskell modules and extra sources using the context in which the component is being built.If the build kind is 5, we load the component into GHCi instead of linking. Load a target component into a repl, or write to disk a script which runs GHCi with the GHC options Cabal elaborated to load the component interactively. ,The context and component being built in it. The linker-specific GHC optionsThe wanted build ways and corresponding GhcOptions that were used to compile the modules in that way.The target dir (2024-01:note: not the same as build target dir, see Note [Build Target Dir vs Target Dir] in Distribution.Simple.GHC.Build)Name of executable-like targetRun the configured GHC program The linker-specific GHC optionsThe wanted build ways and corresponding GhcOptions that were used to compile the modules in that way.The target dir (2024-01:note: not the same as build target dir, see Note [Build Target Dir vs Target Dir] in Distribution.Simple.GHC.Build)Run the configured GHC program "The library target build directory5The list of extra lib dirs that exist (aka "cleaned")Run the configured Ghc program3Extra build sources (that were compiled to objects)A list with the runtime-paths (rpaths), or empty if not linking dynamically 1Wanted build ways and corresponding build options 8The configured GHC program that will be used for linkingHandles used for loggingChecks GHC options for commonly misused or non-portable flags.!!!!!! ! +Lennart Kolmodin 2008, Francesco Ariis 2022BSD3cabal-devel@haskell.orgportableNone3 5 This function is an oddity due to the historical GenericPackageDescription/PackageDescription split. It is only maintained not to break interface, use  if possible.?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 .Sanity 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. Same as , but working with .2This function is included for legacy reasons, use  if you are working with !.Sanity checks that require IO.  looks at the files in the package and expects to find the package unpacked at the given filepath.Wraps  into .!4Issue a warning if the text contains any "dotlines".!! checks. Remember that for historical quirks in the cabal codebase we have both ! and  and that PD is both a *field* of GPD and a concept of its own (i.e. a fully realised GPD). In this case we are checking (correctly) GPD, so for target info/checks you should walk condLibrary_ etc. and *not* the (empty) target info in PD. See !+ for a convenient hack when you only have .!August 2022: this function is an oddity due to the historical GenericPackageDescription/PackageDescription split (check Distribution.Types.PackageDescription for a description of the relationship between GPD and PD. It is only maintained not to break interface, should be deprecated in the future in favour of ) when PD and GPD are refactored sensibly.!?Checks for matchless globs and too strict matching (<2.4 spec).!! is the most general way to invoke package checks. We pass to it two interfaces (one to check contents of packages, the other to inspect working tree for orphan files) and before that a Boolean to indicate whether we want pure checks or not. Based on these parameters, some checks will be performed, some omitted. Generality over m means we could do non pure checks in monads other than IO (e.g. a virtual filesystem, like a zip file, a VCS filesystem, etc).!Find a package description file in the given directory. Looks for .cabal files. Like , but generalized over monads.}~ }~ None Z!Compute the dependencies of a !! that should be recorded in the depends field of InstalledPackageInfo.!Corresponds to .!The final, string  that will uniquely identify the compilation products of this component.!Given 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.!An !> is a library with requirements which we will typecheck only.!The dependencies which need to be passed to the compiler to bring modules into scope. These are > because these may refer to partially instantiated libraries.!0The modules exported/reexported by this library.! The requirements of the library.!An ! is a library which is fully instantiated (or, possibly, has no requirements at all.)!The dependencies which need to be passed to the compiler to bring modules into scope. These always refer to installed fully instantiated libraries.!"How this library was instantiated.!Dependencies induced by !. These are recorded here because there isn't a convenient way otherwise to get the  we need to fill componentPackageDeps as needed.!0The modules exported/reexported by this library.!A ! 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.!Corresponds to . Invariant: if ! records a , it coincides with this one.!Corresponds to .!Corresponds to . Build-tools don't participate in mix-in linking. (but what if they could?)!Extra metadata depending on whether or not this is an indefinite library (typechecked only) or an instantiated component (can be compiled).!The  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.!Corresponds to .!A state monad for doing instantiations (can't use actual State because that would be an extra dependency.)! The state of !; a mapping from  s to their ready component, or Nothing if its an external component which we don't know how to build.!Get the ! of a ! IF it is a library.!!!!!!!!!!!!!!!!!!!!!!!!!! ! ! "! ! !  YNone #S!;Pretty-print a missing dependency, resolving opaque hashed s to their human-readable package id and signature info when possible.When an indefinite Backpack package is installed separately (e.g. via nix callCabal2nix), only the indefinite variant (with unfilled signatures) exists in the package DB. The consumer needs an instantiated variant which was never built. The fix is to add both packages to the same cabal project so cabal can fill the signatures.!all installed packages+dep UnitId to its PackageId (from includes)the missing dependencyZNoneLPrint a Setup message stating (1) what operation we are doing, for (2) which component (with enough details to uniquely identify the build in question.)'Operation being done (capitalized), on:PackageComponent name3Instantiation, if available. Polymorphic to take  OpenModule or Module[Isaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone3- Compute the !$ of a library that we built inplace. Construct 6 for the final install location of a library package.;This function knows about the layout of installed packages.5Create an empty package DB at the specified location. Construct  for a library in a package, given a set of installation directories. Construct 3 for a library that is in place in the build tree.:This function knows about the layout of in place packages.Run hc-pkg using a given package DB stack, directly forwarding the provided command-line arguments to it.8Translate relative include dir paths to absolute paths.location of the dist tree(Install in the user's database?; verbose(Install in the user's database?; verbose   \+(c) 2003-2005, Isaac Jones, Malcolm WallaceBSD3cabal-devel@haskell.orgportableNone3 Convenience function; get the suffixes of these preprocessors.(Apply preprocessors to the sources from !2 for a given component (lib, exe, or test suite).XXX: This is terribleFind any extra C sources generated by preprocessing that need to be added to the component (addresses issue #238).Find the first extension of the file that exists, and preprocess it if required.Just 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.Over-ride this hook to get different behavior during hscolour.=Over-ride this hook to get different behavior during install. Hook to run after bench command.Hook to run after build command. Second arg indicates verbosity level.Hook to run after clean command. Second arg indicates verbosity level.#Hook to run after configure commandHook to run after copy commandHook to run after haddock command. Second arg indicates verbosity level.Hook to run after hscolour command. Second arg indicates verbosity level.Hook to run after install command. postInst should be run on the target, not on the build machine."Hook to run after register commandHook to run after repl command. Second arg indicates verbosity level.Hook to run after test command.$Hook to run after unregister command!Hook to run before bench command.Hook to run before build command. Second arg indicates verbosity level.Hook to run before clean command. Second arg indicates verbosity level.$Hook to run before configure commandHook to run before copy commandHook to run before haddock command. Second arg indicates verbosity level.Hook to run before hscolour command. Second arg indicates verbosity level."Hook to run before install command#Hook to run before register commandHook to run before repl command. Second arg indicates verbosity level. Hook to run before test command.%Hook to run before unregister commandRead the description fileOver-ride this hook to get different behavior during registration.Over-ride this hook to get different behavior during interpretation.:Over-ride this hook to get different behavior during test.Over-ride this hook to get different behavior during unregistration.++IIsaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone #&'(3&,<Adjust ! to be compatible with the given   and . See also , which additionally informs the user of unavailable requested features via warning messages.Like 6, but includes warnings for downgraded build options.#Warnings to emit after downgrading  when the compiler (or another toolchain program) doesn't support a requested feature.Makes 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))Check that localBuildInfoFile is up-to-date with respect to the .cabal file.4Compute 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.Like  but takes a given  " instead of needing to query the hc-pkg program to obtain it.Configure the compiler ONLY.7Configure the compiler and associated programs such as hc-pkg, haddock and toolchain program such as ar, ld.7Configure programs associated to the compiler, such as hc-pkg, haddock and toolchain program such as ar, ld. Perform the "./setup configure " action. Returns the LocalBuildInfo, also writing it to the  setup-config file.Run the Cabal library configure phase.NB: this function does not persist the resulting  to the  setup-config- file; that is the responsibility of callers.Return 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.Return 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.) 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.List 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. Looks up the  of the given  s from the   in the .A set of files (or directories) that can be monitored to detect when there might have been a change in the installed packages.Create 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.Like , 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. 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.The 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.Get the path of dist/setup-config.Try to read the .8Adds the extra program paths from the flags provided to  configure as well as specified locations for certain known programs and their default arguments. Read the 5, returning either an error or the local build info.Try to read the .$After running configure, output the  to the ./The errors that can be thrown when reading the  setup-config file.Incorrect header.Mismatched version.No file!No header found.Cannot parse file contents.Installed packages!Libraries internal to the packageCollection of components that are promised, i.e. are not installed already.See ! for more details.:Packages for which we have been given specific deps to use! Format a  as a user-facing error message.!An external dependency from the package database, OR an internal dependency which we are getting from the package database.!A promised dependency, which doesn't yet exist, but should be provided at the build time.We have these such that we can configure components without actually building its dependencies, if these dependencies need to be built later again. For example, when launching a multi-repl, we need to build packages in the interactive ghci session, no matter whether they have been built before. Building them in the configure phase is then redundant and costs time.!An internal dependency ( should be a library name) which we are going to have to build. (The  here is a hack to get a modest amount of polymorphism out of the Pkg' typeclass.)!Compute a default  from , applying compiler-specific defaults but without compiler capability checks (see  for that).!>Check for use of Cabal features which require compiler support!,Check if the user used any deprecated flags.!Sanity check: if '--exact-configuration' was given, ensure that the complete flag assignment was specified on the command line.!=Output package check warnings and errors. Exit if any errors.!0Preform checks if a relocatable build is allowed!2Perform checks if a shared executable can be built!?Select and apply coverage settings for the build based on the  and  .!Select and apply profiling settings for the build based on the  and  .!Configure a required program, ensuring that it exists in the PATH (or where the user has specified the program must live) and making it available for use via the ; interface. If the program is known (exists in the input ), we will make sure that the program matches the required version; otherwise we will accept any version of the program and assume that it is a simpleProgram.!(Identifier of the current Cabal package.!+Identifier of the current compiler package.!Returns true if a dependency is satisfiable. This function may report a dependency satisfiable even when it is not, but not vice versa. This is to be passed to finalize!'Finalize a generic package description.The workhorse is !.! Parse the  setup-config file header, returning the package identifiers for Cabal and the compiler.!$Select dependencies for the package.!Test for a package dependency and record the version we have installed.! Generate the  setup-config file header.original optionsadjusted options (result of )installed dependenciesuser-specified hc path (optional)user-specified hc path (optional)user-specified hc-pkg path (optional)(program database containing the compileruser-specified hc-pkg path (optional)default "dist" prefixoverride "dist" prefixoverride "dist" prefixThe file path of the  setup-config file.The stack of package databases.Construct an exception that is thrown if a unit-id is not found in the installed packages, from the unit-id that is missing.0The unit ids to lookup in the installed packagesWorking directory.The dist directory path.The dist directory path.Working directory.The dist directory path.Working directory.The file path of the  setup-config file.Working directory.The dist directory path.Working directoryThe dist directory path.The  to write.! Path to the .cabal file's directory!use external internal deps?exact configuration? allow depending on private libs?!tests if a dependency is satisfiable. Might say it's satisfiable even when not.!The file contents.!Package id of current package'Are we configuring a single component?!The processed package.99 ( #^Simon Marlow 2004BSD3cabal-devel@haskell.orgportableNone3 Create an archive from a tree of source files, and clean up the tree.Given a date produce a corresponding integer representation. For example given a date 18032008 produce the number 20080318.#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. A variant of  with configurable die.Note: may still die/ directly. For example on missing include file.Since @3.4.0.0Prepare 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 .)Prepare a directory tree of source files.Note: must be called with the CWD set to the directory containing the '.cabal' file.Create a source distribution. Modifies a  by appending a snapshot number corresponding to the given date. Modifies a  by appending a snapshot number corresponding to the given date.!Remove the auto-generated modules (like 'Paths_*') from 'exposed-modules' and 'other-modules'.!8Given a buildinfo, return the names of all source files.!Given a list of include paths, try to find the include file named f. Return the name of the file and the full path, or exit with error if there's no such file.!Find the main executable file.!Find a module definition file#TODO: I don't know if this is right!)Find the setup script file, if it exists.!/Find the setup hooks script file, if it exists.!Create a default setup script in the target directory, if it doesn't exist.!)The name of the tarball without extension  verbosityinfo from cabal filesource tree to archivename of archive to create verbositydirectory with cabal fileinfo from the cabal file&extra preprocessors (include suffixes) verbosity  alternative. Since  ! prefixes the error message with  errorPrefix, whatever is passed in here and wants to die should do the same. See issue #7331.directory with cabal fileinfo from the cabal file&extra preprocessors (include suffixes) verbosityworking directoryinfo from the cabal filesource tree to populate'extra preprocessors (includes suffixes) verbosityworking directoryinfo from the cabal filesource tree to populate'extra preprocessors (includes suffixes)information from the tarballverbosity & snapshotbuild prefix (temp dir)'extra preprocessors (includes suffixes)!  alternative. Since  ! prefixes the error message with  errorPrefix, whatever is passed in here and wants to die should do the same. See issue #7331.working directoryExtra preprocessorsExposed modules!working directorymain-is! verbosity  alternative. Since  ! prefixes the error message with  errorPrefix, whatever is passed in here and wants to die should do the same. See issue #7331.directory with cabal fileinfo from the cabal file&extra preprocessors (include suffixes)! verbosityinfo from the cabal file source tree  Isaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone3B!!Convert Windows path to Unix ones! host platform!_Isaac Jones 2003-2005, Ross Paterson 2006, Duncan Coutts 2007-2008, 2012BSD3cabal-devel@haskell.orgportableNone &3Update the program database to include any build-tool-depends specified in the given 0 on build tools internal to the current package.This function:'adds these internal build tools to the ;, including paths to their respective data directories, adds their paths to the current , and adds the data directory environment variable for the current package to the current , so that any programs configured from now on will be able to invoke these build tools.4Build the libraries and executables in this package.Built-in pre-build  SetupHooks for a given !.Creates the autogenerated files for a particular configured component.Legacy function: does not run pre-build hooks or pre-processors. This function is insufficient on its own to prepare the build for a component.Consumers wanting to prepare the sources of a component, e.g. in order to launch a REPL session, are advised to run  Setup repl  compName --repl-multi-file= fn instead.Initialize a new package db file for libraries defined internally to the package.Runs  on every configured component.Legacy function: does not run pre-build hooks or pre-processors. This function is insufficient on its own to prepare the build for a package.Consumers wanting to prepare the sources of a package, e.g. in order to launch a REPL session, are advised to run Setup repl --repl-multi-file= fn instead.Creates the autogenerated files for a particular configured component, and runs the pre-build hook.Compute and execute PreBuildComponentRules7, returning the monitored files declared by the rules.7Start an interpreter without loading any package files.Write the given autogenerated files in the autogenerated modules directory for the component.Generate and write to disk all built-in autogenerated files for the specified component. These files will be put in the autogenerated module directory for this component (see autogenComponentsModuleDir).This includes:Paths_ pkg.hs, PackageInfo_ pkg.hs,Backpack signature files for components that are not fully instantiated,cabal_macros.h.:A representation of the contents of an autogenerated file.!Add extra ASM sources generated by preprocessing to build information.!Add extra C sources generated by preprocessing to build information.!Add extra C-- sources generated by preprocessing to build information.!Add extra C++ sources generated by preprocessing to build information.!Add extra JS sources generated by preprocessing to build information.!Add extra HS modules generated by preprocessing to build information.!+Add extra source dir for generated modules.!Translate a exe-style # component into an exe for building!Build a foreign libraryNOTE: We assume that we already checked that we can actually build the foreign library in configure.!?Built-in autogenerated files and their contents. This includes:Paths_ pkg.hs, PackageInfo_ pkg.hs,Backpack signature files for components that are not fully instantiated,cabal_macros.h.!Check for conditions that would prevent the build from succeeding.!&Write available build information for  to disk.Dumps detailed build information 'build-info.json' to the given directory. Build information contains basics such as compiler details, but also lists what modules a component contains and how to compile the component, assuming lib:Cabal made sure that dependencies are up-to-date.! An empty ".hsig" Backpack signature module for each requirement, so that GHC has a source file to look at it when it needs to typecheck a signature. It's harmless to generate these modules, even when there is a real hsig file written by the user, since include path ordering ensures that the real hsig= file will always be picked up before the autogenerated one.!Translate a exe-style # component into an exe for building!Translate a lib-style ( component into a lib + exe for building 'Mostly information from the .cabal fileConfiguration information#Flags that the user passed to build%preprocessors to run before compiling build hooks'Mostly information from the .cabal fileConfiguration information#Flags that the user passed to build%preprocessors to run before compiling "dist" prefix'mostly information from the .cabal fileConfiguration informationBuild info about the componentThe verbosity to use "dist" prefix'mostly information from the .cabal fileConfiguration informationThe verbosity to usepre-build hookConfiguration information'Mostly information from the .cabal fileConfiguration information#Flags that the user passed to build%preprocessors to run before compilingpre-build hook'Mostly information from the .cabal fileConfiguration information#Flags that the user passed to build%preprocessors to run before compiling!3To which directory should the build-info be dumped?=Should we dump detailed build information for this component?'Mostly information from the .cabal fileConfiguration information#Flags that the user passed to build!absolute inplace dir Deprecated: This function does not prepare all source files for a component. Suggestion: use 'Setup repl  compName --repl-multi-file= fn'. Deprecated: This function does not prepare all source files for a package. Suggestion: use 'Setup repl --repl-multi-file= fn'.     `Thomas Tuegel 2010BSD3cabal-devel@haskell.orgportableNone &()3 Perform the " ./setup test " action.!positional command-line arguments information from the .cabal file#information from the configure stepflags sent to testaIsaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone &(3? !Execute Haddock configured with  HaddocksFlags. It is used to build index and contents for documentation of multiple packages.Given a list of s, return a list of interfaces and HTML paths, and an optional warning for packages with missing documentation.!1The FilePath of a directory, it's a monoid under !.!A record that represents the arguments to the haddock executable, a product monoid.!?Path to the interface file, relative to argOutputDir, required.!Package name, required."Optional name used to construct haddock's `--package-name` option for various components (tests suites, sublibriaries, etc)."!(Hide modules ?, modules to hide)"Ignore export lists in modules?"(Template for modules, template for symbols, template for lines)."Generate hyperlinked sources"Generate quickjump index"Optional custom CSS file."Optional URL to contents page."Generate contents"Optional URL to index page."Generate index"9Optional base url from which static files will be loaded."%HTML or Hoogle doc or both? Required." (Interface file, URL to the HTML docs and hyperlinked-source for links)."$Where to generate the documentation."Page title, required."Prologue text, required for  , ignored by haddocks."Prologue file name, ignored by , optional for haddocks." Additional flags to pass to GHC.""To find the correct GHC, required."Re-exported modules"Modules to process."#haddock's static / auxiliary files."haddock's `--use-unicode` flag"7Get Haddock program and check if it matches the request"If Hi Haddock is supported, this function creates temporary directories and copies existing interface and object files produced by GHC into them, then passes them off to the given continuation.If Hi Haddock is _not_ supported, we can't re-use GHC's compilation files. Instead, we use a clean temporary directory to the continuation, with no hope for recompilation avoidance.-See Note [Hi Haddock Recompilation Avoidance]"*Call haddock with the specified arguments. pre-build hookpre-build hook"quickjump feature"Working directoryHaddock's version Continuation"require targets"Directories for -hidir, -odir, and -stubdir to GHC through Haddock. See Note [Hi Haddock Recompilation Avoidance]template for HTML location common args"Directories for -hidir, -odir, and -stubdir to GHC through Haddock. See Note [Hi Haddock Recompilation Avoidance]template for HTML location common args"Directories for -hidir, -odir, and -stubdir to GHC through Haddock. See Note [Hi Haddock Recompilation Avoidance]template for HTML location common args"Directories for -hidir, -odir, and -stubdir to GHC through Haddock. See Note [Hi Haddock Recompilation Avoidance]template for HTML location common args"Directories for -hidir, -odir, and -stubdir to GHC through Haddock. See Note [Hi Haddock Recompilation Avoidance]template for HTML location common args"template for HTML location"pre-build hookCalled when the  exe is not found."Directories for -hidir, -odir, and -stubdir to GHC through Haddock. See Note [Hi Haddock Recompilation Avoidance]template for HTML location         8<>bJohan Tibell 2011BSD3cabal-devel@haskell.orgportableNone& Perform the " ./setup bench " action.!positional command-line arguments information from the .cabal file#information from the configure stepflags sent to benchmarkcIsaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone #&3Basic autoconf : runs  ./configure , if present.the pre-hooks, except for pre-conf, read additional build information from package .buildinfo , if present.Thus  configure/ can use local system information to generate package .buildinfo and possibly other files.A 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. A version of  that is passed the command line arguments, rather than getting them from the environment. A version of 0 that allows passing explicit verbosity handles.Like , but accepts the package description as input rather than using IO to read it.A customizable version of .A customizable version of - that also takes the command line arguments.A customizable version of .CabalA customizable version of - that also takes the command line arguments.Hooks that correspond to a plain instantiation of the "simple" build system A version of , that allows setting custom logging handles."Combine the preprocessors in the given hooks with the preprocessors built into cabal."The central command chooser of the Simple build system, with other defaultMain functions acting as exposed callers, and with  $ operating as an exceptions handler. This uses l to read response files, preprocessing response files given by "@" prefixes. Given hooks and args, this runs  onto the args, getting  data back, which is then pattern-matched into IO actions for execution, with arguments applied by the parser." A version of ") that allows setting the logging handles." Read the  or throw an exception."Try to read the  """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" """""""""##############!##################################################################################################################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$          mmp  su             |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||         !!!!!!!!!!!!!!!!""""""""""###$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) * * * * * * * * * * * * * * * * * * + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +++ + + + + + + + + + + + + + + + + + + + + + + + + , , -                                                                                                      . . . . . . . . . . . . . . . . . . . . . . / / / / / / / / / 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 2 3 3 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 6 6 6 6 6 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       8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 88888888888888888888888888888888888888888888889999999999999999999999999;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<===============================================>>>>>>>??@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDEFGGGGGGGGGGGGGGGGGGGGHHJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKLLLLLLAAAAAAAAAAAAAMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPQQQQQQRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTT TTTTTTTTT::::::::::::::::::::::::::UUUUUUUUUUUUUUUUUUUUUUUUVVVVWWWXX      YZ[[[[[[[[[[[[[[[[\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII^^^^^^^^^^______________________`aaaaaaaaaaaaaaaabcccccccccccccccccccccccccccgggggggggggggggggggggggkkkkkkkkkkkkkkmmmmmmnnop wwwwwwwwwwwwwwww{||||||||||||||||||||||||||||||| &&&&''''' ./33578888;====@@                              C         F G J J                        N N N N N N N N N N N N N N N N   P P P P P Q S S S S S S S S S T T T T T T T T T                         !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!:!:!:!:!:!:!:!:!:!:!:!:!:!:!U!U!U!U!U!U!U!V!W!W!W!W!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ! ! ! ! !!"""""""""""""""""""!"!"!"!"!"!"""""""""!!"""""""Y""""\"\"I"I"I"I"I"I"I"I"I"I"I"I"I"I"I"I"I"I"""I"I"I"I"^"^"^"^"^"^"^"^"^"^"^"""""_"_"_"_"_"_"_"_"__"_"_"_"_"_"a"""a"a""a""a""a""a""a""a""a""a""a""a""a""a""a""a""a""a""a""a""a""a""a""a""a""a""a""a"a"a"a"a"a"a"a"a#a#a#c#c#c#c#c###########"#"###################################################################################################################################################  # #######################$#$#$$$$$$$$$$$$$$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%#%%Cabal-3.18.2.0-inplaceDistribution.Compat.StackDistribution.Simple.Utils"Distribution.Simple.LocalBuildInfo Distribution.Compat.ResponseFileDistribution.Compat.CreatePipe Distribution.Backpack.FullUnitIdDistribution.Backpack.ModSubst!Distribution.Backpack.ModuleShape$Distribution.Backpack.PreModuleShapeDistribution.Compat.ProcessDistribution.Compat.SysInfoDistribution.Compat.Time%Distribution.PackageDescription.CheckDistribution.ReadE$Distribution.Simple.BuildToolDependsDistribution.Simple.BuildWayDistribution.Simple.CCompilerDistribution.Simple.Flag!Distribution.Simple.Glob.Internal%Distribution.Simple.FileMonitor.Types(Distribution.Simple.InstallDirs.InternalDistribution.Simple.InstallDirs$Distribution.Simple.Program.InternalDistribution.TestSuiteDistribution.Types.AnnotatedId#Distribution.Types.ComponentInclude*Distribution.Types.ComponentLocalBuildInfo Distribution.Types.DumpBuildInfo!Distribution.Types.GivenComponent$Distribution.Types.PackageName.MagicDistribution.Types.ParStratDistribution.Types.TargetInfoDistribution.Utils.IODataDistribution.Utils.JsonDistribution.Utils.MapAccumDistribution.Utils.ProgressDistribution.Verbosity.InternalDistribution.Verbosity#Distribution.Simple.SetupHooks.Rule%Distribution.Simple.SetupHooks.Errors!Distribution.Simple.Program.Types$Distribution.Simple.PreProcess.TypesDistribution.Simple.Errors$Distribution.Simple.PreProcess.Unlit+Distribution.Simple.Build.PackageInfoModuleDistribution.Utils.NubListDistribution.Utils.LogProgressDistribution.Simple.Program.Run"Distribution.Simple.Program.Script(Distribution.Simple.Program.ResponseFileDistribution.Simple.Program.Hpc Distribution.Simple.Program.Find 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.LocalBuildConfig!Distribution.Types.LocalBuildInfoDistribution.Simple.Test.LogDistribution.Simple.Program.LdDistribution.Simple.Program.ArDistribution.Simple.Hpc Distribution.Simple.Build.MacrosDistribution.Simple.Configure)Distribution.Backpack.ConfiguredComponent%Distribution.Backpack.LinkedComponent%Distribution.Backpack.ComponentsGraph Distribution.Simple.Build.InputsDistribution.Simple.BuildTargetDistribution.Simple.BuildPathsDistribution.Simple.UHCDistribution.Simple.Test.LibV09Distribution.Simple.Test.ExeV10'Distribution.Simple.SetupHooks.Internal(Distribution.Simple.SetupHooks.HooksMainDistribution.Simple.GHC!Distribution.Simple.ShowBuildInfoDistribution.Simple.Install%Distribution.Simple.Build.PathsModuleDistribution.Backpack.Configure$Distribution.Backpack.DescribeUnitIdDistribution.Simple.RegisterDistribution.Simple.PreProcessDistribution.Simple.UserHooksDistribution.Simple.SrcDistDistribution.Simple.BuildDistribution.Simple.TestDistribution.Simple.HaddockDistribution.Simple.BenchDistribution.SimpleCabal'src/Distribution/Backpack/FullUnitId.hs%src/Distribution/Backpack/ModSubst.hs!Distribution.Backpack.ModuleScope(src/Distribution/Backpack/ModuleScope.hs(src/Distribution/Backpack/ModuleShape.hs+src/Distribution/Backpack/PreModuleShape.hsDistribution.Compat.Async src/Distribution/Compat/Async.hsDistribution.Compat.CopyFileDistribution.Compat.Environment$Distribution.Compat.GetShortPathName%Distribution.Compat.Internal.TempFile$Distribution.Compat.Prelude.InternalSystem.ProcessprocGHC.ResponseFileexpandResponsesrc/Distribution/Compat/Time.hsDistribution.GetOptSystem.EnvironmentgetArgssrc/Distribution/GetOpt.hsDistribution.Lex-Distribution.PackageDescription.Check.Warning4src/Distribution/PackageDescription/Check/Warning.hssrc/Distribution/ReadE.hsDistribution.PackageCheck#src/Distribution/Simple/BuildWay.hs$src/Distribution/Simple/CCompiler.hssrc/Distribution/Simple/Flag.hs(src/Distribution/Simple/Glob/Internal.hs,src/Distribution/Simple/FileMonitor/Types.hs/src/Distribution/Simple/InstallDirs/Internal.hs&src/Distribution/Simple/InstallDirs.hssrc/Distribution/TestSuite.hs%src/Distribution/Types/AnnotatedId.hs*Distribution.Backpack.PreExistingComponent1src/Distribution/Backpack/PreExistingComponent.hs1src/Distribution/Types/ComponentLocalBuildInfo.hs'src/Distribution/Types/DumpBuildInfo.hs(src/Distribution/Types/GivenComponent.hs"src/Distribution/Types/ParStrat.hs$src/Distribution/Types/TargetInfo.hs System.IO hGetContentshPutStrhClose src/Distribution/Utils/IOData.hssrc/Distribution/Utils/Json.hs"src/Distribution/Utils/MapAccum.hs"src/Distribution/Utils/Progress.hsDistribution.Utils.UnionFind#src/Distribution/Utils/UnionFind.hs&src/Distribution/Verbosity/Internal.hssrc/Distribution/Verbosity.hs*src/Distribution/Simple/SetupHooks/Rule.hs,src/Distribution/Simple/SetupHooks/Errors.hs(src/Distribution/Simple/Program/Types.hs+src/Distribution/Simple/PreProcess/Types.hs!src/Distribution/Simple/Errors.hsDistribution.Backpack.UnifyM#src/Distribution/Backpack/UnifyM.hsDistribution.Backpack.MixLinkDistribution.ZinzaPrelude src/Distribution/ZinzaPrelude.hs'Distribution.Simple.Build.PathsModule.Z.src/Distribution/Simple/Build/PathsModule/Z.hs-Distribution.Simple.Build.PackageInfoModule.Z4src/Distribution/Simple/Build/PackageInfoModule/Z.hs"Distribution.Simple.Build.Macros.Z)src/Distribution/Simple/Build/Macros/Z.hs Paths_Cabal CreatePipeDispDocProcesswithCreateProcess ExceptiondisplayException src/Distribution/Simple/Utils.hs!src/Distribution/Utils/NubList.hs%src/Distribution/Utils/LogProgress.hsIPIInstalledPackageInfo'src/Distribution/Simple/PackageIndex.hssrc/Distribution/Simple/Glob.hs+Distribution.PackageDescription.Check.Monad2src/Distribution/PackageDescription/Check/Monad.hs1Distribution.PackageDescription.Check.Conditional#src/Distribution/Simple/Compiler.hs Distribution.Simple.GHC.ImplInfo&src/Distribution/Simple/Program/GHC.hs%src/Distribution/Simple/Program/Db.hs"src/Distribution/Simple/Command.hs Distribution.Simple.Setup.Common'src/Distribution/Simple/Setup/Common.hsDistribution.Simple.Setup.Test%src/Distribution/Simple/Setup/Test.hsDistribution.Simple.Setup.SDist&src/Distribution/Simple/Setup/SDist.hsDistribution.Simple.Setup.Repl%src/Distribution/Simple/Setup/Repl.hs"Distribution.Simple.Setup.Register)src/Distribution/Simple/Setup/Register.hs!Distribution.Simple.Setup.Install(src/Distribution/Simple/Setup/Install.hs"Distribution.Simple.Setup.Hscolour)src/Distribution/Simple/Setup/Hscolour.hs!Distribution.Simple.Setup.Haddock(src/Distribution/Simple/Setup/Haddock.hs Distribution.Simple.Setup.Global'src/Distribution/Simple/Setup/Global.hsDistribution.Simple.Setup.Copy%src/Distribution/Simple/Setup/Copy.hs Distribution.Simple.Setup.Config D.C.SetupfilterConfigureFlags'src/Distribution/Simple/Setup/Config.hsbuild*src/Distribution/Types/LocalBuildConfig.hs ConfigFlags(src/Distribution/Types/LocalBuildInfo.hs InstallDirsabsoluteInstallDirsprefixRelativeInstallDirs#src/Distribution/Simple/Test/Log.hssrc/Distribution/Simple/Hpc.hsDistribution.Backpack.Id,src/Distribution/Backpack/LinkedComponent.hsDistribution.Simple.Setup.Clean&src/Distribution/Simple/Setup/Clean.hsDistribution.Simple.Setup.Build&src/Distribution/Simple/Setup/Build.hs#Distribution.Simple.Setup.Benchmark*src/Distribution/Simple/Setup/Benchmark.hs src/Distribution/Simple/Setup.hs&src/Distribution/Simple/BuildTarget.hsHaddock.src/Distribution/Simple/SetupHooks/Internal.hs/src/Distribution/Simple/SetupHooks/HooksMain.hs Distribution.Simple.GHC.Internal'src/Distribution/Simple/GHC/Internal.hs)Distribution.Simple.GHC.EnvironmentParser0src/Distribution/Simple/GHC/EnvironmentParser.hs#Distribution.Simple.GHC.Build.UtilsDistribution.ModuleNamemain%Distribution.Simple.GHC.Build.ModulesHpcWay*Distribution.Simple.GHC.Build.ExtraSources"Distribution.Simple.GHC.Build.LinkDistribution.Simple.GHC.Build,Distribution.PackageDescription.Check.Common3src/Distribution/PackageDescription/Check/Common.hs+Distribution.PackageDescription.Check.Paths,Distribution.PackageDescription.Check.Target3src/Distribution/PackageDescription/Check/Target.hsfindPackageDesc$Distribution.Backpack.ReadyComponent+src/Distribution/Backpack/ReadyComponent.hsLBC BuildOptions$src/Distribution/Simple/Configure.hs#Distribution.Simple.ConfigureScript src/Distribution/Simple/Build.hs"src/Distribution/Simple/Haddock.hs ghc-internalGHC.Internal.Stack.Types CallStackGHC.Internal.Data.Ord comparingGHC.Internal.Data.OldList isInfixOf intercalateCabal-syntax-3.18.2.0-inplaceDistribution.Utils.GenericdropWhileEndLEequating fromUTF8BS fromUTF8LBS ignoreBOMisAbsoluteOnAnyPlatformisRelativeOnAnyPlatform listUnionlistUnionRight lowercasenormaliseLineEndingsordNubordNubBy ordNubRight readUTF8FilesafeHeadsafeInitsafeLastsafeTailsortNubtakeWhileEndLEtoUTF8BS toUTF8LBS uninterspersewithFileContentswithUTF8FileContentswrapLinewrapTextwriteFileAtomic writeUTF8FileDistribution.Types.LibraryNamedefaultLibName LibraryName LMainLibName LSubLibName Distribution.Types.ComponentNamecomponentNameStringshowComponentName ComponentName CBenchNameCExeName CFLibNameCLibName CNotLibName CTestNameDistribution.Types.ComponentcomponentBuildInfocomponentBuildable componentName foldComponent ComponentCBenchCExeCFLibCLibCTest%Distribution.Types.PackageDescription getComponentlookupComponentpkgBuildableComponents pkgComponentsGHC.Internal.StackwithFrozenCallStackprettyCallStack callStackGHC.Internal.ResponseFile escapeArgsprocess-1.6.30.0-f6acf73db8ea29915ce16942360f910a67900cbc5c2fd2265f7c0859409953f3System.Process.Internals createPipeexpandOpenUnitId expandUnitIdFullDb FullUnitId$fGenericFullUnitId$fShowFullUnitIdModSubstmodSubst$fModSubstList $fModSubstMap$fModSubstOpenModule$fModSubstOpenUnitId $fModSubstSet$fModSubstTuple2emptyModuleShapeshapeInstalledPackage ModuleShapemodShapeProvidesmodShapeRequires$fBinaryModuleShape$fEqModuleShape$fGenericModuleShape$fModSubstModuleShape$fShowModuleShape$fStructuredModuleShapemixLinkPreModuleShaperenamePreModuleShapetoPreModuleShapePreModuleShapepreModShapeProvidespreModShapeRequires$fEqPreModuleShape$fGenericPreModuleShape$fShowPreModuleShapesetFileOrdinarysetFileExecutablecreateTempDirectoryenableProcessJobs WithCallStackparentSrcLocPrefixwithLexicalCallStackfullCompilerVersion getCurTime getFileAge getModTimeModTime$fBinaryModTime$fBoundedModTime $fEqModTime$fGenericModTime $fOrdModTime $fReadModTime $fShowModTime$fStructuredModTimefilterPackageChecksByIdfilterPackageChecksByIdStringisHackageDistErrorppCheckExplanationIdppPackageCheckCheckExplanation AbsolutePathAllRightsReservedLicenseAutogenIncludesNotIncludedAutogenIncludesNotIncludedExeAutogenNoOtherAutogenNotExposedBOMStartBadRelativePathBaseNoUpperBoundsBenchmarkNotSupportedBenchmarkTypeNotKnownCOptCPP COptONumberCVAutogenPackageInfoCVAutogenPackageInfoGuardCVAutogenPaths CVCustomSetupCVDefaultExtensionsCVDefaultLanguageCVDefaultLanguageComponentCVDefaultLanguageComponentSoftCVExplicitDepsCustomSetup CVExtensionsCVExtensionsDeprecatedCVExtraDocFilesCVExtraDynamicCVExtraFrameworkDirsCVMixins CVMultiLib CVReexportedCVSourceRepository CVSources CVTestSuiteCVVirtualModulesDeclaredUsedFlagsDeprecatedExtensions DistPointDuplicateModuleDuplicateSectionsDynamicUnneededFDeferTypeErrorsUnneeded FilePathEmptyFilePathNameTooLongFilePathSplitTooLongFilePathTooLongFreeTextDotline GTLowerBounds GitProtocolGlobExactMatch GlobNoDir GlobNoMatchGlobSyntaxErrorIllegalLibraryNameImpossibleInternalDepImpossibleInternalExeInvalidNameWin InvalidOnWinInvalidTestWith JUnneeded LEUpperBoundsLanguagesAsExtensionLicenseMessParseMainCCabal1_18MissingConfigureScriptMissingExpectedDocFilesMissingFieldCategoryMissingFieldDescriptionMissingFieldMaintainerMissingFieldSynOrDescMissingFieldSynopsisMissingInternalExeMissingLocation MissingModuleMissingSetupFileMissingSourceControl MissingTag MissingTypeMissingUpperBounds MultiDesc NONELicense NoBuildType NoCustomSetupNoDesc NoHsLhsMainNoHsLhsMainBench NoLicense NoLicenseFileNoMainIsNoModulesExposed NoNameFieldNoTargetNoVersionFieldNonASCIICustomFieldNotPackageNameOptAlternativesOptExtsOptFasmOptHideOptHpcOptJSPPOptMakeOptOOptONotOptOOneOptOTwoOptProfOptRts OptSplitObjsOptSplitSections OptWithRtsOptWls ParseWarningPotentialDupModuleProfilingUnneededRebindableClashPackageInfoRebindableClashPathsRecursiveGlobInRootRelativeOutside ShortDescSignaturesCabal2SubdirGoodRelPath SubdirRelPathSuspiciousFlagNameSynopsisTooLongTestsuiteNotSupportedTestsuiteTypeNotKnownTrailingZeroUpperBounds UncommonBSD4 UnknownArchUnknownCompilerUnknownCompilersUnknownDirectoryUnknownExtensions UnknownFileUnknownLanguagesUnknownLicenseVersion UnknownOSUnnamedInternalUnrecognisedLicenseUnrecognisedSourceRepoUpperBoundSetupWErrorUnneededWrongFieldForExpectedDocFilesZPrefixCheckExplanationIDCheckExplanationIDString PackageCheckPackageBuildImpossiblePackageBuildWarningPackageDistInexcusablePackageDistSuspiciousPackageDistSuspiciousWarn explanationReadErunReadE succeedReadE failReadE parsecToReadEparsecToReadEErrunexpectMsgString$fFunctorReadEdesugarBuildTooldesugarBuildToolSimplegetAllInternalToolDependenciesgetAllToolDependencies isInternalbuildWayInterfaceExtensionbuildWayObjectExtensionBuildWayDynWay ProfDynWayProfWay StaticWay$fEnumBuildWay $fEqBuildWay $fOrdBuildWay$fReadBuildWay$fShowBuildWaycDialectFilenameExtensioncSourceExtensionsfilenameCDialectCDialectC CPlusPlus ObjectiveCObjectiveCPlusPlus $fEqCDialect$fMonoidCDialect$fSemigroupCDialect$fShowCDialect BooleanFlagasBoolFlagNoFlagtoFlagfromFlagfromFlagOrDefault flagToMaybeflagElim flagToListallFlags maybeToFlag mergeListFlag$fBooleanFlagBool GlobPieceWildCardLiteralUnion GlobPiecesGlobGlobDirGlobDirRecursiveGlobFileGlobDirTrailingdispGlobPiecesisGlobEscapedChar$fStructuredGlobPiece$fBinaryGlobPiece $fParsecGlob $fPrettyGlob$fStructuredGlob $fBinaryGlob$fEqGlob $fShowGlob $fGenericGlob $fEqGlobPiece$fShowGlobPiece$fGenericGlobPieceMonitorKindDir DirExists DirModTime DirNotExistsMonitorKindFile FileExists FileModTime FileHashed FileNotExistsMonitorFilePath MonitorFileMonitorFileGlob monitorPathmonitorKindDirmonitorKindFilemonitorPathGlob FilePathRootFilePathRelativeFilePathHomeDir RootedGlob monitorFilemonitorFileHashedmonitorNonExistentFilemonitorFileExistencemonitorDirectorymonitorNonExistentDirectorymonitorDirectoryExistencemonitorFileOrDirectorymonitorFileGlobmonitorFileGlobExistencemonitorFileSearchPathmonitorFileHashedSearchPath$fParsecFilePathRoot$fPrettyFilePathRoot$fStructuredFilePathRoot$fBinaryFilePathRoot$fParsecRootedGlob$fPrettyRootedGlob$fStructuredRootedGlob$fBinaryRootedGlob$fStructuredMonitorKindFile$fBinaryMonitorKindFile$fStructuredMonitorKindDir$fBinaryMonitorKindDir$fStructuredMonitorFilePath$fBinaryMonitorFilePath$fEqMonitorFilePath$fShowMonitorFilePath$fGenericMonitorFilePath$fEqMonitorKindDir$fShowMonitorKindDir$fGenericMonitorKindDir$fEqMonitorKindFile$fShowMonitorKindFile$fGenericMonitorKindFile$fEqRootedGlob$fShowRootedGlob$fGenericRootedGlob$fEqFilePathRoot$fShowFilePathRoot$fGenericFilePathRootPathTemplateVariable PrefixVar BindirVar LibdirVar LibsubdirVar DynlibdirVarBytecodelibdirVar DatadirVar DatasubdirVar DocdirVar HtmldirVar PkgNameVar PkgVerVarPkgIdVar LibNameVar CompilerVarOSVarArchVarAbiVar AbiTagVarExecutableNameVarTestSuiteNameVarTestSuiteResultVarBenchmarkNameVar PathComponentOrdinaryVariable$fReadPathTemplateVariable$fShowPathTemplateVariable $fStructuredPathTemplateVariable$fNFDataPathTemplateVariable$fBinaryPathTemplateVariable$fReadPathComponent$fShowPathComponent$fStructuredPathComponent$fNFDataPathComponent$fBinaryPathComponent$fEqPathComponent$fOrdPathComponent$fGenericPathComponent$fEqPathTemplateVariable$fOrdPathTemplateVariable$fGenericPathTemplateVariablePathTemplateEnv PathTemplateCopyDest NoCopyDestCopyToCopyToDbInstallDirTemplates sysconfdir haddockdirhtmldirmandirdocdir datasubdirdatadir includedir libexecsubdir libexecdirflibdirbytecodelibdir dynlibdir libsubdirlibdirbindirprefixcombineInstallDirsdefaultInstallDirsdefaultInstallDirs'substituteInstallDirTemplatestoPathTemplatefromPathTemplatecombinePathTemplatesubstPathTemplateinitialPathTemplateEnvpackageTemplateEnvcompilerTemplateEnvplatformTemplateEnvabiTemplateEnvinstallDirsTemplateEnvinstallDirsGrammar$fSemigroupInstallDirs$fMonoidInstallDirs$fStructuredInstallDirs$fNFDataInstallDirs$fBinaryInstallDirs$fStructuredCopyDest$fBinaryCopyDest$fParsecPathTemplate$fReadPathTemplate$fShowPathTemplate$fStructuredPathTemplate$fNFDataPathTemplate$fBinaryPathTemplate$fEqPathTemplate$fOrdPathTemplate$fGenericPathTemplate $fEqCopyDest$fShowCopyDest$fGenericCopyDest$fEqInstallDirs$fReadInstallDirs$fShowInstallDirs$fFunctorInstallDirs$fGenericInstallDirsstripExtractVersion testGroup OptionDescr optionDefaultoptionDescription optionName optionType OptionType OptionBool OptionEnum OptionFile OptionNumber OptionRngSeed OptionSet OptionStringoptionFileExtensionsoptionFileIsDiroptionFileMustExistoptionNumberBoundsoptionNumberIsIntoptionStringMultilineOptionsProgressFinishedResultErrorFailPassTest ExtraOptionsGroup concurrently groupName groupTests TestInstancenameoptionsrun setOptiontags$fEqOptionDescr$fEqOptionType $fEqResult$fReadOptionDescr$fReadOptionType $fReadResult$fShowOptionDescr$fShowOptionType $fShowResult AnnotatedId ann_cnameann_idann_pid$fEqAnnotatedId$fFunctorAnnotatedId$fOrdAnnotatedId$fPackageAnnotatedId$fShowAnnotatedIdci_cnameci_idci_pkgidComponentInclude ci_ann_id ci_implicit ci_renamingcomponentIsIndefinitemaybeComponentCompatPackageKeymaybeComponentExposedModulesmaybeComponentInstantiatedWithComponentLocalBuildInfoBenchComponentLocalBuildInfoExeComponentLocalBuildInfoFLibComponentLocalBuildInfoLibComponentLocalBuildInfoTestComponentLocalBuildInfocomponentCompatPackageKeycomponentCompatPackageNamecomponentComponentIdcomponentExeDepscomponentExposedModulescomponentIncludescomponentInstantiatedWithcomponentInternalDepscomponentIsIndefinite_componentIsPubliccomponentLocalNamecomponentPackageDepscomponentUnitId$fBinaryComponentLocalBuildInfo $fGenericComponentLocalBuildInfo$fIsNodeComponentLocalBuildInfo$fReadComponentLocalBuildInfo$fShowComponentLocalBuildInfo#$fStructuredComponentLocalBuildInfo DumpBuildInfoNoDumpBuildInfo$fBinaryDumpBuildInfo$fBoundedDumpBuildInfo$fEnumDumpBuildInfo$fEqDumpBuildInfo$fGenericDumpBuildInfo$fNFDataDumpBuildInfo$fOrdDumpBuildInfo$fParsecDumpBuildInfo$fReadDumpBuildInfo$fShowDumpBuildInfo$fStructuredDumpBuildInfoGivenComponentgivenComponentIdgivenComponentNamegivenComponentPackagePromisedComponentpromisedComponentIdpromisedComponentNamepromisedComponentPackage$fBinaryGivenComponent$fBinaryPromisedComponent$fEqGivenComponent$fEqPromisedComponent$fGenericGivenComponent$fGenericPromisedComponent$fReadGivenComponent$fReadPromisedComponent$fShowGivenComponent$fShowPromisedComponent$fStructuredGivenComponent$fStructuredPromisedComponentfakePackageCabalFileName fakePackageIdfakePackageName nonExistentPackageThisIsCabalBugisParallelBuildParStratParStratInstall ParStratXNumJobsSerialUseSem$fNFDataParStratX$fShowParStratX TargetInfo targetCLBItargetComponent$fBinaryTargetInfo$fGenericTargetInfo$fIsNodeTargetInfo$fShowTargetInfo$fStructuredTargetInfo IODataModeIODataModeTextIODataModeBinaryKnownIODataModehGetIODataContentstoIOData iodataModeIOData IODataText IODataBinary withIODatanull hPutContents$fNFDataIOData$fKnownIODataModeByteString$fKnownIODataModeList.= renderJsonJson JsonArrayJsonBoolJsonNull JsonNumber JsonObject JsonString $fShowJson mapAccumM$fApplicativeStateM$fFunctorStateM failProgress foldProgress stepProgress$fAlternativeProgress$fApplicativeProgress$fFunctorProgress$fMonadProgress VerbosityFlag VCallStack VCallSiteVNoWrap VMarkOutput VTimestampVStderrVNoWarnVerbosityLevelSilentNormalVerbose Deafening$fStructuredVerbosityLevel$fNFDataVerbosityLevel$fBinaryVerbosityLevel$fStructuredVerbosityFlag$fNFDataVerbosityFlag$fBinaryVerbosityFlag$fGenericVerbosityFlag$fShowVerbosityFlag$fReadVerbosityFlag$fEqVerbosityFlag$fOrdVerbosityFlag$fEnumVerbosityFlag$fBoundedVerbosityFlag$fGenericVerbosityLevel$fShowVerbosityLevel$fReadVerbosityLevel$fEqVerbosityLevel$fOrdVerbosityLevel$fEnumVerbosityLevel$fBoundedVerbosityLevelVerbosityFlagsvLevelVerbosityHandles vStderrHandle vStdoutHandle VerbosityverbosityHandlesverbosityFlagsdefaultVerbosityHandlesverbosityLevelverbosityChosenOutputHandleverbosityErrorHandlesetVerbosityHandles mkVerbositymodifyVerbosityFlagsmkVerbosityFlagssilentnormalverbose deafening moreVerbose makeVerbose lessVerboseintToVerbosityflagToVerbosity showForCabal showForGHCverboseCallSiteverboseCallStackverboseMarkOutputverboseUnmarkOutput verboseNoWrapverboseTimestampverboseNoTimestamp verboseStderrverboseNoStderr verboseNoWarnverboseNoFlagsverboseHasFlagsisVerboseCallSiteisVerboseCallStackisVerboseMarkOutputisVerboseNoWrapisVerboseQuietisVerboseTimestampisVerboseStderrisVerboseNoWarn$fStructuredVerbosityHandles$fNFDataVerbosityHandles$fPrettyVerbosityFlags$fParsecVerbosityFlags$fStructuredVerbosityFlags$fNFDataVerbosityFlags$fBinaryVerbosityFlags$fStructuredVerbosity$fNFDataVerbosity$fGenericVerbosity$fGenericVerbosityFlags$fShowVerbosityFlags$fReadVerbosityFlags$fEqVerbosityFlagsDict RuleExecCmdRuleDynDepsCmdRuleCmdsDepsResdepsRes DynDepsCmd dynDepsCmd RuleCommandsStaticRuleCommandDynamicRuleCommandsstaticRuleArgRepstaticRuleCommanddynamicRuleTypeRepdynamicRuleCommand dynamicDepsdynamicRuleInstances CommandDataCommand cmdInstances actionArg actionPtrStaticRulesrunRulesRulesT runRulesTRulesEnvrulesEnvNameSpacerulesEnvVerbosityRulesM RuleOutput outputIndex outputOfRule DependencyRuleDependencyFileDependencyLocationlocationRelPathlocationBaseDirRuleDataRuleresultsstaticDependencies ruleCommands RuleBinarySScopeSUserSSystemScopeUserSystemRuleIdruleName ruleNameSpace SystemStatic userStaticKey UserStatic userStaticPtr staticRule dynamicRulelocationnoRulesrules computeRules mkCommand runCommand ruleDepsCmdrunRuleDynDepsCmd ruleExecCmdrunRuleExecCmd ruleBinary$fShowLocation$fBinaryLocation $fOrdLocation $fEqLocation$fBinaryStatic $fOrdStatic $fEqStatic $fShowStatic$fBinaryScopedArgument$fBinaryScopedArgument0$fBinaryRuleCommands$fBinaryRuleCommands0$fEqRuleCommands$fEqRuleCommands0$fShowRuleCommands$fBinaryCommandData$fBinaryCommandData0$fEqCommandData$fEqCommandData0$fShowCommandData$fShowRuleData$fMonadTransRulesT $fMonoidRules$fSemigroupRules$fStructuredRuleCommands$fStructuredLocation$fFunctorRulesT$fApplicativeRulesT $fMonadRulesT$fMonadIORulesT$fMonadFixRulesT$fGenericRuleData $fShowDepsRes $fEqDepsRes $fOrdDepsRes$fGenericNoCmd $fEqNoCmd $fOrdNoCmd $fShowNoCmd $fBinaryNoCmd$fEqScopedArgument$fOrdScopedArgument$fShowScopedArgument $fEqStatic0 $fOrdStatic0 $fShowStatic0$fBinaryStatic0$fShowDependency$fEqDependency$fOrdDependency$fGenericDependency$fBinaryDependency$fStructuredDependency$fShowRuleOutput$fEqRuleOutput$fOrdRuleOutput$fGenericRuleOutput$fBinaryRuleOutput$fStructuredRuleOutput $fShowRuleId $fEqRuleId $fOrdRuleId$fGenericRuleId$fBinaryRuleId$fStructuredRuleId$fShowRulesNameSpace$fEqRulesNameSpace$fOrdRulesNameSpace$fGenericRulesNameSpace$fBinaryRulesNameSpace$fStructuredRulesNameSpace$fBinaryDepsRes$fBinaryDynDepsCmd$fEqDynDepsCmd$fBinaryDynDepsCmd0$fEqDynDepsCmd0$fShowDynDepsCmd$fStructuredRuleData$fStructuredRuleData0$fBinaryRuleData$fBinaryRuleData0 $fEqRuleData $fEqRuleData0$fShowRuleData0IllegalComponentDiffReasonCannotChangeNameCannotChangeComponentFieldCannotChangeBuildInfoFieldCannotApplyComponentDiffReasonMismatchedComponentTypesIllegalComponentDiffRulesExceptionCyclicRuleDependencies!CantFindSourceForRuleDependenciesMissingRuleOutputsInvalidRuleOutputIndexDuplicateRuleIdSetupHooksExceptionCannotApplyComponentDiffsetupHooksExceptionCodesetupHooksExceptionMessage$fShowSetupHooksException$$fShowCannotApplyComponentDiffReason $fShowIllegalComponentDiffReason$fShowRulesException programPathsimpleConfiguredProgramsuppressOverrideArgsConfiguredProgramprogramDefaultArgs programIdprogramLocationprogramMonitorFilesprogramOverrideArgsprogramOverrideEnvprogramPropertiesprogramVersionProgArgProgramprogramFindLocationprogramFindVersion programNameprogramNormaliseArgsprogramPostConfProgramLocation FoundOnSystem UserSpecified locationPathProgramSearchPathProgramSearchPathEntryProgramSearchPathDefaultProgramSearchPathDir$fBinaryConfiguredProgram$fBinaryProgramLocation$fBinaryProgramSearchPathEntry$fEqConfiguredProgram$fEqProgramLocation$fEqProgramSearchPathEntry$fGenericConfiguredProgram$fGenericProgramLocation$fGenericProgramSearchPathEntry$fReadConfiguredProgram$fReadProgramLocation$fShowConfiguredProgram $fShowProgram$fShowProgramLocation$fShowProgramSearchPathEntry$fStructuredConfiguredProgram$fStructuredProgramLocation"$fStructuredProgramSearchPathEntrySuffixPreProcessCommand PreProcessorrunPreProcessor ppOrderingplatformIndependentbuiltinHaskellSuffixesbuiltinHaskellBootSuffixes$fStructuredSuffix$fBinarySuffix$fPrettySuffix $fEqSuffix $fOrdSuffix $fShowSuffix$fGenericSuffix$fIsStringSuffixCabalExceptionNoBenchMarkProgramEnableBenchMarkBenchMarkNameDisabled NoBenchMarkNoLibraryFoundCompilerNotInstalledCantFindIncludeFileUnsupportedTestSuiteUnsupportedBenchMarkNoIncludeFileFound NoModuleFoundRegMultipleInstancePkgSuppressingChecksOnFileNoSupportDirStylePackageDbOnlySupportSpecificPackageDbFailedToParseOutputDescribe DumpFailedFailedToParseOutputDump ListFailedFailedToParseOutputListProgramNotFoundNoSupportForHoogleNoSupportForQuickJumpFlagNoGHCVersionFromHaddockNoGHCVersionFromCompilerHaddockAndGHCVersionDoesntMatchMustHaveSharedLibrariesHaddockPackageFlagsUnknownCompilerFlavorFailedToDetermineTargetNoMultipleTargetsREPLNotSupportedNoSupportBuildingTestSuiteNoSupportBuildingBenchMark BuildingNotSupportedWithCompiler PkgDumpFailedFailedToParseOutputCantFindSourceModuleVersionMismatchJSVersionMismatchGHCJSGlobalPackageDBLimitationGlobalPackageDBSpecifiedFirstMatchDirFileGlobMatchDirFileGlobErrorsErrorParsingFileDoesntExist FailedParsing NotFoundMsgUnrecognisedBuildTargetReportBuildTargetProblemsUnknownBuildTargetAmbiguousBuildTargetCheckBuildTargetsVersionMismatchGHCCheckPackageDbStackGlobalPackageDbSpecifiedFirstCantInstallForeignLibNoSupportForPreProcessingTest"NoSupportForPreProcessingBenchmarkCantFindSourceForPreProcessFile NoSupportPreProcessingTestExtras%NoSupportPreProcessingBenchmarkExtrasUnlitExceptionRunProgramInvocationExceptionGetProgramInvocationException GetProgramInvocationLBSExceptionCheckSemaphoreSupportNoLibraryForPackageSanityCheckHookedBuildInfoConfigureScriptNotFoundNoValidComponentConfigureEitherSingleOrAllConfigCIDValidForPreComponentSanityCheckForEnableComponents"SanityCheckForDynamicStaticLinkingUnsupportedLanguagesUnsupportedLanguageExtensionCantFindForeignLibrariesExpectedAbsoluteDirectoryFlagsNotSpecifiedEncounteredMissingDependencyCompilerDoesn'tSupportThinningCompilerDoesn'tSupportReexportsCompilerDoesn'tSupportBackpackLibraryWithinSamePackageReportFailedDependenciesNoPackageDatabaseSpecifiedHowToFindInstalledPackagesPkgConfigNotFound BadVersionUnknownCompilerException NoWorkingGcc NoOSSupportNoCompilerSupportInstallDirsNotPrefixRelative ExplainErrorsCheckPackageProblemsLibDirDepsPrefixNotRelativeCombinedConstraintsCantParseGHCOutputIncompatibleWithCabalCouldn'tFindTestProgramTestCoverageSupportCouldn'tFindTestProgLibV09TestCoverageSupportLibV09RawSystemStdoutFindFileFindModuleFileExMultipleFilesWithExtensionRelocRegistrationInfoCreatePackageDB WithHcPkgRegisMultiplePkgNotSupportedRegisteringNotImplementedNoTestSuitesEnabledTestNameDisabled NoSuchTestConfigureProgramRequireProgramNoProgramFound BadVersionDbUnknownVersionDbMissingCoveredInstalledLibrary/MultiReplDoesNotSupportComplexReexportedModules!StandaloneBytecodeNotSupportedYetFailedDependencyDependencyNotExistsDependencyMissingInternalDependencyNoVersion exceptionCodeexceptionMessage$fShowCabalException$fShowFailedDependencyplainunlitgeneratePackageInfoModuleaddLibraryPath annotateIOcabalCompilerInfo cabalGitInfo cabalVersion chattyTrycopyDirectoryRecursive copyFileTo copyFileToCwdcopyFileVerbose copyFilescreateDirectoryIfMissingVerbosedebug debugNoWrapdefaultPackageDescCwddefaultTempFileOptionsdie'dieNoVerbosity dieNoWrapdieWithExceptiondieWithLocation'doesExecutableExistdropExeExtensionexceptionWithCallStackPrefixexceptionWithMetadata exeExtensionsexistsAndIsMoreRecentThanfindAllFilesCwdWithExtensionfindAllFilesWithExtension findFileCwdfindFileCwdWithExtensionfindFileCwdWithExtension' findFileExfindFileWithExtensionfindFileWithExtension' findFirstFilefindHookedPackageDescfindModuleFileCwdfindModuleFileExfindModuleFilesCwdfindModuleFilesExfindProgramVersionfromCreatePipegetDirectoryContentsRecursivehandleDoesNotExist ignoreSigPipeinfo infoNoWrapinstallDirectoryContentsinstallExecutableFileinstallExecutableFilesinstallMaybeExecutableFileinstallMaybeExecutableFilesinstallOrdinaryFileinstallOrdinaryFilesisInSearchPathisUserException maybeExitmoreRecentFilenotice noticeDoc noticeNoWrap rawSystemExitrawSystemExitCoderawSystemExitWithEnvrawSystemExitWithEnvCwdrawSystemIOWithEnvrawSystemIOWithEnvAndAction rawSystemProcrawSystemProcActionrawSystemStdInOutrawSystemStdoutremoveFileForcibly rewriteFileExrewriteFileLBS setupMessageshortRelativePathstripCommonPrefix topHandlertopHandlerWithtryFindPackageDescwarn warnError withFileLockwithOutputMarkerwithTempDirectorywithTempDirectoryCwdwithTempDirectoryCwdExwithTempDirectoryEx withTempFilewithTempFileCwdwithTempFileExxargsTempFileOptionsoptKeepTempFilesVerboseException $fEqTraceWhen$fExceptionVerboseException$fShowVerboseException overNubList overNubListR toNubList toNubListRNubList fromNubListNubListR fromNubListR$fBinaryNubList $fEqNubList $fEqNubListR$fGenericNubList$fMonoidNubList$fSemigroupNubList$fMonoidNubListR$fSemigroupNubListR$fNFDataNubList $fReadNubList$fReadNubListR $fShowNubList$fShowNubListR$fStructuredNubListaddProgressCtx dieProgress infoProgressrunLogProgress warnProgress LogProgress$fApplicativeLogProgress$fFunctorLogProgress$fMonadLogProgressemptyProgramInvocationgetEffectiveEnvironmentgetFullEnvironmentgetProgramInvocationLBS getProgramInvocationLBSAndErrorsgetProgramInvocationOutput#getProgramInvocationOutputAndErrorsmultiStageProgramInvocationprogramInvocationprogramInvocationCwdrunProgramInvocationsimpleProgramInvocation IOEncodingIOEncodingTextIOEncodingUTF8ProgramInvocationprogInvokeArgs progInvokeCwd progInvokeEnvprogInvokeInputprogInvokeInputEncodingprogInvokeOutputEncodingprogInvokePathprogInvokeWheninvocationAsBatchFileinvocationAsShellScriptinvocationAsSystemScriptwithResponseFilemarkupuniondefaultProgramSearchPathfindProgramOnSearchPathgetExtraPathEnvgetSystemSearchPathlogExtraProgramOverrideEnvlogExtraProgramSearchPathprogramSearchPathAsPATHVar simpleProgram allPackagesallPackagesByNameallPackagesBySourcePackageId&allPackagesBySourcePackageIdAndLibNamebrokenPackagesdeletePackageNamedeleteSourcePackageId deleteUnitIddependencyClosuredependencyCyclesdependencyGraphdependencyInconsistencieseligibleDependenciesfromListinsertlookupComponentIdlookupDependencylookupInternalDependencylookupInternalPackageNamelookupPackageIdlookupPackageNamelookupSourcePackageId lookupUnitIdmatchingDependenciesmergemoduleNameIndexreverseDependencyClosurereverseTopologicalOrder searchByNamesearchByNameSubstringsearchWithPredicatetopologicalOrderInstalledPackageIndex PackageIndex SearchResult AmbiguousNone Unambiguous$fBinaryPackageIndex$fEqPackageIndex$fGenericPackageIndex$fMonoidPackageIndex$fSemigroupPackageIndex$fReadPackageIndex$fShowPackageIndex$fStructuredPackageIndex flattenDups parseStringreadAndParseFilereadGenericPackageDescriptionreadHookedBuildInfoexplainGlobSyntaxErrorfileGlobMatches globMatchesisRecursiveInRootmatchDirFileGlobmatchDirFileGlobWithDie matchGlobmatchGlobPieces parseFileGlobrunDirFileGlob GlobResult GlobMatchGlobMatchesDirectoryGlobMissingDirectoryGlobWarnMultiDot EmptyGlobLiteralFileNameGlobStarNoExtensionOnStarStarInDirectoryStarInExtensionStarInFileNameVersionDoesNotSupportGlobVersionDoesNotSupportGlobStar$fEqGlobResult$fEqGlobSyntaxError$fFunctorGlobResult$fOrdGlobResult$fShowGlobResult$fShowGlobSyntaxErrorCheckPackageContentOpsdoesDirectoryExist doesFileExistgetFileContents listDirectoryabsolutePackageDBPathabsolutePackageDBPathsarDashLSupportedarResponseFilesSupportedbackpackSupportedbytecodeArtifactsSupportedcoercePackageDBcoercePackageDBStackcompilerCompatFlavorcompilerCompatVersioncompilerFlavor compilerInfocompilerVersioncoverageSupporteddynamicSupportedextensionsToFlagsflagToDebugInfoLevelflagToOptimisationLevelflagToProfDetailLevelinterpretPackageDBinterpretPackageDBStack jsemSupported jsemVersionknownProfDetailLevelslanguageToFlagslibraryDynDirSupportedlibraryVisibilitySupportedpackageKeySupportedparmakeSupportedprofilingDynamicSupported"profilingDynamicSupportedOrUnknownprofilingSupportedprofilingVanillaSupported"profilingVanillaSupportedOrUnknown readPackageDbreexportedAsSupportedreexportedModulesSupportedregistrationPackageDBrenamingPackageFlagsSupportedshowCompilerIdshowCompilerIdWithAbishowProfDetailLevelunifiedIPIDRequiredunitIdSupportedunsupportedExtensionsunsupportedLanguagesCompilercompilerAbiTagcompilerCompatcompilerExtensions compilerIdcompilerLanguagescompilerPropertiescompilerWiredInUnitIds CompilerFlagDebugInfoLevelMaximalDebugInfoMinimalDebugInfo NoDebugInfoNormalDebugInfoOptimisationLevelMaximumOptimisationNoOptimisationNormalOptimisation PackageDB PackageDBCWD PackageDBSPackageDBStackPackageDBStackCWDPackageDBStackSPackageDBStackX PackageDBXGlobalPackageDBSpecificPackageDB UserPackageDBProfDetailLevelProfDetailAllFunctionsProfDetailDefaultProfDetailExportedFunctionsProfDetailNoneProfDetailOtherProfDetailTopLateProfDetailToplevelFunctions$fBinaryCompiler$fBinaryDebugInfoLevel$fBinaryOptimisationLevel$fBinaryPackageDBX$fBinaryProfDetailLevel$fBoundedDebugInfoLevel$fBoundedOptimisationLevel$fEnumDebugInfoLevel$fEnumOptimisationLevel $fEqCompiler$fEqDebugInfoLevel$fEqOptimisationLevel$fEqPackageDBX$fEqProfDetailLevel$fFoldablePackageDBX$fFunctorPackageDBX$fGenericCompiler$fGenericDebugInfoLevel$fGenericOptimisationLevel$fGenericPackageDBX$fGenericProfDetailLevel$fNFDataCompiler$fNFDataDebugInfoLevel$fNFDataOptimisationLevel$fNFDataPackageDBX$fNFDataProfDetailLevel$fOrdPackageDBX$fParsecDebugInfoLevel$fParsecOptimisationLevel$fParsecProfDetailLevel$fReadCompiler$fReadDebugInfoLevel$fReadOptimisationLevel$fReadPackageDBX$fReadProfDetailLevel$fShowCompiler$fShowDebugInfoLevel$fShowOptimisationLevel$fShowPackageDBX$fShowProfDetailLevel$fStructuredCompiler$fStructuredDebugInfoLevel$fStructuredOptimisationLevel$fStructuredPackageDBX$fStructuredProfDetailLevel$fTraversablePackageDBXdefaultRegisterOptionsdescribedescribeInvocationdumpdumpInvocationexposeexposeInvocationhidehideInvocationinitinitInvocationinvokelistlistInvocationrecacherecacheInvocationregisterregisterInvocation unregisterunregisterInvocationRegisterOptionsregisterAllowOverwriteregisterMultiInstanceregisterSuppressFilesCheck getImplInfo GhcImplInfoflagHie flagProfLateflagWarnMissingHomeModulessupportsGHC2021supportsGHC2024supportsPkgEnvFiles unitIdForExes ghcInvocationnormaliseGhcArgspackageDbArgsDbrenderGhcOptionsrunGHCrunGHCWithResponseFilerunReplProgramGhcDynLinkModeGhcDynamicOnlyGhcStaticAndDynamic GhcStaticOnlyGhcModeGhcModeAbiHashGhcModeCompileGhcModeInteractive GhcModeLink GhcModeMake GhcObjectMode GhcByteCodeGhcByteCodeAndObjectCode GhcObjectCodeGhcOptimisationGhcMaximumOptimisationGhcNoOptimisationGhcNormalOptimisationGhcSpecialOptimisation GhcOptionsghcOptAsmOptionsghcOptBytecodeDirghcOptBytecodeLib ghcOptCabalghcOptCcOptionsghcOptCcProgramghcOptCppIncludePathghcOptCppIncludesghcOptCppOptionsghcOptCxxOptionsghcOptDebugInfoghcOptDylibNameghcOptDynHiSuffixghcOptDynLinkModeghcOptDynObjSuffixghcOptExtensionMapghcOptExtensions ghcOptExtraghcOptExtraDefaultghcOptExtraPath ghcOptFPicghcOptFfiIncludesghcOptGHCiScriptsghcOptGppProgram ghcOptHPCDir ghcOptHiDirghcOptHiSuffixghcOptHideAllPackages ghcOptHieDirghcOptInputFilesghcOptInputModulesghcOptInputScriptsghcOptInstantiatedWithghcOptJSppOptionsghcOptLanguageghcOptLinkFrameworkDirsghcOptLinkFrameworksghcOptLinkLibPathghcOptLinkLibsghcOptLinkModDefFilesghcOptLinkNoHsMainghcOptLinkOptions ghcOptLinkRts ghcOptModeghcOptNoAutoLinkPackages ghcOptNoCode ghcOptNoLink ghcOptNumJobs ghcOptObjDirghcOptObjSuffixghcOptObjectModeghcOptOptimisationghcOptOutputDirghcOptOutputDynFileghcOptOutputFileghcOptPackageDBsghcOptPackagesghcOptProfilingAutoghcOptProfilingMode ghcOptRPaths ghcOptSharedghcOptSourcePathghcOptSourcePathClearghcOptSplitObjsghcOptSplitSectionsghcOptStaticLib ghcOptStubDirghcOptThisComponentIdghcOptThisUnitIdghcOptUnitFilesghcOptVerbosityghcOptWarnMissingHomeModules GhcProfAutoGhcProfAutoAllGhcProfAutoExportedGhcProfAutoToplevel GhcProfLate$fEqGhcDynLinkMode $fEqGhcMode$fEqGhcObjectMode$fEqGhcOptimisation$fEqGhcProfAuto$fGenericGhcOptions$fMonoidGhcOptions$fSemigroupGhcOptions$fShowGhcDynLinkMode $fShowGhcMode$fShowGhcObjectMode$fShowGhcOptimisation$fShowGhcOptions$fShowGhcProfAuto alexProgram arProgrambuiltinPrograms c2hsProgram cppProgram cpphsProgramdoctestProgram gccProgram ghcPkgProgram ghcProgramghcjsPkgProgram ghcjsProgram gppProgramhaddockProgram happyProgram hpcProgram hsc2hsProgramhscolourProgram jhcProgram ldProgrampkgConfigProgram runghcProgram stripProgram tarProgram uhcProgramaddKnownProgramaddKnownProgramsclearUnconfiguredProgramsconfigureAllKnownProgramsconfigureProgramconfigureUnconfiguredProgramconfiguredProgramsdefaultProgramDbemptyProgramDbgetProgramSearchPath knownProgramslookupKnownProgram lookupProgramlookupProgramByNamelookupProgramVersionmodifyProgramSearchPath needProgramprependProgramSearchPath!prependProgramSearchPathNoLoggingreconfigureProgramsrequireProgramrequireProgramVersionrestoreProgramDbsetProgramSearchPathunconfigureProgramupdateConfiguredProgsupdatePathProgDb updateProgramupdateUnconfiguredProgsuserMaybeSpecifyPathuserSpecifiedArgsuserSpecifyArgsuserSpecifyArgssuserSpecifyPathuserSpecifyPathsConfiguredProgs ProgramDbconfiguredProgsprogOverrideEnvprogSearchPathunconfiguredProgsUnconfiguredProgs$fBinaryProgramDb$fReadProgramDb$fShowProgramDb$fStructuredProgramDbgetDbProgramOutputgetDbProgramOutputCwdgetProgramOutput runDbProgramrunDbProgramCwd runProgram runProgramCwdstripExestripLibboolOptboolOpt' choiceOptchoiceOptFromEnumcommandAddActioncommandFromSpeccommandParseArgscommandShowOptions commandsRuncommandsRunWithFallbackdefaultCommandFallback fmapOptDescrgetNormalCommandDescriptions helpCommandUI hiddenCommand liftOption liftOptionL mkCommandUI multiOptionnoArg noExtraFlagsoptArgoptArg' optArgDef'optionreqArgreqArg'usageAlternatives usageDefaultArgPlaceHolder CommandParse CommandErrors CommandHelp CommandListCommandReadyToGo CommandSpec CommandType HiddenCommand NormalCommand CommandUIcommandDefaultFlagscommandDescription commandName commandNotescommandOptionscommandSynopsis commandUsage DescriptionLFlags MkOptDescrNameOptDescrBoolOpt ChoiceOptOptArgReqArgOptFlags OptionField optionDescrSFlagsShowOrParseArgs ParseArgsShowArgs$fFunctorCommandParsecommonSetupTempFileOptionsconfigureCCompilerconfigureLinkerdefaultCommonSetupFlagsdefaultDistPreffalseArgoptionDistPrefoptionVerbosityprogramDbOptionsprogramDbPaths'programFlagsDescription splitArgstrueArgCommonSetupFlagssetupCabalFilePath setupDistPrefsetupKeepTempFiles setupTargetssetupVerbositysetupWorkingDirdefaultTestFlagsemptyTestFlags testCommand testOptions' TestFlagsTestCommonFlagstestCabalFilePathtestCommonFlags testDistPreftestFailWhenNoTestSuites testHumanLog testKeepTixtestMachineLog testOptionstestShowDetails testTargets testVerbositytestWorkingDir testWrapperTestShowDetailsAlwaysDirectFailuresNever StreamingdefaultSDistFlagsemptySDistFlags sdistCommand SDistFlagsSDistCommonFlagssDistCabalFilePathsDistCommonFlagssDistDirectory sDistDistPrefsDistListSources sDistSnapshot sDistTargetssDistVerbositysDistWorkingDirdefaultReplFlags replCommand replOptions ReplFlagsReplCommonFlagsreplCabalFilePathreplCommonFlags replDistPrefreplProgramArgsreplProgramPaths replReloadreplReplOptions replTargets replVerbosityreplWorkingDir ReplOptionsreplOptionsFlagOutputreplOptionsFlagsreplOptionsNoLoad replWithRepldefaultRegisterFlagsemptyRegisterFlagsregisterCommandunregisterCommand RegisterFlagsRegisterCommonFlags regGenPkgConf regGenScript regInPlace regPackageDB regPrintIdregisterCabalFilePathregisterCommonFlagsregisterDistPrefregisterTargetsregisterVerbosityregisterWorkingDirdefaultInstallFlagsemptyInstallFlagsinstallCommand InstallFlagsInstallCommonFlagsinstallCabalFilePathinstallCommonFlags installDestinstallDistPrefinstallInPlaceinstallPackageDBinstallTargetsinstallUseWrapperinstallVerbosityinstallWorkingDirdefaultHscolourFlagsemptyHscolourFlagshscolourCommand HscolourFlagsHscolourCommonFlagshscolourBenchmarks hscolourCSShscolourCabalFilePathhscolourCommonFlagshscolourDistPrefhscolourExecutableshscolourForeignLibshscolourTargetshscolourTestSuiteshscolourVerbosityhscolourWorkingDirdefaultHaddockFlagsdefaultHaddockProjectFlagsemptyHaddockFlagsemptyHaddockProjectFlagshaddockCommandhaddockOptionshaddockProjectCommandhaddockProjectOptions HaddockFlagsHaddockCommonFlagshaddockBaseUrlhaddockBenchmarkshaddockCabalFilePathhaddockCommonFlagshaddockContents haddockCsshaddockDistPrefhaddockExecutableshaddockForHackagehaddockForeignLibs haddockHooglehaddockHscolourCss haddockHtmlhaddockHtmlLocation haddockIndexhaddockInternalhaddockLinkedSourcehaddockOutputDirhaddockProgramArgshaddockProgramPathshaddockQuickJumphaddockResourcesDirhaddockTargetshaddockTestSuiteshaddockUseUnicodehaddockVerbosityhaddockWorkingDirHaddockProjectFlagshaddockProjectBenchmarkshaddockProjectCommonFlagshaddockProjectCsshaddockProjectDirhaddockProjectExecutableshaddockProjectForeignLibshaddockProjectHackagehaddockProjectHooglehaddockProjectHscolourCsshaddockProjectHtmlLocationhaddockProjectInterfaceshaddockProjectInternalhaddockProjectProgramArgshaddockProjectProgramPathshaddockProjectProloguehaddockProjectResourcesDirhaddockProjectTestSuiteshaddockProjectUseUnicode HaddockTargetForDevelopment ForHackage VisibilityHiddenVisibledefaultGlobalFlagsemptyGlobalFlags globalCommand GlobalFlagsglobalFullVersionglobalNumericVersion globalVersionglobalWorkingDir copyCommanddefaultCopyFlagsemptyCopyFlags CopyFlagsCopyCommonFlagscopyCabalFilePathcopyCommonFlagscopyDest copyDistPref copyTargets copyVerbositycopyWorkingDirconfigPrograms configureArgsconfigureCommandconfigureOptionsdefaultConfigFlagsemptyConfigFlagsinstallDirsOptionsreadPackageDbList showPackageDbshowPackageDbListConfigCommonFlags!configAllowDependingOnPrivateLibsconfigBenchmarksconfigBytecodeLib configCIDconfigCabalFilePathconfigCommonFlagsconfigConfigurationsFlagsconfigConfigureArgsconfigConstraintsconfigCoverageconfigCoverageForconfigDebugInfoconfigDependenciesconfigDeterministicconfigDistPrefconfigDumpBuildInfo configDynExeconfigExactConfigurationconfigExtraFrameworkDirsconfigExtraIncludeDirsconfigExtraLibDirsconfigExtraLibDirsStaticconfigFlagErrorconfigFullyStaticExe configGHCiLibconfigHcFlavor configHcPath configHcPkg configIPIDconfigIgnoreBuildToolsconfigInstallDirsconfigInstantiateWithconfigLibCoverageconfigOptimizationconfigPackageDBs configProfconfigProfDetail configProfExe configProfLibconfigProfLibDetailconfigProfSharedconfigProgPrefixconfigProgSuffixconfigProgramArgsconfigProgramPathExtraconfigProgramPathsconfigPrograms_configPromisedDependenciesconfigRelocatableconfigScratchDirconfigSharedLibconfigSplitObjsconfigSplitSectionsconfigStaticLibconfigStripExesconfigStripLibs configTargets configTestsconfigUseResponseFilesconfigUserInstallconfigVanillaLibconfigVerbosityconfigWorkingDirbuildOptionsConfigFlags exeCoverage libCoverage relocatable splitObjs splitSections stripExes stripLibswithBytecodeLib withDebugInfo withDynExewithFullyStaticExe withGHCiLibwithOptimization withProfExewithProfExeDetail withProfLibwithProfLibDetailwithProfLibShared withSharedLib withStaticLibwithVanillaLibComponentBuildDescrcomponentGraphcomponentNameMap installedPkgs promisedPkgsLocalBuildConfigextraConfigArgswithBuildOptions withProgramsLocalBuildDescrcomponentBuildDescrpackageBuildDescrPackageBuildDescrcompilercomponentEnabledSpec configFlagsextraCoverageForflagAssignment hostPlatforminstallDirTemplates localPkgDescr pkgDescrFile withPackageDB$fBinaryBuildOptions$fBinaryComponentBuildDescr$fBinaryLocalBuildConfig$fBinaryLocalBuildDescr$fBinaryPackageBuildDescr$fEqBuildOptions$fGenericBuildOptions$fGenericComponentBuildDescr$fGenericLocalBuildConfig$fGenericLocalBuildDescr$fGenericPackageBuildDescr$fReadBuildOptions$fReadComponentBuildDescr$fReadLocalBuildConfig$fReadLocalBuildDescr$fReadPackageBuildDescr$fShowBuildOptions$fShowComponentBuildDescr$fShowLocalBuildConfig$fShowLocalBuildDescr$fShowPackageBuildDescr$fStructuredBuildOptions$fStructuredComponentBuildDescr$fStructuredLocalBuildConfig$fStructuredLocalBuildDescr$fStructuredPackageBuildDescrallTargetsInBuildOrderallTargetsInBuildOrder'buildDir buildDirPBD buildWayscomponentNameCLBIscomponentNameTargetscomponentNameTargets' distPrefLBIlocalCompatPackageKeylocalComponentId localPackage localUnitIdneededTargetsInBuildOrderneededTargetsInBuildOrder' packageRoot progPrefix progSuffixsetupFlagsBuildDir testCoverage unitIdTarget unitIdTarget'withAllTargetsInBuildOrderwithAllTargetsInBuildOrder'withNeededTargetsInBuildOrderwithNeededTargetsInBuildOrder'LocalBuildInfoNewLocalBuildInfolocalBuildConfiglocalBuildDescr$fBinaryLocalBuildInfo$fGenericLocalBuildInfo$fReadLocalBuildInfo$fShowLocalBuildInfo$fStructuredLocalBuildInfoabsoluteComponentInstallDirsabsoluteInstallCommandDirsabsoluteWorkingDirLBIallComponentsInBuildOrder allLibModulescomponentBuildDirdepLibraryPathsenabledBenchLBIsenabledTestLBIsinterpretSymbolicPathLBI mbWorkDirLBI"prefixRelativeComponentInstallDirswithAllComponentsInBuildOrder withBenchLBI withExeLBI withLibLBI withTestLBIcountTestResultslocalPackageLog suiteError suiteFailed suitePassedsummarizePackagesummarizeSuiteFinishsummarizeSuiteStart summarizeTesttestSuiteLogPath PackageLogpackageplatform testSuitesTestLogs GroupLogsTestLogtestNametestOptionsReturned testResult TestSuiteLoglogFiletestLogs testSuiteName$fEqPackageLog $fEqTestLogs$fEqTestSuiteLog$fReadPackageLog$fReadTestLogs$fReadTestSuiteLog$fShowPackageLog$fShowTestLogs$fShowTestSuiteLogcombineObjectFilescreateArLibArchiveguessWayhtmlDir markupPackagemixDirtixDir tixFilePath HPCMarkupInfolibsModulesToIncludepathsToLibsArtifactsDynProfProfDynVanilla $fBoundedWay $fEnumWay$fEqWay $fReadWay $fShowWaygenerateCabalMacrosHeadergeneratePackageVersionMacroscomputeCompatPackageKeycomputeComponentIdcc_cidcc_namecc_pkgiddispConfiguredComponentextendConfiguredComponentMapnewPackageDepsBehaviourtoConfiguredComponenttoConfiguredComponentsConfiguredComponent cc_ann_id cc_component cc_exe_deps cc_includes cc_publicConfiguredComponentMapdispLinkedComponentextendLinkedComponentMaplc_cidlc_instslc_pkgidlc_uidtoLinkedComponenttoLinkedComponentsLinkedComponent lc_ann_id lc_component lc_exe_deps lc_includes lc_publiclc_shapelc_sig_includesLinkedComponentMap$fPackageLinkedComponentcomponentCycleMsgcomponentsGraphToListdispComponentsWithDepsmkComponentsGraphComponentsGraphComponentsWithDeps cleanCommanddefaultCleanFlagsemptyCleanFlags CleanFlagsCleanCommonFlagscleanCabalFilePathcleanCommonFlags cleanDistPref cleanSaveConf cleanTargetscleanVerbositycleanWorkingDir buildCommand buildOptionsdefaultBuildFlagsemptyBuildFlags BuildFlagsBuildCommonFlagsbuildCabalFilePathbuildCommonFlags buildDistPref buildNumJobsbuildProgramArgsbuildProgramPaths buildTargetsbuildUseSemaphorebuildVerbositybuildWorkingDirbenchmarkCommandbenchmarkOptions'defaultBenchmarkFlagsemptyBenchmarkFlagsBenchmarkFlagsBenchmarkCommonFlagsbenchmarkCabalFilePathbenchmarkCommonFlagsbenchmarkDistPrefbenchmarkOptionsbenchmarkTargetsbenchmarkVerbositybenchmarkWorkingDirbuildingWhatCommonFlagsbuildingWhatDistPrefbuildingWhatVerbositybuildingWhatWorkingDir BuildingWhat BuildHaddock BuildHscolour BuildNormal BuildRepl$fBinaryBuildingWhat$fGenericBuildingWhat$fShowBuildingWhat$fStructuredBuildingWhatbuildBI buildCLBI buildCompilerbuildComponent buildIsLibPreBuildComponentInputs buildingWhatlocalBuildInfo targetInfobuildTargetComponentNamereadBuildTargetsreadTargetInfosreadUserBuildTargetsreportBuildTargetProblemsreportUserBuildTargetProblemsresolveBuildTargetsshowBuildTargetshowUserBuildTarget BuildTargetBuildTargetComponentBuildTargetFileBuildTargetModuleBuildTargetProblemBuildTargetAmbiguousBuildTargetExpectedBuildTargetNoSuch QualLevelQL1QL2QL3UserBuildTargetUserBuildTargetProblemUserBuildTargetUnrecognised$fAlternativeMatch$fApplicativeMatch$fFunctorMatch$fBinaryBuildTarget$fBoundedComponentKind$fEnumComponentKind$fEnumQualLevel$fEqBuildTarget$fEqComponentKind$fEqMatchError$fEqUserBuildTarget$fGenericBuildTarget $fMonadMatch$fMonadPlusMatch$fOrdBuildTarget$fOrdComponentKind$fOrdMatchError$fOrdUserBuildTarget$fShowBuildTarget$fShowBuildTargetProblem$fShowComponentKind $fShowMatch$fShowMatchError$fShowMaybeAmbiguous$fShowQualLevel$fShowUserBuildTarget$fShowUserBuildTargetProblemautogenComponentModulesDirautogenPackageInfoModuleNameautogenPackageModulesDirautogenPathsModuleNamebenchmarkBuildDir buildInfoPref cppHeaderName dllExtension exeBuildDir exeExtension flibBuildDirgetBenchmarkSourceFilesgetExeSourceFilesgetFLibSourceFilesgetLibSourceFilesgetSourceFilesgetTestSourceFileshaddockBenchmarkDirPathhaddockDirNamehaddockLibraryDirPathhaddockLibraryNamehaddockLibraryPathhaddockPackageLibraryNamehaddockPackageLibraryName' haddockPath haddockPrefhaddockTestDirPath hscolourPrefmkBytecodeLibNamemkGenericSharedBundledLibNamemkGenericSharedLibNamemkGenericStaticLibName mkLibName mkProfLibNamemkProfSharedLibNamemkSharedLibNamemkStaticLibName objExtensionpreBuildRulesCacheFilesrcPrefstaticLibExtensionstubName testBuildDirbuildExebuildLib configuregetInstalledPackagesinplacePackageDbPath installLibregisterPackagerunTestsimpleTestStub stubFilePathstubMain stubWriteLogwriteSimpleTestStubapplyComponentDiffsbuildInfoComponentDiffemptyComponentDiff executeRulesexecuteRulesUserOrSystemforComponents_"hookedBuildInfoComponentDiff_maybehookedBuildInfoComponents noBuildHooksnoConfigureHooksnoInstallHooksnoPreConfComponentOutputsnoPreConfPackageOutputs noSetupHooks BenchmarkDiff BuildHookspostBuildComponentHookpreBuildComponentRules BuildInfoDiff ComponentDiff componentDiffConfigureHookspostConfPackageHookpreConfComponentHookpreConfPackageHookExecutableDiffForeignLibDiffInstallComponentHookInstallComponentInputs copyFlags InstallHooksinstallComponentHook LibraryDiffPostBuildComponentHookPostBuildComponentInputs buildFlagsPostConfPackageHookPostConfPackageInputsPreBuildComponentRulesPreConfComponentHookPreConfComponentInputs componentPreConfComponentOutputsPreConfPackageHookPreConfPackageInputsPreConfPackageOutputsextraConfiguredProgs SetupHooks buildHooksconfigureHooks installHooks TestSuiteDiff$fBinaryComponentDiff$fBinaryInstallComponentInputs $fBinaryPostBuildComponentInputs$fBinaryPostConfPackageInputs$fBinaryPreBuildComponentInputs$fBinaryPreConfComponentInputs$fBinaryPreConfComponentOutputs$fBinaryPreConfPackageInputs$fBinaryPreConfPackageOutputs$fGenericInstallComponentInputs!$fGenericPostBuildComponentInputs$fGenericPostConfPackageInputs $fGenericPreBuildComponentInputs$fGenericPreConfComponentInputs $fGenericPreConfComponentOutputs$fGenericPreConfPackageInputs$fGenericPreConfPackageOutputs$fMonoidBuildHooks$fSemigroupBuildHooks$fMonoidConfigureHooks$fSemigroupConfigureHooks$fMonoidInstallHooks$fSemigroupInstallHooks$fMonoidNotDemandedRuleReasons!$fSemigroupNotDemandedRuleReasons$fMonoidSetupHooks$fSemigroupSetupHooks$fSemigroupComponentDiff$$fSemigroupPreConfComponentSemigroup$fSemigroupPreConfPkgSemigroup$fShowComponentDiff$fShowInstallComponentInputs$fShowPostBuildComponentInputs$fShowPostConfPackageInputs$fShowPreBuildComponentInputs$fShowPreConfComponentInputs$fShowPreConfComponentOutputs$fShowPreConfPackageInputs$fShowPreConfPackageOutputs$fStructuredComponentDiff"$fStructuredInstallComponentInputs$$fStructuredPostBuildComponentInputs!$fStructuredPostConfPackageInputs#$fStructuredPreBuildComponentInputs"$fStructuredPreConfComponentInputs#$fStructuredPreConfComponentOutputs $fStructuredPreConfPackageInputs!$fStructuredPreConfPackageOutputs hooksMain hooksVersionCabalABIcabalLocalBuildInfoHooksABI confHooks HooksVersion cabalABIHash hooksABIHashhooksAPIVersion$fBinaryHooksVersion$fEqHooksVersion$fShowSetupHooksExeException$fGenericCabalABI$fGenericHooksABI$fGenericHooksVersion$fOrdHooksVersion$fShowBadHooksExecutableArgs$fShowHooksVersion$fStructuredCabalABI$fStructuredHooksABIcomponentGhcOptionsghcPlatformAndVersionStringrenderGhcEnvironmentFilesimpleGhcEnvironmentFilewriteGhcEnvironmentFileGhcEnvironmentFileEntryGhcEnvFileClearPackageDbStackGhcEnvFileCommentGhcEnvFilePackageDbGhcEnvFilePackageIdparseGhcEnvironmentFilereadGhcEnvironmentFile ParseErrorExccompilerBuildWay buildFLibcompilerProgramDbconfigureCompiler getGhcInfogetGlobalPackageDB getInstalledPackagesMonitorFiles getLibDirgetPackageDBContents hcPkgInfo installExe installFLib isDynamic libAbiHashpkgRootreplExereplFLibreplLibrunCmdstartInterpreter getGhcAppDir mkBuildInfo mkBuildInfo'mkCompilerInfomkComponentInfoinstallinstallFileGlobinstall_setupHooksgeneratePathsModule pkgPathEnvVarcheckConfiguredPackage checkPackagecheckPackageContentcheckPackageFilescheckPackageFilesGPDwrapParseWarning!configureComponentLocalBuildInfos setupMessage'abiHashabsoluteInstalledPackageInfocreatePackageDBdeletePackageDBdoesPackageDBExistgeneralInstalledPackageInfogenerateRegistrationInfo initPackageDBinplaceInstalledPackageInfointernalPackageDBPath invokeHcPkgregisterWithHandlesunregisterWithHandlesknownSuffixHandlersmkSimplePreProcessorplatformDefinesppAlexppC2hsppCppppCpp'ppHappyppHsc2hs ppSuffixesppUnlitpreprocessComponentpreprocessExtraspreprocessFilerunSimplePreProcessorunsortedPPSuffixHandleremptyUserHooksArgs UserHooks benchHook buildHook cleanHookconfHookcopyHook haddockHookhookedPreProcessorshookedPrograms hscolourHookinstHook postBench postBuild postCleanpostConfpostCopy postHaddock postHscolourpostInstpostRegpostReplpostTest postUnregpreBenchpreBuildpreCleanpreConfpreCopy preHaddock preHscolourpreInstpreRegpreReplpreTestpreUnregreadDescregHookreplHooktestHook unregHookadjustBuildOptionsadjustBuildOptionsAndWarnbuildOptionsAdjustmentWarningsccLdOptionsBuildInfocheckForeignDepscheckPersistBuildConfigOutdatedcombinedConstraintscomputeEffectiveProfilingcomputePackageInfocomputePackageInfoFromIndexconfigCompilerconfigCompilerAuxExconfigCompilerExconfigCompilerProgDbconfigureComponentsconfigureFinalconfigurePackageconfigure_setupHooksfinalCheckPackage findDistPreffindDistPrefOrDefaultgetConfigStateFilegetInstalledPackagesByIdgetInternalLibrariesgetPersistBuildConfiginterpretPackageDbFlagslocalBuildInfoFilemaybeGetPersistBuildConfig mkProgramDbmkPromisedDepsSetrunPostConfPackageHookrunPreConfComponentHookrunPreConfPackageHooktryGetConfigStateFiletryGetPersistBuildConfigwritePersistBuildConfigConfigStateFileErrorConfigStateFileBadHeaderConfigStateFileBadVersionConfigStateFileMissingConfigStateFileNoHeaderConfigStateFileNoParsecfgStateFileErrorCwdcfgStateFileErrorFile PackageInfoinstalledPackageSetinternalPackageSetpromisedDepsSetrequiredDepsMap$fExceptionConfigStateFileError$fShowConfigStateFileError createArchivedateToSnapshotNumberlistPackageSourceslistPackageSourcesWithDieprepareSnapshotTree prepareTreeprintPackageProblemssdistsnapshotPackagesnapshotVersionaddInternalBuildToolsbuild_setupHooksbuiltinPreBuildHookscomponentInitialBuildStepscreateInternalPackageDBinitialBuildStepspreBuildComponentreplrepl_setupHooksrunPreBuildHookswriteAutogenFileswriteBuiltinAutogenFiles AutogenFile AutogenModuleAutogenFileContents$fEqAutogenFile$fOrdAutogenFile$fShowAutogenFiletestcreateHaddockIndexhaddockhaddockPackagePathshaddock_setupHookshscolourhscolour_setupHooks $fEqDirectory $fEqOutput$fGenericHaddockArgs$fMonoidDirectory$fSemigroupDirectory$fMonoidHaddockArgs$fSemigroupHaddockArgs$fOrdDirectory$fReadDirectory$fShowDirectorybenchautoconfSetupHooksautoconfUserHooks benchAction buildAction cleanActionconfigureAction copyAction defaultMaindefaultMainArgsdefaultMainArgsWithHandlesdefaultMainNoReaddefaultMainWithHooksdefaultMainWithHooksArgsdefaultMainWithHooksNoReaddefaultMainWithHooksNoReadArgsdefaultMainWithSetupHooksdefaultMainWithSetupHooksArgs haddockActionhscolourAction installActionregisterAction replAction sdistActionsimpleUserHookssimpleUserHooksWithHandles testActionunregisterActionemptyModuleScope ModuleScopeModuleProvides ModuleNameDistribution.Types.PackageName PackageNameModuleRequires ModuleSource WithSourceDistribution.Backpack OpenModuledispModuleSource getSource unWithSourcemodScopeProvidesmodScopeRequiresFromBuildDependsFromExposedModules FromMixinsFromOtherModulesFromSignaturesModuleWithSource$fFoldableWithSource$fFunctorWithSource$fModSubstWithSource$fTraversableWithSource'Distribution.Types.InstalledPackageInfoAsyncCancelledcancelAsyncMGHC.Internal.MVarMVarAsync asyncThreadIdGHC.Internal.Conc.SyncThreadId withAsyncuninterruptibleCancelwait waitCatch withAsyncNF$fExceptionAsyncCancelled$fShowAsyncCancelled$fEqAsyncCancelledcopyFilecopyFileChanged filesEqualcopyExecutableFilecopyOrdinaryFilesetDirOrdinarysetEnvgetEnvironmentGHC.Internal.System.Environment lookupEnvunsetEnvgetShortPathNameopenNewBinaryFileGHC.Internal.System.IOopenBinaryTempFile openTempFileDistribution.Compat.Exception catchExitcatchIOtryIODistribution.Compat.Prelude<<>>foldl1foldr1tracetraceM traceShow traceShowId traceShowMDistribution.Compat.Semigroupgmappendgmemptybase-4.21.2.0-b708Data.List.NonEmptyheadlastnonEmptytaildeepseq-1.5.1.0-ca8dControl.DeepSeqdeepseqforceGHC.Internal.Base$$!++.=<<absurdapasTypeOfconstflipidjoinliftMliftM2mapord otherwiseuntilvacuouswhenGHC.Internal.CharchrGHC.Internal.Control.MonadfilterMfoldMguardunlessGHC.Internal.Data.EithereitherpartitionEithersGHC.Internal.Data.Foldableallandanyconcat concatMapfindfor_notElemor sequence_ traverse_GHC.Internal.Data.FunctiononGHC.Internal.Data.Functor<$>voidGHC.Internal.Data.Maybe catMaybes fromMaybeisJust isNothing listToMaybemapMaybemaybe maybeToList dropWhileEnd intersperse isPrefixOf isSuffixOflinesnubnubBy partitionsortsortByunfoldrunlinesunwordswordsGHC.Internal.Data.TraversableforGHC.Internal.Data.TuplecurryfstsnduncurryGHC.Internal.Data.TypeabletypeRepGHC.Internal.ErrerrorerrorWithoutStackTrace undefinedGHC.Internal.IOcatchevaluatethrowIOGHC.Internal.IO.ExceptionioError userErrorGHC.Internal.List!!breakcycledrop dropWhilefilteriteratelookuprepeat replicatereversescanlscanl1scanrscanr1spansplitAttake takeWhileunzipunzip3zipzip3zipWithzipWith3GHC.Internal.NumsubtractGHC.Internal.Readlex readParenGHC.Internal.Real^^^even fromIntegralgcdlcmodd realToFracGHC.Internal.ShowshowChar showParen showStringshowsGHC.Internal.System.Exit exitFailure exitSuccessexitWith appendFilegetChar getContentsgetLineinteractprintputCharputStrputStrLnreadFilereadIOreadLn writeFileGHC.Internal.Text.Read readMaybereadsGHC.Internal.UnicodeisAlpha isAlphaNumisDigitisSpaceisUppertoLowertoUpperghc-prim GHC.Classes&&not||pretty-1.1.3.6-8fcbText.PrettyPrint.HughesPJ<+>GHC.PrimseqDistribution.Compat.NonEmptySet NonEmptySetDistribution.Utils.Structured Structuredbinary-0.8.9.3-4d1aData.Binary.ClassBinarygetputputListcontainers-0.7-482aData.Map.InternalMapData.Set.InternalSetNFDatarnf Alternative<|>emptymanysome Applicative*><*<*>liftA2pureFunctor<$fmapMonad>>>>=return MonadPlusmplusmzeroMonoidmappendmconcatmemptyNonEmpty:| Semigroup<>VoidGHC.Internal.Control.ArrowfirstGHC.Internal.Control.Monad.Fail MonadFailfailGHC.Internal.Data.DataDataEitherLeftRightFoldableelemfoldMapfoldlfoldl'foldrlengthmaximumminimumproductsumtoListGHC.Internal.Data.Functor.ConstConstgetConst"GHC.Internal.Data.Functor.IdentityIdentity runIdentityGHC.Internal.Data.ProxyProxyGHC.Internal.Data.StringIsString fromString Traversable sequenceAtraverseTypeRep#GHC.Internal.Data.Typeable.InternalTypeableGHC.Internal.EnumBoundedmaxBoundminBoundEnumenumFrom enumFromThenenumFromThenTo enumFromTofromEnumpredsucctoEnumGHC.Internal.Exception.TypebacktraceDesired fromException toException SomeExceptionGHC.Internal.FloatFloating**acosacoshasinasinhatanatanhcoscoshexploglogBasepisinsinhsqrttantanh RealFloatatan2 decodeFloat encodeFloatexponent floatDigits floatRadix floatRangeisDenormalizedisIEEE isInfiniteisNaNisNegativeZero scaleFloat significandGHC.Internal.GenericsGenericFilePathExitCode ExitFailure ExitSuccessIOError IOExceptionGHC.Internal.IntInt16Int32Int64Int8Num*+-abs fromIntegernegatesignumReadreadList readsPrec Fractional/ fromRationalrecipIntegraldivdivModmodquotquotRemrem toIntegerRationalReal toRationalRealFracceilingfloorproperFractionroundtruncateShowshowshowList showsPrecShowS)GHC.Internal.Text.ParserCombinators.ReadPReadSGHC.Internal.WordWord16Word32Word64Word8Eq/===Ord<<=>>=comparemaxmin GHC.TypesIOOrderingEQGTLT ghc-bignumGHC.Num.IntegerIntegerStringGHC.Internal.MaybeMaybeJustNothingBoolFalseTrueCharDoubleFloatIntWord~posixTimeToModTimetime-1.14-09f5"Data.Time.Clock.Internal.POSIXTime POSIXTimegetOptArgOrdergetOpt' usageInfoArgDescrNoArgPermute RequireOrderfmtLongfmtShortOption$fFunctorArgDescr$fFunctorOptDescrtokenizeQuotedWordsCETypeWarnLang$fShowPackageCheckppCET ppExplanation ppWarnLangextractCheckExplanation CETBenchmark CETExecutableCETForeignLibrary CETLibraryCETSetupCETTestLangC LangCPlusPlus$fBoundedCheckExplanationID$fEnumCheckExplanationID $fEqCEType$fEqCheckExplanation$fEqCheckExplanationID$fEqPackageCheck $fEqWarnLang $fOrdCEType$fOrdCheckExplanation$fOrdCheckExplanationID$fOrdPackageCheck $fOrdWarnLang $fShowCEType$fShowCheckExplanation$fShowCheckExplanationID$fShowWarnLangPackageDescriptionDistribution.Types.BuildInfo BuildInfobuildToolDependsDistribution.Types.ComponentId ComponentIdDistribution.Types.UnitIdUnitIdipiToPreExistingComponentPreExistingComponentConfiguredPromisedComponent pc_compname pc_pkgnamepr_cid pr_pkgnamepc_cid pc_munged_id pc_open_uidpc_shapepc_uid($fHasMungedPackageIdPreExistingComponent$fHasUnitIdPreExistingComponent$$fPackageConfiguredPromisedComponent$fPackagePreExistingComponent!Distribution.Types.ModuleRenamingModuleRenamingDistribution.Types.Versionversion0GHC.Internal.IO.Handle equivalentPointfreshLink readPointrepr writePoint $fEqPoint verboseQuietGHC.Internal.IO.StdHandlesstderrstdout verboseFlag verboseNoFlag isVerboseFlagTokNoCmdstaticPtrNameSpaceRulesNameSpaceGHC.Internal.StaticPtr StaticPtrInforulesInNameSpace addErrContextaddErrContextMconvertInclude ModuleScopeUconvertModuleProvidesModuleProvidesUconvertModuleProvidesUconvertModuleScopeUconvertModuleSubst ModuleSubstUconvertModuleSubstUemptyModuleScopeU getUnifEnvliftSTGHC.Internal.STSTUnifyM runUnifyMModuleUDistribution.Types.ModuleModuleModuleU'UnifEnv unify_ctxunify_db unify_errs unify_reqsunify_self_cid unify_uniqUnitIdUunify_verbosityUnitIdU'UnifRef UnitIdUniqueconvertUnitIdU' OpenUnitId readUnifRef writeUnifRefaddErr convertModuleconvertModuleU convertUnitIdconvertUnitIdU failIfErrsfailWithtryM ModuleVarUModuleWithSourceU UnitIdThunkU$fApplicativeUnifyM$fFunctorUnifyM $fMonadUnifyMmixLink linkProvision unifyModule execWritertellDistribution.Pretty prettyShowforM_WriterVersion$fApplicativeWriter$fFunctorWriter $fMonadWriterrenderZ zAbsolutezBindirzDatadir zDynlibdir zIsAArch64zIsI386 zIsWindowszIsX8664zLibdir zLibexecdirzManglePkgNamezNot zPackageNamezPrefix zRelocatable zSysconfdirzVersionDigits $fGenericZ zCopyright zHomepage zSynopsis zComponentId zMangleStrzNotNull zPackageKeyzPackageVersion zPackageszToolsZPackagezpkgName zpkgVersionzpkgXzpkgYzpkgZZTool ztoolName ztoolVersionztoolXztoolYztoolZ$fGenericZPackage$fGenericZToolversiongetDataFileName getBinDir getDynLibDir getDataDir getLibexecDir getSysconfDirdirectory-1.3.10.1-5b13System.Directory withMetadatawithTrailingNewlineMarkWhen NormalMark TraceWhen AlwaysTraceaddErrorPrefix errorPrefixannotateErrorStringcompatWithCreateProcess copyFilesWithdisplaySomeExceptionWithContextioeErrorStringioeGetVerbatimioeModifyErrorStringioeSetVerbatim logCommandprefixWithProgName getProgName traceWhenverbatimUserError warnMessagewithCallStackPrefix withTimestampwrapTextVerbosity readNubList formatMsgmarkupInvocationunionInvocationDistribution.Types.PackageId PackageIdPackageInstalled DepUniqueKeycheckNameMatchesasksCMcheckPcheckSpecVerGte checkSpecVer execCheckM initCheckCtxCheckCtxliftIntlocalCMpristineCheckCtxtellPCheckInterfaceCheckMCheckPreDistributionOpsPNamesTargetAnnotationcheckcheckInt checkIntDep initPNamesliftCMtellCMcheckPkg ccDesugarccFlag ccInterfaceccNames ccSpecVersion ciPackageOps ciPreDistOps ciPureCheckslistDirectoryMrunDirFileGlobMpnBenchspnExecs pnPackageId pnSubLibspnTests taPackageFlagtaTarget$fApplicativeCheckM$fFunctorCheckM$fEqTargetAnnotation $fMonadCheckM$fOrdTargetAnnotation$fShowTargetAnnotationcheckCondTargetannotateCondTreeDistribution.Types.CondTreeCondTree checkCondVarsinitTargetAnnotationupdateTargetAnnotationcheckDuplicateModules waySupportedextensionToFlagextensionToFlag' ghcSupportedDistribution.Compiler abiTagStringbuildCompilerFlavorbuildCompilerIdclassifyCompilerFlavordefaultCompilerFlavorknownCompilerFlavorsperCompilerFlavorToListunknownCompilerInfoAbiTagNoAbiTagCompilerFlavorEtaGHCGHCJSHBCHeliumHugsJHCLHCMHSNHC OtherCompilerUHCYHC CompilerId CompilerInfocompilerInfoAbiTagcompilerInfoCompatcompilerInfoExtensionscompilerInfoIdcompilerInfoLanguagescompilerInfoWiredInUnitIdsPerCompilerFlavorghcjsVersionImplInfoghcVersionImplInfo OpenModuleVar splitRTSArgs(Distribution.Types.VersionRange.InternalorLaterVersionconfigureProgramsupdatePathProgupdatePathProgsuserSpecifiedPath CommonFlag commandHelpextraCompilationArtifactsprogramDbOptionprogramDbPathstestOrBenchmarkHelpText optionNumJobs reqArgFlagreqSymbolicPathArgFlagwithCommonSetupOptions$fBinaryCommonSetupFlags$fEqCommonSetupFlags$fGenericCommonSetupFlags$fMonoidCommonSetupFlags$fSemigroupCommonSetupFlags$fReadCommonSetupFlags$fShowCommonSetupFlags$fStructuredCommonSetupFlags$fBinaryTestFlags$fBinaryTestShowDetails$fBoundedTestShowDetails$fEnumTestShowDetails$fEqTestShowDetails$fGenericTestFlags$fGenericTestShowDetails$fMonoidTestFlags$fSemigroupTestFlags$fMonoidTestShowDetails$fSemigroupTestShowDetails$fNFDataTestShowDetails$fOrdTestShowDetails$fParsecTestShowDetails$fPrettyTestShowDetails$fShowTestFlags$fShowTestShowDetails$fStructuredTestFlags$fStructuredTestShowDetails$fGenericSDistFlags$fMonoidSDistFlags$fSemigroupSDistFlags$fShowSDistFlags$fBinaryReplFlags$fBinaryReplOptions$fGenericReplFlags$fGenericReplOptions$fMonoidReplFlags$fSemigroupReplFlags$fMonoidReplOptions$fSemigroupReplOptions$fShowReplFlags$fShowReplOptions$fStructuredReplFlags$fStructuredReplOptions$fGenericRegisterFlags$fMonoidRegisterFlags$fSemigroupRegisterFlags$fShowRegisterFlags$fGenericInstallFlags$fMonoidInstallFlags$fSemigroupInstallFlags$fShowInstallFlags$fBinaryHscolourFlags$fGenericHscolourFlags$fMonoidHscolourFlags$fSemigroupHscolourFlags$fShowHscolourFlags$fStructuredHscolourFlags$fBinaryHaddockFlags$fBinaryHaddockTarget$fEqHaddockTarget$fEqVisibility$fGenericHaddockFlags$fGenericHaddockProjectFlags$fGenericHaddockTarget$fMonoidHaddockFlags$fSemigroupHaddockFlags$fMonoidHaddockProjectFlags$fSemigroupHaddockProjectFlags$fNFDataHaddockTarget$fParsecHaddockTarget$fPrettyHaddockTarget$fShowHaddockFlags$fShowHaddockProjectFlags$fShowHaddockTarget$fShowVisibility$fStructuredHaddockFlags$fStructuredHaddockTarget$fGenericGlobalFlags$fMonoidGlobalFlags$fSemigroupGlobalFlags$fBinaryCopyFlags$fGenericCopyFlags$fMonoidCopyFlags$fSemigroupCopyFlags$fShowCopyFlags$fStructuredCopyFlagsdispModSubstEntryparsecModSubstEntry$fBinaryConfigFlags$fEqConfigFlags$fGenericConfigFlags$fMonoidConfigFlags$fSemigroupConfigFlags$fReadConfigFlags$fShowConfigFlags$fStructuredConfigFlags"Distribution.Types.HookedBuildInfoHookedBuildInfoPackageIdentifier mkTargetInfoDistribution.Types.LibraryLibraryDistribution.Types.Executable ExecutableDistribution.Types.Benchmark BenchmarkwithExelibrary wipeMetadatahpcDirmkConfiguredComponenttoConfiguredComponent'"Distribution.Types.IncludeRenamingIncludeRenamingDistribution.Compat.GraphGraph$fBinaryCleanFlags$fGenericCleanFlags$fMonoidCleanFlags$fSemigroupCleanFlags$fShowCleanFlags$fStructuredCleanFlags$fBinaryBuildFlags$fGenericBuildFlags$fMonoidBuildFlags$fSemigroupBuildFlags$fReadBuildFlags$fShowBuildFlags$fStructuredBuildFlags$fBinaryBenchmarkFlags$fGenericBenchmarkFlags$fMonoidBenchmarkFlags$fSemigroupBenchmarkFlags$fShowBenchmarkFlags$fStructuredBenchmarkFlags matchPlusUserBuildTargetSingleUserBuildTargetDoubleUserBuildTargetTripleMatchmatchInexactly findMatchreadUserBuildTargetcheckBuildTargets exactMatchesinexactMatchesmatchPlusShadowingshowBuildTarget'Distribution.Types.TestSuite TestSuiteuhcLanguageExtensionsaddBuiltinVersionsinstalledPkgConfigisPkgDirmkInstalledPackageInfo stubRunTestsNotDemandedRuleReasonsNDRRnonDemandedRulesnonAutogenHaskellModulesfilesNotInAutogenFoldersPreConfComponentSemigroupPreConfPkgSemigroup missingDep ruleUpToDatetraverseComponents NoHookTypeNoHandleBadHooksExeArgsUnknownHookTypeCouldNotDecodeInput NoDynDepsCmdBadHooksExecutableArgshooksExeVerbosity runHookHandleconfigureToolchainfilterGhciFlags ghcArchStringDistribution.SystemArchghcEnvironmentFileName ghcOsStringOSmkGhcOptPackagesrenderGhcEnvironmentFileEntryPlatformcheckPackageDbEnvVar getExtensionsgetHaskellObjects getLanguagesghcLookupPropertyghcOptionsSincelinkGhcOptions mkGHCiLibNamemkGHCiProfLibNameoptimizationCFlagsprofDetailLevelFlagsourcesGhcOptionssplitCandCxxOptions substTopDirtargetPlatform SplitSource CcProgram CxxProgram$fEqGhcEnvironmentFileEntry$fOrdGhcEnvironmentFileEntry$fShowGhcEnvironmentFileEntry$fExceptionParseErrorExc$fShowParseErrorExccheckNeedsRecompilationdecodeMainIsArgexeMainModuleName exeTargetName extensionInfindExecutableMain flibBuildNameflibTargetNamegetObjectFileNameisCisCxx isHaskellobjectFilePathsupportsDynamicToo withDynFLibDistribution.Types.ForeignLib ForeignLibforeignLibType isProfiledbuildHaskellModulescomponentInputsbuildWayExtraHcOptionsbuildWayHpcWaybuildAllExtraSourcesbuildExtraSourcesbuildAsmSources buildCSourcesbuildCmmSourcesbuildCxxSources asmSourcescSourcesbuildJsSourcesextractRtsInfo getRPaths hasThreadedlinkExecutablelinkFLib linkLibrarylinkOrLoadComponentrunReplOrWriteFlags replNoLoadDynamicRtsInfodynRtsDebugLibdynRtsEventlogLibdynRtsThreadedDebugLibdynRtsThreadedEventlogLibdynRtsThreadedLibdynRtsVanillaLibRtsInfortsDynamicInfo rtsLibPaths rtsStaticInfo StaticRtsInfostatRtsDebugLibstatRtsEventlogLibstatRtsProfilingLibstatRtsThreadedDebugLibstatRtsThreadedEventlogLibstatRtsThreadedLibstatRtsThreadedProfilingLibstatRtsVanillaLib BuildSources GBuildModegbuild gbuildSourcesgetUserPackageDBpopThreadedFlaggetInstalledPackages'guessGhcPkgFromGhcPathguessHaddockFromGhcPathguessHsc2hsFromGhcPathguessToolFromGhcPathtoPackageIndexgetCompilerArgs copyComponent copyPackageinstallDataFilesinstallIncludeFiles CabalFieldcheckCustomFieldcheckDependencyVersionRangecheckPVP checkPVPs partitionDepsAssocDepPathKindPathKindDirectory PathKindFile PathKindGlob $fEqPathKindisGoodRelativeDirectoryPathisGoodRelativeFilePathisGoodRelativeGlob isInsideDist checkTarPath checkGlobcheckPackageFileNamesWithGlob checkPathfileExtensionSupportedLanguagecheckGHCOptionscheckBenchmarkcheckExecutablecheckForeignLib checkLibrarycheckTestSuite $fEqBITarget$fShowBITarget,Distribution.Types.GenericPackageDescriptionGenericPackageDescription checkDotlinecheckGenericPackageDescriptionpd2gpdcheckGlobResultcheckPackagePrim rc_dependsReadyComponentrc_pkgidrc_uidtoReadyComponentsIndefiniteComponentindefc_includesindefc_providesindefc_requiresInstantiatedComponentinstc_includes instc_instsinstc_insts_depsinstc_providesrc_cid rc_open_uid rc_component rc_exe_depsrc_i rc_publicInstMInstS rc_munged_id"Distribution.Types.MungedPackageIdMungedPackageIddispReadyComponent rc_ann_id$fApplicativeInstM$fFunctorInstM$fHasUnitIdReadyComponent$fIsNodeReadyComponent $fMonadInstM$fPackageReadyComponentdispMissingDepDistribution.Types.AbiHashAbiHash hsSourceDirsPreProcessorExtrasknownExtrasHandlersPromisedDependencydispConfigStateFileErrorExternalDependencyInternalDependencybuildOptionsFromConfigFlagscheckCompilerProblemscheckDeprecatedFlagscheckExactConfigurationcheckPackageProblemscheckRelocatablecheckSharedExesconfigureCoverageconfigureProfilingconfigureRequiredProgramcurrentCabalIdcurrentCompilerIddependencySatisfiablefinalizePackageDescription2-Distribution.PackageDescription.Configuration finalizePD parseHeaderselectDependenciesselectDependency showHeaderfilterAutogenModulesallSourcesBuildInfofindIncludeFilefindMainExeFilefindModDefFile findSetupFilefindSetupHooksFilemaybeCreateDefaultSetupScript tarBallNamelistPackageSources'overwriteSnapshotPackageDesctoUnixrunConfigureScriptDistribution.Types.BuildType BuildTypeaddExtraAsmSourcesaddExtraCSourcesaddExtraCmmSourcesaddExtraCxxSourcesaddExtraJsSourcesaddExtraOtherModules addSrcDirbenchmarkExeV10asExebuiltinAutogenFilescheckSemaphoreSupport dumpBuildInfoemptySignatureModulestestSuiteExeV10AsExetestSuiteLibV09AsLibAndExe DirectoryDistribution.Utils.Path HaddockArgsargInterfaceFileargPackageNameargComponentNameargHideModulesargIgnoreExports argLinkSourceargLinkedSource argQuickJump argCssFile argContentsargGenContentsargIndex argGenIndex argBaseUrl argOutput argInterfaces argOutputDirargTitle argPrologueargPrologueFile argGhcOptions argGhcLibDir argReexports argTargetsargResourcesDir argUseUnicodegetHaddockProgreusingGHCCompilationArtifacts runHaddock fromBenchmarkfromExecutablefromForeignLib fromLibraryfromTest getInterfaces hscolour' mkHaddockArgsallSuffixHandlersdefaultMainHelperdefaultMainHelperWithHandlesgetBuildConfigtryGetBuildConfigDistribution.License knownLicenseslicenseFromSPDX licenseToSPDX mungedName'mungedVersion' packageNamepackageVersion mkAbiHash unAbiHash mkComponentId unComponentIdDistribution.Types.Dependency depLibraries depPkgName depVerRange mainLibSet mkDependencysimplifyDependency mkPackageNamemkPackageNameST unPackageNameunPackageNameST Distribution.Types.PkgconfigNamemkPkgconfigNameunPkgconfigNamegetHSLibraryNamemkLegacyUnitIdmkUnitIdnewSimpleUnitIdunUnitIdunsafeMkDefUnitId alterVersion mkVersion mkVersion' nullVersionversionNumbers"Distribution.Types.VersionIntervalasVersionIntervalsfromVersionIntervalstoVersionIntervalsunVersionIntervalsDistribution.Types.VersionRangefoldVersionRangehasGTLowerBoundhasLEUpperBound hasLowerBoundhasTrailingZeroUpperBound hasUpperBound isAnyVersionnormaliseVersionRangestripParensVersionRange withinRangeanaVersionRange anyVersioncataVersionRangeearlierVersionembedVersionRangehyloVersionRangeintersectVersionRanges laterVersionmajorBoundVersionmajorUpperBound noVersionnotThisVersionorEarlierVersionprojectVersionRange thisVersionunionVersionRangeswildcardUpperBound withinVersionDistribution.Version isNoVersionisSpecificVersionremoveLowerBoundremoveUpperBoundsimplifyVersionRangetransformCarettransformCaretLowertransformCaretUpperLanguage.Haskell.ExtensionclassifyExtensionclassifyLanguagedeprecatedExtensionsknownExtensionsknownLanguagesLicenseAGPLAllRightsReservedApacheBSD2BSD3BSD4GPLISCLGPLMITMPL OtherLicense PublicDomainUnknownLicenseUnspecifiedLicenseHasMungedPackageIdmungedId HasUnitIdinstalledUnitIdPackage packageIdinstalledDependspkgName pkgVersion PkgconfigName DefUnitId unDefUnitIdBoundExclusiveBoundInclusiveBound LowerBound UpperBound NoUpperBoundVersionIntervalVersionIntervals VersionRange VersionRangeFEarlierVersionF GTLowerBoundIntersectVersionRangesF LEUpperBound LaterVersionFMajorBoundVersionFOrEarlierVersionFOrLaterVersionF TZUpperBound ThisVersionFUnionVersionRangesF ExtensionDisableExtensionEnableExtensionUnknownExtensionKnownExtensionAllowAmbiguousTypesAlternativeLayoutRule!AlternativeLayoutRuleTransitional ApplicativeDoArrowsAutoDeriveTypeable BangPatternsBinaryLiteralsBlockArgumentsCApiFFICPPCUSKsConstrainedClassMethodsConstraintKinds DataKindsDatatypeContextsDeepSubsumptionDefaultSignaturesDeriveAnyClassDeriveDataTypeableDeriveFoldable DeriveFunctor DeriveGeneric DeriveLiftDeriveTraversableDerivingStrategies DerivingViaDisambiguateRecordFieldsDoAndIfThenElseDoRecDuplicateRecordFields EmptyCaseEmptyDataDeclsEmptyDataDerivingExistentialQuantificationExplicitForAllExplicitLevelImportsExplicitNamespacesExtendedDefaultRulesExtendedLiteralsExtensibleRecordsFieldSelectorsFlexibleContextsFlexibleInstancesForeignFunctionInterfaceFunctionalDependencies GADTSyntaxGADTsGHCForeignImportPrimGeneralisedNewtypeDerivingGeneralizedNewtypeDerivingGenerics HereDocumentsHexFloatLiteralsImplicitParamsImplicitPreludeImplicitStagePersistenceImportQualifiedPostImpredicativeTypesIncoherentInstances InstanceSigsInterruptibleFFI JavaScriptFFIKindSignatures LambdaCaseLexicalNegationLiberalTypeSynonyms LinearTypes ListTuplePuns MagicHash ModifiersMonadComprehensionsMonadFailDesugaringMonoLocalBinds MonoPatBindsMonomorphismRestrictionMultiParamTypeClasses MultiWayIfMultilineStringsNPlusKPatterns NamedDefaultsNamedFieldPunsNamedWildCardsNegativeLiteralsNewQualifiedOperatorsNondecreasingIndentationNullaryTypeClasses NumDecimalsNumericUnderscores OrPatternsOverlappingInstancesOverloadedLabelsOverloadedListsOverloadedRecordDotOverloadedRecordUpdateOverloadedStringsPackageImportsParallelArraysParallelListCompPartialTypeSignatures PatternGuardsPatternSignaturesPatternSynonyms PolyKindsPolymorphicComponentsPostfixOperators QualifiedDoQualifiedStringsQuantifiedConstraints QuasiQuotes Rank2Types RankNTypesRebindableSyntax RecordPunsRecordWildCards RecursiveDoRegularPatterns RelaxedLayoutRelaxedPolyRecRequiredTypeArgumentsRestrictedTypeSynonymsRoleAnnotationsSafe SafeImportsScopedTypeVariablesStandaloneDerivingStandaloneKindSignatures StarIsTypeStaticPointersStrict StrictDataTemplateHaskellTemplateHaskellQuotesTraditionalRecordSyntaxTransformListComp Trustworthy TupleSectionsTypeAbstractionsTypeApplicationsTypeData TypeFamiliesTypeFamilyDependencies TypeInType TypeOperatorsTypeSynonymInstances UnboxedSums UnboxedTuplesUndecidableInstancesUndecidableSuperClasses UnicodeSyntaxUnliftedDatatypesUnliftedFFITypesUnliftedNewtypesUnsafe ViewPatterns XmlSyntaxLanguageGHC2021GHC2024 Haskell2010 Haskell98UnknownLanguage