qgwW       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdef g h i j k l m n o p!q!r!s!t!u!v!w!x!y!z!{!|!}!~!!!!!!!!!!!!""""""""""""""##############$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%% % % % % %%%%%%%%%%%%%%%%%%% %!%"%#%$%%%&%'%(%)%*%+%,%-%.%/%0%1%2%3%4%5%6%7%8%9%:%;%<%=%>%?%@%A%B%C%D%E%F%G%H%I%J&K&L&M&N&O&P&Q&R&S&T&U&V'W'X'Y'Z'['\']'^'_'`'a'b(c(d(e(f(g(h(i(j(k(l)m)n)o)p)q)r)s)t)u)v)w*x*y*z*{*|*}*~****++++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, , , , , ,,,,,,,,,,,,,,,,,,, ,!,",#,$,%,&,',(,),*,+,,,-,.,/,0,1,2,3,4,5,6,7,8-9-:-;-<-=->-?-@-A-B-C-D-E-F-G-H-I-J-K-L-M-N-O-P-Q-R-S-T-U-V-W-X-Y-Z-[-\-]-^-_-`-a-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q.r.s.t.u.v/w/x/y/z/{/|/}/~/.01111111111111222222222222222223333333333333333333444444444444445555555555555555555555555555566666666666777777777777777777777777777777777 7 7 7 8 88888889999999::::: :!:":#:$:%:&:';(;);*;+;,;-;.;/;0;1;2;3<4<5<6<7<8<9<:<;<<<=<>=?=@=A=B=C=D=E=F=G=H=I=J=K=L=M>N>O>P>Q>R>S>T>U>V>W>X>Y?Z?[?\?]?^?_?`?a@b@c@d@e@f@g@h@i@j@k@l@m@n@o@pAqArAsAtAuAvAwAxAyAzA{A|A}A~BBBBBBBBBBBBBBBCCCCCCCCDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFGGGGGGG G G G G GGGGGGGGGGGGGGGGGGG G!G"G#G$G%G&G'G(G)G*G+G,G-G.G/G0G1G2H3H4H5H6H7H8H9H:H;H<H=H>H?H@HAHBHCIDIEIFIGIHIIIJIKILIMINIOIPIQIRISITIUIVIWJXJYKZK[K\K]K^K_K`KaKbKcKdKeKfKgKhKiKjKkKlKmKnKoKpKqKrKsKtKuKvKwKxKyKzK{K|L}L~LLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQ Q Q Q Q QQQQQQQQQQQQQQQQQQQ Q!Q"Q#Q$Q%Q&Q'Q(Q)Q*Q+Q,Q-Q.Q/Q0Q1Q2Q3Q4R5R6R7R8/9/:/;/</=/>/?/@/A/B/C/D/E/F/G/H/I/J/K/L/M/N/O/P/Q/R/S/T/U/V/W/X/Y/Z/[/\/]/^/_/`/a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x/y/z/{/|/}/~/////////////SSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTUUUUUUUUUUU                                                                                        V VVVVVVVVVVVVVVVVVVW W!W"W#W$W%W&W'W(X)X*X+X,X-X.X/X0X1X2X3Y4Y5Y6Y7Y8Y9Y:Y;Y<Y=Y>Y?Y@YAYBYCYDYEYFYGYHYIYJYKYLYMYNYOYPYQYRYSYTYUYVYWZXZYZZZ[Z\Z]Z^Z_Z`ZaZbZcZdZeZfZgZhZiZjZk[l[m[n\o]p]q^r^s^t^u^v^w^x^y^z^{^|^}^~^^^^^^^^^^^^^^^^^______________________________`````````````aabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccc c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c !c "c #c $c %c &c 'c (c )c *c +c ,c -c .c /c 0c 1c 2c 3c 4c 5c 6c 7c 8c 9c :c ;c <c =c >c ?c @d Ad Bd Cd Dd Ed Fd Gd Hd Id Jd Kd Ld Md Nd Od Pd Qd Rd Sd Td Ud Vd Wd Xd Yd Zd [d \d ]d ^d _d `d ad bd cd de ee fe ge he ie je ke le me ne oe pf qf rf sf tf uf vf wf xf yf zf {f |f }f ~f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f 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 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 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 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 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 .0 /0 00 10 20 30 40 50 60 70 80 90 :0 ;0 <0 =0 >0 ?0 @0 A0 B0 C0 D0 E0 F0 G0 H0 I0 J0 K0 L0 M0 N0 O0 P0 Q0 R0 S0 T0 U0 V0 W0 X0 Y0 Z0 [0 \0 ]0 ^0 _0 `0 a0 b0 c0 d0 e0 f0 g0 h0 i0 j0 k0 l0 m0 n0 o0 p0 q0 r0 s0 t0 u0 v0 w0 x0 y0 z0 {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 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 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 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 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 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 0 0 0 0 0 0 0 0 0 0 0 g g g g g !g "g #g $g %g &g 'g (g )g *g +g ,g -g .g /g 0g 1g 2g 3g 4g 5g 6g 7g 8g 9g :g ;g <g =g >g ?g @g Ag Bg Cg Dg Eg Fg Gg Hg Ig Jg Kg Lg Mg Ng Og Pg Qg Rg Sg Tg Ug Vg Wh Xh Yh Zh [h \h ]h ^h _h `h ah bh ch dh eh fh gh hh ih jh ki lj mj nj oj pj qj rj sj tj uj vj wj xj yj zj {j |k }k ~l l l l l l m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n n o o p p p p p p p p p p p p p p p p q q q q q q q q !q "q #q $q %q &q 'q (q )q *q +q ,r -r .r /r 0r 1r 2r 3r 4r 5r 6r 7r 8r 9r :r ;r <r =r >r ?r @r Ar Br Cr Dr Er Fr Gr Hr Ir Jr Kr Lr Mr Nr Or Pr Qr Rr Sr Tr Ur Vr Wr Xr Yr Zr [s \s ]s ^s _s `s as bs cs ds es fs gs hs is js ks ls ms ns os ps qs rs st tt ut vt wt xt yt zu {u |u }u ~u u u u u u v v v v v v w w w w w w w w w w w w e e e e e e e x x x x x x x x x x x x x x x x x x e e e e e e e e e e e e e e e e e e e e e e e e y z z { { { { { { { | } } } } } } } } } } } } } } . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ~ ~ ~ ~ ~ ~                             ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o Safedsk8Lazily reconstruct a value previously written to a file. dbca kllkSafe+!mnonom!Safe Safe}       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYeSafeZ[None6<KSTp Cabal's own $ copy to avoid requiring an orphan d instance.Once the oldest binary version we support provides a d instance for  we can remove this one here.NB: \" is defined differently and not a  sGenerically generate a   (') operation for any type implementing  . This operation will append two values by point-wise appending their component fields. It is only defined for product types. s a (s b c) = s (s a b) c tGenerically generate a   ) for any product-like type implementing  .%It is only defined for product types. s t a = a = s a t   432765pqrst  432765pqrst]^_`pqrSafeQV Give 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. We didn't implement this for base-4.8.1 because we cannot rely on freezing to have taken place.eThis function is for when you *really* want to add a call stack to raised IO, but you don't have a $ so you can't use  . If you have a  Verbosity$, please use that function instead.  None<QSTVЄaHidden internal type-class New name for  GHC.Generics-based i implementation#This is needed in order to support  deepseq < 1.4 which didn't have a  -based default i implementation yet.&In order to define instances, use e.g. -instance NFData MyType where rnf = genericRnf'The implementation has been taken from  deepseq-1.4.2 's default i implementation.Dbcdefghijklmnopqrstuvwxyz{|}~ .*+01/,&%-(')   "#$89:;<=>@A  CDEFGHIJK   L !"#$%&'()*+,-./01MNOPQRS23456789:;<TUVWX=]\[ZY`_^>?@ABCDdbcaejistaEBSD3cabal-dev@haskell.org experimentalportableNone֒FGHFI"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgportableNone"LConsumes and returns the next character. Fails if there is no input left.PLook-ahead: returns the part of the input that is left, without consuming it. Always fails.'Succeeds iff we are at the end of inputSymmetric choice.}Local, exclusive, left-biased choice: If left parser locally produces any result at all, then right parser is not used.zTransforms a parser into one that does the same, but in addition returns the exact characters read. IMPORTANT NOTE: ] gives a runtime error if its first argument is built using any occurrences of readS_to_P.TConsumes and returns the next character, if it satisfies the specified predicate.+Parses and returns the specified character.(Parses and returns the specified string.BParses the first zero or more characters satisfying the predicate.AParses the first one or more characters satisfying the predicate.+Combines all parsers in the specified list.Skips all whitespace.Like J but succeeds only if there is at least one whitespace character to skip. count n p  parses n occurrences of p/ in sequence. A list of results is returned. between open close p  parses open, followed by p and finally close. Only the value of p is returned. option x p will either parse p or return x without consuming any input. optional p optionally parses p and always returns ().4Parses zero or more occurrences of the given parser.3Parses one or more occurrences of the given parser.Like , but discards the result.Like , but discards the result. sepBy p sep$ parses zero or more occurrences of p, separated by sep*. Returns a list of values returned by p. sepBy1 p sep# parses one or more occurrences of p, separated by sep*. Returns a list of values returned by p. endBy p sep$ parses zero or more occurrences of p, separated and ended by sep. endBy p sep# parses one or more occurrences of p, separated and ended by sep. chainr p op x$ parses zero or more occurrences of p, separated by op#. Returns a value produced by a right9 associative application of all functions returned by op!. If there are no occurrences of p, x is returned. chainl p op x$ parses zero or more occurrences of p, separated by op#. Returns a value produced by a left9 associative application of all functions returned by op!. If there are no occurrences of p, x is returned.Like (, but parses one or more occurrences of p.Like (, but parses one or more occurrences of p.manyTill p end$ parses zero or more occurrences of p, until end3 succeeds. Returns a list of values returned by p.hConverts a parser into a Haskell ReadS-style function. This is the main way in which you can "run" a " parser: the expanded type is 1 readP_to_S :: ReadP a -> String -> [(a,String)] Converts a Haskell ReadS-style function into a parser. Warning: This introduces local backtracking in the resulting parser, and therefore a possible inefficiency.$C$CJKLMNOPQ55None Dbcdefghijklmnopqrstuvwxyz{|}~ 01+*/.,&%-(')   "#$89:;<=>@A  CDEFGHIJK   L !"#$%&'()*+,-./01MNOPQRS23456789:;<TUVWX=]\[ZY`_^>?@ABCDdbcaejistg st jiidcbacb]\[ZY`_^eNMQPORS8A@;<:9>= 10/.-,+*)('&%10+*".$# WVXUKJIFHGLTED(c) Edward Z. Yang 2016BSD3cabal-dev@haskell.org experimentalportableNone 1<FT=,A simple, trivial data type which admits an  instance.The T class is used for datatypes which represent directed graph nodes. A node of type a- is associated with some unique key of type  a); given a node we can determine its key (") and the keys of its neighbors ().A graph of nodes a5. The nodes are expected to have instance of class .Get the value from a .O(1). Is the graph empty?O(1)#. The number of nodes in the graph.O(log V)#. Check if the key is in the graph.O(log V)(. Lookup the node at a key in the graph.O(1). The empty graph.O(log V). Insert a node into a graph.O(log V)*. Delete the node at a key from the graph.O(log V)M. Lookup and delete. This function returns the deleted value if it existed. O(V + V')U. Right-biased union, preferring entries from the second map when conflicts occur.  x =  (f x). O(V + V')Q. Left-biased union, preferring entries from the first map when conflicts occur.(V + E)b. Compute the strongly connected components of a graph. Requires amortized construction of graph.(V + E)K. Compute the cycles of a graph. Requires amortized construction of graph.O(1). Return a list of nodes paired with their broken neighbors (i.e., neighbor keys which are not in the graph). Requires amortized construction of graph.bLookup the immediate neighbors from a key in the graph. Requires amortized construction of graph.jLookup the immediate reverse neighbors from a key in the graph. Requires amortized construction of graph.HCompute the subgraph which is the closure of some set of keys. Returns Nothing` if one (or more) keys are not present in the graph. Requires amortized construction of graph.HCompute the reverse closure of a graph from some set of keys. Returns Nothing` if one (or more) keys are not present in the graph. Requires amortized construction of graph.STopologically sort the nodes of a graph. Requires amortized construction of graph.[Reverse topologically sort the nodes of a graph. Requires amortized construction of graph.RO(1)[. Convert a map from keys to nodes into a graph. The map must satisfy the invariant that R m == fromList ( m)+; if you can't fulfill this invariant use fromList ( m)E instead. The values of the map are assumed to already be in WHNF. O(V log V)<. Convert a list of nodes (with distinct keys) into a graph.O(V)'. Convert a graph into a list of nodes.O(V)&. Convert a graph into a list of keys.O(V)%. Convert a graph into a set of keys.O(1)D. Convert a graph into a map from keys to nodes. The resulting map m* is guaranteed to have the property that  ((k,n) -> k ==  n) ( m).O(1). Convert a graph into a ,. Requires amortized construction of graph.$hgf$hgfSTUVWXYcabal-devel@haskell.org Windows-onlyNone?1Z (c) Ben Gamari 2015-2019BSD3cabal-dev@haskell.org experimentalportableNoneAtDifference list.Make  with containing single element.[NoneG7\: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._`a\]^None<QVJ0bsetEnv name value, sets the specified environment variable to value.Throws  if either name or value1 is the empty string or contains an equals sign.cdeb None<QVJ(c) Sven Panne 2002-2005/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgportableNoneVfReturn a string describing the usage of a command, derived from the header (first argument) and the options described by the second argument.gpProcess the command-line, and return the list of values that matched (and those that didn't). The arguments are:The order requirements (see h)The option descriptions (see i)9The actual command line arguments (presumably got from ).gj returns a triple consisting of the option arguments, a list of non-options, and a list of error messages.jThis is almost the same as g, 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. hklminopqrfgjstuvwxBen Gamari 2015-2019cabal-devel@haskell.orgportableNoneXIy cabal-devel@haskell.orgportableSafeY Jose Iborra 2008BSD3cabal-devel@haskell.orgportableNoneZ"Parser with simple error reporting2011, Dan Knappcabal-devel@haskell.orgportableNonefRepresents 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.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.Takes a dialect of C and whether code is intended to be passed through the preprocessor, and returns a filename extension for containing that code.Infers from a filename's extension the dialect of C which it contains, and whether it is intended to be passed through the preprocessor....cabal-devel@haskell.orgportableNonejNo unliteration. takes a filename (for error reports), and transforms the given string, to eliminate the literate comments from the program text.z {|}~cabal-devel@haskell.orgportableNonep.@Extract the version number from the output of 'strip --version'.Invoking "strip --version" gives very inconsistent results. We ignore everything in parentheses (see #2497), look for the first word that starts with a number, and try parsing out the first two components of it. Non-GNU strip' doesn't appear to have a version flag.Thomas Tuegel 2010BSD3cabal-devel@haskell.orgportableNone<QVOIf true, then children of this group may be run in parallel. Note that this setting is not inherited by children. In particular, consider a group F with "concurrently = False" that has some children, including a group T with "concurrently = True". The children of group T may be run concurrently with each other, as long as none are run at the same time as any of the direct children of group F.)IA human-readable description of the option to guide the user setting it..Perform the test./1A name for the test, unique within a test suite.00Users can select groups of tests by their tags.15Descriptions of the options recognized by this test.2Try to set the named option to the given value. Returns an error message if the option is not supported or the value could not be correctly parsed; otherwise, a ,5 with the option set to the given value is returned.3PCreate a named group of tests, which are assumed to be safe to run in parallel.+      !"#$%&'()*+,-./0123+,-./012&'()*+ !"#$%     3       !"#$%&'()*+,-./012Duncan Coutts 2007cabal-devel@haskell.orgportableNone@}The default rendering style used in Cabal for console output. It has a fixed page width and adds line breaks automatically.A%Pretty-prints with the default style.B&A style for rendering all on one line.!Parser for non-negative integers.=>?@ABCD=>?@ABCD=>?Duncan Coutts 2007-2008cabal-devel@haskell.orgportableNone16JThese are the known Arches: I386, X86_64, PPC, PPC64, Sparc ,Arm, Mips, SH, IA64, S39, Alpha, Hppa, Rs6000, M68k, Vax and JavaScript.The following aliases can also be used: * PPC alias: powerpc * PPC64 alias : powerpc64 * Sparc aliases: sparc64, sun4 * Mips aliases: mipsel, mipseb * Arm aliases: armeb, armel\These are the known OS names: Linux, Windows, OSX ,FreeBSD, OpenBSD, NetBSD, DragonFly ,Solaris, AIX, HPUX, IRIX ,HaLVM ,Hurd ,IOS, Android,GhcjsThe following aliases can also be used:, * Windows aliases: mingw32, win32, cygwin32 * OSX alias: darwin * Hurd alias: gnu * FreeBSD alias: kfreebsdgnu * Solaris alias: solaris2n3How strict to be when classifying strings into the \ and J enums.vThe reason we have multiple ways to do the classification is because there are two situations where we need to do it.For parsing OS and arch names in .cabal files we really want everyone to be referring to the same or or arch by the same name. Variety is not a virtue in this case. We don't mind about case though.For the System.Info.os/arch different Haskell implementations use different names for the same or/arch. Also they tend to distinguish versions of an OS/arch which we just don't care about.The p classification allows us to recognise aliases that are already in common use but it allows us to distinguish them from the canonical name which enables us to warn about such deprecated aliases.x4The platform Cabal was compiled on. In most cases, LocalBuildInfo.hostPlatform8 should be used instead (the platform we're targeting).2HIJRKLMNOPQSTUVWXYZ[\^]_`abcdefghijklmnqoprstuvwxy2\]^_`abcdefghijklmtJKLMNOPQRSTUVWXYZ[wHIxyrunopqsvHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqNone16.The type of build system used by this package.calls Distribution.Simple.defaultMaincalls 9Distribution.Simple.defaultMainWithHooks defaultUserHooks, which invokes  configure@ to generate additional build information used by later phases.calls Distribution.Make.defaultMainuses user-supplied Setup.hs or  Setup.lhs (default)a package that uses an unknown build type cannot actually be built. Doing it this way rather than just giving a parse error means we get better error messages and allows you to inspect the rest of the package description.None16?A boolean expression parameterized over the variable type used.Boolean negation of a  value.Boolean AND of two Condtion values.Boolean OR of two  values.5Simplify the condition and return its free variables.(partial) variable assignment  None13456A ( represents a conditional branch, e.g.,  if flag(foo) on some syntax a). It also has an optional false branch.A  is used to represent the conditional structure of a Cabal file, reflecting a syntax element subject to constraints, and then any number of sub-elements which may be enabled subject to some condition. Both a and c are usually  s.:To be more concrete, consider the following fragment of a Cabal file: Ibuild-depends: base >= 4.0 if flag(extra) build-depends: base >= 4.2 %One way to represent this is to have  ConfVar [ Dependency]  BuildInfo . Here, L represents the actual fields which are not behind any conditional, while J recursively records any further fields which are behind a conditional. ) records the constraints (in this case,  base >= 4.0V) which would be applied if you use this syntax; in general, this is derived off of targetBuildInfo (perhaps a good refactoring would be to convert this into an opaque type, with a smart constructor that pre-computes the dependencies.)FExtract the condition matched by the given predicate from a cond tree.wWe use this mainly for extracting buildable conditions (see the Note above), but the function is in fact more general.wFlattens a CondTree using a partial flag assignment. When a condition cannot be evaluated, both branches are ignored.Flatten a CondTree. This will resolve the CondTree by taking all possible paths into account. Note that since branches represent exclusive choices this may not result in a "sane" result.None16None16ϡ-Merge in all dependent libraries (i.e., use ghc -shared -static0 rather than just record the dependencies, ala ghc -shared -dynamicM). This option is compulsory on Windows and unsupported on other platforms.None16,What kind of foreign library is to be built?A native shared library (.so on Linux, .dylib on OSX, or .dll on Windows).2A native static library (not currently supported.)None16 IAn enumeration of common source control systems. The fields used in the n depend on the type of repo. The tools and methods used to obtain and track the repo depend on the repo type. /What this repo info is for, what it represents. The repository for the "head" or development version of the project. This repo is where we should track the latest development activity or the usual repo people should get to contribute patches. The repository containing the sources for this exact package version or release. For this kind of repo a tag should be given to give enough information to re-create the exact sources.CInformation about the source revision control system for a package.When specifying a repo it is useful to know the meaning or intention of the information as doing so enables automation. There are two obvious common purposes: one is to find the repo for the latest development version, the other is to find the repo for this specific release. The ReopKind6 specifies which one we mean (or another custom one).A package can specify one or the other kind or both. Most will specify just a head repo but some may want to specify a repo to reconstruct the sources for this package release. The required information is the  which tells us if it's using ,  for example. The ? and other details are interpreted according to the repo type.)The kind of repo. This field is required.;The type of the source repository system for this repo, eg  or . This field is required.)The location of the repository. For most )s this is a URL. This field is required. can put multiple "modules" on one server and requires a module name in addition to the location to identify a particular repo. Logically this is part of the location but unfortunately has to be specified separately. This field is required for the  $ and should not be given otherwise.The name or identifier of the branch, if any. Many source control systems have the notion of multiple branches in a repo that exist in the same location. For example  and  use this while systems like  use different locations for different branches. This field is optional but should be used if necessary to identify the sources, especially for the   repo kind.UThe tag identify a particular state of the repository. This should be given for the   repo kind and not for   kind.Some repositories contain multiple projects in different subdirectories This field specifies the subdirectory where this packages sources can be found, eg the subdirectory containing the .cabal file. It is interpreted relative to the root of the repository. This field is optional. If not given the default is "." ie no subdirectory.                Safe[wHash a string using GHC's fingerprinting algorithm (a 128-bit MD5 hash) and then encode the resulting hash in base 62.None#1Monadic variant of  mapAccumL.11None3 4A 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 Hhttp://blog.ezyang.com/2012/01/problem-set-the-codensity-transformation/5Emit a step and then continue.6Fail the computation.7 Consume a 4 calculation. Much like 0P 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 Right456745674Safe<Decode > from UTF8-encoded octets.;Invalid data will be decoded as the replacement character (U+FFFD) See also ==Encode >! to a list of UTF8-encoded octets See also  decodeUtf8<=None16> Compact representation of short Strings-The data is stored internally as UTF8 in an  when compiled against bytestring >= 0.10.4F, and otherwise the fallback is to use plain old non-compat '[Char]'.3Note: This type is for internal uses (such as e.g.  PackageName*) and shall not be exposed in Cabal's API? Construct > from >@Convert > to ><=>?@>?@<=>None16KDLA pkg-config library name?This is parsed as any valid argument to the pkg-config utility.MConvert L to >N Construct a L from a >N is the inverse to MANote: No validations are performed to ensure that the resulting L is validRNLMNLMNLNone16K#jYA Yf uniquely identifies the transitive source code closure of a component (i.e. libraries, executables).CFor non-Backpack components, this corresponds one to one with the UnitIdD, which serves as the basis for install paths, linker symbols, etc.Use Z and [ to convert from/to a >.This type is opaque since  Cabal-2.0Z Construct a Y from a >Z is the inverse to [ANote: No validations are performed to ensure that the resulting Y is valid[Convert Y to >_ZYZ[Y[ZY None16K'f ABI HashesUse h and g to convert from/to a >.This type is opaque since  Cabal-2.0g Construct a f from a >h is the inverse to gANote: No validations are performed to ensure that the resulting f is validhConvert f to >khfghfghf!Duncan Coutts 2008BSD3cabal-devel@haskell.orgportableNone163"Strict/unpacked representation of  [ShortText]pA valid Haskell module name.t Construct a p= from valid module components, i.e. parts separated by dots.uThe module name Main.vDThe individual components of a hierarchical module name. For example 1components (fromString "A.B.C") = ["A", "B", "C"]wSConvert a module name to a file path, but without any file extension. For example: )toFilePath (fromString "A.B.C") = "A/B/C"| Construct a p from a valid module name >.This is just a convenience function intended for valid module strings. It is an error if it is used with a string that is not a valid module name. If you are parsing user input then use C instead. pqrstuvw pqtvwusrpq"None16ARenaming applied to the modules provided by a package. The boolean indicates whether or not to also include all of the original names of modules. Thus, ModuleRenaming False []$ is "don't expose any modules, and ModuleRenaming True [( Data.Bool, Bool)]+ is, "expose all modules, but also expose  Data.Bool as Bool)". If a renaming is omitted you get the .=(NB: This is a list not a map so that we can preserve order.)"A module renaming/thinning; e.g., (A as B, C as C) brings B and C into scope.@The default renaming, bringing all exported modules into scope.Hiding renaming, e.g.,  hiding (A, B)C, bringing all exported modules into scope except the hidden ones.3The default renaming, if something is specified in  build-depends only.HTests if its the default renaming; we can use a more compact syntax in # in this case.#None16D@A renaming on an include: (provides renaming, requires renaming)The  applied when you only  build-depends on a package.Is an  the default one?#Isaac Jones, Simon Marlow 2003-2004=BSD3 portions Copyright (c) 2007, Galois Inc.cabal-devel@haskell.orgportableNone6<QV~FWraps text to the default line width. Existing newlines are preserved.HWraps a list of words to a list of lines of words of a particular width.?Gets the contents of a file, but guarantee that it gets closed.The file is read lazily but if it is not fully consumed by the action then the remaining input is truncated and the file is closed.Writes a file atomically.nThe file is either written successfully or an IO exception is raised and the original file is left unchanged.On windows it is not possible to delete a file that is open by a process. This case will give an IO exception but the atomic property is not affected.,Whether BOM is at the beginning of the input7Check whether a file has Unicode byte order mark (BOM).DIgnore a Unicode byte order mark (BOM) at the beginning of the input2Reads a UTF8 encoded text file as a Unicode StringReads lazily using ordinary .2Reads a UTF8 encoded text file as a Unicode StringSame behaviour as .4Writes a Unicode String as a UTF8 encoded text file.Uses ", so provides the same guarantees.3Fix different systems silly line ending conventionsdropWhileEndLE p is equivalent to reverse . dropWhile p . reversep, but quite a bit faster. The difference between "Data.List.dropWhileEnd" and this version is that the one in  Data.Listj is strict in elements, but spine-lazy, while this one is spine-strict but lazy in elements. That's what LE" stands for - "lazy in elements".Example: F> tail $ Data.List.dropWhileEnd (<3) [undefined, 5, 4, 3, 2, 1] *** Exception: Prelude.undefined > tail $ dropWhileEndLE (<3) [undefined, 5, 4, 3, 2, 1] [5,4,3] > take 3 $ Data.List.dropWhileEnd (<3) [5, 4, 3, 2, 1, undefined] [5,4,3] > take 3 $ dropWhileEndLE (<3) [5, 4, 3, 2, 1, undefined] *** Exception: Prelude.undefined takeWhileEndLE p is equivalent to reverse . takeWhile p . reverse;, but is usually faster (as well as being easier to read).Like  , but has  O(n log n) complexity instead of O(n^2) . Code for  and  taken from Niklas Hambchen's  $http://github.com/nh2/haskell-ordnubordnub package.Like  and F. Selects a key for each element and takes the nub based on that key. Like "Data.List.union", but has  O(n log n) complexity instead of O(n^2).A right-biased version of .Example: 3> ordNub [1,2,1] [1,2] > ordNubRight [1,2,1] [2,1] A right-biased version of .Example: ]> listUnion [1,2,3,4,3] [2,1,1] [1,2,3,4,3] > listUnionRight [1,2,3,4,3] [2,1,1] [4,3,2,1,1] A total variant of 0. and  are like  and K but have platform independent heuristics. The System.FilePath exists in two versions, Windows and Posix. The two versions don't agree on what is a relative path and we don't know if we're given Windows or Posix paths. This results in false positives when running on Posix and inspecting Windows paths, like the hackage server does. System.FilePath.Posix.isAbsolute "C:\hello" == False System.FilePath.Windows.isAbsolute "/hello" == False This means that we would treat paths that start with "/" to be absolute. On Posix they are indeed absolute, while on Windows they are not.The portable versions should be used when we might deal with paths that are from another OS than the host OS. For example, the Hackage Server deals with both Windows and Posix paths while performing the PackageDescription checks. In contrast, when we run 'cabal configure' we do expect the paths to be correct for our OS and we should not have to use the platform independent heuristics.  isRelativeOnAnyPlatform = not . ;?BB?;SafeZ "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.A variable which can be unified; alternately, this can be thought of as an equivalence class with a distinguished representative.Mutable write to a Read the current value of .2Create a fresh equivalence class with one element.)Flatten any chains of links, returning a 8 which points directly to the canonical representation.6Return the canonical element of an equivalence class .gUnify two equivalence classes, so that they share a canonical element. Keeps the descriptor of point2.5Test if two points are in the same equivalence class.$Ian Lynagh 2007BSD3cabal-devel@haskell.orgportableNone6: /Turn on verbose call-site printing when we log.0Turn on verbose call-stack printing when we log.Turn on -----BEGIN CABAL OUTPUT-----I markers for output from Cabal (as opposed to GHC, or system dependent).ATurn off marking; useful for suppressing nondeterministic output.'Disable line-wrapping for log messages.Mark the verbosity as quiet+Helper function for flag toggling functions0Test if we should output call sites when we log.1Test if we should output call stacks when we log.!Test if we should output markets.3Test if line-wrapping is disabled for log messages.Test if we had called  on the verbosity+Helper function for flag testing functions.%FIsaac Jones, Simon Marlow 2003-2004 Duncan Coutts 2008BSD3cabal-devel@haskell.orgportableNone16K($A complementary representation of a r. Instead of a boolean version predicate it uses an increasing sequence of non-overlapping, non-empty intervals.aThe key point is that this representation gives a canonical representation for the semantics of xs. This makes it easier to check things like whether a version range is empty, covers all versions, or requires a certain minimum or maximum version. It also makes it easy to check equality or containment. It also makes it easier to identify 'simple' version predicates for translation into foreign packaging systems that do not support complex version range expressions.A - represents the version of a software entity. Instances of z and  are provided, which gives exact equality and lexicographic ordering of the version number components (i.e. 2.1 > 2.0, 1.2.3 > 1.2.2, etc.).*This type is opaque and distinct from the  type in  Data.Version since  Cabal-2.0!. The difference extends to the d8 instance using a different (and more compact) encoding. Construct ( from list of version number components.For instance, mkVersion [3,2,1] constructs a  representing the version 3.2.1.-All version components must be non-negative.  mkVersion []# currently represents the special null version; see also  . Variant of  which converts a  Data.Version  into Cabal's  type.Unpack ( into list of version number components.This is the inverse to , so the following holds: %(versionNumbers . mkVersion) vs == vs "Constant representing the special null The   compares (via ) as less than every proper  value. 3Apply function to list of version number components 0alterVersion f == mkVersion . f . versionNumbers The version range -any4. That is, a version range containing all versions. withinRange v anyVersion = True HThe empty version range, that is a version range containing no versions.WThis can be constructed using any unsatisfiable version range expression, for example  > 1 && < 1. withinRange v noVersion = FalseThe version range == v (withinRange v' (thisVersion v) = v' == vThe version range  v|| v +withinRange v' (notThisVersion v) = v' /= vThe version range > v (withinRange v' (laterVersion v) = v' > vThe version range >= v +withinRange v' (orLaterVersion v) = v' >= vThe version range < v *withinRange v' (earlierVersion v) = v' < vThe version range <= v -withinRange v' (orEarlierVersion v) = v' <= vThe version range  vr1 || vr2 X withinRange v' (unionVersionRanges vr1 vr2) = withinRange v' vr1 || withinRange v' vr2The version range  vr1 && vr2 \ withinRange v' (intersectVersionRanges vr1 vr2) = withinRange v' vr1 && withinRange v' vr2$The difference of two version ranges c withinRange v' (differenceVersionRanges vr1 vr2) = withinRange v' vr1 && not (withinRange v' vr2)The inverse of a version range B withinRange v' (invertVersionRange vr) = not (withinRange v' vr)The version range == v.*.For example, for version 1.2, the version range == 1.2.* is the same as >= 1.2 && < 1.3 withinRange v' (laterVersion v) = v' >= v && v' < upper v where upper (Version lower t) = Version (init lower ++ [last lower + 1]) tThe version range ^>= v.For example, for version 1.2.3.4, the version range  ^>= 1.2.3.4 is the same as >= 1.2.3.4 && < 1.3. Note that ^>= 1 is equivalent to  >= 1 && < 1.1.  since 2.0@Given a version range, remove the highest upper bound. Example: (>= 1 && < 3) || (>= 4 && < 5) is converted to  (>= 1 &&  3)|| (= 4).@Given a version range, remove the lowest lower bound. Example:  (>= 1 &&  3)|| ( = 4 && < 5) is converted to  (>= 0 &&  3)|| ( = 4 && < 5).-Fold over the basic syntactic structure of a .bThis provides a syntactic view of the expression defining the version range. The syntactic sugar ">= v", "<= v" and "== v.*"2 is presented in terms of the other basic syntax.For a semantic view use  .An extended variant of K that also provides a view of the expression in which the syntactic sugar ">= v", "<= v" and  "== v.*"I is presented explicitly rather than in terms of the other basic syntax..Does this version fall within the given range?(This is the evaluation function for the  type. View a  as a union of intervals.5This provides a canonical view of the semantics of a \ as opposed to the syntax of the expression used to define it. For the syntactic view use .Each interval is non-empty. The sequence is in increasing order and no intervals overlap or touch. Therefore only the first and last can be unbounded. The sequence can be empty if the range is empty (e.g. a range expression like  1&& 2).COther checks are trivial to implement using this view. For example: hisNoVersion vr | [] <- asVersionIntervals vr = True | otherwise = False isSpecificVersion vr | [(LowerBound v InclusiveBound ,UpperBound v' InclusiveBound)] <- asVersionIntervals vr , v == v' = Just v | otherwise = Nothing! Does this  place any restriction on the ! or is it in fact equivalent to .^Note this is a semantic check, not simply a syntactic check. So for example the following is True (for all v). EisAnyVersion (EarlierVersion v `UnionVersionRanges` orLaterVersion v)"This is the converse of !l. It check if the version range is empty, if there is no possible version that satisfies the version range.For example this is True (for all v): FisNoVersion (EarlierVersion v `IntersectVersionRanges` LaterVersion v)#6Is this version range in fact just a specific version?For example the version range ">= 3 && <= 3" contains only the version 3.$ Simplify a  expression. For non-empty version ranges this produces a canonical form. Empty or inconsistent version ranges are left as-is because that provides more information."If you need a canonical form use )fromVersionIntervals . toVersionIntervals&It satisfies the following properties: 8withinRange v (simplifyVersionRange r) = withinRange v r  withinRange v r = withinRange v r' ==> simplifyVersionRange r = simplifyVersionRange r' || isNoVersion r || isNoVersion r'<Compute next greater major version to be used as upper bound Example: 0.4.1 produces the version 0.5. which then can be used to construct a range >= 0.4.1 && < 0.5%&Inspect the list of version intervals.&Directly construct a  from a list of intervals.Each interval must be non-empty. The sequence must be in increasing order and no intervals may overlap or touch. If any of these conditions are not satisfied the function returns Nothing.6Check an upper bound does not intersect a lower bound:--| or ---) or ---] or ---) but not ---] |--- (--- (--- [--- [---'5Test if a version falls within the version intervals.VIt exists mostly for completeness and testing. It satisfies the following properties: }withinIntervals v (toVersionIntervals vr) = withinRange v vr withinIntervals v ivs = withinRange v (fromVersionIntervals ivs)( Convert a $ to a sequence of version intervals.) Convert a  value back into a 0 expression representing the version intervals.-+Does the version range have an upper bound?.4Does the version range have an explicit lower bound?jNote: this function only considers the user-specified lower bounds, but not the implicit >=0 lower bound."-any" version "== v" "> v" "< v""_ || _" union"_ && _" intersection "-any" version "== v" "> v" "< v" ">= v" "<= v""== v.*" wildcard. The function is passed the inclusive lower bound and the exclusive upper bounds of the range defined by the wildcard."^>= v" major upper bound The function is passed the inclusive lower bound and the exclusive major upper bounds of the range defined by this operator."_ || _" union "_ && _" intersection "(_)" parentheses>      !"#$%&'()*+,-.>     !"#$-. ()'%&*+, &None16J/The "test-type" field in the test suite stanza.K"type: exitcode-stdio-x.y"L"type: detailed-x.y"M'Some unknown test type e.g. "type: foo"JKLMNJKLMNJKLM'None16&VpThe test suite interfaces that are currently defined. Each test suite must specify which interface it supports.ZMore interfaces may be defined in future, either new revisions or totally new interfaces.WTest interface "exitcode-stdio-1.0". The test-suite takes the form of an executable. It returns a zero exit code for success, non-zero for failure. The stdout and stderr channels may be logged. It takes no command line parameters and nothing on stdin.XTest interface "detailed-0.9". The test-suite takes the form of a library containing a designated module that exports "tests :: [Test]".YqA test suite that does not conform to one of the above interfaces for the given reason (e.g. unknown test type).VWXYVWXYVWXY(None16( b.Describes a dependency on a pkg-config librarybcbcbc)None16*il3The "benchmark-type" field in the benchmark stanza.m"type: exitcode-stdio-x.y"n,Some unknown benchmark type e.g. "type: foo"lmnolmnolmn*None163wnThe benchmark interfaces that are currently defined. Each benchmark must specify which interface it supports.ZMore interfaces may be defined in future, either new revisions or totally new interfaces.xBenchmark interface "exitcode-stdio-1.0". The benchmark takes the form of an executable. It returns a zero exit code for success, non-zero for failure. The stdout and stderr channels may be logged. It takes no command line parameters and nothing on stdin.yuA benchmark that does not conform to one of the above interfaces for the given reason (e.g. unknown benchmark type).wxywxywxy+The License data type.8Isaac Jones 2003-2005 Duncan Coutts 2008BSD3cabal-devel@haskell.orgportableNone16UIIndicates the license under which a package's source code is released. Versions of the licenses not listed here will be rejected by Hackage and cause  cabal check to issue a warning.GNU General Public License,  6https://www.gnu.org/licenses/old-licenses/gpl-2.0.html version 2 or  %https://www.gnu.org/licenses/gpl.html version 3. &https://www.gnu.org/licenses/agpl.html,GNU Affero General Public License, version 3.$GNU Lesser General Public License,  7https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html version 2.1 or  &https://www.gnu.org/licenses/lgpl.html version 3. .http://www.opensource.org/licenses/bsd-license2-clause BSD license. /http://www.opensource.org/licenses/bsd-3-clause3-clause BSD license. 1http://directory.fsf.org/wiki/License:BSD_4Clause4-clause BSD license. This license has not been approved by the OSI and is incompatible with the GNU GPL. It is provided for historical reasons and should be avoided. &http://www.opensource.org/licenses/MIT MIT license. Ahttp://www.isc.org/downloads/software-support-policy/isc-license/ ISC license https://www.mozilla.org/MPL/#Mozilla Public License, version 2.0. https://www.apache.org/licenses/Apache License, version 2.0.ZThe author of a package disclaims any copyright to its source code and dedicates it to the public domain. This is not a software license. Please note that it is not possible to dedicate works to the public domain in every jurisdiction, nor is a work that is in the public domain in one jurisdiction necessarily in the public domain elsewhere.Explicitly 'All Rights Reserved', eg for proprietary software. The package may not be legally modified or redistributed by anyone but the rightsholder.No license specified which legally defaults to 'All Rights Reserved'. The package may not be legally modified or redistributed by anyone but the rightsholder.Any other software license.$Indicates an erroneous license name..The list of all currently recognised licenses.,Isaac Jones 2003-2004BSD3libraries@haskell.orgportableNone16?cAllow overlapping class instances, provided there is a unique most specific instance for each use. chttp://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#instance-overlapIgnore structural rules guaranteeing the termination of class instance resolution. Termination is guaranteed by a fixed-depth recursion stack, and compilation may fail if this depth is exceeded. hhttp://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#undecidable-instancesImplies . Allow the implementation to choose an instance even when it is possible that further instantiation of types will lead to a more specific instance being applicable. chttp://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#instance-overlap (deprecated) Allow recursive bindings in do blocks, using the rec keyword. See also .Allow recursive bindings using mdo, a variant of do. DoRec( provides a different, preferred syntax. _http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#recursive-do-notationdProvide syntax for writing list comprehensions which iterate over several lists together, like the  family of functions. fhttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#parallel-list-comprehensions*Allow multiple parameters in a type class. khttp://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#multi-param-type-classes,Enable the dreaded monomorphism restriction. Ihttp://www.haskell.org/ghc/docs/latest/html/users_guide/monomorphism.html$Allow a specification attached to a multi-parameter type class which indicates that some parameters are entirely determined by others. The implementation will check that this property holds for the declared instances, and will use this property to reduce ambiguity in instance resolution. jhttp://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#functional-dependenciesLike Y but does not allow a higher-rank type to itself appear on the left of a function arrow. khttp://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#universal-quantificationNAllow a universally-quantified type to occur on the left of a function arrow. khttp://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#universal-quantification@Allow data constructors to have polymorphic arguments. Unlike -, does not allow this for ordinary functions. khttp://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#universal-quantification1Allow existentially-quantified data constructors. lhttp://www.haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#existential-quantification=Cause a type variable in a signature, which has an explicit forallQ quantifier, to scope over the definition of the accompanying value declaration. hhttp://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#scoped-type-variablesDeprecated, use  instead.7Enable implicit function parameters with dynamic scope. fhttp://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#implicit-parametersHRelax some restrictions on the form of the context of a type signature. dhttp://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#flexible-contextsORelax some restrictions on the form of the context of an instance declaration. ahttp://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#instance-rules2Allow data type declarations with no constructors. _http://www.haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#nullary-types.Run the C preprocessor on Haskell source code. [http://www.haskell.org/ghc/docs/latest/html/users_guide/options-phases.html#c-pre-processor]Allow an explicit kind signature giving the kind of types over which a type variable ranges. Zhttp://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#kindingbEnable a form of pattern which forces evaluation before an attempted match, and a form of strict let/where binding. Jhttp://www.haskell.org/ghc/docs/latest/html/users_guide/bang-patterns.html&Allow type synonyms in instance heads. ihttp://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#flexible-instance-headDEnable Template Haskell, a system for compile-time metaprogramming. Mhttp://www.haskell.org/ghc/docs/latest/html/users_guide/template-haskell.htmlEnable the Foreign Function Interface. In GHC, implements the standard Haskell 98 Foreign Function Interface Addendum, plus some GHC-specific extensions. @http://www.haskell.org/ghc/docs/latest/html/users_guide/ffi.htmlEnable arrow notation. Khttp://www.haskell.org/ghc/docs/latest/html/users_guide/arrow-notation.html (deprecated)l Enable generic type classes, with default instances defined in terms of the algebraic structure of a type. Lhttp://www.haskell.org/ghc/docs/latest/html/users_guide/generic-classes.html,Enable the implicit importing of the module Prelude. When disabled, when desugaring certain built-in syntax into ordinary identifiers, use whatever is in scope rather than the Prelude -- version. [http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#rebindable-syntaxEnable syntax for implicitly binding local names corresponding to the field names of a record. Puns bind specific names, unlike . Uhttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#record-punsDEnable a form of guard which matches a pattern and binds variables. Xhttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#pattern-guardsAllow a type declared with newtype to use deriving9 for any class with an instance for the underlying type. Vhttp://www.haskell.org/ghc/docs/latest/html/users_guide/deriving.html#newtype-deriving,Enable the "Trex" extensible records system. Ahttp://cvs.haskell.org/Hugs/pages/users_guide/hugs-only.html#TREXEnable type synonyms which are transparent in some definitions and opaque elsewhere, as a way of implementing abstract datatypes. Fhttp://cvs.haskell.org/Hugs/pages/users_guide/restricted-synonyms.htmlHEnable an alternate syntax for string literals, with string templating. Ahttp://cvs.haskell.org/Hugs/pages/users_guide/here-documents.htmlAllow the character #W as a postfix modifier on identifiers. Also enables literal syntax for unboxed values. Thttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#magic-hashcAllow data types and type synonyms which are indexed by types, i.e. ad-hoc polymorphism for types. Jhttp://www.haskell.org/ghc/docs/latest/html/users_guide/type-families.html=Allow a standalone declaration which invokes the type class deriving mechanism. Zhttp://www.haskell.org/ghc/docs/latest/html/users_guide/deriving.html#stand-alone-derivingpAllow certain Unicode characters to stand for certain ASCII character sequences, e.g. keywords and punctuation. Xhttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#unicode-syntax:Allow the use of unboxed types as foreign types, e.g. in foreign import and foreign export. Ihttp://www.haskell.org/ghc/docs/latest/html/users_guide/ffi.html#id681687Enable interruptible FFI. Rhttp://www.haskell.org/ghc/docs/latest/html/users_guide/ffi.html#ffi-interruptible*Allow use of CAPI FFI calling convention (foreign import capi). Ihttp://www.haskell.org/ghc/docs/latest/html/users_guide/ffi.html#ffi-capi|Defer validity checking of types until after expanding type synonyms, relaxing the constraints on how synonyms may be used. _http://www.haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#type-synonyms\Allow the name of a type constructor, type class, or type variable to be an infix operator.Enable syntax for implicitly binding local names corresponding to the field names of a record. A wildcard binds all unmentioned names, unlike . Zhttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#record-wildcardsDeprecated, use  instead.QAllow a record field name to be disambiguated by the type of the record it's in. ]http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#disambiguate-fields=Enable traditional record syntax (as supported by Haskell 98) chttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#traditional-record-syntaxVEnable overloading of string literals using a type class, much like integer literals. ehttp://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#overloaded-strings{Enable generalized algebraic data types, in which type variables may be instantiated on a per-constructor basis. Implies . Vhttp://www.haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#gadt>Enable GADT syntax for declaring ordinary algebraic datatypes. \http://www.haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#gadt-style"Make pattern bindings monomorphic. Rhttp://www.haskell.org/ghc/docs/latest/html/users_guide/monomorphism.html#id630981DRelax the requirements on mutually-recursive polymorphic functions. _http://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#typing-bindsEAllow default instantiation of polymorphic types in more situations. `http://downloads.haskell.org/~ghc/latest/docs/html/users_guide/ghci.html#type-defaulting-in-ghciEnable unboxed tuples. Vhttp://www.haskell.org/ghc/docs/latest/html/users_guide/primitives.html#unboxed-tuplesEnable deriving for classes  and . Whttp://www.haskell.org/ghc/docs/latest/html/users_guide/deriving.html#deriving-typeableEnable deriving for  and . Whttp://www.haskell.org/ghc/docs/latest/html/users_guide/deriving.html#deriving-typeable&Enable support for default signatures. khttp://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#class-default-signatures?Allow type signatures to be specified in instance declarations. `http://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#instance-sigsVAllow a class method's type to place additional constraints on a class type variable. ehttp://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#class-method-typescAllow imports to be qualified by the package name the module is intended to be imported from, e.g. import "network" Network.Socket Yhttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#package-imports (deprecated)A Allow a type variable to be instantiated at a polymorphic type. mhttp://www.haskell.org/ghc/docs/6.12.3/html/users_guide/other-type-extensions.html#impredicative-polymorphism (deprecated)1 Change the syntax for qualified infix operators. ahttp://www.haskell.org/ghc/docs/6.12.3/html/users_guide/syntax-extns.html#new-qualified-operatorsURelax the interpretation of left operator sections to allow unary postfix operators. [http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#postfix-operatorscEnable quasi-quotation, a mechanism for defining new concrete syntax for expressions and patterns. _http://www.haskell.org/ghc/docs/latest/html/users_guide/template-haskell.html#th-quasiquotation\Enable generalized list comprehensions, supporting operations such as sorting and grouping. ihttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#generalised-list-comprehensionscEnable monad comprehensions, which generalise the list comprehension syntax to work for any monad. ^http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#monad-comprehensions]Enable view patterns, which match a value by applying a function and matching on the result. Whttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#view-patternsxAllow concrete XML syntax to be used in expressions and patterns, as per the Haskell Server Pages extension language:  &http://www.haskell.org/haskellwiki/HSP. The ideas behind it are discussed in the paper "Haskell Server Pages through Dynamic Loading" by Niklas Broberg, from Haskell Workshop '05.Allow regular pattern matching over lists, as discussed in the paper "Regular Expression Patterns" by Niklas Broberg, Andreas Farre and Josef Svenningsson, from ICFP '04.'Enable the use of tuple sections, e.g. (, True) desugars into x -> (x, True). Xhttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#tuple-sectionsGAllow GHC primops, written in C--, to be imported into a Haskell file.!Support for patterns of the form n + k, where k is an integer literal. Vhttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#n-k-patternsImprove the layout rule when if expressions are used in a do block.Enable support for multi-way if -expressions. Vhttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#multi-way-ifEnable support lambda-case expressions. Uhttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#lambda-caseqMakes much of the Haskell sugar be desugared into calls to the function with a particular name that is in scope. [http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#rebindable-syntaxMake forallN a keyword in types, which can be used to give the generalisation explicitly. chttp://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#explicit-foralls0Allow contexts to be put on datatypes, e.g. the Eq a in /data Eq a => Set a = NilSet | ConsSet a (Set a). chttp://www.haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#datatype-contextsLocal (let and where) bindings are monomorphic. chttp://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#mono-local-bindsEnable deriving for the  class. Whttp://www.haskell.org/ghc/docs/latest/html/users_guide/deriving.html#deriving-typeableEnable deriving for the  class. Whttp://www.haskell.org/ghc/docs/latest/html/users_guide/deriving.html#deriving-typeableEnable deriving for the  class. Whttp://www.haskell.org/ghc/docs/latest/html/users_guide/deriving.html#deriving-typeable&Enable non-decreasing indentation for do blocks. fhttp://www.haskell.org/ghc/docs/latest/html/users_guide/bugs-and-infelicities.html#infelicities-syntaxAllow imports to be qualified with a safe keyword that requires the imported module be trusted as according to the Safe Haskell definition of trust. import safe Network.Socket Vhttp://www.haskell.org/ghc/docs/latest/html/users_guide/safe-haskell.html#safe-importstCompile a module in the Safe, Safe Haskell mode -- a restricted form of the Haskell language to ensure type safety. Thttp://www.haskell.org/ghc/docs/latest/html/users_guide/safe-haskell.html#safe-trustCompile a module in the Trustworthy, Safe Haskell mode -- no restrictions apply but the module is marked as trusted as long as the package the module resides in is trusted. Thttp://www.haskell.org/ghc/docs/latest/html/users_guide/safe-haskell.html#safe-trustzCompile a module in the Unsafe, Safe Haskell mode so that modules compiled using Safe, Safe Haskell mode can't import it. Thttp://www.haskell.org/ghc/docs/latest/html/users_guide/safe-haskell.html#safe-trustAllow type classimplicit parameterbequality constraints to be used as types with the special kind constraint. Also generalise the  (ctxt => ty)H syntax so that any type of kind constraint can occur before the arrow. Lhttp://www.haskell.org/ghc/docs/latest/html/users_guide/constraint-kind.htmlEnable kind polymorphism. Nhttp://www.haskell.org/ghc/docs/latest/html/users_guide/kind-polymorphism.htmlEnable datatype promotion. Fhttp://www.haskell.org/ghc/docs/latest/html/users_guide/promotion.htmlEnable parallel arrays syntax ([:, :]) for Data Parallel Haskell. <http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell+Enable explicit role annotations, like in (/type role Foo representational representational). Bhttp://www.haskell.org/ghc/docs/latest/html/users_guide/roles.htmlWEnable overloading of list literals, arithmetic sequences and list patterns using the IsList type class. chttp://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#overloaded-listsoEnable case expressions that have no alternatives. Also applies to lambda-case expressions if they are enabled. Thttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#empty-case#Triggers the generation of derived : instances for every datatype and type class declaration. Zhttp://www.haskell.org/ghc/docs/latest/html/users_guide/deriving.html#auto-derive-typeable;Desugars negative literals directly (without using negate). [http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#negative-literals5Allow the use of binary integer literal syntax (e.g.  0b11001001 to denote 201). Yhttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#binary-literals>Allow the use of floating literal syntax for all instances of  , including  and . Vhttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#num-decimals7Enable support for type classes with no type parameter. ghttp://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#nullary-type-classes9Enable explicit namespaces in module import/export lists. ]http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#explicit-namespacesUAllow the user to write ambiguous types, and the type inference engine to infer them. \http://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#ambiguityEnable foreign import javascript.4Allow giving names to and abstracting over patterns. chttp://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#pattern-synonymsAllow anonymous placeholders (underscore) inside type signatures. The type inference engine will generate a message describing the type inferred at the hole's location. jhttp://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#partial-type-signaturesAllow named placeholders written with a leading underscore inside type signatures. Wildcards with the same name unify to the same type. bhttp://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#named-wildcardsEnable deriving for any class. chttp://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#derive-any-classEnable deriving for the  class. Shttp://www.haskell.org/ghc/docs/latest/html/users_guide/deriving.html#deriving-lift.Enable support for 'static pointers' (and the staticN keyword) to refer to globally stable names, even across different programs. Lhttp://www.haskell.org/ghc/docs/latest/html/users_guide/static-pointers.htmlVSwitches data type declarations to be strict by default (as if they had a bang using  BangPatterns*), and allow opt-in field laziness using ~.TSwitches all pattern bindings to be strict by default (as if they had a bang using  BangPatterns*), ordinary patterns are recovered using ~ . Implies  StrictData. Allows do-notation for types that are  as well as . When enabled, desugaring do notation tries to use ( *) and  and join as far as possible. ;Allow records to use duplicated field labels for accessors. 2Enable explicit type applications with the syntax id @Int. Dissolve the distinction between types and kinds, allowing the compiler to reason about kind equality and therefore enabling GADTs to be promoted to the type-level. GAllow recursive (and therefore undecideable) super-class relationships.xA temporary extension to help library authors check if their code will compile with the new planned desugaring of fail. A subset of TemplateHaskell including only quasi-quoting.Allows use of the #label syntax.WAllow functional dependency annotations on type families to declare them as injective.2This represents language extensions beyond a base  definition (such as L) that are supported by some implementations, usually in some special mode.VWhere applicable, references are given to an implementation's official documentation.Enable a known extensionDisable a known extension4An unknown extension, identified by the name of its LANGUAGE pragma.+This represents a Haskell language dialect. Language ;s are interpreted relative to one of these base languages.>The Haskell 98 language as defined by the Haskell 98 report. http://haskell.org/onlinereport/BThe Haskell 2010 language as defined by the Haskell 2010 report. /http://www.haskell.org/onlinereport/haskell2010,An unknown language, identified by its name._Extensions that have been deprecated, possibly paired with another extension that replaces it. for s is really really slow so for the Text instance what we do is make a simple table indexed off the first letter in the extension name. The extension names actually cover the range 'A'-'Z'q pretty densely and the biggest bucket is 7 so it's not too bad. We just do a linear search within each bucket.This gives an order of magnitude improvement in parsing speed, and it'll also allow us to do case insensitive matches in future if we prefer.          w     -Isaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone16/ ;Compiler information used for resolving configurations. Some fields can be set to Nothing to indicate that the information is unknown.=Compiler flavour and version.>GTag for distinguishing incompatible ABI's on the same architecture/os.?QOther implementations that this compiler claims to be compatible with, if known.@'Supported language standards, if known.ASupported extensions, if known.RLike Q* but compatible with the old ReadS parser.IIt is compatible in the sense that it accepts only the same strings, eg GHC4 but not "ghc". However other strings get mapped to P . The point of this is that we do not allow extra valid values that would upset older Cabal versions that had a stricter parser however we cope with new values more gracefully so that we'll be able to introduce new value in future without breaking things so much.UvThe default compiler flavour to pick when compiling stuff. This defaults to the compiler used to build the Cabal lib.4However if it's not a recognised compiler then it's = and the user will have to specify which compiler they want.WMake a CompilerInfo of which only the known information is its CompilerId, its AbiTag and that it does not claim to be compatible with other compiler id's. 8:9;<=>?@ABCDEFLMNOGHIJKPQRSTUVW DEFGHIJKLMNOPTSURQBC;<=>?@AW89:V89:;<=>?@ABCD EFGHIJKLMNOP"(c) The University of Glasgow 2004BSD3cabal-devel@haskell.orgportableNoneȁPretty-print free-format text, ensuring that it is vertically aligned, and with blank lines replaced by dots for correct re-parsing.r breaks a string up into a list of strings at newline characters. The resulting strings do not contain newlines.(the indentation used for pretty printing"(c) The University of Glasgow 2004BSD3cabal-devel@haskell.orgportableNoneQV We parse generically based on indent level and braces '{' '}'. To do that we split into lines and then '{' '}' tokens and other spans within a line.The  token is for bits that start a line, eg: "\n blah blah { blah" tokenises to: 8[Line n 2 False "blah blah", OpenBracket, Span n "blah"]cso lines are the only ones that can have nested layout, since they have a known indentation level.eg: we can't have this: if ... { } else otherubecause other cannot nest under else, since else doesn't start a line so cannot have nested layout. It'd have to be: if ... { } else other]but that's not so common, people would normally use layout or brackets not both in a single if else construct. "if ... { foo : bar } else other this is OK"span in a line, following brackets A regular  property: value fieldKA section with a name and possible parameter. The syntactic structure is:   sectionname  arg {  field* } 1A conditional block with an optional else branch:  if  condition {  field* } else {  field* } 4The type of a function which, given a name-value pair of an unrecognized field, and the current structure being built, decides whether to incorporate the unrecognized field (by returning Just x, where x is a possibly modified version of the structure being built), or not (by returning Nothing).q!Field descriptor. The parameter a< parameterizes over where the field's value is stored in.ufieldSet n str x5 Parses the field value from the given input string str and stores the result in xK if the parse was successful. Otherwise, reports an error on line number n.A default unrecognized field parser which simply returns Nothing, i.e. ignores all unrecognized fields, so warnings will be generated.A default unrecognized field parser which silently (i.e. no warnings will be generated) ignores unrecognized fields, by returning the structure being built unmodified.Tokenise a single line, splitting on '{' '}' and the spans in between. Also trims leading & trailing space on those spans within the line.HParse the stream of tokens into a tree of them, based on indent / layoutParse the stream of tokens into a tree of them, based on indent This parse state expect to be in a layout context, though possibly nested within a braces context so we may still encounter closing braces.}Parse the stream of tokens into a tree of them, based on explicit braces This parse state expects to find a closing bracket.\Convert the parse tree into the Field AST Also check for dodgy uses of tabs in indentation. Convert ifthenelse s to sparse a module name(indent level of the parent/previous line'accumulating param, trees in this levelremaining tokens1collected trees on this level and trailing tokens(line of the '{', used for error messages'accumulating param, trees in this levelremaining tokens1collected trees on this level and trailing tokens'The parser for the stuff between commas'The parser for the stuff between commas'The parser for the stuff between commas'The parser for the stuff between commasLqrstuvwxyz{|}~qrstuvwxyz{|}~1None16KA package name.Use  and  to convert from/to a >.This type is opaque since  Cabal-2.0Convert  to > Construct a  from a > is the inverse to ANote: No validations are performed to ensure that the resulting  is valid2None16K*9An unqualified component name, for any kind of component.This is distinguished from a  ComponentName and  ComponentId. The former also states which of a library, executable, etc the name refers too. The later uniquely identifiers a component and its closure.Convert  to > Construct a  from a > is the inverse to ANote: No validations are performed to ensure that the resulting  is valid8Converts a package name to an unqualified component namewUseful in legacy situations where a package name may refer to an internal component, if one is defined with that name.8Converts an unqualified component name to a package name is the inverse of .wUseful in legacy situations where a package name may refer to an internal component, if one is defined with that name.3None16}This gets the underlying unqualified component name. In fact, it is guaranteed to uniquely identify a component, returning Nothing if the  was for the public library. Convert the  of a library into a .  4None16KZ"The name and version of a package.!The name of this package, eg. foo#the version of this package, eg 1.24Type alias so we can use the shorter name PackageId.5None16K8 A  for a definite package. The  invariant says that a B identified this way is definite; i.e., it has no unfilled holes.A unit identifier identifies a (possibly instantiated) package/component that can be installed the installed package database. There are several types of components that can be installed:-A traditional library with no holes, so that  unitIdHash is Nothing. In the absence of Backpack,  is the same as a Y.?An indefinite, Backpack library with holes. In this case,  unitIdHash is still NothingI, but in the install, there are only interfaces, no compiled objects.DAn instantiated Backpack library with all the holes filled in.  unitIdHash is a Just) a hash of the instantiating mapping.A unit is a component plus the additional information on how the holes are filled in. Thus there is a one to many relationship: for a particular component there are many different ways of filling in the holes, and each different combination is a unit (and has a separate ). is distinct from  OpenUnitId+, in that it is always installed, whereas  OpenUnitId are intermediate unit identities that arise during mixin linking, and don't necessarily correspond to any actually installed unit. Since the mapping is not actually recorded in a H, you can't actually substitute over them (but you can substitute over  OpenUnitId). See also  Distribution.Backpack.FullUnitId0 for a mechanism for expanding an instantiated  to retrieve its mapping.lBackwards compatibility note: if you need to get the string representation of a UnitId to pass, e.g., as a  -package-id flag, use the A5 function, which will work on all versions of Cabal.4If you need backwards compatibility, consider using A7 instead, which is supported by all versions of Cabal.@Create a unit identity with no associated hash directly from a Y.YMake an old-style UnitId from a package identifier. Assumed to be for the public library=Returns library name prefixed with HS, suitable for filenamesUnsafely create a  from a .. Your responsibility is to ensure that the  invariant holds.The textual format for , coincides with the format GHC accepts for  -package-id.  6None16K@HA module identity uniquely identifies a Haskell module by qualifying a p with the 4 which defined it. This type distinguishes between two packages which provide a module with the same name, or a module from the same package compiled with different dependencies. There are a few cases where Cabal needs to know about module identities, e.g., when writing out reexported modules in the InstalledPackageInfo.7None16;=KQVj$An explicit substitution on modules.cNB: These substitutions are NOT idempotent, for example, a valid substitution is (A -> B, B -> A). Unlike a , an 5 is either an ordinary module from some unit, OR an ], representing a hole that needs to be filled in. Substitutions are over module variables.An  describes a (possibly partially) instantiated Backpack component, with a description of how the holes are filled in. Unlike , the  ModuleSubst is kept in a structured form that allows for substitution (which fills in holes.) This form of unit cannot be installed. It must first be converted to a .In the absence of Backpack, there are no holes to fill, so any such component always has an empty module substitution; thus we can lossly represent it as an 'OpenUnitId uid'.For a source component using Backpack, however, there is more structure as components may be parametrized over some signatures, and these "holes" may be partially or wholly filled.OpenUnitId plays an important role when we are mix-in linking, and is recorded to the installed packaged database for indefinite packages; however, for compiled packages that are fully instantiated, we instantiate  into .(For more details see the Backpack spec Qhttps://github.com/ezyang/ghc-proposals/blob/backpack/proposals/0000-backpack.rstKIdentifies a component which may have some unfilled holes; specifying its Y and its . TODO: Invariant that + is non-empty? See also the Text instance.mIdentifies a fully instantiated component, which has been compiled and abbreviated as a hash. The embedded . MUST NOT be for an indefinite component; an & is guaranteed not to have any holes.Get the set of holes ( ModuleVar) embedded in a .eSafe constructor from a UnitId. The only way to do this safely is if the instantiation is provided. Create a  from a Y% and an instantiation with no holes.Get the set of holes ( ModuleVar) embedded in a .RPretty-print the entries of a module substitution, suitable for embedding into a  or passing to GHC via --instantiate-with.5Pretty-print a single entry of a module substitution. Inverse to  dispModSubst. Inverse to dispModSubstEntry.Get the set of holes ( ModuleVar) embedded in a .. This is NOT the domain of the substitution.@When typechecking, we don't demand that a freshly instantiated Y be compiled; instead, we just depend on the installed indefinite unit installed at the Y.CTake a module substitution and hash it into a string suitable for . Note that since this takes , not 2, you are responsible for recursively converting  into  . See also $Distribution.Backpack.ReadyComponent.8None;=l 2Applying module substitutions to semantic objects.      9None6l:None16ml;None16m'()*'()*'()*<None16oJ36Describes a dependency on an executable from a package34534534=None16q6>0Describes a dependency on a source package (API)D Simplify the  expression in a >. See $.>?@ABCD>?@ABCD>?>None16u PIs this a default 'custom-setup' section added by the cabal-install code (as opposed to user-provided)? This field is only used internally, and doesn't correspond to anything in the .cabal file. See #3199.MNOPMNOPMNOP?NonewYtA map of dependencies. Newtyped since the default monoid instance is not appropriate. The monoid instance uses .\ Input mapExtra constraintsYZ[\YZ[\Y"(c) The University of Glasgow 2004BSD3cabal-devel@haskell.orgportableNone{ This is a indeed a munged package id, but the constructor name cannot be changed or the Read instance (the entire point of this type) will break.       NoneHINVARIANT: entries for ModuleName m, have msrc_module is OpenModuleVar mEvery Module in scope at a p is annotated with the  it comes from.A l 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 pV; this is only an error if we attempt to use those modules to fill a requirement. A  can influence the  ModuleShape via a reexport. An empty . !"#$% !"#$%@None16KatA combination of a package and component name used in various legacy interfaces, chiefly bundled with a version as MungedPackageId". It's generally better to use a UnitId to opaquely refer to some compilation/packing unit, but that doesn't always work, e.g. where a "name" is needed, in which case this can be used as a fallback.Use c and b to convert from/to a >.bConvert a to >c Construct a a from a >c is the inverse to bANote: No validations are performed to ensure that the resulting a is validdComputes the package name for a library. If this is the public library, it will just be the original package name; otherwise, it will be a munged package name recording the original package name as well as the name of the internal library.A lot of tooling in the Haskell ecosystem assumes that if something is installed to the package database with the package name fooJ, then it actually is an entry for the (only public) library in package foo. With internal packages, this is not necessarily true: a public library as well as arbitrarily many internal libraries may come from the same package. To prevent tools from getting confused in this case, the package name of these internal libraries is munged so that they do not conflict the public library proper. A particular case where this matters is ghc-pkg: if we don't munge the package name, the inplace registration will OVERRIDE a different internal library.We munge into a reserved namespace, "z-", and encode both the component name and the package name of an internal library using the following format:8compat-pkg-name ::= "z-" package-name "-z-" library-namedwhere package-name and library-name have "-" ( "z" + ) "-" segments encoded by adding an extra "z".cWhen we have the public library, the compat-pkg-name is just the package-name, no surprises there!icabcdeabcdea&ANone16KpA simple pair of a a and . a is to p as  PackageName is to . See a for more info.r@The combined package and component name. see documentation for a.s/The version of this package / component, eg 1.2t See docs for @&. this is a thin wrapper around that.pqrstpqrstpqrsBIsaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone16K~Class of installed packages.?The primary data type which is an instance of this package is InstalledPackageInfo, but when we are doing install plans in Cabal install we may have other, installed package-like things which contain more metadata. Installed packages have exact dependencies .'Packages that have an installed unit IDClass of things that have a Types in this class are all notions of a package. This allows us to have different types for the different phases that packages go though, from simple name/id, package description, configured or installed packages.;Not all kinds of packages can be uniquely identified by a n. In particular, installed packages cannot, there may be many installed instances of the same source package.)Compatibility wrapper for Cabal pre-1.24.1LMNYZ[fgh>?@ABCD~ ~~CNoneAn  is a Y, i, etc. which is annotated with some other useful information that is useful for printing to users, etc.DNoneDDid this come from an entry in mixins", or was implicitly generated by  build-depends?This should always return  or EIsaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone36<QV!The $prefix path variableThe $bindir path variableThe $libdir path variableThe  $libsubdir path variableThe  $dynlibdir 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_64:The Compiler's ABI identifier, $arch-$os-$compiler-$abitag%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_An abstract path, possibly containing variables that need to be substituted for to get a real .The location prefix for the copy command.)The installation directories in terms of s that contain variables.The defaults for most of the directories are relative to each other, in particular they are all relative to a single prefix. This makes it convenient for the user to override the default installation directory by only having to specify --prefix=... rather than overriding each individually. This is done by allowing $-style variables in the dirs. These are expanded by textual substitution (see ).A few of these installation directories are split into two components, the dir and subdir. The full installation path is formed by combining the two together with /Y. The reason for this is compatibility with other Unix build systems which also support --libdir and  --datadir/. We would like users to be able to configure --libdir=/usr/lib64 for example but because by default we want to support installing multiple versions of packages and building the same package for multiple compilers we append the libsubdir to get: /usr/lib64/$libname/$compiler.{An additional complication is the need to support relocatable packages on systems which support such things, like Windows.9The directories where we will install files for packages.We have several different directories for different types of files since many systems have conventions whereby different types of files in a package are installed in different directories. This is particularly the case on Unix style systems.foreign libraries5Substitute the install dir templates into each other.To prevent cyclic substitutions, only some variables are allowed in particular dir templates. If out of scope vars are present, they are not substituted for. Checking for any remaining unsubstituted vars can be done as a subsequent operation.-The reason it is done this way is so that in  we can replace  with the  and get resulting s that still have the U in them. Doing this makes it each to check which paths are relative to the $prefix.Convert from abstract install directories to actual absolute ones by substituting for all the variables in the abstract paths, to get real absolute path.BCheck which of the paths are relative to the installation $prefix.If any of the paths are not relative, ie they are absolute paths, then it prevents us from making a relocatable package (also known as a "prefix independent" package). Convert a  to a  including any template vars.7Convert back to a path, any remaining vars are included=The initial environment has all the static stuff but no paths??'()*FNone16Describes a legacy  `build-tools`"-style dependency on an executableIt is "legacy" because we do not know what the build-tool referred to. It could refer to a pkg-config executable (PkgconfigName), or an internal executable (UnqualComponentName). Thus the name is stringly typed.GNone16>component is buildable here | Tools needed to build this bit.CThis is a legacy field that "build-tool-depends" larely supersedes.CUnless use are very sure what you are doing, use the functions in , rather than accessing this field directly.&Haskell tools needed to build this bitoThis field is better than "build-tools" because it allows one to precisely specify an executable in a package.CUnless use are very sure what you are doing, use the functions in , rather than accessing this field directly.'options for pre-processing Haskell codeoptions for C compiler options for linker !pkg-config packages that are used support frameworks for Mac OS X #extra locations to find frameworks..where to look for the Haskell module hierarchynon-exposed or non-main modulesFnot present on sdist, Paths_* or user-generated with a custom Setup.hs+language used when not explicitly specified'other languages used within the package'language extensions used by all modules1other language extensions used within the package*the old extensions field, treated same as Kwhat libraries to link with when compiling a program that uses your packageAif present, overrides extraLibs when package is loaded with GHCi.directories to find .h files'The .h files to be found in includeDirs$.h files to install with the package @Custom fields starting with x-, stored in a simple assoc-list.!7Dependencies specific to a library or executable target$The s used by this component%The +s that are used somewhere by this component&The  Extensions/ that are used by all modules in this component'1Select options for a particular Haskell compiler.(      !"#$%&'()(      !"#$%&'()       !"HNone16}2&A "test-suite" stanza in a cabal file.9+Get all the module names from a test suite.:QGet all the auto generated module names from a test suite. This are a subset of 9. 23456789: 23456789:23456INone16(~HWhat sigs need implementations?I$Is the lib to be exposed by default?LNGet all the module names from the library (exposed and internal modules) which are explicitly listed in the package description which would need to be compiled. (This does not include reexports, which do not need to be compiled.) This may not include all modules for which GHC generated interface files (i.e., implicit modules.)M`Get all the auto generated module names from the library, exposed or not. This are a subset of N.N!Backwards-compatibility shim for L%. In most cases, you actually want  allLibModules, which returns all modules that will actually be compiled, as opposed to those which are explicitly listed in the package description (L*); unfortunately, the type signature for  allLibModules" is incompatible since we need a ComponentLocalBuildInfo. CDEFGHIJKLMN CDEFGHIJKLMNCDEFGHIJJNone16PLWW2 is mechanism that hooks can use to override the s inside packages. One example use-case (which is used in core libraries today) is as a way of passing flags which are computed by a configure script into Cabal. In this case, the autoconf build type adds hooks to read in a textual W' format prior to doing any operations.TQuite honestly, this mechanism is a massive hack since we shouldn't be editing the PackageDescription data structure (it's easy to assume that this data structure shouldn't change and run into bugs, see for example 1c20a6328579af9e37677d507e2e9836ef70ab9d). But it's a bit convenient, because there isn't another data structure that allows adding extra  style things.=In any case, a lot of care has to be taken to make sure the W is applied to the PackageDescription&. In general this process occurs in Distribution.SimpleV, which is responsible for orchestrating the hooks mechanism. The general strategy: &We run the pre-hook, which produces a WD (e.g., in the Autoconf case, it reads it out from a file).4We sanity-check the hooked build info with sanityCheckHookedBuildInfo.We update our PackageDescription. (either freshly read or cached from LocalBuildInfo) with updatePackageDescription.FIn principle, we are also supposed to update the copy of the PackageDescription stored in LocalBuildInfo at  localPkgDescrm. Unfortunately, in practice, there are lots of Custom setup scripts which fail to update  localPkgDescr so you really shouldn't rely on it. It's not DEPRECATED because there are legitimate uses for it, but... yeah. Sharp knife. See  ,https://github.com/haskell/cabal/issues/3606, for more information on the issue.*It is not well-specified whether or not a W1 applied at configure time is persistent to the LocalBuildInfo. The fact that W is passed to confHook MIGHT SUGGEST that the W is applied at this time, but actually since 9317b67e6122ab14e53f81b573bd0ecb388eca5a it has been ONLY used to create a modified package description that we check for problems: it is never actually saved to the LBI. Since W is applied monoidally to the existing build infos (and it is not an idempotent monoid), it could break things to save it, since we are obligated to apply any new Wy and then we'd get the effect twice. But this does mean we have to re-apply it every time. Hey, it's more flexibility.WXWXKNone16hZA foreign library stanza is like a library stanza, except that the built code is intended for consumption by a non-Haskell client.\Name of the foreign library]9What kind of foreign library is this (static or dynamic).^_What options apply to this foreign library (e.g., are we merging in all foreign dependencies.)_+Build information for this foreign library.`Libtool-style version-info data to compute library version. Refer to the libtool documentation on the current:revision:age versioning scheme.aLinux library versionb*(Windows-specific) module definition files{This is a list rather than a maybe field so that we can flatten the condition trees (for instance, when creating an sdist)c Construct Y from (current, revision, age) numbers.For instance, mkLibVersionInfo (3,0,0) constructs a Y representing the version-info 3:0:0.,All version components must be non-negative.d From a given Y, extract the (current, revision, age) numbers.e&Given a version-info field, produce a major.minor.build versionf#Given a version-info field, return "major.minor.build" as a >g Return the major! version of a version-info field.hAn empty foreign library.i%Modules defined by a foreign library.jIs the foreign library shared?k1Get a version number for a foreign library. If we're on Linux, and a Linux version is specified, use that. If we're on Linux, and libtool-style version-info is specified, translate that field into appropriate version numbers. Otherwise, this feature is unsupported so we don't return any version data.YZ[\]^_`abcdefghijkZ[\]^_`abhijkYcdefgY+Z[\]^_`abLNone16k$Get all the module names from an exeJGet all the auto generated module names from an exe This are a subset of . |}~ |}~|}~MNone16o%A "benchmark" stanza in a cabal file.*Get all the module names from a benchmark.PGet all the auto generated module names from a benchmark. This are a subset of .  NNone6r0Is a component buildable (i.e., not marked with buildable: False)? See also this note in IDistribution.Types.ComponentRequestedSpec#buildable_vs_enabled_components.  ONone6~0A reason explaining why a component is disabled.SDescribes what components are enabled by user-interaction. See also this note in IDistribution.Types.ComponentRequestedSpec#buildable_vs_enabled_components.fThe default set of enabled components. Historically tests and benchmarks are NOT enabled by default.3Is this component enabled? See also this note in IDistribution.Types.ComponentRequestedSpec#buildable_vs_enabled_components.8Is this component name enabled? See also this note in IDistribution.Types.ComponentRequestedSpec#buildable_vs_enabled_components.+Is this component disabled, and if so, why?,0Is this component name disabled, and if so, why?PIsaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone16<QV:This data type is the internal representation of the file  pkg.cabal. It contains two kinds of information about the package: information which is needed for all packages, such as the package name and version, and information which is needed for the simple build system only, such as the compiler options and library name."A one-line summary of this package*A more verbose description of this package@Custom fields starting with x-, stored in a simple assoc-list.#YOU PROBABLY DON'T WANT TO USE THIS FIELD. This field is special! Depending on how far along processing the PackageDescription we are, the contents of this field are either nonsense, or the collected dependencies of *all* the components in this package. buildDepends is initialized by  finalizePD and flattenPackageDescription3; prior to that, dependency info is stored in the CondTree built around a GenericPackageDescriptionK. When this resolution is done, dependency info is written to the inner \ and this field. This is all horrible, and #2066 tracks progress to get rid of this field.The version of the Cabal spec that this package description uses. For historical reasons this is specified with a version range but only ranges of the form >= vf make sense. We are in the process of transitioning to specifying just a single version, not a range.OThe version of the Cabal spec that this package should be interpreted against.Historically we used a version range but we are switching to using a single version. Currently we accept either. This function converts into a single version by ignoring upper bounds in the version range.UThe range of versions of the Cabal tools that this package is intended to work with.This function is deprecated and should not be used for new purposes, only to support old packages that rely on the old interpretation.2Does this package have a buildable PUBLIC library?%Does this package have any libraries?If the package description has a buildable library section, call the given function with the library build info as argument. You probably want  withLibLBI if you have a LocalBuildInfo, see the note in IDistribution.Types.ComponentRequestedSpec#buildable_vs_enabled_components for more information.'does this package have any executables?%Perform the action on each buildable |1 in the package description. You probably want  withExeLBI if you have a LocalBuildInfo, see the note in IDistribution.Types.ComponentRequestedSpec#buildable_vs_enabled_components for more information.'Does this package have any test suites?$Perform an action on each buildable 2" in a package. You probably want  withTestLBI if you have a LocalBuildInfo, see the note in IDistribution.Types.ComponentRequestedSpec#buildable_vs_enabled_components for more information.&Does this package have any benchmarks?$Perform an action on each buildable " in a package. You probably want  withBenchLBI if you have a LocalBuildInfo, see the note in IDistribution.Types.ComponentRequestedSpec#buildable_vs_enabled_components for more information.-Does this package have any foreign libraries?%Perform the action on each buildable Z in the package description.The  for the library (if there is one and it's buildable), and all buildable executables, test suites and benchmarks. Useful for gathering dependencies.Return all of the Os of enabled components, i.e., all of the ones that would be built if you run  ./Setup build."All the components in the package.XA list of all components in the package that are buildable, i.e., were not marked with buildable: FalseQ. This does NOT indicate if we are actually going to build the component, see  instead.9A list of all components in the package that are enabled.88 QNone16 A ConfVar# represents the variable type used.A " is a total or partial mapping of s to j flag values. It represents the flags chosen by the user or discovered during configuration. For example --flags=foo --flags=-bar becomes [("foo", True), ("bar", False)]A 1 is the name of a user-defined configuration flagUse  and  to convert from/to a >.This type is opaque since  Cabal-2.0A flag can represent a feature to be included, or a way of linking a target against its dependencies, or in fact whatever you can think of.A % initialized with default parameters. Construct a  from a > is the inverse to ANote: No validations are performed to ensure that the resulting  is validConvert  to >+String representation of a flag-value pair. Pretty-prints a flag assignment.Parses a flag assignment.          -     Isaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone16y     JKLMNVWXYlmnowxyMNOP      !"#$%&'()23456789:CDEFGHIJKLMNWX|}~     CDEFGHIJKLMN|}~23456VWXYJKLM8N79:wxylmno      !"#$%&'()WX          MNOPRNone4ODesugar a "build-tools" entry into proper a executable dependency if possible.*An entry can be so desguared 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.5mGet everything from "build-tool-depends", along with entries from "build-tools" that we know how to desugar.AThis should almost always be used instead of just accessing the  field directly.6ADoes 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 B}) 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.7DGet 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 6 also apply to this function.45674567/"(c) The University of Glasgow 2004libraries@haskell.orgportableNone16FT ,8QAn ABI dependency is a dependency on a library which also records the ABI hash (R ) of the library it depends on.SThe primary utility of this is to enable an extra sanity when GHC loads libraries: it can check if the dependency has a matching ABI and if not, refuse to load this library. This information is critical if we are shadowing libraries; differences in the ABI hash let us know what packages get shadowed by the new version of a package.Z overrides YkGet the indefinite unit identity representing this package. This IS NOT guaranteed to give you a substitution; for instantiated packages you will get $DefiniteUnitId (installedUnitId ipi)A. For indefinite libraries, however, you will correctly get an  OpenUnitId with the appropriate .lReturns the set of module names which need to be filled for an indefinite package, or the empty set if the package is definite.m,Backwards compatibility with Cabal pre-1.24.KThis type synonym is slightly awful because in cabal-install we define an ' but it's a ComponentId, not a UnitId!.Returns Just if the named field of the IPI record would not contain the package name verbatim. This helps us avoid writing  package-name when it's redundant./Setter for the  package-name9 field. It should be acceptable for this to be a no-op.05Returns the munged package name, which we write into name- for compatibility with old versions of GHC.Fvwxyz{|}~89:;<=>?@ACi_Rcdf`UHIJKLMNOPQ[BDEFGSTVWXYZ\]^abeghjklmnopqrstF@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghimjkol<=>?89:;vwxz{|}~ynpqrst89:;<=>?@)ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghiSNone6FT* ?The first five fields are common across all algebraic variants.NIt would be very convenient to store the literal Library here, but if we do that, it will get serialized (via the Binary) instance twice. So instead we just provide the ComponentName, which can be used to find the Component in the PackageDescription. NB: eventually, this will NOT uniquely identify the ComponentLocalBuildInfo. The computed Y of this component. The computed = which uniquely identifies this component. Might be hashed.:Is this an indefinite component (i.e. has unfilled holes)?"How the component was instantiatedMResolved internal and external package dependencies for this component. The  specifies a set of build dependencies that must be satisfied in terms of version ranges. This field fixes those dependencies to the specific versions available on this machine for this compiler.QThe set of packages that are brought into scope during compilation, including a P which may used to hide or rename modules. This is what gets translated into  -package-id. arguments. This is a modernized version of ', which is kept around for BC purposes.7The internal dependencies which induce a graph on the 0 of this package. This does NOT coincide with  because it ALSO records  'build-tool'. dependencies on executables. Maybe one day  cabal-install& will also handle these correctly too!BCompatibility "package key" that we pass to older versions of GHC.@Compatibility "package name" that we register this component as.dA list of exposed modules (either defined in this component, or reexported from another component.)qConvenience field, specifying whether or not this is the "public library" that has the same name as the package.1.TNoneFT1The T contains all the information necessary to build a specific target (e.g., componentmodule4file) in a package. In principle, one can get the  from a  and LocalBuildInfo@, but it is much more convenient to have the component in hand."(c) The University of Glasgow 2004BSD3cabal-devel@haskell.orgportableNone81BThis is the InstalledPackageInfo type used by ghc-6.4.2 and later.It's here purely for the  instance so that we can read the package database used by those ghc versions. It is a little hacky to read the package db directly, but we do need the info and until ghc-6.9 there was no better method.@In ghc-6.4.1 and before the format was slightly different. See Distribution.Simple.GHC.IPI642123456789:;<=>?@ABCDEFGHIJKLMNO129:;<=>?@ABC8DEFGHI37JN45K6LMUNone6<A L describes the provisions and requirements of a library. We can extract a  from an @.AThe default module shape, with no provisions and no requirements.NoneQVYLPThe mutable counterpart of QThe mutable counterpart of .RThe mutable counterpart of a  ModuleSubst (not defined here).S!An integer for uniquely labeling TA nodes. We need these labels in order to efficiently serialize Ts 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 'UnitId's/'Module'$s which participate in unification!TA mutable version of # which can be imperatively unified.UA mutable version of # which can be imperatively unified.VContents of a mutable T reference.WContents of a mutable U reference.XCA convenient alias for mutable references in the unification monad.YThe unification environment.Z%A supply of unique integers to label Th cells. This is used to determine loops in unit identifiers (which can happen with mutual recursion.)[The 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.\'How verbose the error message should be]The error reporting context^0The package index for expanding unit identifiers_Accumulated errors`GThe unification monad, this monad encapsulates imperative unification.a+Run a computation in the unification monad.bLift a computation from c monad to ` monad. Internal use only.dImperatively read a X.eImperatively write a X.f(Get the current unification environment.g)Add a fixed message to the error context.hAAdd a message to the error context. It may make monadic queries.iConversion of  ModuleSubst to RjConversion of R to  ModuleSubstk An empty Q.l Convert a  into a Q", so we can do unification on it.m Convert a Q to a .n Convert a  to a Po Convert a P to a .pqrstuvQRTUVwxWyzY{Z[\]^_`ab|}~fghijklmnopqrstuvVwxWyzY{Z[\]^_`NoneZ_/CGiven 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.NonefStripped down version of LinkedComponent0 for things we don't need to know how to build.7The actual name of the package. This may DISAGREE with pc_pkgid9 for internal dependencies: e.g., an internal component lib may be munged to  z-pkg-z-lib+, but we still want to use it when we see lib in  build-depends!The actual name of the component. Convert an @ into a *, which was brought into scope under the 0 (important for a package qualified reference.) SafegT #Isaac Jones, Simon Marlow 2003-2004=BSD3 portions Copyright (c) 2007, Galois Inc.cabal-devel@haskell.orgportableNone6<QVEAdvanced options for  and .Keep temporary files?%No glob at all, just an ordinary filedir prefix and extension, like "foo/bar/*.baz" corresponds to FileGlob "foo/bar" ".baz"/When should we output the marker? Things like  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.Tag an = whose error string should be output to the screen verbatim. Check if an % should be output verbatim to screen. Create a ) whose error text will be output verbatimGiven 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.)BC wrapper around !.CNon fatal conditions that may be indicative of an error or problem.We display these at the  verbosity level.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.Display a message at ( verbosity level, but without wrapping.Pretty-print a  status message at : verbosity level. Use this if you need fancy formatting.KDisplay a "setup status message". Prefer using setupMessage' if possible.,More detail on the operation of some action.6We display these messages when the verbosity level is 'Detailed internal debugging information6We display these messages when the verbosity level is  A variant of Y that doesn't perform the automatic line wrapping. Produces better output in some cases.XPerform an IO action, catching any IO exceptions and printing an error if one occurs.!Run an IO computation, returning e- if it raises a "file does not exist" error.Wraps text unless the +nowrap verbosity flag is activeWrap 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 j; 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.VAppend a trailing newline to a string if it does not already have a trailing newline.8Prepend a call-site and/or call-stack based on VerbositybDetermine if we should emit a call stack. If we trace, it also emits any prefix we should append./Add all necessary metadata to a logging message$Run a command and return its output.8The output is assumed to be text in the locale encoding.Run a command and return its output, errors and exit status. Optionally also supply some input. Also provides control over whether the binary/text mode of the input and output.Look for a program on the path.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.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 bigArgsJFind 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 x but returns which element of the search path the file was found in, and the file path relative to that base directory.@Finds the files corresponding to a list of Haskell module names.As  but for a list of module names.5Find the file corresponding to a Haskell module name.This is similar to j but specialised to a module name. The function fails if the file corresponding to the module is missing.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.,Is this directory in the system search path?(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.Like -, but also checks that the first file exists.Same as createDirectoryIfMissing% but logs at higher verbosity levels.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.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.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.EInstall a file that may or not be executable, preserving permissions.Given a relative path to a file, copy it to the given directory, preserving the relative path and creating the parent directories if needed.Common implementation of , ,  and .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: RcopyFiles normal "dist/src" [("", "src/Foo.hs"), ("dist/build/", "src/Bar.hs")]qThis 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. This is like  but uses . This is like  but uses . This is like  but uses .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.?Recursively copy the contents of one directory to another path.Like ., but also checks that the file is executable.4Use a temporary filename that doesn't already exist. A version of  that additionally takes a  argument.%Create and use a temporary directory.Creates a new temporary directory inside the given directory, making use of the template. The temp directory is deleted after use. For example: >withTempDirectory verbosity "src" "sdist." $ \tmpDir -> do ...The tmpDir: will be a new subdirectory of the given directory, e.g.  src/sdist.342. A version of  that additionally takes a  argument.See 5This function is provided for backwards-compatibilityWrite 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: the file is assumed to be ASCII-encoded.DThe path name that represents the current directory. In Unix, it's "."D, but this is system-specific. (E.g. AmigaOS uses the empty string "" for the current directory.)"Drop the extension if it's one of  , or return the path unchanged.DList of possible executable file extensions on the current platform.Package description file (pkgname.cabal)DFind a package description file in the given directory. Looks for .cabal files.Like  , but calls  in case of error. -Optional auxiliary package information file (pkgname .buildinfo) FFind auxiliary package information in the given directory. Looks for  .buildinfo files. .a description of the action we were attemptingthe action itselfNew working dir or inheritNew environment or inheritstdinstdoutstderrNew working dir or inheritNew environment or inheritstdinstdoutstderr7Any handles created for stdin, stdout, or stderr with  CreateProcess, and a handle to the process.Program location ArgumentsNew working dir or inheritNew environment or inheritinput text and binary modeoutput in binary modeoutput, errors, exit version args8function to select version number from program outputlocationsearch locations File Name"build prefix (location of objects)search suffixesmodules"build prefix (location of objects)search suffixesmoduleCreate its parents too?Temp dir to create the file inFile name template. See  .Temp dir to create the file inFile name template. See  . Where to look pkgname.cabal Directory to searchdir/pkgname .buildinfo , if presentw;?B  w  B?;VNone1  %NubListR : A right-biased version of  . That is +toNubListR ["-XNoFoo", "-XFoo", "-XNoFoo"] will result in ["-XFoo", "-XNoFoo"], unlike the normal ), which is left-biased. Built on top of  and .ANubList : A de-duplicated list that maintains the original order.'Smart constructor for the NubList type.7Lift a function over lists to a function over NubLists.1Helper used by NubList/NubListR's Read instances.(Smart constructor for the NubListR type.8Lift a function over lists to a function over NubListRs.>Binary instance for 'NubList a' is the same as for '[a]'. For c6, we just pull off constructor and put the list. For b, we get the list and make a  out of it using .Monoid operations on NubLists. For a valid Monoid instance we need to satistfy 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)dClosure : appending two lists of type a and removing duplicates obviously does not change the type.        WNone<KQVFThe 44 monad with specialized logging and error messages. Run !, outputting traces according to ,  if there is an error.!"Output a warning trace message in .")Output an informational trace message in .#+Fail the computation with an error message.:Format a message with context. (Something simple for now.)$+Add a message to the error/warning context. !"#$ !"#$XDuncan Coutts 2013cabal-devel@haskell.orgportableNone6<QV.)A specific dir*The system default+OA search path to use when locating executables. This is analogous to the unix $PATH or win32 %PATH%Q but with the ability to use the system default method for finding executables () which on unix is simply looking on the $PATH* but on win32 is a bit more complicated).The default to use is [ProgSearchPathDefault] but you can add extra dirs either before, after or instead of the default, e.g. here we add an extra dir to search after the usual ones. 8['ProgramSearchPathDefault', 'ProgramSearchPathDir' dir]. Interpret a + to construct a new $PATHx env var. Note that this is close but not perfect because on Windows the search algorithm looks at more than just the %PATH%./=Get the system search path. On Unix systems this is just the $PATH6 env var, but on windows it's a bit more complicated.()*+,-./+()*,-./()*Y)Isaac Jones 2006, Duncan Coutts 2007-2009cabal-devel@haskell.orgportableNone16<QV[3Where 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.4HThe user gave the path to this program, eg. --ghc-path=/usr/bin/ghc-6.65$The program was found automatically.7KRepresents a program which has been configured and is thus ready to be run.(These are usually made by configuring a B=, but if you have to construct one directly then start with K and override any extra fields.9Just the name again:,The version of this program, if it is known.;Default command-line args for this program. These flags will appear first on the command line, so they can be overridden by subsequent flags.<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.?Location of the program. eg. /usr/bin/ghc-6.4@In addition to the ?" where the program was found, these are additional locations that were looked at. The combination of ths found location and these not-found locations can be used to monitor to detect when the re-configuring the program might give a different result (e.g. found in a different location).B-Represents a program which can be configured.9Note: rather than constructing this directly, start with J and override any extra fields.D'The simple name of the program, eg. ghcEzA function to search for the program if its location was not specified by the user. Usually this will just be a call to -.It is supplied with the prevailing search path which will typically just be used as-is, but can be extended or ignored as needed.For the purpose of change monitoring, in addition to the location where the program was found, it returns all the other places that were tried.FTry 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.GA 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.H&The full path of a configured program.I/Suppress any extra arguments added by the user.JMake 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: L(simpleProgram "foo") { programFindLocation = ... , programFindVersion ... }KMake a simple 7. 2simpleConfiguredProgram "foo" (FoundOnSystem path)()*+3456789:;<=>?@ABCDEFGHIJKBCDEFG+()*J789:;<=>?@HIA34566K345667 89:;<=>?@BCDEFGZDuncan Coutts 2009cabal-devel@haskell.orgportableNone<QVpmZ7Represents 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.ieReturn the current environment extended with the given overrides. If an entry is specified twice in  overrides%, the second entry takes precedence.jLike 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: I$ initial args_0 $ middle args_1 $ middle args_2 ... $ final args_nWXYZ[\]^_`abcdefghijZ[\]^_`abcWXYdefjghiWXYZ [\]^_`abc[Duncan Coutts 2009cabal-devel@haskell.orgportableNoneukoGenerate a system script, either POSIX shell script or Windows batch file as appropriate for the given system.l5Generate a POSIX shell script that invokes a program.m5Generate a Windows batch file that invokes a program.klmklm\Duncan Coutts 2009cabal-devel@haskell.orgportableNone<QVwnCall ld -r* to link a bunch of object files together.nn]Thomas Tuegel 2011cabal-devel@haskell.orgportableNone<QV#o%Invoke hpc with the given parameters.TPrior 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.oPath to .tix filePaths to .mix file directories(Path where html output should be located&List of modules to exclude from reportPath to .tix filePaths to .mix file directories)Path where html output should be located'List of modules to exclude from reportpPaths to .tix filesPath to resultant .tix file%List of modules to exclude from unionPaths to .tix filesPath to resultant .tix file%List of modules to exclude from unionopop^)Isaac Jones 2006, Duncan Coutts 2007-2009cabal-devel@haskell.orgportableNoneqUThe default list of programs. These programs are typically used internally to Cabal.qrstuvwxyz{|}~qrtsuvwxyz}~{|_)Isaac Jones 2006, Duncan Coutts 2007-2009cabal-devel@haskell.orgportableNone1<QVThe configuration is a collection of information about programs. It contains information both about configured programs and also about programs that we are yet to configure.The idea is that we start from a collection of unconfigured programs and one by one we try to configure them at which point we move them into the configured collection. For unconfigured programs we record not just the BC but also any user-provided arguments and location for the program.The 'Read'\/'Show' and d1 instances do not preserve all the unconfigured Programs because B is not in 'Read'\/'Show'D because it contains functions. So to fully restore a deserialised . use this function to add back all the known Bs.IIt does not add the default programs, but you probably want them, use q) in addition to any extra you might need./Add a known program that we may configure laterGet the current + used by the . This is the default list of locations where programs are looked for when configuring them. This can be overridden for specific programs (with f), and specific known programs can modify or ignore this search path in their own configuration code.Change the current + used by the }. This will affect programs that are configured from here on, so you should usually set it before configuring any programs.Modify the current + used by the . This will affect programs that are configured from here on, so you should usually modify it before configuring any programs.User-specify this path. Basically override any path information for this program in the configuration. If it's not a known program ignore it.User-specify the arguments for this program. Basically override any args information for this program in the configuration. If it's not a known program, ignore it..Like ) but for a list of progs and their paths.Like ( but for a list of progs and their args.FGet the path that has been previously specified for a program, if any.EGet any extra args that have been previously specified for a program. Try to find a configured program,Update a configured program in the database.List all configured programs.Try to configure a specific program. If the program is already included in the collection of unconfigured programs then we use any user-supplied location and arguments. If the program gets configured successfully it gets added to the configured collection.Note that it is not a failure if the program cannot be configured. It's only a failure if the user supplied a location and the program could not be found at that location.The reason for it not being a failure at this stage is that we don't know up front all the programs we will need, so we try to configure them all. To verify that a program was actually successfully configured use .$Configure a bunch of programs using  . Just a .rUnconfigure a program. This is basically a hack and you shouldn't use it, but it can be handy for making sure a  actually reconfigures.JTry to configure all the known programs that have not yet been configured.\reconfigure a bunch of programs given new user-specified args. It takes the same inputs as  and - and for all progs with a new path it calls .;Check that a program is configured and available to be run.lIt raises an exception if the program could not be configured, otherwise it returns the configured program.;Check that a program is configured and available to be run.mAdditionally check that the program version number is suitable and return it. For example you could require  or  ( [1,0] [])NIt returns the configured program, its version number and a possibly updated b. If the program could not be configured or the version is unsuitable, it returns an error value.Like O, but raises an exception in case of error instead of returning 'Left errMsg'.4Note that this instance does not preserve the known Bs. See  for details.4Note that this instance does not preserve the known Bs. See  for details.4Note that this instance does not preserve the known Bs. See  for details. Program name"user-specified path to the program Program nameuser-specified args`)Isaac Jones 2006, Duncan Coutts 2007-2009cabal-devel@haskell.orgportableNone<QV"Runs the given configured program.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. VerbosityThe program to runAny extra arguments to add VerbosityThe program to runAny extra arguments to add verbosityThe program to runlook up the program hereAny extra arguments to add verbosityThe program to runlook up the program hereAny extra arguments to addo()*+,-3456789:;<=>?@ABCDEFGHIJZ[\]^_`abcdefghqrtuvwxyz{|pBCDEFG+()*J-,789:;<=>?@HA34566IZ[\]^_`abcdefghqrtuvwxyz{|acabal-devel@haskell.orgportableNone<QVbp(c) David Himmelstrup 2005, Bjorn Bringert 2007, Duncan Coutts 2008-2009cabal-devel@haskell.orgportableNone6;<= 1.(We maintain the invariant that, for any =, there is only one instance of the package in our database.)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 Q, they can also be efficiently looked up by package name or by name and version.*Build an index out of a bunch of packages.If there are duplicates by $ then later ones mask earlier ones.Merge two indexes.SPackages 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 M. This is the mechanism we use to prefer user packages over global packages.(Inserts a single package into the index.8This is equivalent to (but slightly quicker than) using  or  with a singleton index.2Removes a single installed package from the index.3Backwards compatibility wrapper for Cabal pre-1.24.&Removes all packages with this source  from the index.DRemoves all packages with this (case-sensitive) name from the index.9NB: Does NOT delete internal libraries from this package.$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.AThey 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.!Does a lookup by unit identifier..Since multiple package DBs mask each other by (, then we get back at most one package.TDoes a lookup by component identifier. In the absence of Backpack, this is just a .+Backwards compatibility for Cabal pre-1.24.4Does a lookup by source package id (name & version).>There can be multiple installed packages with the same source  but different K. They are returned in order of preference, with the most preferred first.Convenient alias of 0, but assuming only one package per package ID.%Does a lookup by source package name.=Does a lookup by source package name and a range of versions.oWe get back any number of versions of the specified package name, all satisfying the version range constraint.VThis 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.oWe get back any number of versions of the specified package name, all satisfying the version range constraint.INVARIANT: List of eligible @ is non-empty./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.BThat is, all packages that contain the given string in their name.\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.HAll packages that have immediate dependencies that are not in the index.GReturns such packages along with the dependencies that they're missing.ATries 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.BTakes the transitive closure of the packages reverse dependencies. The given s must be in the index.+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 .LGiven 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.7A rough approximation of GHC's module finder, takes a c 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.$$cIsaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone16 iInSome 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.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: n[GlobalPackageDB] [GlobalPackageDB, UserPackageDB] [GlobalPackageDB, SpecificPackageDB "package.conf.inplace"]Note that the k 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.rSome 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 isloated environments of packages, for example to build a collection of related packages without installing them globally.Compiler flavour and version. GTag for distinguishing incompatible ABI's on the same architecture/os. GOther implementations that this compiler claims to be compatible with. Supported language standards. Supported extensions. ?A key-value map for properties not covered by the above fields. JIs 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. fcase compilerCompatVersion GHC compiler of Just (Version (7:_)) -> ... _ -> ... aReturn the package that we should register into. This is the package db at the top of the stack. Make package paths absolute BFor the given compiler, return the extensions it does not support. FFor the given compiler, return the flags for the supported extensions. 0Does this compiler support parallel --make mode? .Does this compiler support reexported-modules? >Does this compiler support thinning/renaming on package flags? :Does this compiler have unified IPIDs (so no package keys) (Does this compiler support package keys? $Does this compiler support unit IDs? $Does this compiler support Backpack? RDoes this compiler support a package database entry with: "dynamic-library-dirs"? 4Does this compiler support Haskell program coverage? %Does this compiler support profiling?&Utility function for GHC only features[8:9;<=>?@ABCDEFLMNOGHIJKPQRSTUVW                           !;                            !    dDuncan Coutts 2009, 2013cabal-devel@haskell.orgportableNone<QV  @+Additional variations in the behaviour for  S. B7Allows re-registering / overwriting an existing package CuInsist on the ability to register multiple instances of a single version of a single package. This will fail if the hc-pkg does not support it, see  M and  N. DRequire that no checks are performed on the existence of package files mentioned in the registration info. This must be used if registering prior to putting the files in their final place. This will fail if the hc-pkg does not support it, see  O. E6Information about the features and capabilities of an hc-pkg program. Hno package DB stack supported I'hc-pkg does not support verbosity flags J-use package-conf option instead of package-db K*supports directory style package databases L*requires directory style package databases M%supports --enable-multi-instance flag N#supports multi-instance via recache O$supports --force-files or equivalent PCall hc-pkg9 to initialise a package database at the location {path}. hc-pkg init {path} QRun hc-pkg` using a given package DB stack, directly forwarding the provided command-line arguments to it. R Defaults are True, False and False SCall hc-pkg to register a package. Ahc-pkg register {filename | -} [--user | --global | --package-db] TCall hc-pkg to unregister a package <hc-pkg unregister [pkgid] [--user | --global | --package-db] UCall hc-pkg$ to recache the registered packages. 1hc-pkg recache [--user | --global | --package-db] VCall hc-pkg to expose a package. 8hc-pkg expose [pkgid] [--user | --global | --package-db] WCall hc-pkg to retrieve a specific package :hc-pkg describe [pkgid] [--user | --global | --package-db] XCall hc-pkg to hide a package. 6hc-pkg hide [pkgid] [--user | --global | --package-db] YCall hc-pkgK to get all the details of all the packages in the given package database. ZCall hc-pkgQ to get the source package Id of all the packages in the given package database.(This is much less information than with  YL, but also rather quicker. Note in particular that it does not include the , just the source 3 which is not necessarily unique in any package db.$ @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c$ E F G H I J K L M N O @ A B C D R P Q S T U V X Y W Z [ \ ] ^ _ a b ` c @ A B C D E F G H I J K L M N Ocabal-devel@haskell.orgportableNone g dDInformation about features and quirks of a GHC-based implementation.Compiler flavors based on GHC behave similarly enough that some of the support code for them is shared. Every implementation has its own peculiarities, that may or may not be a direct result of the underlying GHC version. This record keeps track of these differences.All shared code (i.e. everything not in the Distribution.Simple.FLAVOR module) should use implementation info rather than version numbers to test for supported features. f"XHaskell2010 and -XHaskell98 flags g(-supported-languages gives Ext and NoExt h%NondecreasingIndentation is always on ighci-script flag supported jnew style -fprof-auto* flags k&use package-conf instead of package-db lg flag supported m picks up .ghc.environment files n"Wmissing-home-modules is supportedThe GHCJS versionThe GHC version d e k f g h i j l m n o d e f g h i j k l m nfDuncan Coutts 2007BSD3cabal-devel@haskell.org(non-portable (ExistentialQuantification)None<CQV L pwraps 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.(Common flags that apply to every command ~ Long command line option strings !Short command line option strings aAn OptionField takes one or more OptDescrs, describing the command line interface for the field. LWe 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. QThe name of the command as it would be entered on the command line. For example "build". BA short, one line description of the command to use in help texts. IA function that maps a program name to a usage summary for this command. ;Additional explanation of the command to use in help texts. +Post-Usage notes and examples in help texts Initial / empty flags &All the Option fields for this command zCreate an option taking a single OptDescr. No explicit Name is given for the Option, the name is the first LFlag given. Create an option taking several OptDescrs. You will have to give the flags and description individually to the OptDescr constructor. .Create a string-valued command line interface. CCreate a string-valued command line interface with a default value. !(String -> a) variant of "reqArg" !(String -> a) variant of "optArg" create a Choice option create 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. uto view as a FieldDescr, we sort the list of interfaces (Req > Bool > Choice > Opt) and consider only the first one. :Show flags in the standard long option command line formatDThe help text for this command with descriptions of all the options. 0Default "usage" documentation text for commands. HCreate "usage" documentation from a list of parameter configurations. Make a Command from standard GetOpt options. 'Parse a bunch of command line arguments jMark command as hidden. Hidden commands don't show up in the 'progname help' or 'progname --help' output. Utility function, many commands do not accept additional flags. This action fails with a helpful error message if the user supplies any extra. 6Helper function for creating globalCommand description DMkOptDescr constructors partially applied to flags and description. namesynopsisusage alternativesinitial/empty flagsoptions &Is the command a global or subcommand?@ p q r s t u v x w z y { | } ~  @ v w x y z r s t u p q  ~ } | { p q r s t u v w x y z     08Isaac Jones 2003-2004 Duncan Coutts 2007BSD3cabal-devel@haskell.orgportableNone6<QV \L 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.  Flags to register and  unregister2: (user package, gen-script, in-place, verbosity)  Flags to sdist: (snapshot, verbosity)  Flags to install: (package db, verbosity)  Flags to copy6: (destdir, copy-prefix (backwards compat), verbosity)  Flags to  configure command.+IMPORTANT: every time a new flag is added, f should be updated. IMPORTANT: every time a new flag is added, it should be added to the Eq instance All programs that cabal may run !user specified programs paths "user specified programs args #Extend the $PATH $3The "flavor" of the compiler, such as GHC or JHC. %given compiler location &given hc-pkg location 'Enable vanilla library (Enable profiling in the library )Build shared library *+Enable dynamic linking of the executables. +%Enable profiling in the executables. ,1Enable profiling in the library and executables. -8Profiling detail level in the library and executables. .'Profiling detail level in the library /Extra arguments to  configure 0Enable optimization. 1Installed executable prefix. 2Installed executable suffix. 3Installation paths 5"path to search for extra libraries 60path to search for extra frameworks (OS X only) 7path to search for header files 8explicit IPID to be used 9explicit CID to be used :dbe as deterministic as possible (e.g., invariant over GHC, database, etc). Used by the test suite ; "dist" prefix <Cabal file to use =verbosity level >The --user/--global flag ?Which package DBs to use @!Enable compiling library for GHCi AEnable -split-objs with GHC BEnable executable stripping CEnable library stripping D)Additional constraints for dependencies. EThe packages depended on. FThe requested Backpack instantiation. If empty, either this package does not use Backpack, or we just want to typecheck the indefinite package. HEnable test suite compilation IEnable benchmark compilation JEnable program coverage K$Enable program coverage (deprecated) LXAll direct dependencies and flags are provided on the command line by the user via the '--dependency' and  '--flags' options. MEHalt and show an error message indicating an error in flag assignment N Enable relocatable package built OEmit debug info. Pdual to  Q Q<Ignore upper bounds on all or some dependencies. Wrapped in = to distinguish between "default" and "explicitly disabled". RdDependencies can be relaxed either for all packages in the install plan, or only for some packages. U [* in the context of lower bounds (i.e. for  --allow-older flag) X [* in the context of upper bounds (i.e. for  --allow-newer flag) [aGeneric data type for policy when relaxing bounds in dependencies. Don't use this directly: use  U or  XW depending on whether or not you are relaxing an lower or upper bound (respectively). \_Default: honor the upper bounds in all dependencies, never choose versions newer than allowed. ]:Ignore upper bounds in dependencies on the given packages. ^4Ignore upper bounds in dependencies on all packages. _:Flags that apply at the top level, not to any sub-command. c#Types that represent boolean flags. e1All flags are monoids, they come in two flavours:  list flags eg !--ghc-option=foo --ghc-option=bar&gives us all the values ["foo", "bar"] singular value flags, eg: --enable-foo --disable-foogives us Just False So this Flag type is for the latter singular kind of flag. Its monoid instance gives us the behaviour where it starts out as  g' and later flags override earlier ones. rConvert  [ to a boolean. sMore convenient version of  s. Results in an A# if internal invariant is violated. Inverse to .5Pretty-print a single entry of a module substitution.For each known program PROG in progDb , produce a  with-PROG  . Like *, but allows to customise the option name. Like *, but allows to customise the option name.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  PROG-options  . Arguments to pass to a  configure script, e.g. generated by autoconf. pHelper 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"] SsplitArgs "\"-DMSGSTR=\\\"foo bar\\\"\" --baz" = ["-DMSGSTR=\"foo bar\"","--baz"]                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~   _ ` a b q o p    ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q { u v s [ \ ] ^ R S T r X Y Z U V W t x y       ~ | }                    w z h e f g i j k l m n c d                                    4   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f ggNone6<QV q. 1Data cached after configuration step. See also  . dOptions passed to the configuration step. Needed to re-run configuration when .cabal is out of date 9The final set of flags which were picked for this package ;What components were enabled during configuration, and why. !uExtra args on the command line for the configuration step. Needed to re-run configuration when .cabal is out of date "xThe installation directories for the various different kinds of files TODO: inplaceDirTemplates :: InstallDirs FilePath # The compiler we're building with $The platform we're building for %Where to build the package. &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. 'LA map from component name to all matching components. These coincide with  & (All 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 InstalledPackageInfoe 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.) )5the filename containing the .cabal file, if available *WARNING WARNING WARNING Be VERY careful about using this function; we haven't deprecated it but using it could introduce subtle bugs related to W.In principle, this is supposed to contain the resolved package description, that does not contain any conditionals. However, it MAY NOT contain the description wtih a W applied to it; see Wc for the whole sordid saga. As much as possible, Cabal library should avoid using this parameter. +"Location and args for all programs ,)What package database to use, global/user -Whether to build normal libs. .,Whether to build profiling versions of libs. /)Whether to build shared versions of libs. 0'Whether to link executables dynamically 1+Whether to build executables for profiling. 2"Level of automatic profile detail. 3"Level of automatic profile detail. 42Whether to build with optimization (if available). 5*Whether to emit debug info (if available). 61Whether to build libs suitable for use with GHCi. 7&Use -split-objs with GHC, if available 8+Whether to strip executables during install 9)Whether to strip libraries during install :-Whether to enable executable program coverage ;*Whether to enable library program coverage </Prefix to be prepended to installed executables =.Suffix to be appended to installed executables ? Extract the Y) from the public library component of a  D if it exists, or make a fake component ID based on the package ID. @ Extract the  of a  . This is a "safe" use of  * A Extract the " from the library component of a  ? if it exists, or make a fake unit ID based on the package ID. BNExtract the compatibility package key from the public library component of a  C if it exists, or make a fake package key based on the package ID.+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. C 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  . E Return all s associated with :. In the presence of Backpack there may be more than one! FReturn the list of default ms 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  . GExecute f for every w 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  . H3Return the list of all targets needed to build the uidsG, in the order they need to be built. Has a prime because it takes a # argument which may disagree with  * in  . IExecute f for every  needed to build uidKs, respecting the build dependency order. Has a prime because it takes a # argument which may disagree with  * in  . JpIs coverage enabled for test suites? In practice, this requires library and executable profiling to be enabled. R_External package dependencies for the package as a whole. This is the union of the individual , less any internal deps.7   # *   ! " $ % & ' ( ) + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R7     ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? A B @ E C D F G H I J K L M N O P Q R "    ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = >hIsaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone6<QV $ Y#Perform the action on each enabled & in the package description with the . Z#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. `%Perform the action on each buildable C or |V (Component) in the PackageDescription, subject to the build order specified by the compBuildOrder field of the given  CPrivate helper function for some of the deprecated implementations. d|Determine the directories containing the dynamic libraries of the transitive dependencies of the component we are building.EWhen wanted, and possible, returns paths relative to the installDirs  eIGet all module names that needed to be built by GHC; i.e., all of these pGs have interface files associated with them that need to be installed. fOBackwards 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  g instead. gSee . hOBackwards 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  i instead. iSee  dBuilding for inplace?&Generate prefix-relative library pathsComponent that is being built   # *   ! " $ % & ' ( ) + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? A B R W X Y Z [ \ ] ^ _ ` a b c d e f g h i j     ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > R ? A B W X b c d e ` a _ Y Z [ \ ] ^ f h g i jiDuncan Coutts 2009cabal-devel@haskell.orgportableNone<QVZ o kCall ar: to create a library archive from a bunch of object files.ar by default includes various metadata for each object file in their respective headers, so the output can differ for the same inputs, making it difficult to avoid re-linking. GNU ar(1) has a deterministic mode (-Dr) flag that always writes zero for the mtime, UID and GID, and 0644 for the file mode. However detecting whether -DJ is supported seems rather harder than just re-implementing this feature.j k kjjThomas Tuegel 2011BSD3cabal-devel@haskell.orgportableNone<QV  r?Path to the .tix file containing a test suite's sum statistics. tAttempt to guess the way the test suites in this package were compiled and linked with the library so the correct module interfaces are found. u*Generate the HTML markup for a test suite. v<Generate the HTML markup for all of a package's test suites."dist/" prefix/Directory containing component's HPC .mix files p"dist/" prefixComponent name,Directory containing test suite's .mix files q"dist/" prefixComponent name,Directory containing test suite's .tix files r"dist/" prefixComponent namePath to test suite's .tix file s"dist/" prefixComponent name*Path to test suite's HTML markup directory u"dist/" prefix Library name v"dist/" prefix Library name l m n o p q r s t u v l m n o t s p q r v u l m n okSimon Marlow 2008cabal-devel@haskell.orgportableNone  |The contents of the cabal_macros.h" for the given configured package. }(Helper function that generates just the  VERSION_pkg and MIN_VERSION_pkgb macros for a list of package ids (usually used with the specific deps of a configured package).(Helper function that generates just the TOOL_VERSION_pkg and MIN_TOOL_VERSION_pkg* macros for a list of configured programs.Common implementation of  } and . Generate the CURRENT_COMPONENT_ID; definition for the component ID of the current package. Generate the CURRENT_PACKAGE_VERSION? definition for the declared version of the current package. | } | }lNone  ~QA list of components associated with the source level dependencies between them. FA graph of source-level components by their source-level dependencies  Pretty-print  ~.  Create a  of +, or report a cycle if there is a problem. $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.) AError message when there is a cycle; takes the SCC of components. ~    ~ mNone<QV /Logs test suite results, itemized by test case. \Logs all test results for a package, broken down first by test suite and then by test case. A  1 with package and platform information specified. <Count the number of pass, fail, and error test results in a   tree. From a  %, determine if the test suite passed. From a  %, determine if the test suite failed. From a  1, determine if the test suite encountered errors. Print a summary to the console after all test suites have been run indicating the number of successful test suites and cases. Returns  if all test suites passed and  otherwise. ~Print a summary of a single test case's result to the console, supressing output for certain verbosity or test filter levels. |Print a summary of the test suite's results on the console, suppressing output for certain verbosity or test filter levels. )Passes, fails, and errors, respectively. test suite nametest suite results      nNone6<QV A  -fprof-auto -fprof-auto-top -fprof-auto-exported -static -dynamic -static -dynamic-too -O0 -O -O2 e.g. -Odph ghc -c ghc  ghc --make ghci / ghc --interactive ghc --abi-hash( | GhcModeDepAnalysis -- ^ ghc -M( | GhcModeEvaluate -- ^ ghc -e %A structured set of GHC options/flags &The major mode for the ghc invocation. _Any extra options to pass directly to ghc. These go at the end and hence override other stuff. pExtra default flags to pass directly to ghc. These go at the beginning and so can be overridden by other stuff. CThe main input files; could be .hs, .hi, .c, .o, depending on mode. /The names of input Haskell modules, mainly for --make mode. Location for output file; the ghc -o flag. $Location for dynamic output file in   mode; the  ghc -dyno flag. ?Start with an empty search path for Haskell source files; the ghc -i flag (-i$ on it's own with no path argument). *Search path for Haskell source files; the ghc -i flag. ,The unit ID the modules will belong to; the ghc -this-unit-id flag (or -this-package-key or  -package-name( on older versions of GHC). This is a > because we assume you've already figured out what the correct format for this string is (we need to handle backwards compatibility.) GHC doesn't make any assumptions about the format of definite unit ids, so when we are instantiating a package it needs to be told explicitly what the component being instantiated is. This only gets set when   is non-empty tHow the requirements of the package being compiled are to be filled. When typechecking an indefinite package, the  is always a L; otherwise, it specifies the installed module that instantiates a package. *No code? (But we turn on interface writing "GHC package databases to use, the ghc -package-conf flag. :The GHC packages to bring into scope when compiling, the ghc -package-id flags. $Start with a clean package set; the ghc -hide-all-packages flag .Warn about modules, not listed in command line /Don't automatically link in Haskell98 etc; the ghc -no-auto-link-packages flag. #Names of libraries to link in; the ghc -l flag. *Search path for libraries to link in; the ghc -L flag. +Options to pass through to the linker; the  ghc -optl flag. %OSX only: frameworks to link in; the ghc -framework flag. 6OSX only: Search path for frameworks to link in; the ghc -framework-path flag. 1Don't do the link step, useful in make mode; the  ghc -no-link flag. Don't link in the normal RTS main entry point; the ghc -no-hs-main flag. *Module definition files (Windows specific) /Options to pass through to the C compiler; the  ghc -optc flag. $Options to pass through to CPP; the  ghc -optP flag. 4Search path for CPP includes like header files; the ghc -I flag. 0Extra header files to include at CPP stage; the ghc -optP-include flag. 5Extra header files to include for old-style FFI; the  ghc -#include flag. The base language; the ghc -XHaskell98 or  -XHaskell2010 flag. The language extensions; the ghc -X flag. hA GHC version-dependent mapping of extensions to flags. This must be set to be able to make use of the  . $What optimisation level to use; the ghc -O flag. Emit debug info; the ghc -g flag. Compile in profiling mode; the  ghc -prof flag. .Automatically add profiling cost centers; the ghc -fprof-auto* flags. *Use the "split object files" feature; the ghc -split-objs flag. (Run N jobs simultaneously (if possible). Enable coverage analysis; the ghc -fhpc -hpcdir flags.  Extra GHCi startup scripts; the  -ghci-script flag only in   mode only in   mode 9Get GHC to be quiet or verbose with what it's doing; the ghc -v flag. JPut the extra folders in the PATH environment variable we invoke GHC with ZLet GHC know that it is Cabal that's calling it. Modifies some of the GHC error messages.GHC <7.6 uses '-package-conf' instead of  '-package-db'.GHC >= 7.6 uses the  '-package-db' flag. See  ,https://ghc.haskell.org/trac/ghc/ticket/5977.S S      < None;=QV . .This method computes a default, "good enough" Yl for a package. The intent is that cabal-install (or the user) will specify a more detailed IPID via the --ipid flag if necessary. In 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.OIn 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.CSo 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 d 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.RIf it is not of this form, we rehash the IPID into the correct form and pass that.UFor sub-components, we rehash the IPID into the correct format and pass that.d  pNone F 1A configured component, we know exactly what its Y is, and the Ys of the things it depends on. 7Unique identifier of component, plus extra useful info. FThe fragment of syntax from the Cabal file describing this component. 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.) !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-dependsC). Not mix-in linked yet; component configuration only looks at Ys. +Uniquely identifies a configured component. %The package this component came from. The x of a component; this uniquely identifies a fragment of syntax within a specified Cabal file describing the component. Pretty-print a  . Construct a  , given that the Yc and library/executable dependencies are known. The primary work this does is handling implicit backpack-include fields.Also computes the YU, and sets cc_public if necessary. This is Cabal-only; cabal-install won't use this.'build-depends:' stanzas are currently ambiguous as the external packages and internal libraries are specified the same. For now, we assume internal libraries shadow, and this function disambiguates accordingly, but soon the underlying ambiguity will be addressed.                          qNoneFTV Z 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 component Corresponds to  .  build-tools and build-tool-depends dependencies. Corresponds to  . :Is this the public library of a package? Corresponds to  . Corresponds to  i, 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 .) !Like  K, but this specifies includes on signature packages which have no exports. "KThe module shape computed by mix-in linking. This is newly computed from  #Uniquely identifies a  . Corresponds to  . $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). &The instantiation of  %I; this always has the invariant that it is a mapping from a module name A to  A (the hole A).        ! " # $ % & ' ( ) *       ! " & % # $ ( ) '  *       ! "r(c) Duncan Coutts 2012BSD-likeduncan@community.haskell.orgNone6<QV 8A 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 . 1 expected thing(actually got) 2 (no such thing, actually got) 6A fully resolved build target. 7A specific component 8.A specific module within a specific component. 9,A specific file within a specific component. :4Various ways that a user may specify a build target.OA target specified by a single name. This could be a component module or file. Jcabal 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. Pcabal build lib:foo exe:foo cabal build foo:Data.Foo cabal build foo:Data/Foo.hssA fully qualified target, either a module or file qualified by a component name with the component namespace kind. acabal build lib:foo:Data/Foo.hs exe:foo:Data/Foo.hs cabal build lib:foo:Data.Foo exe:foo:Data.Foo ;Take a list of >9 build targets, and parse and validate them into actual  s to be built registered whatever. =GRead a list of user-supplied build target strings and resolve them to  6s according to a f. If there are problems with any of the targets e.g. they don't exist or are misformatted, throw an  IOException.Unless you use  -!, this function is PARTIAL; use  A instead. AUnambiguously render a  6., so that it can be parsed in all situations. BRGiven a bunch of user-specified targets, try to resolve what it is they refer to.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.)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.)Lift a list of matches to an exact match.)Lift a list of matches to an exact match.fGiven 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 e. 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).DCheck that the given build targets are valid in the current context.)Also swizzle into a more convenient form. , . / - 0 3 1 2 4 5 6 7 8 9 : ; < = > ? @ A B C ; = 6 7 8 9 A , - . / < : > @ 4 5 ? B 0 1 2 3 C  , - . / 0 1 2 3 4 5 6 7 8 9 :s9Isaac Jones 2003-2004, Duncan Coutts 2008BSD3cabal-devel@haskell.orgportableNone<QV  ]mThis is the name of the directory in which the generated haddocks should be stored. It does not include the  distdochtml prefix. ^IThe directory to which generated haddock documentation should be written. _rThe directory in which we put auto-generated modules for EVERY component in the package. See deprecation notice. `YThe directory in which we put auto-generated modules for EVERY component in the package. aQThe directory in which we put auto-generated modules for a particular component. c?The name of the auto-generated module associated with a package dGThe name of the auto-generated Paths_* module associated with a package j:The directory where we put build results for an executable k>The directory where we put build results for a foreign library oLDefault extension for executable files on the current platform. (typically "" on Unix and "exe" on Windows or OS/2) p5Extension for object files. For GHC the extension is "o". qCExtension for dynamically linked (or shared) libraries (typically "so" on Unix and "dll" on Windows) rExtension for static librariesnTODO: Here, as well as in dllExtension, it's really the target OS that we're interested in, not the build OS. h [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r h [ ] \ ^ _ ` a c d b e l m n o p q r i f g h j ktAndres Loeh 2009BSD3cabal-devel@haskell.orgportableNone<QV  'The flags for the supported extensions. lHack 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. s t u v w x y s t u v w x yuIsaac Jones 2003-2007BSD3cabal-devel@haskell.orgportableNone<QV J/Adjust the way we find and configure gcc and ld:Get the packages from specific PackageDBs, not cumulative. |Build a library with LHC. }Build an executable with LHC.YFilter the "-threaded" flag when profiling as it does not work with ghc-6.8 and older. Install executables for GHC. 6Install for ghc, .hi, .a and, if --with-ghci given, .o Where to copy the files toBuild locationExecutable (prefix,suffix) install location&install location for dynamic librariesBuild location z { | } ~  z { | }  ~vIsaac Jones 2003-2006BSD3cabal-devel@haskell.orgportableNone<QV &The flags for the supported extensions HBuilding a package for JHC. Currently C source files are not supported. LBuilding an executable for JHC. Currently C source files are not supported.  wNone<QV  install location&install location for dynamic librariesBuild location Isaac Jones 2003-2007cabal-devel@haskell.orgportableNone<QV  'The kinds of entries we can stick in a .ghc.environment file.  -- a comment package-id foo-1.0-4fe301a... global-package-db, user-package-db or package-db blahpackage.conf.d clear-package-db/Adjust the way we find and configure gcc and ld.Strip out flags that are not supported in ghci'GHC's rendering of it's host or target J` as used in its platform strings and certain file locations (such as user package db location).'GHC's rendering of it's host or target \` as used in its platform strings and certain file locations (such as user package db location).GHC's rendering of it's 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 3Make 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 H and GHC % are needed as part of the file name.The .ghc.environment-$arch-$os-$ver file name.Render a bunch of GHC environment file entries/Render an individual GHC environment file entry directory in which to put itthe GHC target platformthe GHC version the content  !"#$%&'   xNone<QV  9Given a single package DB, return all installed packages. 8Given a package DB stack, return all installed packages.  Return the $ to the global GHC package database. .Start a REPL without loading any source files. 6Install for ghc, .hi, .a and, if --with-ghci given, .o Get the JavaScript file name and command and arguments to run a program compiled by GHCJS the exe should be the base program name without exe extension install location&install location for dynamic librariesBuild location Where to copy the files toBuild locationExecutable (prefix,suffix)  eIsaac Jones 2003-2007BSD3cabal-devel@haskell.orgportableNone<QV '{ (sBuilding an executable, starting the REPL, and building foreign libraries are all very similar and implemented in ). The (6 distinguishes between the various kinds of operation.*Given something like usrlocalbinghc-6.6.1(.exe) we try and find the corresponding tool; e.g. if the tool is ghc-pkg, we try looking for a versioned or unversioned ghc-pkg in the same dir, that is: f/usr/local/bin/ghc-pkg-ghc-6.6.1(.exe) /usr/local/bin/ghc-pkg-6.6.1(.exe) /usr/local/bin/ghc-pkg(.exe)+Given something like usrlocalbinghc-6.6.1(.exe) we try and find a corresponding ghc-pkg, we try looking for both a versioned and unversioned ghc-pkg in the same dir, that is: f/usr/local/bin/ghc-pkg-ghc-6.6.1(.exe) /usr/local/bin/ghc-pkg-6.6.1(.exe) /usr/local/bin/ghc-pkg(.exe),Given something like usrlocalbinghc-6.6.1(.exe) we try and find a corresponding hsc2hs, we try looking for both a versioned and unversioned hsc2hs in the same dir, that is: c/usr/local/bin/hsc2hs-ghc-6.6.1(.exe) /usr/local/bin/hsc2hs-6.6.1(.exe) /usr/local/bin/hsc2hs(.exe)-Given something like usrlocalbinghc-6.6.1(.exe) we try and find a corresponding haddock, we try looking for both a versioned and unversioned haddock in the same dir, that is: f/usr/local/bin/haddock-ghc-6.6.1(.exe) /usr/local/bin/haddock-6.6.1(.exe) /usr/local/bin/haddock(.exe) 9Given a single package DB, return all installed packages. 8Given a package DB stack, return all installed packages..Given a list of !(PackageDB, InstalledPackageInfo) pairs, produce a  PackageIndex. Helper function used by   and  .  Return the $ to the global GHC package database./ Return the & to the per-user GHC package database.0:Get the packages from specific PackageDBs, not cumulative. .Start a REPL without loading any source files. Build a foreign library Build a foreign library Build an executable with GHC. Build an executable with GHC.18Target 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  q 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).2#Name for the library when building.If the `lib-version-info` field or the `lib-version-linux`g 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.lThis method allows to adjust the name of the library at build time such that the correct soname can be set.3Main module name when overridden by ghc-options: -main-is ... or  if no -main-is flag could be found. In case of , ! can be assumed.4Decode 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.57Return C sources, GHC input files and GHC input modules)(Generic build function. See comment for (.6 Do we need the RPATH workaround?See Note [RPATH].77Extract (and compute) information about the RTS library!TODO: This hardcodes the name as  HSrts-ghc versionM. 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.8Returns 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.93Finds the object file name of the given source file:7Calculate the RPATHs for the component we are building. Calculates relative RPATHs when  > is set.;YFilter the "-threaded" flag when profiling as it does not work with ghc-6.8 and older. yExtracts a String representing a hash of the ABI of a built library. It can fail if the library has not yet been built. Install executables for GHC.  Install foreign library for GHC. 6Install for ghc, .hi, .a and, if --with-ghci given, .o5 specVersion:Component we are building Where to copy the files toBuild locationExecutable (prefix,suffix) install locationBuild location install location&install location for dynamic librariesBuild location+ d e k f g h i j l m n o + o d e f g h i j k l m n<=>?@(ABCDyIsaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone<QV 1w  Perform the "./setup install" and " ./setup copy@" actions. Move files into place based on the prefix argument.2This does NOT register libraries, you should call register to do that.ECopy package global files.F'Copy files associated with a component.G&Install the files listed in data-filesH:Install the files listed in install-includes for a library  information from the .cabal file#information from the configure stepflags sent to copy or install  zbIsaac Jones 2003-2005, Ross Paterson 2006, Duncan Coutts 2007-2008cabal-devel@haskell.orgportableNone 9# [Generates the name of the environment variable controlling the path component of interest.Note: The format of these strings is part of Cabal's public API; changing this function constitutes a *backwards-compatibility* break. Tpath component; one of "bindir", "libdir", "datadir", "libexecdir", or "sysconfdir"environment variable name  {None<QV K :The name of the stub executable associated with a library  TestSuite. SThe filename of the source file for the stub executable associated with a library  TestSuite. $Write the source file for a library  TestSuite stub executable. 2Source code for library test suite stub executable 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.I The test runner used in library  TestSuite$ stub executables. Runs a list of gs. 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. From a test stub, write the  : to temporary file for the calling Cabal process to read. library  TestSuite# for which a stub is being created6path to directory where stub source should be located  |None<QV L8  }Thomas Schilling, 2007BSD3cabal-devel@haskell.orgportableNone 9J0A set of targets with their package dependenciesK9A map of dependencies that combines version ranges using .L)Result of dependency test. Isomorphic to Maybe d but renamed for clarity.MSimplify a configuration condition using the OS and arch names. Returns the names of all the flags occurring in the condition. .Parse a configuration condition from a string.NJTry to find a flag assignment that satisfies the constraints of all trees.Returns either the missing dependencies, or a tuple containing the resulting data, the associated dependencies, and the chosen flag assignments.In case of failure, the union of the dependencies that led to backtracking on all branches is returned. [TODO: Could also be specified with a function argument.]LTODO: The current algorithm is rather naive. A better approach would be to:IRule out possible paths, by taking a look at the associated dependencies.Infer the required values for the conditions of these paths, and calculate the required domains for the variables used in these conditions. Then picking a flag assignment would be linear (I guess).iThis would require some sort of SAT solving, though, thus it's not implemented unless we really need it.  Transforms a h by putting the input under the "then" branch of a conditional that is True when Buildable is True. If   can determine that Buildable is always True, it returns the input unchanged. If Buildable is always False, it returns the empty .OThis is a special version of   for the P type.fIt is not simply a specialisation. It is more complicated than it ought to be because of the way the P monoid instance works. The  mempty = Ql forgets the component type, which has the effect of completely deleting components that are not buildable.See  *https://github.com/haskell/cabal/pull/4094 for more details. LExtract conditions matched by the given predicate from all cond trees in a  .RmCombine the target-specific dependencies in a TargetSet to give the dependencies for the package as a whole.S\Collect up the targets in a TargetSet of tagged targets, storing the dependencies as we go. >Create a package description with all configurations resolved.This function takes a  ; and several environment parameters and tries to generate G by finding a flag assignment that result in satisfiable dependencies.&It takes as inputs a not necessarily complete specifications of flags assignments, an optional package index as well as platform parameters. If some flags are not assigned explicitly, this function will try to pick an assignment that causes this function to succeed. The package index is optional since on some platforms we cannot determine which packages have been installed before. When no package index is supplied, every dependency is assumed to be satisfiable, therefore all not explicitly assigned flags will get their default values.This function will fail if it cannot find a flag assignment that leads to satisfiable dependencies. (It will not try alternative assignments for explicitly specified flags.) In case of failure it will return the missing dependencies that it encountered when trying different flag assignments. On success, it will return the package description and the full flag assignment chosen.,Note that this drops any stanzas which have buildable: Falseu. While this is arguably the right thing to do, it means we give bad error messages in some situations, see #3858. hFlatten a generic package description by ignoring all conditions and just join the field descriptors into on package description. Note, however, that this may lead to inconsistent field values, since all values are joined into one field, which may not be possible in the original package description, due to the use of exclusive choices (if ... else ...).TODO: One particularly tricky case is defaulting. In the original package description, e.g., the source directory might either be the default or a certain, explicitly set path. Since defaults are filled in only after the package has been resolved and when no explicit value has been set, the default path will be missing from the package description returned by this function. Walk a   and apply f to all nested  build-depends fields.T Walk all  s inside a  O and apply appropriate transformations to all nodes. Helper function used by   and  .N3Domain for each flag name, will be tested in order.-OS as returned by Distribution.System.buildOS1Arch as returned by Distribution.System.buildArchCompiler informationAdditional constraintsDependency test function.}Either the missing dependencies (error case), or a pair of (set of build targets with dependencies, chosen flag assignments) %Explicitly specified flag assignmentsjIs a given dependency satisfiable from the set of available packages? If this is unknown then use True.The J and \Compiler informationAdditional constraintshEither missing dependencies or the resolved package description along with the flag assignments chosen. %Explicitly specified flag assignmentsjIs a given dependency satisfiable from the set of available packages? If this is unknown then use True.The J and \Compiler informationAdditional constraints    PUVQJWKXYLZ[.Isaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone1<QV  sAn intermediate type just used for parsing the benchmark stanza. After validation it is converted into the proper  type. tAn intermediate type just used for parsing the test-suite stanza. After validation it is converted into the proper 2 type.\Store any fields beginning with "x-" in the customFields field of a PackageDescription. All other fields will generate a warning.]`Given a parser and a filename, return the parse of the file, after checking if the file exists. Parse the given package file. Parses the given file into a  .In Cabal 1.2 the syntax for package descriptions was changed to a format with sections and possibly indented property descriptions.^Parse a list of fields, given a list of field descriptions, a structure to accumulate the parsed fields, and a function that can decide what to do with fields which don't match any of the field descriptions.^.descriptions of fields we know how to parse1possibly do something with unrecognized fields accumulatorfields to be parsed_list of parseable fields1possibly do something with unrecognized fieldsaccumulated result and warningsthe field to be parsed$qrstuvwx $ vwxqrstu `ab   ~Jrgen Nicklisch-Franken 2010BSD3cabal-devel@haskell.org provisionalportableNone c+Recompile with false for regression testing 7Writes a .cabal file from a generic package description 0Writes a generic package description to a string since 1.26.0.0  since 1.26.0.0  since 1.26.0.0  since 1.26.0.0      Lennart Kolmodin 2008BSD3cabal-devel@haskell.orgportableNone # JA record of operations needed to check the contents of packages. Used by  . -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 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. xLike PackageDistSuspicious but will only display warnings rather than causing abnormal exit when you run 'cabal check'. 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. ?Check for common mistakes and problems in package descriptions.This is the standard collection of checks covering all aspects except for checks that require looking at files within the package. For those see  .It requires the  I and optionally a particular configuration of that package. If you pass @ then we just check a version of the generic description using  .d,Check that this package description is sane.e3Check that the package declares the version in the "cabal-version" field correctly.fA variation on the normal = instance, shows any ()'s in the original textual syntax. We need to show these otherwise it's confusing to users when we complain of their presence but do not pretty print them!gACheck the build-depends fields for any weirdness or bad practise. Sanity check things that requires IO. It looks at the files in the package and expects to find the package unpacked in at the given file path. eSanity 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.zThe point of this extra generality is to allow doing checks in some virtual file system, for example a tarball in memory.hDFind a package description file in the given directory. Looks for .cabal files. Like  , but generalized over monads. Check the names of all files in a package for portability problems. This should be done for example when creating or validating a package tarball.i=Check a file name is valid for the portable POSIX tar format.vThe POSIX tar format has a restriction on the length of file names. It is unfortunately not a simple restriction like a maximum length. The exact restriction is that either the whole path be 100 characters or less, or it be possible to split the path on a directory separator such that the first part is 155 characters or less and the second part 100 characters or less.h pkgname.cabal                                          Martin Sj&#xF6;gren 2004BSD3cabal-devel@haskell.orgportableNone<QV IELMNYZ[fgh>?@ABCD~      None<KQV  An opaque type representing a file's modification time, represented internally as a 64-bit unsigned integer in the Windows UTC format. `Return modification time of the given file. Works around the low clock resolution problem that j has on GHC < 7.8.}This is a modified version of the code originally written for Shake by Neil Mitchell. See module Development.Shake.FileInfo. !Convert POSIX seconds to ModTime.kConvert l to  . !Return age of given file in days. Return the current time as  . !7Based on code written by Neil Mitchell for Shake. See sleepFileTimeCalibrate in . Returns a pair of microsecond values: first, the maximum delay seen, and the recommended delay to use before testing for file modification change. The returned delay is never smaller than 10 ms, but never larger than 1 second.      !      !  NoneFT -]mkA state monad for doing instantiations (can't use actual State because that would be an extra dependency.)n The state of m; a mapping from  s to their ready component, or Nothing@ if its an external component which we don't know how to build.oAn o> is a library with requirements which we will typecheck only.p The requirements of the library.q0The modules exported/reexported by this library.rbThe dependencies which need to be passed to the compiler to bring modules into scope. These are > because these may refer to partially instantiated libraries.sAn sV is a library which is fully instantiated (or, possibly, has no requirements at all.)t"How this library was instantiated.uDependencies induced by tW. These are recorded here because there isn't a convenient way otherwise to get the  we need to fill componentPackageDeps as needed.v0The modules exported/reexported by this library.wThe dependencies which need to be passed to the compiler to bring modules into scope. These always refer to installed fully instantiated libraries.xA x 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.yThe  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 ); y9 can be conveniently used to test for equality, whereas % cannot always be used in this case.zCorresponds to  #. Invariant: if y records a Y, it coincides with this one.{Corresponds to  .|Corresponds to  N. Build-tools don't participate in mix-in linking. (but what if they could?)}Corresponds to  .~Extra metadata depending on whether or not this is an indefinite library (typechecked only) or an instantiated component (can be compiled).The final, string I that will uniquely identify the compilation products of this component.Corresponds to  $.Compute the dependencies of a x! that should be recorded in the depends field of InstalledPackageInfo.Get the p of a x IF it is a library.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 S_The implementation is a bit more involved to memoize instantiation if we have done it already. We also call  improveUnitIdG during this process, so that fully instantiated components are given  HashedUnitId.opqrstuvwxyz{|}~mopqrstuvwxyz{|}~None "#1FTVZ . ( (None<QV 3 )Print 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.orgportableNone<QV @ , Compute the f$ of a library that we built inplace. .5Create an empty package DB at the specified location. 1Run hc-pkg` using a given package DB stack, directly forwarding the provided command-line arguments to it. 3 Construct @F for a library in a package, given a set of installation directories. 4 Construct @3 for a library that is in place in the build tree.:This function knows about the layout of in place packages. 5 Construct @6 for the final install location of a library package.;This function knows about the layout of installed packages. *(Install in the user's database?; verbose 38Translate relative include dir paths to absolute paths. 4top of the build treelocation of the dist tree @ A B C D R * + , - . / 0 1 2 3 4 5 6 7 * 6 7 - / . 0 , 1 2 @ A B C D R + 4 5 3+(c) 2003-2005, Isaac Jones, Malcolm WallaceBSD3cabal-devel@haskell.orgportableNone<QV n 8gA preprocessor for turning non-Haskell files with the given extension into plain Haskell source files.Function to determine paths to possible extra C sources for a preprocessor: just takes the path to the build directory and uses this to search for C sources with names that match the preprocessor's output name format. 9The 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: tppTestHandler :: PreProcessor ppTestHandler = PreProcessor { platformIndependent = True, runPreProcessor = mkSimplePreProcessor $ \inFile outFile verbosity -> do info verbosity (inFile++" has been preprocessed to "++outFile) stuff <- readFile inFile writeFile outFile ("-- preprocessed as a test\n\n" ++ stuff) return ExitSuccess 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. ?(Apply preprocessors to the sources from 2 for a given component (lib, exe, or test suite).QFind the first extension of the file that exists, and preprocess it if required. I>Convenience function; get the suffixes of these preprocessors. JGStandard preprocessors: GreenCard, c2hs, hsc2hs, happy, alex and cpphs.CStandard preprocessors with possible extra C sources: c2hs, hsc2hs. KsFind any extra C sources generated by preprocessing that need to be added to the component (addresses issue #238).source directoriesbuild directorypreprocess for sdistmodule file name verbositybuiltin suffixespossible preprocessors 8 9 : ; < = > ? @ A B C D E F G H I J K ? K J I 8 9 : ; < = > B C @ E D G H A F 9 : ; <Isaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone<QV 0 LHooks allow authors to add specific functionality before and after a command is run, and also to specify additional preprocessors.WARNING: The hooks interface is under rather constant flux as we try to understand users needs. Setup files that depend on this interface may break in future releases. N Used for  ./setup test ORead the description file P3Custom preprocessors in addition to and overriding  J. QgThese programs are detected at configure time. Arguments for them are added to the configure command. R$Hook to run before configure command S?Over-ride this hook to get different behavior during configure. T#Hook to run after configure command UHHook to run before build command. Second arg indicates verbosity level. V;Over-ride this hook to get different behavior during build. WGHook to run after build command. Second arg indicates verbosity level. XGHook to run before repl command. Second arg indicates verbosity level. YDOver-ride this hook to get different behavior during interpretation. ZFHook to run after repl command. Second arg indicates verbosity level. [HHook to run before clean command. Second arg indicates verbosity level. \;Over-ride this hook to get different behavior during clean. ]GHook to run after clean command. Second arg indicates verbosity level. ^Hook to run before copy command _:Over-ride this hook to get different behavior during copy. `Hook to run after copy command a"Hook to run before install command b=Over-ride this hook to get different behavior during install. cdHook to run after install command. postInst should be run on the target, not on the build machine. dHHook to run before sdist command. Second arg indicates verbosity level. e;Over-ride this hook to get different behavior during sdist. fGHook to run after sdist command. Second arg indicates verbosity level. g#Hook to run before register command hBOver-ride this hook to get different behavior during registration. i"Hook to run after register command j%Hook to run before unregister command kDOver-ride this hook to get different behavior during unregistration. l$Hook to run after unregister command mKHook to run before hscolour command. Second arg indicates verbosity level. n>Over-ride this hook to get different behavior during hscolour. oJHook to run after hscolour command. Second arg indicates verbosity level. pJHook to run before doctest command. Second arg indicates verbosity level. q=Over-ride this hook to get different behavior during doctest. rIHook to run after doctest command. Second arg indicates verbosity level. sJHook to run before haddock command. Second arg indicates verbosity level. t=Over-ride this hook to get different behavior during haddock. uIHook to run after haddock command. Second arg indicates verbosity level. v Hook to run before test command. w:Over-ride this hook to get different behavior during test. xHook to run after test command. y!Hook to run before bench command. z;Over-ride this hook to get different behavior during bench. { Hook to run after bench command. }Empty  L which do nothing.2 L M S N O P Q R T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | }2 L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } L/ M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z {Thomas Tuegel 2010BSD3cabal-devel@haskell.orgportableNone<QV  ~ Perform the " ./setup test " action. ~!positional command-line arguments information from the .cabal file#information from the configure stepflags sent to test ~ ~Johan Tibell 2011BSD3cabal-devel@haskell.orgportableNone<QV   Perform the " ./setup bench " action. !positional command-line arguments information from the .cabal file#information from the configure stepflags sent to benchmark  Simon Marlow 2004BSD3cabal-devel@haskell.orgportableNone<QV #Callback type for use by sdistWith. Create a source distribution. List all source files of a package. Returns a tuple of lists: first component is a list of ordinary files, second one is a list of those files that may be executable.KList those source files that may be executable (e.g. the configure script).HList those source files that should be copied with ordinary permissions. )Prepare a directory tree of source files.)Find the setup script file, if it exists.KCreate a default setup script in the target directory, if it doesn't exist.Find the main executable file.Find a module definition file#TODO: I don't know if this is rightCGiven 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.(Remove the auto-generated modules (like  'Paths_*') from 'exposed-modules' and 'other-modules'. Prepare 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  .  Modifies a A by appending a snapshot number corresponding to the given date.  Modifies a A by appending a snapshot number corresponding to the given date. WGiven a date produce a corresponding integer representation. For example given a date 18032008 produce the number 20080318. ECreate an archive from a tree of source files, and clean up the tree.8Given a buildinfo, return the names of all source files.)The name of the tarball without extension verbosityinfo from cabal fileinfo from configuresource tree to archivename of archive to create information from the tarballInformation from configureverbosity & snapshotbuild prefix (temp dir)'extra preprocessors (includes suffixes)  verbosityinfo from the cabal file'extra preprocessors (include suffixes)  verbosityinfo from the cabal filesource tree to populate'extra preprocessors (includes suffixes)  verbosityinfo from the cabal filesource tree to populate(extra preprocessors (includes suffixes) verbosityinfo from the cabal file source treeExtra preprocessorsExposed modules oIsaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone"#1<QV2,}An external dependency from the package database, OR an internal dependency which we are getting from the package database.An internal dependency (H should be a library name) which we are going to have to build. (The C here is a hack to get a modest amount of polymorphism out of the  typeclass.) /The errors that can be thrown when reading the  setup-config file. No header found. Incorrect header. Cannot parse file contents. No file! Mismatched version. Format a   as a user-facing error message.  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.  Read the  5, returning either an error or the local build info. Try to read the  .  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. Try to read the  . $After running configure, output the   to the  .(Identifier of the current Cabal package.+Identifier of the current compiler package. Parse the  setup-configL file header, returning the package identifiers for Cabal and the compiler. Generate the  setup-config file header. MCheck that localBuildInfoFile is up-to-date with respect to the .cabal file. Get the path of dist/setup-config. 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  h+ 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.)  Perform the "./setup configure" action. Returns the  .setup-config file.,Check if the user used any deprecated flags.Sanity check: if '--exact-configuration'X was given, ensure that the complete flag assignment was specified on the command line. 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.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 finalizePD. 1Relax the dependencies of this package if needed.;Finalize a generic package description. The workhorse is  7 but there's a bit of other nattering about necessary.(TODO: what exactly is the business with  flaggedTests and flaggedBenchmarks?>Check for use of Cabal features which require compiler support$Select dependencies for the package.?Select and apply coverage settings for the build based on the   and . 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-profilingF also affects profiling of benchmarks and (non-detailed) test suites.@Select and apply profiling settings for the build based on the   and .GTest for a package dependency and record the version we have installed. ;List all installed packages in the given package databases. 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. A set of files (or directories) that can be monitored to detect when there might have been a change in the installed packages. KThe user interface specifies the package dbs to use with a combination of --global, --user and $--package-db=global|user|clear|$filer. This function combines the global/user flag and interprets the package-db flag into a single package db stack.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. 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"] return (ccldOptionsBuildInfo (words ccflags) (words ldflags))=Output package check warnings and errors. Exit if any errors.0Preform checks if a relocatable build is allowed The file path of the  setup-config file. The file path of the  setup-config file. The dist directory path. The dist directory path. The dist directory path. The dist directory path.The   to write.The file contents.The processed package. The dist directory path. default "dist" prefixoverride "dist" prefix override "dist" prefixuse external internal deps?exact configuration? installed set internal setrequired dependenciesPtests if a dependency is satisfiable. Might say it's satisfiable even when not.internal packagesinstalled packages required depsPackage id of current packageInstalled packages;Packages for which we have been given specific deps to use'Are we configuring a single component? The stack of package databases."d   F "  d F   hIsaac Jones 2003-2005, Ross Paterson 2006, Duncan Coutts 2007-2008, 2012BSD3cabal-devel@haskell.orgportableNone<QVJ 4Build the libraries and executables in this package. 7Start an interpreter without loading any package files.EAdd extra C sources generated by preprocessing to build information.Translate a exe-style 2# component into an exe for buildingTranslate a lib-style 2( component into a lib + exe for buildingTranslate a exe-style # component into an exe for buildingRInitialize a new package db file for libraries defined internally to the package.Build a foreign libraryeNOTE: We assume that we already checked that we can actually build the foreign library in configure. Runs   on every configured component. FCreates the autogenerated files for a particular configured component. !Generate and write out the Paths_ pkg.hs and cabal_macros.h files 'Mostly information from the .cabal fileConfiguration information#Flags that the user passed to build%preprocessors to run before compiling '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 informationThe verbosity to use  "dist" prefix'mostly information from the .cabal fileConfiguration informationThe verbosity to use  Isaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone6<QV\3The FilePath of a directory, it's a monoid under '( /)'.TA record that represents the arguments to the haddock executable, a product monoid.?Path to the interface file, relative to argOutputDir, required.Package name, required.!(Hide modules ?, modules to hide)Ignore export lists in modules?A(Template for modules, template for symbols, template for lines).Optional custom CSS file.Optional URL to contents page.%HTML or Hoogle doc or both? Required. 0(Interface file, URL to the HTML docs for links).$Where to generate the documentation.Page title, required.Prologue text, required. Additional flags to pass to GHC."To find the correct GHC, required.Modules to process.*Call haddock with the specified arguments. Given a list of @ps, return a list of interfaces and HTML paths, and an optional warning for packages with missing documentation.template for HTML locationtemplate for HTML locationtemplate for HTML locationtemplate for HTML locationtemplate for HTML locationCalled when the   exe is not found.  Moritz Angermann 2017BSD3cabal-devel@haskell.orgportableNone6<QV_AA record that represents the arguments to the doctest executable.Modules to process  Isaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone<QVo 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 customizable version of  . A customizable version of  - that also takes the command line arguments. Like  P, but accepts the package description as input rather than using IO to read it. A customizable version of  .VCombine the preprocessors in the given hooks with the preprocessors built into cabal. LHooks that correspond to a plain instantiation of the "simple" build system Basic autoconf  L: T runs  ./configure , if present.the pre-hooks  U,  [,  ^,  a,  g and  j+ read additional build information from package .buildinfo , if present.Thus  configure/ can use local system information to generate package .buildinfo and possibly other files.LMNYZ[fgh      !"#$%&'()*+,-.     8:9;<=>?@ABCDEFLMNOGHIJKPQRSTUVW>?@ABCD~                            ! L M S N O P Q R T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } < L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | }       !"#$%$&$'$($)$*$+,-./0/1/2/3/4/5/6789:;<=>?@ABCDEFDEGDEHDEIJKLJMJNJOPQRPQSTUVWXYYZ[\]^_`abcdefghijklmnopqrstuGvwxyz{|}~< ?                         !"#$$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<= > ? @ A B C D E F G!H!H!I!J!K!!L!M!N!O!P!Q!R!S!T!U!V!W!X!Y!Z![!\!]!^!_"`"`"a"b"c"d"e"f"g"h"i"j"k"l###m#n#o#p#q#r#s#t#u#v#w#xyz{|}~$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%!%%%%%%%%%%% % % % % %%%%%%%%%%%&&&&&&&& &!&"&#&$'%'&'''(')'*'+','-'.'/'0(1(1(2(3(4(5(6(7(8(9):);)<)=)>)?)@)A)B)C)D*E*F*G*H*I*J*K*L*M*N*O+P+Q+R+S+T+U+V+W+X+Y+Z+[+\+]+^+_+`+a+b+c+d+e+f+g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,{,|,},~,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,L,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,------- - - - - - ------------------- -!-"-#-$-%-&-'-(-)-*-+-,---.-/-0-1-2-3-4-5-6-7-8-9-:;;<=>?@ABCDEFGHI1J1K1L1M1N1O1P1Q1R1S1T1U1V2W2X2Y2Z2[2\2]2^2_2`2a2b2c2d2e2f2g3h3i3j3k3l3m3n3o3p3q3r3s3t3u3v3w3x3y3z4{4{4|4}4~4444444445555555555555555555555555555566666666666777777777777777777777777777777777777888888889999999::::::::::::;;;;;;;;;;;;<<<<<<<<<<<=========== = = = = >>>>>>>>>>>>???????? @!@"@#@$@%@&@'@(@)@*@+@,@-@.@/A0A0A1A2AA3A4A5A6A7A8A9A:A;B<B=B>B?B@BABBBCBDBEBFBGBHBIBJCKCKCLCMCNCOCPCQDRDRDSDTDUDVDWDXEYEZE[E\E]E^E_E`EaEbEcEdEeEfEgEhEiEjEkElEmEnEoEpEqErEsEtEuEvEvEwExEyEzE{E|E}E~EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGG GGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIII I I I J JKKKKKKKKKKKKKKKKKKK K!K"K#K$K%K&K'K(K)K*K+K,K-K.K/K0L1L1L2L3L4L5L6L7L8L9L:L;L<L=L>L?L@MAMAMBMCMDMEMFMGMHMIMJMKMLMMMNMOMPNQNRNSNTNUNVNWNXNYNZN[N\N]N^N_O`OaObOcOdOeOeOfOgOhOiOjOkOlOmOnOoOpOqPrPrPsPtPuPvPwPxPyPzP{P|P}P~PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQ7Q%QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRR////////////?/////t/v/w/x/y/{/|///////////////////////////////H///// / / / / /////////////////// /!S"S#S$S%S&S'S(S)S*S+S,S-S.S/S0S1S2S3S4S5S6S7S8S9S:S;T<T<T=T>T?U@U@UAUBUCUDUEUFUGUHUI J J K L M L N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                              VVVVVVVVVVVVVVVVVVVWWWWWWWWWXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZ[[[\]]^^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ _ _ _ _ _ !_ "_ #_ $_ %_ &_ '_ (_ )_ *_ +_ ,_ -_ ._ /_ 0_ 1_ 2_ 3_ 4_ 5_ 6_ 7_ 8_ 9_ :` ;` <` =` >` ?` @` A` B` C` D` E` F` Ga Ha Ib Jb Kb Lb Mb Nb Ob Pb Qbb Rb Sb Tb Ub Vb Wb Xb Yb Zb [b \b ]b ^b _b `b ab bb cb db eb fb gb hb ib jb kb lb mb nb ob pb qb rb sc tc uc vc wc xc yc zcc {c |c }c ~c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d   f f f f f f f f f f f f f f f f f f f f f f f ff f f f f f f f f f f f f f f ff f f f f f f f !f "f #f $f %f &f 'f (f )f *f +f ,f -f .f /f 0f 1f 20 30 30 40 50 60 70 70 80 90 :0 ;0 <0 =0 >0 ?0 @0 A0 B0 C0 D0 E0 E0 F0 G0 H0 I0 J0 K0 K0 L0 M0 N0 O0 P0 Q0 R0 R0 S0 T0 U0 V0 V0 W0 X0 Y0 Z0 [0 \0 ]0 ^0 _0 `0 a0 b0 c0 d0 e0 f0 g0 h0 i0 j0 k0 l0 l0 m0 n0 o0 p0 q0 q0 r0 s0 t0 u0 v0 w0 x0 y0 y0 z0 {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 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 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 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 000 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 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 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 0 0 !0 "0 #00 $0 %0 &0 '0 (0 )0 *0 +0 ,0 -0 .0 /0 00 10 20 30 40 50 60 70 80 90 :0 ;0 <0 =0 >0 ?0 @0 A0 B0 C0 D0 E0 F0 G0 H0 I0 J0 K0 L0 M0 N0 O0 P0000 Q0 R0 S0 T0 U0 V0 W0 X0 Y0 Z0 [0 \0 ]0 ^0 _0 `0 a0 b0 c0 d0 e0 f0 g0 h0 i0 j0 k0 l0 m0 n0 o0 p0 q0 r0 s0 t0 u0 v0 w0 x0 y0 z0 {0 |0 }0 ~0 0 0 0 0 0 g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g h h h h h h h h h h h h h h h hh hh hi j j j j j j j j j j j j j j j j k k l l l l l l m m m mm m m m m m m m m msm m mm m m m m m m m m m m m m m m m m m m n n n n n n n n n n n n n n n n n n n n n n n n n n n n !n "n #n $n %n &n 'n (n )n *n +n ,n -n .n /n 0n 1n 2n 3n 4n 5n 6n 7n 8n 9n :n ;n <n =n >n ?n @n An Bn Cn Dn En Fn Gn Hn In Jn Kn Ln Mn Nn On Pn Qn Rn Sn Tn Un Vn Wn Xn Yn Zn [n \n ]n ^n _n `n an bn cn d e fp gp hp hp ip jp kp lp mp np op pp qp rp sp tp uq vq wq wq xq yq zq {q |q }q ~q q q q q q q q q r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r s s s s s s s s s s s s s s s s s s s s s s s s t t t t t t t u u u u u u u u u u v v v v v v w w w w w w w w w w w w      x x x x x x x x x x x x x x x x x x e e e e e e e e e e e e e e e e e e e e e e ee y z z { { { { { { { | } } } } } } } } } } } } } } . . . . . . . . . . . . . . . . . . . . . !. ". #. $. %. &. '. (. ). *~ +~ ,~ -~ .~ /~ 0 1 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ _ ` a b c d e f g h i j k l m n o p q q r s t u v w x y z { | } ~   o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o D E F D D D D D D DE DE DE DE D D  D D  J J J J J J J J J J J PJ  J  J  J  J  J J J J J J J J 0J J J J J J J J J J J J  J !J "J #J $J %J &J 'J (J )J *J +J J J ,J-.J-/J01JK2JK3JK4JK5JK6JK7JK8JKJKJK9JKJKJK:JK;JK<JK=JK>JKJKJK?JKJK@JKAJKBJKCJKDJKEJKFJKGJKHJKIJKJJKKJKLJKMJKNJKOJKPJKJKQJKRJKSJKTJKUJKVJKWJKXJKYJKZJK[JK\JK]JK^JK_JK`JKaJKbJKcJK?JKdJKeJKfJKgJKhJKJKJKJK JKiJKjJKklmlnopqrstuvwHwx yz{z|}~n             !"#$#%&'()*+,-./01234w5w6w7w8w9w:ww;w<w=w]w^w_w>w?w@wAwBwCwDwEwFwGw wHwIwJ/KzLzMNOPQRSTUVWXYXZX[\]^_`a`bcd efghijklmn opqrstuvwxyz{|{ }{~{{{{{{ { |$1 >!!!$$$$$$$$$$$$$$$$$%%%%%,B1J2W55??{P  QSUV[\^{|}    @!EEEEqKOQ///stvwxy{| !"#$%&'()*+,-./0123456789:;<=>??@ABCD#E$F(GHIJKLMN/OPPQRSTUVWXYVZ[\]^_` abcde f g h i j k l mnop q r s t u v wxy 2 z { | }V~VVWWWWWWWX]]___ ___bb Obbcfff ff0000ghijkkkknnppprrrrrrrrrrrr Kr Lr Mrrrrrrrrrrrrrrrrrrrrrrrtttttuuuv eeeeeeeeeeeeeeeeeeeeeeeeeeeeeyyyy{}}}}}}}}}} } } } }}} }}.......~xy !"#$%&'()*+,-./0123456"&+78 9:;<=>?@ABCDEFGHoIoJoKoLoMoNoOoPoQoRoSoToUoVoWoXoYoZo[o\o]o^o_o`abcde fghijklmnopqrstuvwxyz{|}~gvt#Cabal-2.0.0.2-ArD10404PgFe4UBxSAxnL$Distribution.Compat.Prelude.InternalDistribution.Compat.SemigroupDistribution.Compat.StackDistribution.Compat.ExceptionDistribution.Utils.GenericDistribution.Compat.ReadPDistribution.Compat.GraphDistribution.Compat.BinaryDistribution.Compat.DListDistribution.Simple.UtilsDistribution.Compat.CreatePipe%Distribution.PackageDescription.UtilsDistribution.ReadEDistribution.Simple.CCompiler$Distribution.Simple.PreProcess.Unlit$Distribution.Simple.Program.InternalDistribution.TestSuiteDistribution.TextDistribution.SystemDistribution.Types.BuildTypeDistribution.Types.ConditionDistribution.Types.CondTree"Distribution.Types.ExecutableScope#Distribution.Types.ForeignLibOption!Distribution.Types.ForeignLibTypeDistribution.Types.SourceRepoDistribution.Utils.MapAccumDistribution.Utils.ProgressDistribution.Utils.ShortText Distribution.Types.PkgconfigNameDistribution.Types.ComponentIdDistribution.Types.AbiHashDistribution.ModuleName!Distribution.Types.ModuleRenaming"Distribution.Types.IncludeRenamingDistribution.VerbosityDistribution.VersionDistribution.Types.TestType%Distribution.Types.TestSuiteInterface&Distribution.Types.PkgconfigDependency Distribution.Types.BenchmarkType%Distribution.Types.BenchmarkInterfaceDistribution.LicenseLanguage.Haskell.ExtensionDistribution.Compiler%Distribution.PackageDescription.Parse!Distribution.InstalledPackageInfoDistribution.Simple.SetupDistribution.Types.PackageName&Distribution.Types.UnqualComponentName Distribution.Types.ComponentNameDistribution.Types.PackageIdDistribution.Types.UnitIdDistribution.Types.ModuleDistribution.BackpackDistribution.Backpack.ModSubst Distribution.Backpack.FullUnitId!Distribution.Types.ModuleReexportDistribution.Types.Mixin Distribution.Types.ExeDependencyDistribution.Types.Dependency!Distribution.Types.SetupBuildInfo Distribution.Types.DependencyMap$Distribution.Types.MungedPackageName"Distribution.Types.MungedPackageIdDistribution.PackageDistribution.Types.AnnotatedId#Distribution.Types.ComponentIncludeDistribution.Simple.InstallDirs&Distribution.Types.LegacyExeDependencyDistribution.Types.BuildInfoDistribution.Types.TestSuiteDistribution.Types.Library"Distribution.Types.HookedBuildInfoDistribution.Types.ForeignLibDistribution.Types.ExecutableDistribution.Types.BenchmarkDistribution.Types.Component)Distribution.Types.ComponentRequestedSpec%Distribution.Types.PackageDescription,Distribution.Types.GenericPackageDescription$Distribution.Simple.BuildToolDepends*Distribution.Types.ComponentLocalBuildInfoDistribution.Types.TargetInfo!Distribution.Backpack.ModuleShapeDistribution.Utils.NubListDistribution.Utils.LogProgress Distribution.Simple.Program.Find!Distribution.Simple.Program.TypesDistribution.Simple.Program.Run"Distribution.Simple.Program.ScriptDistribution.Simple.Program.LdDistribution.Simple.Program.Hpc#Distribution.Simple.Program.BuiltinDistribution.Simple.Program.DbDistribution.Simple.Program!Distribution.Simple.Program.Strip Distribution.Simple.PackageIndexDistribution.Simple.Compiler!Distribution.Simple.Program.HcPkgDistribution.Simple.GHCDistribution.Simple.Command!Distribution.Types.LocalBuildInfo"Distribution.Simple.LocalBuildInfoDistribution.Simple.Program.ArDistribution.Simple.Hpc Distribution.Simple.Build.Macros%Distribution.Backpack.ComponentsGraphDistribution.Simple.Test.LogDistribution.Simple.Program.GHCDistribution.Simple.Configure)Distribution.Backpack.ConfiguredComponent%Distribution.Backpack.LinkedComponentDistribution.Simple.BuildTargetDistribution.Simple.BuildPathsDistribution.Simple.UHCDistribution.Simple.LHCDistribution.Simple.JHC Distribution.Simple.HaskellSuiteDistribution.Simple.GHCJSDistribution.Simple.Install%Distribution.Simple.Build.PathsModuleDistribution.Simple.Test.LibV09Distribution.Simple.Test.ExeV10-Distribution.PackageDescription.Configuration+Distribution.PackageDescription.PrettyPrint%Distribution.PackageDescription.CheckDistribution.MakeDistribution.Compat.TimeDistribution.Backpack.Configure$Distribution.Backpack.DescribeUnitIdDistribution.Simple.RegisterDistribution.Simple.PreProcessDistribution.Simple.UserHooksDistribution.Simple.TestDistribution.Simple.BenchDistribution.Simple.SrcDistDistribution.Simple.BuildDistribution.Simple.HaddockDistribution.Simple.DoctestDistribution.Simple%Distribution.Compat.Internal.TempFileDistribution.Compat.Map.StrictDistribution.Compat.MonadFail Data.MonoidLast Verbosity annotateIODistribution.Compat.PreludeText.PrettyPrint<>Distribution.Compat.SnocListData.MapelemstoList Data.GraphGraph$Distribution.Compat.GetShortPathNameDistribution.Compat.CopyFileDistribution.Compat.EnvironmentControl.Exception IOExceptionDistribution.GetOptSystem.EnvironmentgetArgsDistribution.LexDistribution.Utils.Base62Distribution.Utils.StringIncludeRenaming Data.ListnubnubBySystem.FilePath isAbsolute isRelativeDistribution.Utils.UnionFind Data.TypeableTypeable Data.GenericsData GHC.GenericsGenericGeneric1 Data.FunctorFunctorData.Traversable Traversable Data.FoldableFoldableLanguage.Haskell.TH.SyntaxLiftDistribution.PrettyUtilsDistribution.ParseUtils"Distribution.Simple.GHC.IPIConvert!Distribution.Backpack.ModuleScopecomputeCompatPackageIdBuildToolDependsDistribution.PackageDescriptionCheckDistribution.Simple.GHC.IPI642Distribution.Backpack.UnifyMDistribution.Backpack.MixLink*Distribution.Backpack.PreExistingComponent Paths_Cabal Distribution.Simple.GHC.ImplInfo D.C.SetupfilterConfigureFlagsbuildDistribution.Backpack.Id Distribution.Simple.GHC.InternalmainfindPackageDescTestType$Distribution.Backpack.ReadyComponentbase Control.Arrowfirst Data.String fromStringData.SemigroupGHC.Basememptymappendmconcat Data.DataData.Typeable.InternalIsString SemigroupMonoidGHC.IntInt8Int16Int32Int64ghc-prim GHC.TypesWordGHC.WordWord8Word16Word32Word64GHC.Stack.Types CallStack Control.MonadunlessfoldMfilterMfor sequenceAtraverse GHC.StackwithFrozenCallStack callStack GHC.ExceptionprettyCallStackdisplayExceptionfindfor_ traverse_productsumminimummaximumelemlengthnullfoldl1foldr1foldl'foldlfoldrfoldMapgetAllAllgetAnyAny Data.OldListunfoldrsortBysort intercalate intersperse isInfixOf isSuffixOf isPrefixOfData.Ord comparingText.ParserCombinators.ReadPReadS GHC.UnicodetoUppertoLowerisUpper isAlphaNumisAlphaisDigitisSpacevoidGHC.Charchr Data.MaybemapMaybe catMaybes listToMaybe maybeToList fromMaybe isNothingisJustordapliftM2liftMwhenmanysome<|>empty Alternativemplusmzero MonadPlusbinary-0.8.5.1Data.Binary.ClassputListgetputBinarycontainers-0.5.10.2Data.Map.InternalMap CyclicSCC AcyclicSCCSCCdeepseq-1.4.3.0Control.DeepSeqrnfNFDatadecodeFileOrFail'decodeOrFailIOtryIOcatchIO catchExitLast'getLast'gmappendgmempty $fMonoidLast'$fSemigroupLast'$fGSemigroup:*:$fGSemigroupM1$fGSemigroupK1 $fGMonoid:*: $fGMonoidM1 $fGMonoidK1 $fEqLast' $fOrdLast' $fReadLast' $fShowLast' $fBinaryLast'$fFunctorLast'$fApplicativeLast'$fGenericLast' WithCallStackparentSrcLocPrefixwithLexicalCallStackannotateCallStackIO NoCallStackIOIO<<>> genericRnfReadPlookpfaileof+++<++gathersatisfycharstringmunchmunch1choice skipSpaces skipSpaces1countbetweenoptionoptionalmany1skipMany skipMany1sepBysepBy1endByendBy1chainrchainlchainr1chainl1manyTill readP_to_S readS_to_P $fMonadPlusP$fAlternativeP $fMonadFailP$fMonadP$fApplicativeP $fFunctorP$fMonadFailParser $fMonadParser$fApplicativeParser$fFunctorParserNodeNIsNodeKeynodeKey nodeNeighbors nodeValuesizememberlookupinsert deleteKey deleteLookup unionRight unionLeftstronglyConnCompcyclesbroken neighbors revNeighborsclosure revClosuretopSort revTopSortfromDistinctListkeyskeysSettoMaptoGraph$fIsNodeEither $fNFDataGraph$fFoldableGraph $fEqGraph $fBinaryGraph $fReadGraph $fShowGraph $fIsNodeNode $fFunctorNode $fShowNode$fEqNodeDListrunDList singletonsnoc$fSemigroupDList $fMonoidDListsetFileOrdinarysetFileExecutable createPipeuserBugcabalBugReadErunReadE succeedReadE failReadE parseReadE readEOrFail readP_to_E$fFunctorReadECDialectC ObjectiveC CPlusPlusObjectiveCPlusPluscSourceExtensionscDialectFilenameExtensionfilenameCDialect$fSemigroupCDialect$fMonoidCDialect $fEqCDialect$fShowCDialectplainunlitstripExtractVersionResultPassFailErrorProgressFinishedOptionsGroup ExtraOptions groupName concurrently groupTests OptionType OptionFile OptionString OptionNumber OptionBool OptionEnum OptionSet OptionRngSeedoptionFileMustExistoptionFileIsDiroptionFileExtensionsoptionStringMultilineoptionNumberIsIntoptionNumberBounds OptionDescr optionNameoptionDescription optionType optionDefault TestInstancerunnametagsoptions setOption testGroup$fEqOptionType$fReadOptionType$fShowOptionType$fEqOptionDescr$fReadOptionDescr$fShowOptionDescr $fEqResult $fReadResult $fShowResultTextdispparse defaultStyledisplay flatStyle simpleParsestdParse $fTextVersion $fTextInt $fTextBoolPlatformArchI386X86_64PPCPPC64SparcArmMipsSHIA64S390AlphaHppaRs6000M68kVax JavaScript OtherArchOSLinuxWindowsOSXFreeBSDOpenBSDNetBSD DragonFlySolarisAIXHPUXIRIXHaLVMHurdIOSAndroidGhcjsOtherOSClassificationStrictness PermissiveCompatStrictknownOSs classifyOSbuildOS knownArches classifyArch buildArch buildPlatformplatformFromTriple$fTextOS $fBinaryOS $fTextArch $fBinaryArch$fTextPlatform$fBinaryPlatform$fEqOS $fGenericOS$fOrdOS$fShowOS$fReadOS$fDataOS$fEqArch $fGenericArch $fOrdArch $fShowArch $fReadArch $fDataArch $fEqPlatform$fGenericPlatform $fOrdPlatform$fShowPlatform$fReadPlatform$fDataPlatform BuildTypeSimple ConfigureMakeCustomUnknownBuildTypeknownBuildTypes$fTextBuildType$fBinaryBuildType$fGenericBuildType$fShowBuildType$fReadBuildType $fEqBuildType$fDataBuildType ConditionVarLitCNotCOrCAndcNotcAndcOrsimplifyCondition$fBinaryCondition$fMonadPlusCondition$fAlternativeCondition$fSemigroupCondition$fMonoidCondition$fMonadCondition$fApplicativeCondition$fTraversableCondition$fFoldableCondition$fFunctorCondition$fShowCondition $fEqCondition$fDataCondition$fGenericCondition CondBranchcondBranchConditioncondBranchIfTruecondBranchIfFalseCondTreeCondNode condTreeDatacondTreeConstraintscondTreeComponents condIfThencondIfThenElse mapCondTreemapTreeConstrs mapTreeConds mapTreeDataextractConditionsimplifyCondTreeignoreConditions$fBinaryCondBranch$fFoldableCondBranch$fBinaryCondTree$fShowCondBranch$fEqCondBranch$fDataCondBranch$fGenericCondBranch$fFunctorCondBranch$fTraversableCondBranch$fShowCondTree $fEqCondTree$fDataCondTree$fGenericCondTree$fFunctorCondTree$fFoldableCondTree$fTraversableCondTreeExecutableScopeExecutableScopeUnknownExecutablePublicExecutablePrivate$fSemigroupExecutableScope$fMonoidExecutableScope$fBinaryExecutableScope$fTextExecutableScope$fGenericExecutableScope$fShowExecutableScope$fReadExecutableScope$fEqExecutableScope$fDataExecutableScopeForeignLibOptionForeignLibStandalone$fBinaryForeignLibOption$fTextForeignLibOption$fGenericForeignLibOption$fShowForeignLibOption$fReadForeignLibOption$fEqForeignLibOption$fDataForeignLibOptionForeignLibTypeForeignLibNativeSharedForeignLibNativeStaticForeignLibTypeUnknownknownForeignLibTypesforeignLibTypeIsShared$fMonoidForeignLibType$fSemigroupForeignLibType$fBinaryForeignLibType$fTextForeignLibType$fGenericForeignLibType$fShowForeignLibType$fReadForeignLibType$fEqForeignLibType$fDataForeignLibTypeRepoTypeDarcsGitSVNCVS MercurialGnuArchBazaarMonotone OtherRepoTypeRepoKindRepoHeadRepoThisRepoKindUnknown SourceReporepoKindrepoType repoLocation repoModule repoBranchrepoTag repoSubdiremptySourceRepoknownRepoTypesclassifyRepoKindclassifyRepoType$fTextRepoKind$fBinaryRepoKind$fTextRepoType$fBinaryRepoType$fBinarySourceRepo $fEqRepoKind$fGenericRepoKind $fOrdRepoKind$fReadRepoKind$fShowRepoKind$fDataRepoKind $fEqRepoType$fGenericRepoType $fOrdRepoType$fReadRepoType$fShowRepoType$fDataRepoType$fEqSourceRepo$fGenericSourceRepo$fReadSourceRepo$fShowSourceRepo$fDataSourceRepo mapAccumM$fApplicativeStateM$fFunctorStateM stepProgress failProgress foldProgress$fAlternativeProgress$fApplicativeProgress$fMonadProgress$fFunctorProgressdecodeStringUtf8encodeStringUtf8 ShortText toShortText fromShortText$fIsStringShortText$fMonoidShortText$fSemigroupShortText$fReadShortText$fShowShortText$fNFDataShortText$fBinaryShortText $fEqShortText$fOrdShortText$fGenericShortText$fDataShortText PkgconfigNameunPkgconfigNamemkPkgconfigName$fNFDataPkgconfigName$fTextPkgconfigName$fBinaryPkgconfigName$fIsStringPkgconfigName$fGenericPkgconfigName$fReadPkgconfigName$fShowPkgconfigName$fEqPkgconfigName$fOrdPkgconfigName$fDataPkgconfigName ComponentId mkComponentId unComponentId$fNFDataComponentId$fTextComponentId$fBinaryComponentId$fIsStringComponentId$fGenericComponentId$fReadComponentId$fShowComponentId$fEqComponentId$fOrdComponentId$fDataComponentIdAbiHash unAbiHash mkAbiHash $fTextAbiHash$fBinaryAbiHash$fIsStringAbiHash $fEqAbiHash $fShowAbiHash $fReadAbiHash$fGenericAbiHash ModuleNamevalidModuleComponentsimplefromComponents components toFilePath$fBinaryShortTextLst$fReadShortTextLst$fShowShortTextLst$fNFDataShortTextLst$fIsStringModuleName$fTextModuleName$fNFDataModuleName$fBinaryModuleName$fEqShortTextLst$fGenericShortTextLst$fOrdShortTextLst$fDataShortTextLst$fEqModuleName$fGenericModuleName$fOrdModuleName$fReadModuleName$fShowModuleName$fDataModuleNameModuleRenamingDefaultRenamingHidingRenamingdefaultRenamingisDefaultRenaming$fTextModuleRenaming$fBinaryModuleRenaming$fShowModuleRenaming$fReadModuleRenaming$fEqModuleRenaming$fOrdModuleRenaming$fDataModuleRenaming$fGenericModuleRenamingincludeProvidesRnincludeRequiresRndefaultIncludeRenamingisDefaultIncludeRenaming$fTextIncludeRenaming$fBinaryIncludeRenaming$fShowIncludeRenaming$fReadIncludeRenaming$fEqIncludeRenaming$fOrdIncludeRenaming$fDataIncludeRenaming$fGenericIncludeRenamingwrapTextwrapLinewithFileContentswriteFileAtomicfromUTF8 fromUTF8BS fromUTF8LBStoUTF8 startsWithBOM fileHasBOM ignoreBOM readUTF8FilewithUTF8FileContents writeUTF8FilenormaliseLineEndingsdropWhileEndLEtakeWhileEndLEordNubordNubBy listUnion ordNubRightlistUnionRightsafeTailequating lowercase unintersperseisAbsoluteOnAnyPlatformisRelativeOnAnyPlatformsilentnormalverbose deafening moreVerbose lessVerboseintToVerbosityflagToVerbosity showForCabal showForGHCverboseCallSiteverboseCallStackverboseMarkOutputverboseUnmarkOutput verboseNoWrapverboseNoFlagsverboseHasFlagsisVerboseCallSiteisVerboseCallStackisVerboseMarkOutputisVerboseNoWrapisVerboseQuiet$fBinaryVerbosityLevel$fBinaryVerbosityFlag$fBinaryVerbosity$fBoundedVerbosity$fEnumVerbosity$fOrdVerbosity $fEqVerbosity$fReadVerbosity$fShowVerbosity$fGenericVerbosityLevel$fShowVerbosityLevel$fReadVerbosityLevel$fEqVerbosityLevel$fOrdVerbosityLevel$fEnumVerbosityLevel$fBoundedVerbosityLevel$fGenericVerbosityFlag$fShowVerbosityFlag$fReadVerbosityFlag$fEqVerbosityFlag$fOrdVerbosityFlag$fEnumVerbosityFlag$fBoundedVerbosityFlag$fGenericVerbosityBoundExclusiveBoundInclusiveBound UpperBound NoUpperBound LowerBoundVersionIntervalVersionIntervals VersionRange AnyVersion ThisVersion LaterVersionEarlierVersionWildcardVersionMajorBoundVersionUnionVersionRangesIntersectVersionRangesVersionRangeParensVersion mkVersion mkVersion'versionNumbers nullVersion alterVersion showVersion anyVersion noVersion thisVersionnotThisVersion laterVersionorLaterVersionearlierVersionorEarlierVersionunionVersionRangesintersectVersionRangesdifferenceVersionRangesinvertVersionRange withinVersionmajorBoundVersionbetweenVersionsInclusiveremoveUpperBoundremoveLowerBoundfoldVersionRangefoldVersionRange' withinRangeasVersionIntervals isAnyVersion isNoVersionisSpecificVersionsimplifyVersionRangeversionIntervalsmkVersionIntervalswithinIntervalstoVersionIntervalsfromVersionIntervalsunionVersionIntervalsintersectVersionIntervalsinvertVersionIntervals hasUpperBound hasLowerBound$fNFDataVersion$fBinaryVersion $fReadVersion $fShowVersion $fOrdVersion$fTextVersionRange$fNFDataVersionRange$fBinaryVersionRange$fOrdUpperBound$fOrdLowerBound $fDataVersion $fEqVersion$fGenericVersion$fDataVersionRange$fEqVersionRange$fGenericVersionRange$fReadVersionRange$fShowVersionRange $fEqBound $fShowBound$fEqUpperBound$fShowUpperBound$fEqLowerBound$fShowLowerBound$fEqVersionIntervals$fShowVersionIntervalsTestType TestTypeExe TestTypeLibTestTypeUnknownknownTestTypes$fTextTestType$fBinaryTestType$fGenericTestType$fShowTestType$fReadTestType $fEqTestType$fDataTestTypeTestSuiteInterfaceTestSuiteExeV10TestSuiteLibV09TestSuiteUnsupported$fSemigroupTestSuiteInterface$fMonoidTestSuiteInterface$fBinaryTestSuiteInterface$fEqTestSuiteInterface$fGenericTestSuiteInterface$fReadTestSuiteInterface$fShowTestSuiteInterface$fDataTestSuiteInterfacePkgconfigDependency$fTextPkgconfigDependency$fNFDataPkgconfigDependency$fBinaryPkgconfigDependency$fGenericPkgconfigDependency$fReadPkgconfigDependency$fShowPkgconfigDependency$fEqPkgconfigDependency$fDataPkgconfigDependency BenchmarkTypeBenchmarkTypeExeBenchmarkTypeUnknownknownBenchmarkTypes$fTextBenchmarkType$fBinaryBenchmarkType$fGenericBenchmarkType$fShowBenchmarkType$fReadBenchmarkType$fEqBenchmarkType$fDataBenchmarkTypeBenchmarkInterfaceBenchmarkExeV10BenchmarkUnsupported$fSemigroupBenchmarkInterface$fMonoidBenchmarkInterface$fBinaryBenchmarkInterface$fEqBenchmarkInterface$fGenericBenchmarkInterface$fReadBenchmarkInterface$fShowBenchmarkInterface$fDataBenchmarkInterfaceLicenseGPLAGPLLGPLBSD2BSD3BSD4MITISCMPLApache PublicDomainAllRightsReservedUnspecifiedLicense OtherLicenseUnknownLicense knownLicenses $fTextLicense$fBinaryLicense$fGenericLicense $fReadLicense $fShowLicense $fEqLicense $fDataLicenseKnownExtensionOverlappingInstancesUndecidableInstancesIncoherentInstancesDoRec RecursiveDoParallelListCompMultiParamTypeClassesMonomorphismRestrictionFunctionalDependencies Rank2Types RankNTypesPolymorphicComponentsExistentialQuantificationScopedTypeVariablesPatternSignaturesImplicitParamsFlexibleContextsFlexibleInstancesEmptyDataDeclsCPPKindSignatures BangPatternsTypeSynonymInstancesTemplateHaskellForeignFunctionInterfaceArrowsGenericsImplicitPreludeNamedFieldPuns PatternGuardsGeneralizedNewtypeDerivingExtensibleRecordsRestrictedTypeSynonyms HereDocuments MagicHash TypeFamiliesStandaloneDeriving UnicodeSyntaxUnliftedFFITypesInterruptibleFFICApiFFILiberalTypeSynonyms TypeOperatorsRecordWildCards RecordPunsDisambiguateRecordFieldsTraditionalRecordSyntaxOverloadedStringsGADTs GADTSyntax MonoPatBindsRelaxedPolyRecExtendedDefaultRules UnboxedTuplesDeriveDataTypeable DeriveGenericDefaultSignatures InstanceSigsConstrainedClassMethodsPackageImportsImpredicativeTypesNewQualifiedOperatorsPostfixOperators QuasiQuotesTransformListCompMonadComprehensions ViewPatterns XmlSyntaxRegularPatterns TupleSectionsGHCForeignImportPrimNPlusKPatternsDoAndIfThenElse MultiWayIf LambdaCaseRebindableSyntaxExplicitForAllDatatypeContextsMonoLocalBinds DeriveFunctorDeriveTraversableDeriveFoldableNondecreasingIndentation SafeImportsSafe TrustworthyUnsafeConstraintKinds PolyKinds DataKindsParallelArraysRoleAnnotationsOverloadedLists EmptyCaseAutoDeriveTypeableNegativeLiteralsBinaryLiterals NumDecimalsNullaryTypeClassesExplicitNamespacesAllowAmbiguousTypes JavaScriptFFIPatternSynonymsPartialTypeSignaturesNamedWildCardsDeriveAnyClass DeriveLiftStaticPointers StrictData ApplicativeDoDuplicateRecordFieldsTypeApplications TypeInTypeUndecidableSuperClassesMonadFailDesugaringTemplateHaskellQuotesOverloadedLabelsTypeFamilyDependencies ExtensionEnableExtensionDisableExtensionUnknownExtensionLanguage Haskell98 Haskell2010UnknownLanguageknownLanguagesclassifyLanguageknownExtensionsdeprecatedExtensionsclassifyExtension$fTextLanguage$fBinaryLanguage$fTextKnownExtension$fBinaryKnownExtension$fTextExtension$fBinaryExtension$fGenericLanguage$fShowLanguage$fReadLanguage $fEqLanguage$fDataLanguage$fGenericKnownExtension$fShowKnownExtension$fReadKnownExtension$fEqKnownExtension$fOrdKnownExtension$fEnumKnownExtension$fBoundedKnownExtension$fDataKnownExtension$fGenericExtension$fShowExtension$fReadExtension $fEqExtension$fOrdExtension$fDataExtensionAbiTagNoAbiTag CompilerInfocompilerInfoIdcompilerInfoAbiTagcompilerInfoCompatcompilerInfoLanguagescompilerInfoExtensions CompilerIdCompilerFlavorGHCGHCJSNHCYHCHugsHBCHeliumJHCLHCUHC HaskellSuite OtherCompilerclassifyCompilerFlavorparseCompilerFlavorCompatbuildCompilerFlavorbuildCompilerIddefaultCompilerFlavor abiTagStringunknownCompilerInfo$fTextCompilerFlavor$fBinaryCompilerFlavor$fTextCompilerId$fBinaryCompilerId $fTextAbiTag$fBinaryAbiTag$fBinaryCompilerInfo$fGenericCompilerFlavor$fShowCompilerFlavor$fReadCompilerFlavor$fEqCompilerFlavor$fOrdCompilerFlavor$fDataCompilerFlavor$fEqCompilerId$fGenericCompilerId$fOrdCompilerId$fReadCompilerId$fShowCompilerId $fEqAbiTag$fGenericAbiTag $fShowAbiTag $fReadAbiTag$fGenericCompilerInfo$fShowCompilerInfo$fReadCompilerInfo FieldDescr fieldNamefieldGetfieldSet ParseResult ParseFailedParseOkPWarningPErrorAmbiguousParseNoParse TabsError FromStringLineNo readPToMaybe PackageName unPackageName mkPackageName$fNFDataPackageName$fTextPackageName$fBinaryPackageName$fIsStringPackageName$fGenericPackageName$fReadPackageName$fShowPackageName$fEqPackageName$fOrdPackageName$fDataPackageNameUnqualComponentNameunUnqualComponentNamemkUnqualComponentName packageNameToUnqualComponentName unqualComponentNameToPackageName$fNFDataUnqualComponentName$fTextUnqualComponentName$fBinaryUnqualComponentName$fIsStringUnqualComponentName$fGenericUnqualComponentName$fReadUnqualComponentName$fShowUnqualComponentName$fEqUnqualComponentName$fOrdUnqualComponentName$fDataUnqualComponentName$fSemigroupUnqualComponentName$fMonoidUnqualComponentName ComponentNameCLibName CSubLibName CFLibNameCExeName CTestName CBenchNamedefaultLibNameshowComponentNamecomponentNameStanzacomponentNameStringlibraryComponentName$fTextComponentName$fBinaryComponentName$fEqComponentName$fGenericComponentName$fOrdComponentName$fReadComponentName$fShowComponentNamePackageIdentifierpkgName pkgVersion PackageId$fNFDataPackageIdentifier$fTextPackageIdentifier$fBinaryPackageIdentifier$fGenericPackageIdentifier$fReadPackageIdentifier$fShowPackageIdentifier$fEqPackageIdentifier$fOrdPackageIdentifier$fDataPackageIdentifier DefUnitId unDefUnitIdInstalledPackageIdUnitIdunUnitIdmkUnitIdnewSimpleUnitIdmkLegacyUnitIdgetHSLibraryNameunsafeMkDefUnitId$fIsStringUnitId $fTextUnitId$fBinaryUnitId$fGenericUnitId $fReadUnitId $fShowUnitId $fEqUnitId $fOrdUnitId $fDataUnitId$fNFDataUnitId$fGenericDefUnitId$fReadDefUnitId$fShowDefUnitId $fEqDefUnitId$fOrdDefUnitId$fDataDefUnitId$fBinaryDefUnitId$fNFDataDefUnitId$fTextDefUnitIdModule$fNFDataModule $fTextModule$fBinaryModule$fGenericModule $fReadModule $fShowModule $fEqModule $fOrdModule $fDataModuleOpenModuleSubst OpenModule OpenModuleVar OpenUnitIdIndefFullUnitIdDefiniteUnitIdopenUnitIdFreeHoles mkOpenUnitId mkDefUnitIdopenModuleFreeHolesdispOpenModuleSubstdispOpenModuleSubstEntryparseOpenModuleSubstparseOpenModuleSubstEntryopenModuleSubstFreeHolesabstractUnitIdhashModuleSubst$fTextOpenModule$fNFDataOpenModule$fBinaryOpenModule$fTextOpenUnitId$fNFDataOpenUnitId$fBinaryOpenUnitId$fGenericOpenModule$fReadOpenModule$fShowOpenModule$fEqOpenModule$fOrdOpenModule$fDataOpenModule$fGenericOpenUnitId$fReadOpenUnitId$fShowOpenUnitId$fEqOpenUnitId$fOrdOpenUnitId$fDataOpenUnitIdModSubstmodSubst $fModSubst(,) $fModSubst[] $fModSubstMap $fModSubstSet$fModSubstOpenUnitId$fModSubstOpenModuleFullDb FullUnitIdexpandOpenUnitId expandUnitId$fShowFullUnitId$fGenericFullUnitIdModuleReexportmoduleReexportOriginalPackagemoduleReexportOriginalNamemoduleReexportName$fTextModuleReexport$fBinaryModuleReexport$fEqModuleReexport$fGenericModuleReexport$fReadModuleReexport$fShowModuleReexport$fDataModuleReexportMixinmixinPackageNamemixinIncludeRenaming $fTextMixin $fBinaryMixin $fShowMixin $fReadMixin $fEqMixin $fOrdMixin $fDataMixin$fGenericMixin ExeDependencyqualifiedExeName$fTextExeDependency$fNFDataExeDependency$fBinaryExeDependency$fGenericExeDependency$fReadExeDependency$fShowExeDependency$fEqExeDependency$fDataExeDependency Dependency depPkgName depVerRangethisPackageVersionnotThisPackageVersionsimplifyDependency$fTextDependency$fNFDataDependency$fBinaryDependency$fGenericDependency$fReadDependency$fShowDependency$fEqDependency$fDataDependencySetupBuildInfo setupDependsdefaultSetupDepends$fSemigroupSetupBuildInfo$fMonoidSetupBuildInfo$fBinarySetupBuildInfo$fGenericSetupBuildInfo$fShowSetupBuildInfo$fEqSetupBuildInfo$fReadSetupBuildInfo$fDataSetupBuildInfo DependencyMaptoDepMap fromDepMap constrainBy$fSemigroupDependencyMap$fMonoidDependencyMap$fShowDependencyMap$fReadDependencyMapMungedPackageNameunMungedPackageNamemkMungedPackageNamecomputeCompatPackageNamedecodeCompatPackageName$fNFDataMungedPackageName$fTextMungedPackageName$fBinaryMungedPackageName$fIsStringMungedPackageName$fGenericMungedPackageName$fReadMungedPackageName$fShowMungedPackageName$fEqMungedPackageName$fOrdMungedPackageName$fDataMungedPackageNameMungedPackageId mungedName mungedVersion$fNFDataMungedPackageId$fTextMungedPackageId$fBinaryMungedPackageId$fGenericMungedPackageId$fReadMungedPackageId$fShowMungedPackageId$fEqMungedPackageId$fOrdMungedPackageId$fDataMungedPackageIdPackageInstalledinstalledDepends HasUnitIdinstalledUnitIdHasMungedPackageIdmungedIdPackage packageId mungedName'mungedVersion' packageNamepackageVersioninstalledPackageId$fPackagePackageIdentifier#$fHasMungedPackageIdMungedPackageId AnnotatedIdann_pid ann_cnameann_id$fFunctorAnnotatedId$fPackageAnnotatedId$fShowAnnotatedIdComponentInclude ci_ann_id ci_renaming ci_implicitci_idci_pkgidci_cnamePathTemplateEnvPathTemplateVariable PrefixVar BindirVar LibdirVar LibsubdirVar DynlibdirVar DatadirVar DatasubdirVar DocdirVar HtmldirVar PkgNameVar PkgVerVarPkgIdVar LibNameVar CompilerVarOSVarArchVarAbiVar AbiTagVarExecutableNameVarTestSuiteNameVarTestSuiteResultVarBenchmarkNameVar PathTemplateCopyDest NoCopyDestCopyToInstallDirTemplates InstallDirsprefixbindirlibdir libsubdir dynlibdirflibdir libexecdir libexecsubdir includedirdatadir datasubdirdocdirmandirhtmldir haddockdir sysconfdircombineInstallDirsdefaultInstallDirsdefaultInstallDirs'substituteInstallDirTemplatesabsoluteInstallDirsprefixRelativeInstallDirstoPathTemplatefromPathTemplatecombinePathTemplatesubstPathTemplateinitialPathTemplateEnvpackageTemplateEnvcompilerTemplateEnvplatformTemplateEnvabiTemplateEnvinstallDirsTemplateEnv$fSemigroupInstallDirs$fMonoidInstallDirs$fBinaryInstallDirs$fReadPathTemplateVariable$fShowPathTemplateVariable$fBinaryPathTemplateVariable$fReadPathComponent$fShowPathComponent$fBinaryPathComponent$fReadPathTemplate$fShowPathTemplate$fBinaryPathTemplate$fEqInstallDirs$fReadInstallDirs$fShowInstallDirs$fFunctorInstallDirs$fGenericInstallDirs $fEqCopyDest$fShowCopyDest$fEqPathTemplateVariable$fOrdPathTemplateVariable$fGenericPathTemplateVariable$fEqPathComponent$fOrdPathComponent$fGenericPathComponent$fEqPathTemplate$fOrdPathTemplate$fGenericPathTemplateLegacyExeDependency$fTextLegacyExeDependency$fNFDataLegacyExeDependency$fBinaryLegacyExeDependency$fGenericLegacyExeDependency$fReadLegacyExeDependency$fShowLegacyExeDependency$fEqLegacyExeDependency$fDataLegacyExeDependency BuildInfo buildable buildToolsbuildToolDepends cppOptions ccOptions ldOptionspkgconfigDepends frameworksextraFrameworkDirscSources jsSources hsSourceDirs otherModulesautogenModulesdefaultLanguageotherLanguagesdefaultExtensionsotherExtensions oldExtensions extraLibs extraGHCiLibs extraLibDirs includeDirsincludesinstallIncludes profOptions sharedOptionscustomFieldsBItargetBuildDependsmixinsemptyBuildInfo allLanguages allExtensionsusedExtensions hcOptions hcProfOptionshcSharedOptions$fSemigroupBuildInfo$fMonoidBuildInfo$fBinaryBuildInfo$fGenericBuildInfo$fShowBuildInfo$fReadBuildInfo $fEqBuildInfo$fDataBuildInfo TestSuitetestName testInterface testBuildInfoemptyTestSuitetestType testModulestestModulesAutogen$fSemigroupTestSuite$fMonoidTestSuite$fBinaryTestSuite$fGenericTestSuite$fShowTestSuite$fReadTestSuite $fEqTestSuite$fDataTestSuiteLibrarylibNameexposedModulesreexportedModules signatures libExposed libBuildInfo emptyLibraryexplicitLibModuleslibModulesAutogen libModules$fSemigroupLibrary$fMonoidLibrary$fBinaryLibrary$fGenericLibrary $fShowLibrary $fEqLibrary $fReadLibrary $fDataLibraryHookedBuildInfoemptyHookedBuildInfoLibVersionInfo ForeignLibforeignLibNameforeignLibTypeforeignLibOptionsforeignLibBuildInfoforeignLibVersionInfoforeignLibVersionLinuxforeignLibModDefFilemkLibVersionInfolibVersionInfoCRAlibVersionNumberlibVersionNumberShowlibVersionMajoremptyForeignLibforeignLibModulesforeignLibIsSharedforeignLibVersion$fTextLibVersionInfo$fBinaryLibVersionInfo$fReadLibVersionInfo$fShowLibVersionInfo$fOrdLibVersionInfo$fMonoidForeignLib$fSemigroupForeignLib$fBinaryForeignLib$fDataLibVersionInfo$fEqLibVersionInfo$fGenericLibVersionInfo$fGenericForeignLib$fShowForeignLib$fReadForeignLib$fEqForeignLib$fDataForeignLib ExecutableexeName modulePathexeScope buildInfoemptyExecutable exeModulesexeModulesAutogen$fSemigroupExecutable$fMonoidExecutable$fBinaryExecutable$fGenericExecutable$fShowExecutable$fReadExecutable$fEqExecutable$fDataExecutable Benchmark benchmarkNamebenchmarkInterfacebenchmarkBuildInfoemptyBenchmark benchmarkTypebenchmarkModulesbenchmarkModulesAutogen$fSemigroupBenchmark$fMonoidBenchmark$fBinaryBenchmark$fGenericBenchmark$fShowBenchmark$fReadBenchmark $fEqBenchmark$fDataBenchmark ComponentCLibCFLibCExeCTestCBench foldComponentcomponentBuildInfocomponentBuildable componentNamepartitionComponents$fSemigroupComponent$fShowComponent $fEqComponent$fReadComponentComponentDisabledReasonDisabledComponentDisabledAllTestsDisabledAllBenchmarksDisabledAllButOneComponentRequestedSpecOneComponentRequestedSpectestsRequestedbenchmarksRequesteddefaultComponentRequestedSpeccomponentEnabledcomponentNameRequestedcomponentDisabledReason$fBinaryComponentRequestedSpec$fGenericComponentRequestedSpec$fReadComponentRequestedSpec$fShowComponentRequestedSpec$fEqComponentRequestedSpecPackageDescriptionpackagelicense licenseFiles copyright maintainerauthor stability testedWithhomepagepkgUrl bugReports sourceRepossynopsis descriptioncategorycustomFieldsPD buildDependsspecVersionRaw buildTypesetupBuildInfolibrary subLibraries executables foreignLibs testSuites benchmarks dataFilesdataDir extraSrcFiles extraTmpFiles extraDocFiles specVersiondescCabalVersionemptyPackageDescription hasPublicLibhasLibs allLibrarieswithLibhasExeswithExehasTestswithTest hasBenchmarks withBenchmarkhasForeignLibswithForeignLib allBuildInfoenabledBuildInfosupdatePackageDescription pkgComponentspkgBuildableComponentsenabledComponentslookupComponent getComponent$fPackagePackageDescription$fBinaryPackageDescription$fGenericPackageDescription$fShowPackageDescription$fReadPackageDescription$fEqPackageDescription$fDataPackageDescriptionConfVarFlagImplFlagAssignmentFlagNameMkFlagflagNameflagDescription flagDefault flagManualGenericPackageDescriptionpackageDescriptiongenPackageFlags condLibrarycondSubLibrariescondForeignLibscondExecutablescondTestSuitescondBenchmarks emptyFlag mkFlagName unFlagName showFlagValuedispFlagAssignmentparseFlagAssignment$fBinaryFlagName$fIsStringFlagName $fBinaryFlag$fBinaryConfVar!$fBinaryGenericPackageDescription"$fPackageGenericPackageDescription $fEqFlagName$fGenericFlagName $fOrdFlagName$fShowFlagName$fReadFlagName$fDataFlagName $fShowFlag$fEqFlag $fDataFlag $fGenericFlag $fEqConfVar $fShowConfVar $fDataConfVar$fGenericConfVar$fShowGenericPackageDescription$fEqGenericPackageDescription$fDataGenericPackageDescription"$fGenericGenericPackageDescriptiondesugarBuildToolgetAllToolDependencies isInternalgetAllInternalToolDependencies AbiDependency depUnitId depAbiHash ExposedModule exposedNameexposedReexportInstalledPackageInfosourcePackageIdinstalledComponentId_instantiatedWith sourceLibNamecompatPackageKeyabiHash indefiniteexposed hiddenModulestrusted importDirs libraryDirslibraryDynDirs hsLibrariesextraLibrariesextraGHCiLibrariesdepends abiDepends frameworkDirshaddockInterfaces haddockHTMLspkgRootinstalledComponentIdinstalledOpenUnitIdrequiredSignaturesemptyInstalledPackageInfosourceComponentNameparseInstalledPackageInfoshowInstalledPackageInfoshowInstalledPackageInfoField#showSimpleInstalledPackageInfoFieldfieldsInstalledPackageInfo$fBinaryExposedModule$fTextExposedModule$fBinaryAbiDependency$fTextAbiDependency$fIsNodeInstalledPackageInfo&$fPackageInstalledInstalledPackageInfo$fHasUnitIdInstalledPackageInfo$fPackageInstalledPackageInfo($fHasMungedPackageIdInstalledPackageInfo$fBinaryInstalledPackageInfo$fEqExposedModule$fGenericExposedModule$fReadExposedModule$fShowExposedModule$fEqAbiDependency$fGenericAbiDependency$fReadAbiDependency$fShowAbiDependency$fEqInstalledPackageInfo$fGenericInstalledPackageInfo$fReadInstalledPackageInfo$fShowInstalledPackageInfoComponentLocalBuildInfoLibComponentLocalBuildInfoFLibComponentLocalBuildInfoExeComponentLocalBuildInfoTestComponentLocalBuildInfoBenchComponentLocalBuildInfocomponentLocalNamecomponentComponentIdcomponentUnitIdcomponentIsIndefinite_componentInstantiatedWithcomponentPackageDepscomponentIncludescomponentExeDepscomponentInternalDepscomponentCompatPackageKeycomponentCompatPackageNamecomponentExposedModulescomponentIsPubliccomponentIsIndefinitemaybeComponentInstantiatedWith$fIsNodeComponentLocalBuildInfo$fBinaryComponentLocalBuildInfo $fGenericComponentLocalBuildInfo$fReadComponentLocalBuildInfo$fShowComponentLocalBuildInfo TargetInfo targetCLBItargetComponent$fIsNodeTargetInfo ModuleShapemodShapeProvidesmodShapeRequiresemptyModuleShapeshapeInstalledPackage$fModSubstModuleShape$fBinaryModuleShape$fEqModuleShape$fShowModuleShape$fGenericModuleShapeTempFileOptionsoptKeepTempFilesFileGlobNoGlob cabalVersiondieWithLocationdiedieNoVerbositydieWithLocation'die' dieNoWraptopHandlerWith topHandlerwarnnotice noticeNoWrap noticeDoc setupMessageinfo infoNoWrapdebug debugNoWrap chattyTryhandleDoesNotExist maybeExitprintRawCommandAndArgsprintRawCommandAndArgsAndEnv rawSystemExitrawSystemExitCoderawSystemExitWithEnvrawSystemIOWithEnvcreateProcessWithEnvrawSystemStdoutrawSystemStdInOutfindProgramLocationfindProgramVersionxargsfindFilefindFileWithExtensionfindAllFilesWithExtensionfindFileWithExtension' findFirstFilefindModuleFilesfindModuleFilegetDirectoryContentsRecursiveisInSearchPathaddLibraryPath parseFileGlob matchFileGlobmatchDirFileGlobmoreRecentFileexistsAndIsMoreRecentThancreateDirectoryIfMissingVerbosecopyFileVerboseinstallOrdinaryFileinstallExecutableFileinstallMaybeExecutableFile copyFileTo copyFilesinstallOrdinaryFilesinstallExecutableFilesinstallMaybeExecutableFilesinstallDirectoryContentscopyDirectoryRecursivedoesExecutableExistsmartCopySourcescopyDirectoryRecursiveVerbosedefaultTempFileOptions withTempFilewithTempFileExwithTempDirectorywithTempDirectoryEx rewriteFile rewriteFileEx currentDirshortRelativePathdropExeExtension exeExtensionsdefaultPackageDesctryFindPackageDescdefaultHookedPackageDescfindHookedPackageDesc $fEqTraceWhenNubListR fromNubListRNubList fromNubList toNubList overNubList toNubListR overNubListR$fBinaryNubList $fReadNubList $fShowNubList$fSemigroupNubList$fMonoidNubList$fReadNubListR$fShowNubListR$fSemigroupNubListR$fMonoidNubListR $fEqNubList $fEqNubListR LogProgressrunLogProgress warnProgress infoProgress dieProgressaddProgressCtx$fMonadLogProgress$fApplicativeLogProgress$fFunctorLogProgressProgramSearchPathEntryProgramSearchPathDirProgramSearchPathDefaultProgramSearchPathdefaultProgramSearchPathfindProgramOnSearchPathprogramSearchPathAsPATHVargetSystemSearchPath$fBinaryProgramSearchPathEntry$fEqProgramSearchPathEntry$fGenericProgramSearchPathEntryProgramLocation UserSpecified FoundOnSystem locationPathConfiguredProgram programIdprogramVersionprogramDefaultArgsprogramOverrideArgsprogramOverrideEnvprogramPropertiesprogramLocationprogramMonitorFilesProgArgProgram programNameprogramFindLocationprogramFindVersionprogramPostConf programPathsuppressOverrideArgs simpleProgramsimpleConfiguredProgram$fBinaryProgramLocation$fBinaryConfiguredProgram $fShowProgram$fEqProgramLocation$fGenericProgramLocation$fReadProgramLocation$fShowProgramLocation$fEqConfiguredProgram$fGenericConfiguredProgram$fReadConfiguredProgram$fShowConfiguredProgram IOEncodingIOEncodingTextIOEncodingUTF8ProgramInvocationprogInvokePathprogInvokeArgs progInvokeEnvprogInvokePathEnv progInvokeCwdprogInvokeInputprogInvokeInputEncodingprogInvokeOutputEncodingemptyProgramInvocationsimpleProgramInvocationprogramInvocationrunProgramInvocationgetProgramInvocationOutputgetEffectiveEnvironmentmultiStageProgramInvocationinvocationAsSystemScriptinvocationAsShellScriptinvocationAsBatchFilecombineObjectFilesmarkupunionbuiltinPrograms ghcProgram runghcProgram ghcPkgProgram ghcjsProgramghcjsPkgProgram lhcProgram lhcPkgProgram hmakeProgram jhcProgram uhcProgram hpcProgramhaskellSuiteProgramhaskellSuitePkgProgram happyProgram alexProgram gccProgram arProgram stripProgram hsc2hsProgram c2hsProgram cpphsProgramhscolourProgramdoctestProgramhaddockProgramgreencardProgram ldProgram tarProgram cppProgrampkgConfigProgram ProgramDbemptyProgramDbdefaultProgramDbrestoreProgramDbaddKnownProgramaddKnownProgramslookupKnownProgram knownProgramsgetProgramSearchPathsetProgramSearchPathmodifyProgramSearchPathuserSpecifyPathuserMaybeSpecifyPathuserSpecifyArgsuserSpecifyPathsuserSpecifyArgssuserSpecifiedArgs lookupProgram updateProgramconfiguredProgramsconfigureProgramunconfigureProgramconfigureAllKnownProgramsreconfigureProgramsrequireProgramlookupProgramVersionrequireProgramVersion$fBinaryProgramDb$fReadProgramDb$fShowProgramDbProgramConfiguration runProgramgetProgramOutput runDbProgramgetDbProgramOutputrawSystemProgramrawSystemProgramStdoutrawSystemProgramConfrawSystemProgramStdoutConfemptyProgramConfigurationdefaultProgramConfigurationrestoreProgramConfigurationfindProgramOnPathstripExestripLib SearchResultNone Unambiguous AmbiguousInstalledPackageIndex PackageIndexfromListmerge deleteUnitIddeleteInstalledPackageIddeleteSourcePackageIddeletePackageName allPackagesallPackagesByNameallPackagesBySourcePackageId&allPackagesBySourcePackageIdAndLibName lookupUnitIdlookupComponentIdlookupInstalledPackageIdlookupSourcePackageIdlookupPackageIdlookupPackageNamelookupDependencylookupInternalDependency searchByNamesearchByNameSubstringdependencyCyclesbrokenPackagesdependencyClosurereverseDependencyClosuretopologicalOrderreverseTopologicalOrderdependencyGraphdependencyInconsistenciesmoduleNameIndex$fSemigroupPackageIndex$fMonoidPackageIndex$fBinaryPackageIndex$fEqPackageIndex$fGenericPackageIndex$fShowPackageIndex$fReadPackageIndexProfDetailLevelProfDetailNoneProfDetailDefaultProfDetailExportedFunctionsProfDetailToplevelFunctionsProfDetailAllFunctionsProfDetailOtherDebugInfoLevel NoDebugInfoMinimalDebugInfoNormalDebugInfoMaximalDebugInfoOptimisationLevelNoOptimisationNormalOptimisationMaximumOptimisationPackageDBStack PackageDBGlobalPackageDB UserPackageDBSpecificPackageDBCompiler compilerIdcompilerAbiTagcompilerCompatcompilerLanguagescompilerExtensionscompilerPropertiesshowCompilerIdshowCompilerIdWithAbicompilerFlavorcompilerVersioncompilerCompatFlavorcompilerCompatVersion compilerInforegistrationPackageDBabsolutePackageDBPathsabsolutePackageDBPathflagToOptimisationLevelflagToDebugInfoLevelunsupportedLanguageslanguageToFlagsunsupportedExtensionsextensionsToFlagsparmakeSupportedreexportedModulesSupportedrenamingPackageFlagsSupportedunifiedIPIDRequiredpackageKeySupportedunitIdSupportedbackpackSupportedlibraryDynDirSupportedcoverageSupportedprofilingSupportedflagToProfDetailLevelknownProfDetailLevelsshowProfDetailLevel$fBinaryPackageDB$fBinaryOptimisationLevel$fBinaryDebugInfoLevel$fBinaryCompiler$fBinaryProfDetailLevel $fEqPackageDB$fGenericPackageDB$fOrdPackageDB$fShowPackageDB$fReadPackageDB$fBoundedOptimisationLevel$fEnumOptimisationLevel$fEqOptimisationLevel$fGenericOptimisationLevel$fReadOptimisationLevel$fShowOptimisationLevel$fBoundedDebugInfoLevel$fEnumDebugInfoLevel$fEqDebugInfoLevel$fGenericDebugInfoLevel$fReadDebugInfoLevel$fShowDebugInfoLevel $fEqCompiler$fGenericCompiler$fShowCompiler$fReadCompiler$fEqProfDetailLevel$fGenericProfDetailLevel$fReadProfDetailLevel$fShowProfDetailLevelRegisterOptionsregisterAllowOverwriteregisterMultiInstanceregisterSuppressFilesCheck HcPkgInfo hcPkgProgram noPkgDbStack noVerboseFlagflagPackageConfsupportsDirDbsrequiresDirDbsnativeMultiInstancerecacheMultiInstancesuppressFilesCheckinitinvokedefaultRegisterOptionsregister unregisterrecacheexposedescribehidedumplistinitInvocationregisterInvocationunregisterInvocationrecacheInvocationexposeInvocationdescribeInvocationhideInvocationdumpInvocationlistInvocation GhcImplInfosupportsHaskell2010 reportsNoExtalwaysNondecIndentflagGhciScript flagProfAuto flagDebugInfosupportsPkgEnvFilesflagWarnMissingHomeModules getImplInfo CommandSpecCommand CommandType NormalCommand HiddenCommand CommandParse CommandHelp CommandList CommandErrorsCommandReadyToGo MkOptDescrArgPlaceHolderOptFlagsLFlagsSFlagsOptDescrReqArgOptArg ChoiceOptBoolOpt OptionField optionDescr DescriptionNameShowOrParseArgsShowArgs ParseArgs CommandUI commandNamecommandSynopsis commandUsagecommandDescription commandNotescommandDefaultFlagscommandOptions multiOptionreqArgoptArgreqArg'optArg'noArgboolOptboolOpt' choiceOptchoiceOptFromEnumviewAsFieldDescr liftOptioncommandShowOptions usageDefaultusageAlternatives mkCommandUIcommandParseArgs hiddenCommandcommandAddAction commandsRun noExtraFlagsgetNormalCommandDescriptions helpCommandUIcommandFromSpec$fFunctorCommandParseBenchmarkFlagsbenchmarkDistPrefbenchmarkVerbositybenchmarkOptions TestFlags testDistPref testVerbosity testHumanLogtestMachineLogtestShowDetails testKeepTix testOptionsTestShowDetailsNeverFailuresAlways StreamingDirect ReplFlagsreplProgramPathsreplProgramArgs replDistPref replVerbosity replReload BuildFlagsbuildProgramPathsbuildProgramArgs buildDistPrefbuildVerbosity buildNumJobs buildArgs CleanFlags cleanSaveConf cleanDistPrefcleanVerbosity HaddockFlagshaddockProgramPathshaddockProgramArgs haddockHoogle haddockHtmlhaddockHtmlLocationhaddockForHackagehaddockExecutableshaddockTestSuiteshaddockBenchmarkshaddockForeignLibshaddockInternal haddockCsshaddockHscolourhaddockHscolourCsshaddockContentshaddockDistPrefhaddockKeepTempFileshaddockVerbosity HaddockTarget ForHackageForDevelopment DoctestFlagsdoctestProgramPathsdoctestProgramArgsdoctestDistPrefdoctestVerbosity HscolourFlags hscolourCSShscolourExecutableshscolourTestSuiteshscolourBenchmarkshscolourForeignLibshscolourDistPrefhscolourVerbosity RegisterFlags regPackageDB regGenScript regGenPkgConf regInPlace regDistPref regPrintId regVerbosityregArgs SDistFlags sDistSnapshotsDistDirectory sDistDistPrefsDistListSourcessDistVerbosity InstallFlagsinstallPackageDBinstallDistPrefinstallUseWrapperinstallInPlaceinstallVerbosity CopyFlagscopyDest copyDistPref copyVerbositycopyArgs ConfigFlags configArgsconfigPrograms_configProgramPathsconfigProgramArgsconfigProgramPathExtraconfigHcFlavor configHcPath configHcPkgconfigVanillaLib configProfLibconfigSharedLib configDynExe configProfExe configProfconfigProfDetailconfigProfLibDetailconfigConfigureArgsconfigOptimizationconfigProgPrefixconfigProgSuffixconfigInstallDirsconfigScratchDirconfigExtraLibDirsconfigExtraFrameworkDirsconfigExtraIncludeDirs configIPID configCIDconfigDeterministicconfigDistPrefconfigCabalFilePathconfigVerbosityconfigUserInstallconfigPackageDBs configGHCiLibconfigSplitObjsconfigStripExesconfigStripLibsconfigConstraintsconfigDependenciesconfigInstantiateWithconfigConfigurationsFlags configTestsconfigBenchmarksconfigCoverageconfigLibCoverageconfigExactConfigurationconfigFlagErrorconfigRelocatableconfigDebugInfoconfigAllowOlderconfigAllowNewer RelaxedDepRelaxedDepScoped AllowOlder unAllowOlder AllowNewer unAllowNewer RelaxDeps RelaxDepsNone RelaxDepsSome RelaxDepsAll GlobalFlags globalVersionglobalNumericVersion BooleanFlagasBoolNoFlagdefaultDistPreftoFlagfromFlagfromFlagOrDefault flagToMaybe flagToList maybeToFlagdefaultGlobalFlags globalCommandemptyGlobalFlags isRelaxDepsconfigProgramsconfigAbsolutePathsdefaultConfigFlagsconfigureCommandconfigureOptionsreadPackageDbListshowPackageDbListinstallDirsOptionsemptyConfigFlagsdefaultCopyFlags copyCommandemptyCopyFlagsdefaultInstallFlagsinstallCommandemptyInstallFlagsdefaultSDistFlags sdistCommandemptySDistFlagsdefaultRegisterFlagsregisterCommandunregisterCommandemptyRegisterFlagsemptyHscolourFlagsdefaultHscolourFlagshscolourCommanddefaultDoctestFlagsdoctestCommandemptyDoctestFlagsdefaultHaddockFlagshaddockCommandhaddockOptionsemptyHaddockFlagsdefaultCleanFlags cleanCommandemptyCleanFlags buildVerbosedefaultBuildFlags buildCommand buildOptionsemptyBuildFlagsdefaultReplFlags replCommanddefaultTestFlags testCommandemptyTestFlagsdefaultBenchmarkFlagsbenchmarkCommandemptyBenchmarkFlagsprogramConfigurationPaths'programDbPaths'programConfigurationOptionsprogramDbOptionstrueArgfalseArgoptionDistPrefoptionVerbosity optionNumJobs configureArgsconfigureCCompilerconfigureLinker splitArgs $fEnumFlag $fBoundedFlag$fSemigroupFlag $fMonoidFlag $fFunctorFlag$fBooleanFlagBool$fSemigroupGlobalFlags$fMonoidGlobalFlags$fBinaryRelaxedDep$fTextRelaxedDep$fMonoidRelaxDeps$fSemigroupRelaxDeps$fBinaryRelaxDeps$fMonoidAllowOlder$fSemigroupAllowOlder$fBinaryAllowOlder$fMonoidAllowNewer$fSemigroupAllowNewer$fBinaryAllowNewer$fSemigroupConfigFlags$fMonoidConfigFlags$fEqConfigFlags$fBinaryConfigFlags$fSemigroupCopyFlags$fMonoidCopyFlags$fSemigroupInstallFlags$fMonoidInstallFlags$fSemigroupSDistFlags$fMonoidSDistFlags$fSemigroupRegisterFlags$fMonoidRegisterFlags$fSemigroupHscolourFlags$fMonoidHscolourFlags$fSemigroupDoctestFlags$fMonoidDoctestFlags$fSemigroupHaddockFlags$fMonoidHaddockFlags$fSemigroupCleanFlags$fMonoidCleanFlags$fSemigroupBuildFlags$fMonoidBuildFlags$fSemigroupReplFlags$fMonoidReplFlags$fSemigroupTestShowDetails$fMonoidTestShowDetails$fTextTestShowDetails$fSemigroupTestFlags$fMonoidTestFlags$fSemigroupBenchmarkFlags$fMonoidBenchmarkFlags $fReadFlag$fGenericGlobalFlags$fEqRelaxedDep$fReadRelaxedDep$fShowRelaxedDep$fGenericRelaxedDep $fEqRelaxDeps$fReadRelaxDeps$fShowRelaxDeps$fGenericRelaxDeps$fEqAllowOlder$fReadAllowOlder$fShowAllowOlder$fGenericAllowOlder$fEqAllowNewer$fReadAllowNewer$fShowAllowNewer$fGenericAllowNewer$fGenericConfigFlags$fReadConfigFlags$fShowConfigFlags$fShowCopyFlags$fGenericCopyFlags$fShowInstallFlags$fGenericInstallFlags$fShowSDistFlags$fGenericSDistFlags$fShowRegisterFlags$fGenericRegisterFlags$fShowHscolourFlags$fGenericHscolourFlags$fShowDoctestFlags$fGenericDoctestFlags$fEqHaddockTarget$fShowHaddockTarget$fGenericHaddockTarget$fShowHaddockFlags$fGenericHaddockFlags$fShowCleanFlags$fGenericCleanFlags$fReadBuildFlags$fShowBuildFlags$fGenericBuildFlags$fShowReplFlags$fGenericReplFlags$fEqTestShowDetails$fOrdTestShowDetails$fEnumTestShowDetails$fBoundedTestShowDetails$fShowTestShowDetails$fGenericTestFlags$fGenericBenchmarkFlagsLocalBuildInfo configFlagsflagAssignmentcomponentEnabledSpecextraConfigArgsinstallDirTemplatescompiler hostPlatformbuildDircomponentGraphcomponentNameMap installedPkgs pkgDescrFile localPkgDescr withPrograms withPackageDBwithVanillaLib withProfLib withSharedLib withDynExe withProfExewithProfLibDetailwithProfExeDetailwithOptimization withDebugInfo withGHCiLib splitObjs stripExes stripLibs exeCoverage libCoverage progPrefix progSuffix relocatablelocalComponentId localPackage localUnitIdlocalCompatPackageKeycomponentNameTargets' unitIdTarget'componentNameCLBIsallTargetsInBuildOrder'withAllTargetsInBuildOrder'neededTargetsInBuildOrder'withNeededTargetsInBuildOrder' testCoveragecomponentNameTargets unitIdTargetallTargetsInBuildOrderwithAllTargetsInBuildOrderneededTargetsInBuildOrderwithNeededTargetsInBuildOrdercomponentsConfigsexternalPackageDeps$fBinaryLocalBuildInfo$fGenericLocalBuildInfo$fReadLocalBuildInfo$fShowLocalBuildInfocomponentBuildDirgetComponentLocalBuildInfo withLibLBI withExeLBI withBenchLBI withTestLBIenabledTestLBIsenabledBenchLBIswithComponentsLBIwithAllComponentsInBuildOrderwithComponentsInBuildOrderallComponentsInBuildOrdercomponentsInBuildOrderdepLibraryPaths allLibModulesabsoluteComponentInstallDirs"prefixRelativeComponentInstallDirscreateArLibArchiveWayVanillaProfDynmixDirtixDir tixFilePathhtmlDirguessWay markupTest markupPackage $fBoundedWay $fEnumWay$fEqWay $fReadWay $fShowWaygenerategeneratePackageVersionMacrosComponentsWithDepsComponentsGraphdispComponentsWithDepsmkComponentsGraphcomponentsGraphToListcomponentCycleMsgTestLogsTestLog GroupLogstestOptionsReturned testResult TestSuiteLog testSuiteNametestLogslogFile PackageLogplatformlocalPackageLogcountTestResults suitePassed suiteFailed suiteErrortestSuiteLogPathsummarizePackage summarizeTestsummarizeSuiteFinishsummarizeSuiteStart$fReadTestLogs$fShowTestLogs $fEqTestLogs$fReadTestSuiteLog$fShowTestSuiteLog$fEqTestSuiteLog$fReadPackageLog$fShowPackageLog$fEqPackageLog GhcProfAutoGhcProfAutoAllGhcProfAutoToplevelGhcProfAutoExportedGhcDynLinkMode GhcStaticOnlyGhcDynamicOnlyGhcStaticAndDynamicGhcOptimisationGhcNoOptimisationGhcNormalOptimisationGhcMaximumOptimisationGhcSpecialOptimisationGhcModeGhcModeCompile GhcModeLink GhcModeMakeGhcModeInteractiveGhcModeAbiHash GhcOptions ghcOptMode ghcOptExtraghcOptExtraDefaultghcOptInputFilesghcOptInputModulesghcOptOutputFileghcOptOutputDynFileghcOptSourcePathClearghcOptSourcePathghcOptThisUnitIdghcOptThisComponentIdghcOptInstantiatedWith ghcOptNoCodeghcOptPackageDBsghcOptPackagesghcOptHideAllPackagesghcOptWarnMissingHomeModulesghcOptNoAutoLinkPackagesghcOptLinkLibsghcOptLinkLibPathghcOptLinkOptionsghcOptLinkFrameworksghcOptLinkFrameworkDirs ghcOptNoLinkghcOptLinkNoHsMainghcOptLinkModDefFilesghcOptCcOptionsghcOptCppOptionsghcOptCppIncludePathghcOptCppIncludesghcOptFfiIncludesghcOptLanguageghcOptExtensionsghcOptExtensionMapghcOptOptimisationghcOptDebugInfoghcOptProfilingModeghcOptProfilingAutoghcOptSplitObjs ghcOptNumJobs ghcOptHPCDirghcOptGHCiScriptsghcOptHiSuffixghcOptObjSuffixghcOptDynHiSuffixghcOptDynObjSuffix ghcOptHiDir ghcOptObjDirghcOptOutputDir ghcOptStubDirghcOptDynLinkModeghcOptStaticLib ghcOptShared ghcOptFPicghcOptDylibName ghcOptRPathsghcOptVerbosityghcOptExtraPath ghcOptCabalrunGHC ghcInvocationrenderGhcOptions$fSemigroupGhcOptions$fMonoidGhcOptions $fShowGhcMode $fEqGhcMode$fShowGhcOptimisation$fEqGhcOptimisation$fShowGhcDynLinkMode$fEqGhcDynLinkMode$fShowGhcProfAuto$fEqGhcProfAuto$fShowGhcOptions$fGenericGhcOptionscomputeComponentIdcomputeCompatPackageKeyConfiguredComponentMapConfiguredComponent cc_ann_id cc_component cc_public cc_exe_deps cc_includescc_cidcc_pkgidcc_namedispConfiguredComponenttoConfiguredComponentextendConfiguredComponentMaptoConfiguredComponentsnewPackageDepsBehaviourLinkedComponentMapLinkedComponent lc_ann_id lc_component lc_exe_deps lc_public lc_includeslc_sig_includeslc_shapelc_cidlc_pkgidlc_uidlc_instsdispLinkedComponenttoLinkedComponenttoLinkedComponentsextendLinkedComponentMap$fPackageLinkedComponent QualLevelQL1QL2QL3BuildTargetProblemBuildTargetExpectedBuildTargetNoSuchBuildTargetAmbiguousUserBuildTargetProblemUserBuildTargetUnrecognised BuildTargetBuildTargetComponentBuildTargetModuleBuildTargetFileUserBuildTargetreadTargetInfosbuildTargetComponentNamereadBuildTargetsreadUserBuildTargetsreportUserBuildTargetProblemsshowUserBuildTargetshowBuildTargetresolveBuildTargetsreportBuildTargetProblems$fBinaryBuildTarget $fMonadMatch$fApplicativeMatch$fFunctorMatch$fMonadPlusMatch$fAlternativeMatch$fShowUserBuildTarget$fEqUserBuildTarget$fOrdUserBuildTarget$fEqBuildTarget$fShowBuildTarget$fGenericBuildTarget$fShowUserBuildTargetProblem$fShowBuildTargetProblem$fEnumQualLevel$fShowQualLevel$fEqComponentKind$fOrdComponentKind$fShowComponentKind$fShowMatchError$fEqMatchError $fShowMatch$fShowMaybeAmbiguoussrcPref hscolourPrefhaddockDirName haddockPrefautogenModulesDirautogenPackageModulesDirautogenComponentModulesDir cppHeaderNameautogenModuleNameautogenPathsModuleName haddockNamegetLibSourceFilesgetExeSourceFilesgetFLibSourceFilesgetSourceFiles exeBuildDir flibBuildDir mkLibName mkProfLibNamemkSharedLibName exeExtension objExtension dllExtensionstaticLibExtension configuregetInstalledPackagesbuildLibbuildExe installLibregisterPackageinplacePackageDbPathghcVerbosityOptions ghcOptions installExe hcPkgInfo hstoolVersionnumericVersiongetCompilerVersion getExtensions getLanguages initPackageDB packageDbOptGhcEnvironmentFileEntryGhcEnvFileCommentGhcEnvFilePackageIdGhcEnvFilePackageDbGhcEnvFileClearPackageDbStacksimpleGhcEnvironmentFilewriteGhcEnvironmentFilegetPackageDBContents getLibDirgetGlobalPackageDBreplLibstartInterpreterreplExe libAbiHashcomponentGhcOptions isDynamicrunCmd getGhcInfo getInstalledPackagesMonitorFiles buildFLibreplFLibcomponentCcGhcOptions installFLibinstall pkgPathEnvVarrunTeststubName stubFilePathwriteSimpleTestStubsimpleTestStubstubMain stubWriteLogparseConditionaddBuildableConditionextractConditionsfreeVars finalizePDfinalizePackageDescriptionflattenPackageDescriptiontransformAllBuildInfostransformAllBuildDepends$fSemigroupDepTestRslt$fMonoidDepTestRslt$fSemigroupPDTagged$fMonoidPDTagged$fShowPDTaggedBenchmarkStanzabenchmarkStanzaBenchmarkTypebenchmarkStanzaMainIsbenchmarkStanzaBenchmarkModulebenchmarkStanzaBuildInfoTestSuiteStanzatestStanzaTestTypetestStanzaMainIstestStanzaTestModuletestStanzaBuildInfopkgDescrFieldDescrslibFieldDescrsforeignLibFieldDescrsexecutableFieldDescrstestSuiteFieldDescrsbenchmarkFieldDescrsbinfoFieldDescrsflagFieldDescrssourceRepoFieldDescrsreadHookedBuildInforeadPackageDescriptionreadGenericPackageDescriptionparsePackageDescriptionparseGenericPackageDescriptionparseHookedBuildInfo $fMonadStT$fApplicativeStT $fFunctorStTwriteGenericPackageDescriptionshowGenericPackageDescriptionwritePackageDescriptionshowPackageDescriptionwriteHookedBuildInfoshowHookedBuildInfoCheckPackageContentOps doesFileExistdoesDirectoryExistgetDirectoryContentsgetFileContents PackageCheckPackageBuildImpossiblePackageBuildWarningPackageDistSuspiciousPackageDistSuspiciousWarnPackageDistInexcusable explanation checkPackagecheckConfiguredPackagecheckPackageFilescheckPackageContentcheckPackageFileNames$fShowPackageCheck$fEqPackageCheck defaultMaindefaultMainArgsdefaultMainNoReadModTime getModTimeposixSecondsToModTime getFileAge getCurTimecalibrateMtimeChangeDelay $fReadModTime $fShowModTime$fBinaryModTime$fBoundedModTime $fEqModTime $fOrdModTime!configureComponentLocalBuildInfos setupMessage'generateRegistrationInfocreatePackageDBdoesPackageDBExistdeletePackageDB invokeHcPkggeneralInstalledPackageInfoinplaceInstalledPackageInfoabsoluteInstalledPackageInfointernalPackageDBPathPPSuffixHandler PreProcessorplatformIndependentrunPreProcessormkSimplePreProcessorrunSimplePreProcessorpreprocessComponent ppGreenCardppUnlitppCppppCpp'ppHsc2hsppC2hsplatformDefinesppHappyppAlex ppSuffixesknownSuffixHandlerspreprocessExtras UserHooksrunTestsreadDeschookedPreProcessorshookedProgramspreConfconfHookpostConfpreBuild buildHook postBuildpreReplreplHookpostReplpreClean cleanHook postCleanpreCopycopyHookpostCopypreInstinstHookpostInstpreSDist sDistHook postSDistpreRegregHookpostRegpreUnreg unregHook postUnreg preHscolour hscolourHook postHscolour preDoctest doctestHook postDoctest preHaddock haddockHook postHaddockpreTesttestHookpostTestpreBench benchHook postBenchArgsemptyUserHookstestbenchsdistlistPackageSources prepareTreeprepareSnapshotTreesnapshotPackagesnapshotVersiondateToSnapshotNumber createArchiveprintPackageProblemsConfigStateFileErrorConfigStateFileNoHeaderConfigStateFileBadHeaderConfigStateFileNoParseConfigStateFileMissingConfigStateFileBadVersiongetConfigStateFiletryGetConfigStateFiletryGetPersistBuildConfiggetPersistBuildConfigmaybeGetPersistBuildConfigwritePersistBuildConfigcheckPersistBuildConfigOutdatedlocalBuildInfoFile findDistPreffindDistPrefOrDefaultgetInternalPackagesrelaxPackageDepscomputeEffectiveProfilinginterpretPackageDbFlagsccLdOptionsBuildInfoconfigCompilerAuxExconfigCompilerExconfigCompilerconfigCompilerAuxcheckForeignDeps$fExceptionConfigStateFileError$fShowConfigStateFileErrorreplinitialBuildStepscomponentInitialBuildStepswriteAutogenFileshaddockhaddockPackagePathshscolour$fSemigroupDirectory$fMonoidDirectory$fSemigroupHaddockArgs$fMonoidHaddockArgs$fReadDirectory$fShowDirectory $fEqDirectory$fOrdDirectory$fGenericHaddockArgsdoctest$fSemigroupDoctestArgs$fMonoidDoctestArgs$fShowDoctestArgs$fGenericDoctestArgsdefaultMainWithHooksdefaultMainWithHooksArgsdefaultMainWithHooksNoReadsimpleUserHooksdefaultUserHooksautoconfUserHooks byteSwap64 byteSwap32 byteSwap16 Data.BinarydecodeFileOrFail decodeFile encodeFile decodeOrFaildecodeencode GBinaryPutgput GBinaryGetggetData.Binary.PutputWord8PutData.Binary.GetgetWord8Data.Binary.Get.InternalGet System.IOopenBinaryTempFile openTempFileopenNewBinaryFilecreateTempDirectoryData.Map.Strict.InternalfromDistinctDescListfromDistinctAscListfromDescListWithKeyfromAscListWithKeyfromDescListWithfromAscListWith fromDescList fromAscListfromListWithKey fromListWithfromSet mapKeysWithmapAccumRWithKeymapAccumWithKeymapAccumtraverseWithKey mapWithKeymapmapEitherWithKey mapEithertraverseMaybeWithKeymapMaybeWithKey mergeWithKeyintersectionWithKeyintersectionWithdifferenceWithKeydifferenceWith unionWithKey unionWith unionsWithupdateMaxWithKeyupdateMinWithKey updateMax updateMinupdateAtalterFalterupdateLookupWithKey updateWithKeyupdate adjustWithKeyadjustinsertLookupWithKey insertWithKey insertWithfindWithDefault$Data.Map.Internal.DeprecatedShowTree showTreeWithshowTreeData.Map.Internal.Debugvalid splitRoot deleteFindMax deleteFindMin splitLookupsplit toDescList toAscListassocsfoldMapWithKey foldlWithKey' foldlWithKey foldrWithKey' foldrWithKeyfoldr'mapKeysMonotonicmapKeyspartitionWithKey partition spanAntitonedropWhileAntitonetakeWhileAntitone filterWithKeyfilterisProperSubmapOfByisProperSubmapOf isSubmapOfBy isSubmapOf restrictKeys intersection withoutKeys differenceunionsmaxViewminViewmaxViewWithKeyminViewWithKey deleteMax deleteMinfindMax lookupMaxfindMin lookupMindeleteAtsplitAtdroptakeelemAt lookupIndex findIndexdeletelookupGElookupLElookupGTlookupLT notMember\\!?!Control.Monad.Fail MonadFailfailGMonoidgmempty' GSemigroup gmappend'GNFData++GHC.PrimseqGHC.Listzipprint Data.Tuplefstsnd otherwise$GHC.Real fromIntegral realToFracGHC.EnumBoundedminBoundmaxBoundEnumenumFrom enumFromThenenumFromThenTo enumFromTofromEnumtoEnumsuccpred GHC.ClassesEq==/= GHC.FloatFloatingpiexplogsqrt**logBasesincostanasinacosatansinhcoshtanhasinhacoshatanh Fractional fromRational/recipIntegral toIntegerquotremdivmodquotRemdivModMonad>>=>>returnfmap<$GHC.NumNum*+-negate fromIntegerabssignumOrd>=minmax><<=compareGHC.ReadRead readsPrecreadListReal toRational RealFloat floatRadix floatDigits floatRange decodeFloat encodeFloatexponent significand scaleFloatisNaN isInfiniteisDenormalizedisNegativeZeroisIEEEatan2RealFracproperFractiontruncateroundceilingfloorGHC.ShowShow showsPrecshowshowList Applicativepure<*>*><*BoolFalseTrueCharDoubleFloatInt integer-gmpGHC.Integer.TypeIntegerMaybeNothingJustOrderingLTEQGTRational Data.EitherEitherLeftRightreadIOreadLn appendFile writeFilereadFileinteract getContentsgetLinegetCharputStrLnputStrputCharGHC.IO.ExceptionioErrorGHC.IOFilePath userErrorIOErrornotElemallanyorand concatMapconcat sequence_unwordswordsunlineslines Text.Readreadreadseitherlex readParen<$>lcmgcd^^^oddeven showParen showStringshowCharshowsShowSunzip3unzipzipWith3zipWithzip3!!reversebreakspan dropWhile takeWhilecycle replicaterepeatiteratescanr1scanrscanl1scanllasttailheadmaybeuncurrycurrysubtractasTypeOfuntil$!flip.constid=<<StringGHC.Err undefinederrorWithoutStackTraceerror&&||notgrnfSnocList runSnocListParserRPLookFinalfromMapgraphMap graphForward graphAdjointgraphVertexToNodegraphKeyToVertex graphBrokengetShortPathNamecopyFilecopyFileChanged filesEqualcopyOrdinaryFilecopyExecutableFilesetDirOrdinarysetEnvunsetEnv lookupEnvgetEnvironment usageInfogetOptSystem.Console.GetOptArgOrdergetOpt' RequireOrderPermute ReturnInOrderOptionArgDescrNoArgOptKindOptUnreqOptNonOpt EndOfOptsOptErrtokenizeQuotedWords Classified BirdTrackBlankOrdinaryLine BeginCodeEndCodeCommentparseNat hashToBase62StateM runStateMStepDonebytestring-0.10.8.2Data.ByteString.Short.InternalShortByteStringSTunST ShortTextLstSTLNilSTLConsLinkPoint writePoint readPointfreshrepr equivalentInfo verboseQuiet verboseFlag isVerboseFlag VerbosityFlag VCallStack VCallSiteVNoWrap VMarkOutputVerbosityLevelSilentNormalVerbose DeafeningvLevelvFlagsvQuiet Data.VersionmajorUpperBounddoesNotIntersectPV0PV1classifyKnownExtension showFreeTextlines_ indentWith Separator showFilePath showTokenshowTestedWithTokenSpanFSectionIfBlockUnrecFieldParser warnUnrec ignoreUnrec tokeniseLinemkTreelayoutbracesmkFieldifelseparseModuleNameQ parseSepListparseSpaceListparseCommaListparseOptCommaListField UTFWarning showPWarningcatchParseError parseFailrunPrunElocatedErrorMsg syntaxErrorwarningfield liftField simpleFieldcommaListFieldWithSepcommaListFieldcommaNewLineListFieldspaceListFieldlistFieldWithSep listField optsField boolFieldppFieldsppField showFieldsshowSingleNamedFieldshowSimpleSingleNamedField parseFieldsparseFieldsFlatlineNofName readFieldsreadFieldsFlatparseFilePathQparsePackageNameparseOptVersionparseTestedWithQ parseLicenseQparseLanguageQparseExtensionQ parseTokenQ parseTokenQ' parseQuotedparseMaybeQuoted parseFreeText OpenBracket CloseBracketunDependencyMapconvertPackageIdconvertModuleNameconvertLicenseModuleRequiresModuleProvides ModuleScopeemptyModuleScope ModuleSource msrc_pkgname msrc_compname msrc_renaming msrc_module msrc_implicitmodScopeProvidesmodScopeRequires PathComponentVariablecomponentNameNotRequestedReasonmaybePackageNamesetMaybePackageNamemungedPackageName hugsOptions toCurrentModuleProvidesU ModuleScopeU ModuleSubstU UnitIdUniqueUnitIdUModuleUUnitIdU'ModuleU'UnifRefUnifEnv unify_uniq unify_reqsunify_verbosity unify_ctxunify_db unify_errsUnifyM runUnifyMliftSTGHC.ST readUnifRef writeUnifRef getUnifEnv addErrContextaddErrContextMconvertModuleSubstconvertModuleSubstUemptyModuleScopeUconvertIncludeconvertModuleScopeUconvertModuleProvidesconvertModuleProvidesU ModuleSourceU usrc_pkgname usrc_compname usrc_renaming usrc_module usrc_implicit UnitIdThunkU ModuleVarUaddErrfailWith failIfErrstryM convertUnitId convertModuleconvertUnitIdUconvertModuleUunUnifyMErrMsgerr_msgerr_ctxmixLink linkProvision unifyModulePreExistingComponent pc_pkgname pc_compnameipiToPreExistingComponent pc_munged_idpc_uidpc_cid pc_open_uidpc_shapeversion getBinDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameMarkWhen NormalMark TraceWhen AlwaysTraceioeSetVerbatimioeGetVerbatimverbatimUserErrordisplaySomeExceptionpretty-1.1.3.3Text.PrettyPrint.HughesPJDocwrapTextVerbositywithOutputMarkerwithTrailingNewlinewithCallStackPrefix traceWhen withMetadata copyFilesWithdirectory-1.3.0.2System.Directory AlwaysMark NeverMark VerboseTrace FlagTrace readNubList formatMsg unLogProgressLogEnv le_verbosity le_contextfindExecutablemarkupInvocationunionInvocationuserSpecifiedPathconfigureProgramsunconfiguredProgsprogSearchPathconfiguredProgs DepUniqueKey unitIdIndexpackageIdIndex ghcSupportedghcjsVersionImplInfoghcVersionImplInfolhcVersionImplInfo CommonFlag commandHelpHelpFlagListOptionsFlagparseModSubstEntrydispModSubstEntryprogramDbPathsprogramDbOption mkTargetInfocomponentNameToUnitIds wipeMetadatahpcDirgenerateToolVersionMacrosgenerateMacrosgenerateComponentIdMacrogenerateCurrentPackageVersionpackageDbArgsConfpackageDbArgsDbmkConfiguredComponenttoConfiguredComponent'fixFakePkgNameMatchmatchInexactly findMatchUserBuildTargetSingleUserBuildTargetDoubleUserBuildTargetTripleshowBuildTarget' matchPlusmatchPlusShadowing exactMatchesinexactMatchescheckBuildTargetsMaybeAmbiguous MatchErrorMatchErrorExpectedMatchErrorNoSuchNoMatch ExactMatch InexactMatch ComponentKindLibKindFLibKindExeKindTestKind BenchKind ComponentInfo cinfoName cinfoStrName cinfoSrcDirs cinfoModules cinfoHsFiles cinfoCFiles cinfoJsFilesuhcLanguageExtensionsaddBuiltinVersionsinstalledPkgConfigisPkgDirmkInstalledPackageInfoconfigureToolchaingetInstalledPackages'hackThreadedFlagjhcLanguageExtensionsfilterGhciFlags ghcArchString ghcOsStringghcPlatformAndVersionStringghcEnvironmentFileNamerenderGhcEnvironmentFilerenderGhcEnvironmentFileEntrytargetPlatform mkGHCiLibNameghcLookupPropertygetHaskellObjectsmkGhcOptPackages substTopDircheckPackageDbEnvVarprofDetailLevelFlag GBuildModegbuildguessToolFromGhcPathguessGhcPkgFromGhcPathguessHsc2hsFromGhcPathguessHaddockFromGhcPathtoPackageIndexgetUserPackageDBflibTargetName flibBuildNameexeMainModuleNamedecodeMainIsArg gbuildSourcesifNeedsRPathWorkaroundextractRtsInfocheckNeedsRecompilationgetObjectFileName getRPathsRtsInfo rtsDynamicLib rtsStaticLib rtsLibPaths GBuildExeGReplExe GBuildFLib GReplFLib copyPackage copyComponentinstallDataFilesinstallIncludeFiles stubRunTests TargetSet DepMapUnion DepTestRsltsimplifyWithSysParamsresolveWithFlagsaddBuildableConditionPDTaggedPDTaggedPDNulloverallDependenciesflattenTaggedTargetstransformAllCondTreesLibSubComp unDepMapUnionDepOk MissingDepsstoreXFieldsPDreadAndParseFile parseFieldStTrunStTsimplifiedPrinting checkSanitycheckCabalVersiondisplayRawVersionRangecheckPackageVersions checkTarPathgetModificationTimeposixTimeToModTime time-1.8.0.2"Data.Time.Clock.Internal.POSIXTime POSIXTimeInstMInstSIndefiniteComponentindefc_requiresindefc_providesindefc_includesInstantiatedComponent instc_instsinstc_insts_depsinstc_providesinstc_includesReadyComponent rc_open_uidrc_cid rc_component rc_exe_deps rc_publicrc_irc_uidrc_pkgid rc_depends rc_munged_idtoReadyComponents rc_ann_iddispReadyComponentrunInstMPreProcessorExtraspreprocessFileknownExtrasHandlersCreateArchiveFun!listPackageSourcesMaybeExecutablelistPackageSourcesOrdinary findSetupFilemaybeCreateDefaultSetupScriptfindMainExeFilefindModDefFilefindIncludeFilefilterAutogenModulesallSourcesBuildInfo tarBallNameoverwriteSnapshotPackageDescExternalDependencyInternalDependencydispConfigStateFileErrorcurrentCabalIdcurrentCompilerId parseHeader showHeadercheckDeprecatedFlagscheckExactConfigurationdependencySatisfiableconfigureFinalizedPackagecheckCompilerProblemsconfigureDependenciesconfigureCoverageconfigureProfilingselectDependencyconfigureRequiredProgramcheckPackageProblemscheckRelocatableFailedDependencyDependencyNotExistsDependencyMissingInternalDependencyNoVersionDependencyResolutionaddExtraCSourcestestSuiteExeV10AsExetestSuiteLibV09AsLibAndExebenchmarkExeV10asExecreateInternalPackageDB Directory HaddockArgsargInterfaceFileargPackageNameargHideModulesargIgnoreExports argLinkSource argCssFile argContents argOutput argInterfaces argOutputDirargTitle argPrologue argGhcOptions argGhcLibDir argTargets runHaddock mkHaddockArgs fromLibraryfromExecutablefromForeignLib getInterfaces hscolour'OutputHtmlHoogleDirunDir' argVerbose DoctestArgsallSuffixHandlers