!cB      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWX Y Z [ \ ] ^ _`ab c d e f g h i j k l m nopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+ , - . / 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.{.|.}/~////////////////////////////////////0000000000000000000011111111111111111111111111111111111111111111111111111111111112222222233333333333333 3 3 3 3 3333333333333444444 4!4"4#4$4%4&4'4(4)4*4+4,4-4.4/404142434445464748494:4;4<4=4>4?4@4A4B4C4D4E4F4G4H4I4J4K4L4M4N4O4P4Q4R4S4T5U5V5W5X5Y5Z5[6\6]6^6_6`6a6b6c6d6e6f6g6h6i7j7k7l7m7n7o7p7q7r7s7t7u7v7w7x7y7z7{7|7}7~777888888888888888999999999999:::::::::::::::;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<===============>>>>>>>>>>>>>>>>>>>???????????????@@@@@@@@@@@@@@ @ @ @ @ AAAAAAAAAAAABBBBBBB B!B"B#B$B%B&B'B(B)B*B+B,B-B.B/B0B1B2B3B4B5B6B7B8B9B:B;B<B=B>B?B@BABBBCBDBEBFBGBHBIBJBKCLCMCNCOCPCQCRCSCTCUCVCWCXCYCZD[D\D]D^D_D`DaDbDcDdDeDfDgDhDiDjDkDlEmEnEoEpEqErEsEtEuEvEwExEyEzE{F|F}F~FFFFFFFFGGGGGGGGGGGGGGGGHHHHHHHHHHHHHIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKK L L L L LLLLLLLLLLLLLLLLLLL L!L"L#L$L%L&L'L(L)L*L+L,L-L.L/L0L1L2L3L4L5L6L7L8L9L:L;L<L=L>L?L@LALBLCLDLELFLGLHLILJLKLLLMLNLOLPLQLRLSLTLULVLWLXLYLZL[L\L]L^L_L`LaLbLcLdLeLfLgLhLiLjLkLlLmLnLoLpLqLrLsLtLuLvLwLxLyLzL{L|L}L~LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL L L L L LLLLLLLLLLLLLLLLLLL L!L"L#L$L%L&L'L(L)L*L+L,L-L.L/L0L1L2L3L4L5L6L7L8L9L:L;L<L=L>L?L@LALBLCLDLELFLGLHLILJLKLLLMLNLOLPLQLRLSLTLULVLWLXLYLZL[L\L]L^L_L`LaLbLcLdLeLfLgLhLiLjLkLlLmLnLoLpLqLrLsLtLuLvLwLxLyLzL{L|L}L~LLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOPPPPPPPPQQQQQQQ Q Q Q Q Q Q Q Q Q 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 'S (S )S *S +S ,S -S .S /S 0S 1S 2S 3S 4S 5S 6S 7S 8T 9T :T ;T <T =T >T ?T @T AT BT CT DT ET FT GU HU IU JU KU LU MU NU OU PU QU RU SU TU UU VV WV XV YV ZV [V \V ]V ^V _V `V aV bV cV dV eV fV gV hV iV jV k l m n o p q r s t u v w x y z { | } ~                          W W W W W W W W W W W W W W W W W 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 X X X X X X X X X X X X X X X X X X Y Y Y Y Y Y Y Y Z Z Z Z Z Z Z Z Z Z Z Z Z 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` pa qa ra sa ta ua va wa xb yb zb {b |b }b ~b c c c d d e e e e e e e e e e e e e e e e f f f f f f f f f f f f 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 h h h i i i i i i i i i i i i i i j j k k k k k k k k l l l l l l l l l l l l l l 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 o o o o o o o o o o p p p p p p p p q 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 0r 1r 2r 3r 4r 5r 6r 7r 8r 9r :r ;r <s =s >s ?s @s As Bs Cs Ds Es Fs Gs Hs Is Js Ks Ls Ms Ns Os Ps Qs Rs Ss Ts Us Vs Ws Xs Ys Zs [s \s ]s ^s _s `s as bs cs ds es fs gs hs is js ks ls ms ns os ps qs rs ss ts us vs wt xt yt zt {t |t }t ~t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u !u "u #u $u %u &u 'u (u )u *u +u ,u -u .u /u 0u 1u 2u 3u 4u 5u 6u 7u 8u 9u :u ;u <u =u >u ?u @u Au Bu Cu Du Eu Fu Gu Hu Iu Ju Ku Lu Mu Nu Ou Pu Qu Ru Su Tv Uv Vv Wv Xv Yv Zv [v \v ]v ^v _v `v av bv cv dv ev fv gv hv iv jv kv lv mv nv ov pv qv rv sv tv uv vv wv xv yv zv {v |v }v ~v v v v v v v v v v v v v v v v v v v v v v v v v v v v v v v 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 x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x y y z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z 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 { | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; <=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None26mCabalThe exception thrown by  to terminate a thread.CabalAsync, but based on , as we don't depend on stm.Cabal Returns the " of the thread running the given .CabalASpawn an asynchronous action in a separate thread, and pass its AsyncV handle to the supplied function. When the function returns or throws an exception,  is called on the Async. withAsync action inner = mask $ \restore -> do a <- async (restore action) restore (inner a) `finally` uninterruptibleCancel aThis is a useful variant of async that ensures an Async( is never left running unintentionally.GNote: a reference to the child thread is kept alive until the call to  returns, so nesting many  calls requires linear memory.CabalWait for an asynchronous action to complete, and return its value. If the asynchronous action threw an exception, then the exception is re-thrown by . wait = atomically . waitSTMCabal@Wait for an asynchronous action to complete, and return either Left e# if the action raised an exception e, or Right a if it returned a value a. %waitCatch = atomically . waitCatchSTMCabal.Cancel an asynchronous action by throwing the AsyncCancelled' exception to it, and waiting for the ' thread to quit. Has no effect if the  has already completed. Bcancel a = throwTo (asyncThreadId a) AsyncCancelled <* waitCatch a Note that ) will not terminate until the thread the , refers to has terminated. This means that U will block for as long said thread blocks when receiving an asynchronous exception.For example, it could block if:SIt's executing a foreign call, and thus cannot receive the asynchronous exception;fIt's executing some cleanup handler after having received the exception, and the handler is blocking.CabalCancel an asynchronous actionThis is a variant of , but it is not interruptible.  Safeg7]Cabal8Lazily reconstruct a value previously written to a file.KLMNOPNOM]^^] Safe8XYZYZXSafe8|_`a`a_| Safe9D[\\[Safe9bSafe9 None8=?@ACHcCabalThe FunctionalDependencies version of c type-class.ASince Cabal-3.0 class arguments are in a different order than in newtype. package. This change is to allow usage with DeriveAnyClass (and DerivingStrategies<, in GHC-8.2). Unfortunately one have to repeat inner type. 8newtype New = New Old deriving anyclass (Newtype Old) !Another approach would be to use  TypeFamilies) (and possibly compute inner type using  GHC.Generics), but we think FunctionalDependencies( version gives cleaner type signatures.fCabal#ala Sum foldMap [1, 2, 3, 4 :: Int]10Note:/ the user supplied function for the newtype is ignored.,ala (Sum . (+1)) foldMap [1, 2, 3, 4 :: Int]10gCabal,alaf Sum foldMap length ["cabal", "install"]12Note: as with f0, the user supplied function for the newtype is ignored.hCabal Variant of d, which takes a phantom type.iCabal Variant of d, which takes a phantom type.cdefghicdefghiSafeTjnCabal_Enable process jobs to ensure accurate determination of process completion in the presence of exec(3) on Windows.9Unfortunately the process job support is badly broken in process releases prior to 1.6.8, so we disable it in these versions, despite the fact that this means we may see sporatic build failures without jobs.oCabal2 with process jobs enabled when appropriate. See n.pCabal2 with process jobs enabled when appropriate. See n.qCabal2 with process jobs enabled when appropriate. See n.qCabal Filename of the executable (see  RawCommand for details)Cabal#Arguments to pass to the executableCabal&Optional path to the working directoryCabal(Optional environment (otherwise inherit)nopqoqpnSafeSX\sCabalGive 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 u; 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.uCabaleThis function is for when you *really* want to add a call stack to raised IO, but you don't have a X so you can't use  . If you have a  Verbosity$, please use that function instead.Quv{rsturQuutv{sSafeX]"6}~6~}cabal-devel@haskell.orgportableSafe]vwwvSafe^4Safe`CabalwHash a string using GHC's fingerprinting algorithm (a 128-bit MD5 hash) and then encode the resulting hash in base 62.NonedyCabalShow x in human readable formshowMD5 (Fingerprint 123 456)""000000000000007b00000000000001c8" showMD5 $ md5 $ BS.pack [0..127]""37eff01866ba3f538421b30b7cbefcac"@since 3.2.0.0zCabal@since 3.2.0.0{Cabal@since 3.2.0.0|Cabal@since 3.2.0.0xyz{|xyz{|Safej}CabalDecode ? from UTF8-encoded octets.;Invalid data in the UTF8 stream (this includes code-points U+D800 through U+DFFF0) will be decoded as the replacement character (U+FFFD). See also ~~CabalEncode ?! to a list of UTF8-encoded octetsCode-points in the U+D800-U+DFFF; range will be encoded as the replacement character (i.e. U+FFFD). See also  decodeUtf8}~(c) 2019 Oleg GrenrusNone-.78>HUVXgCabalUsed to implement .CabalClass of types with a known .For regular data types  can be derived generically. Ddata Record = Record { a :: Int, b :: Bool, c :: [Char] } deriving (; ) instance  Record CabalStructure of a datatype.It can be infinite, as far as ~Js involved are finite. (e.g. polymorphic recursion might cause troubles).Cabal5nominal, yet can be parametrised by other structures.Cabala newtype wrapperCabalsum-of-products structureCabal,A sematic version of a data type. Usually 0.CabalA MD5 hash digest of .CabalA van-Laarhoven lens into  of   :: Lens'   CabalA van-Laarhoven lens into  of   :: Lens'   CabalFlatten ) into something we can calculate hash of.As N can be potentially infinite. For mutually recursive types, we keep track of ~s, and put just ~' name when it's occurred another time.Cabal Semantically  . .Cabal Structured :. Encode a value to using binary serialisation to a lazy 5. Encoding starts with 16 byte large structure hash.Cabal"Lazily serialise a value to a fileCabal Structured . Decode a value from a lazy R, reconstructing the original structure. Throws pure exception on invalid inputs.Cabal8Lazily reconstruct a value previously written to a file.CabalUse 6 to infer nameCabalDerive  genrically.xxNone27>MUVQCabalA wrapper around H, providing the < and = instances implemented for H since  base-4.11.Cabal A copy of .Cabal A copy of .CabalGenerically 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.  a ( b c) =  ( a b) c CabalGenerically generate a =  ) for any product-like type implementing ;.%It is only defined for product types.   a = a =  a  <= !"<= !"None>SUVXmCabalHidden internal type-classCabal New name for Cabal GHC.Generics-based V implementation#This is needed in order to support  deepseq < 1.4 which didn't have a ;-based default V 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 V implementation.P &' (C)* +,-.3/%$  #"0LKJIED12345678$#%49:cd;<= !">RU?@ABCDEFGHSTIXYZJKLMNOPVW[\]^_`abhgfijklmnopqrstwxyz}~      !&'()*+,-./01298765<;:>=?@ABFGHPNOMQUWVNone27Cabal 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 APICabal Construct  from ?CabalConvert  to ?Cabal"Convert from UTF-8 encoded strict  ByteString.Cabal Text whether  is empty.CabalO(n). Length in characters. Slow as converts to string.}~}~None4CabalA 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/CabalEmit a step and then continue.CabalFail the computation.Cabal Consume a  calculation. Much like P for lists but with two base cases, one for a final result and one for failure.Eg to convert into a simple P result use: $foldProgress (flip const) Left RightNoneCabalMonadic variant of  mapAccumL.None&'SXCabalCabal Cabal# Wrapper for Note$: This operation uses lazy I/O. Use WW to force all data to be read and consequently the internal file handle to be closed.#CabalaRepresents either textual or binary data passed via I/O functions which support binary/text mode$Cabal2How Text gets encoded is usually locale-dependent.%Cabal2Raw binary which gets read/written in binary mode.'Cabal Test whether # is empty(Cabal# Wrapper for  and This is the dual operation ot  ., and consequently the handle is closed with hClose.Note: this performs lazy-IO.  !"#$%&'( #$% !"&'(#Isaac Jones, Simon Marlow 2003-2004=BSD3 portions Copyright (c) 2007, Galois Inc.cabal-devel@haskell.orgportableNone7>SX !$,CabalFWraps text to the default line width. Existing newlines are preserved.-CabalHWraps a list of words to a list of lines of words of a particular width..Cabal?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./CabalWrites 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.0CabalDecode ? from UTF8-encoded ;Invalid data in the UTF8 stream (this includes code-points U+D800 through U+DFFF0) will be decoded as the replacement character (U+FFFD).1Cabal Variant of 0 for lazy s2CabalEncode ? to to UTF8-encoded Code-points in the U+D800-U+DFFF; range will be encoded as the replacement character (i.e. U+FFFD).3Cabal Variant of 2 for lazy s4CabalCheck that strict  ByteString2 is valid UTF8. Returns 'Just offset' if it's not.5CabalDIgnore a Unicode byte order mark (BOM) at the beginning of the input6Cabal2Reads a UTF8 encoded text file as a Unicode StringReads lazily using ordinary m.7Cabal2Reads a UTF8 encoded text file as a Unicode StringSame behaviour as ..8Cabal4Writes a Unicode String as a UTF8 encoded text file.Uses /", so provides the same guarantees.9Cabal3Fix different systems silly line ending conventions:CabaldropWhileEndLE 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:AsafeTail $ Data.List.dropWhileEnd (<3) [undefined, 5, 4, 3, 2, 1] *** Exception: Prelude.undefined...9safeTail $ 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]7take 3 $ dropWhileEndLE (<3) [5, 4, 3, 2, 1, undefined] *** Exception: Prelude.undefined...;CabaltakeWhileEndLE p is equivalent to reverse . takeWhile p . reverse;, but is usually faster (as well as being easier to read).<CabalLike  , 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.=CabalLike < and F. Selects a key for each element and takes the nub based on that key.>Cabal Like "Data.List.union", but has  O(n log n) complexity instead of O(n^2).?CabalA right-biased version of <.Example:ordNub [1,2,1] :: [Int][1,2]ordNubRight [1,2,1] :: [Int][2,1]@CabalA 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]ACabalA total variant of ^.BCabalA total variant of ].CCabalA total variant of \.DCabalA total variant of [.FCabalLower case stringlowercase "Foobar""foobar"GCabalAscii charactersHCabalAscii letters.ICabalAscii letters and digits.isAsciiAlphaNum 'a'TrueisAsciiAlphaNum ''FalseKCabalLike  , but with H predicateMbreakMaybe (readMaybe :: String -> Maybe Int) ["foo", "bar", "1", "2", "quu"]$(["foo","bar"],Just (1,["2","quu"]))<breakMaybe (readMaybe :: String -> Maybe Int) ["foo", "bar"](["foo","bar"],Nothing)LCabalLike   but with H predicate0spanMaybe listToMaybe [[1,2],[3],[],[4,5],[6,7]]([1,3],[[],[4,5],[6,7]])>spanMaybe (readMaybe :: String -> Maybe Int) ["1", "2", "foo"]([1,2],["foo"])MCabal with monadic action.<take 5 $ unfoldrM (\b r -> Just (r + b, b + 1)) (1 :: Int) 2 [3,4,5,6,7]NCabalThe opposite of snoc, which is the reverse of consExample:unsnoc [1, 2, 3]Just ([1,2],3) unsnoc []NothingOCabalLike N , but for > so without the HExample:unsnocNE (1 :| [2, 3]) ([1,2],3)unsnocNE (1 :| [])([],1)PCabalP and Q 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.QCabal  isRelativeOnAnyPlatform = not . P),-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQ)./0123467859:;EFGHI>@<=?ABCDJ,-MLKNOPQNone271RCabal?A boolean expression parameterized over the variable type used.XCabalBoolean negation of a R value.YCabalBoolean AND of two Condtion values.ZCabalBoolean OR of two R values.[Cabal5Simplify the condition and return its free variables.[Cabal(partial) variable assignment RSTUVWXYZ[ RSTUVWXYZ[Thomas Tuegel 2010BSD3cabal-devel@haskell.orgportableNone>SX HyCabalIf 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.CabalIA human-readable description of the option to guide the user setting it.CabalPerform the test.Cabal1A name for the test, unique within a test suite.Cabal0Users can select groups of tests by their tags.Cabal5Descriptions of the options recognized by this test.CabalTry to set the named option to the given value. Returns an error message if the option is not supported or the value could not be correctly parsed; otherwise, a 5 with the option set to the given value is returned.CabalPCreate a named group of tests, which are assumed to be safe to run in parallel.+lnompqrstuvwxyz{|}~+{|}~tuvwxyzspqrlnomcabal-devel@haskell.orgportableNone'Cabal@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....cabal-devel@haskell.orgportableNone+CabalNo unliteration.Cabal takes a filename (for error reports), and transforms the given string, to eliminate the literate comments from the program text.None27:tCabalThe $prefix path variableCabalThe $bindir path variableCabalThe $libdir path variableCabalThe  $libsubdir path variableCabalThe  $dynlibdir path variableCabalThe $datadir path variableCabalThe  $datasubdir path variableCabalThe $docdir path variableCabalThe $htmldir path variableCabalThe $pkg package name path variableCabalThe $version package version path variableCabalThe $pkgid package Id path variable, eg foo-1.0CabalThe $libname path variableCabal"The compiler name and version, eg  ghc-6.6.1CabalThe operating system name, eg windows or linuxCabalThe CPU architecture name, eg i386 or x86_64CabalThe compiler's ABI identifier,Cabal%The optional ABI tag for the compilerCabal+The executable name; used in shell wrappersCabal$The name of the test suite being runCabal,The result of the test suite being run, eg pass, fail, or error.Cabal#The name of the benchmark being run8Isaac Jones 2003-2004 Duncan Coutts 2007BSD3cabal-devel@haskell.orgportableNone27>CCabal#Types that represent boolean flags.Cabal1All flags are monoids, they come in two flavours:  list flags eg !--ghc-option=foo --ghc-option=bar&gives us all the values ["foo", "bar"] singular value flags, eg: --enable-foo --disable-foogives us Just False So this Flag type is for the latter singular kind of flag. Its monoid instance gives us the behaviour where it starts out as ' and later flags override earlier ones.  2011, Dan Knappcabal-devel@haskell.orgportableNoneOCabalRepresents a dialect of C. The Monoid instance expresses backward compatibility, in the sense that 'mappend a b' is the least inclusive dialect which both a and b! can be correctly interpreted as.CabalA list of all file extensions which are recognized as possibly containing some dialect of C code. Note that this list is only for source files, not for header files.CabalTakes a dialect of C and whether code is intended to be passed through the preprocessor, and returns a filename extension for containing that code.CabalInfers from a filename's extension the dialect of C which it contains, and whether it is intended to be passed through the preprocessor.None7SDCabal-1-indexed row and column positions in a file.Cabal)Shift position by n columns to the right.Cabal(Shift position to beginning of next row.CabalCabalNone7`wCabalParser warning.Cabal0Type of parser warning. We do classify warnings.TDifferent application may decide not to show some, or have fatal behaviour on othersCabalUnclassified warningCabalInvalid UTF encodingCabaltrue or false, not True or FalseCabalthere are version with tagsCabalNew syntax used, but no cabal-version: >= 1.2 specifiedCabalOld syntax used, and cabal-version >= 1.2 specified Cabalextra main-is field Cabalextra test-module fieldCabalextra benchmark-module fieldCabal+legacy cabal file that we know how to patchCabalBDouble dash token, most likely it's a mistake - it's not a commentCabal3e.g. name or version should be specified only once.Cabal>Workaround for derive-package having build-type: Default. See  ,https://github.com/haskell/cabal/issues/5020.          None=?@AXc#CabalIThis is essentially a lazy bytestring, but chunks are glued with newline '\n'.'CabalConvert ? to #.Note: inefficient!#$%&'(#$%'(& None7d~+Cabal Parser error.+,-+,-!NoneSXjs2Cabal Patch legacy .cabal@ file contents to allow parsec parser to accept all of Hackage.=Bool part of the result tells whether the output is modified.CabalK contains first 256 bytes, pre- and post-fingerprints and a patch function.Cabal#Helper to create entries in patchesCabalneedleCabalneedleCabal replacementCabalneedle22(c) Sven Panne 2002-2005/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgportableNonewCabalReturn a string describing the usage of a command, derived from the header (first argument) and the options described by the second argument.CabalpProcess the command-line, and return the list of values that matched (and those that didn't). The arguments are:The order requirements (see )The option descriptions (see )9The actual command line arguments (presumably got from ).j returns a triple consisting of the option arguments, a list of non-options, and a list of error messages.CabalThis is almost the same as , but returns a quadruple consisting of the option arguments, a list of non-options, a list of unrecognized options, and a list of error messages. "BSD3cabal-devel@haskell.orgportableNone}6Cabal"position at current input location7Cabalthe current input8Cabal lexer code=CabalEncountered non breaking space>Cabal"BOM at the start of the cabal file?Cabal Leading tagsFCabal5Execute the given lexer on the supplied input stream.NCabal#Add warning at the current positionCabalAn alex lexer start code3456789:;<=>?@ABCDEFGHIJKLMN3456789@ABCDFHGIJKLM:;<=>?NE#BSD3cabal-devel@haskell.orgportableNoneF[XCabalHTokens of outer cabal file structure. Field values are treated opaquely.YCabal+Haskell-like identifier, number or operatorZCabalString in quotes[CabalOperators and parens\CabalIndentation token]Cabal Lines after :VWXaYZ[\]^_`bcdefghidcXaYZ[\]^_`bVWfihge$None456 lCabal A field name. Invariant:  is lower-case ASCII.oCabal+Section arguments, e.g. name of the librarypCabalUidentifier, or something which looks like number. Also many dot numbers, i.e. "7.6.3"qCabal quoted stringrCabal@everything else, mm. operators (e.g. in if-section conditionals)sCabalhA line of text representing the value of a field from a Cabal file. A field may contain multiple lines. Invariant:  has no newlines.uCabal2A Cabal-like file consists of a series of fields (foo: bar) and sections ( library ...).xCabalSection of field namezCabalAll transitive descendants of u, including itself.Note:# the resulting list is never empty.{Cabal|Cabal}CabalExtract annotation from o.lmnopqrstuwvxyz{|}~uwvxyzst{|opqr}nlm~%BSD3cabal-devel@haskell.orgportableNone@A&CabalThe + (with a prime) is an instance of parsec's  wrapped around lexer's 4 (without a prime)Cabal%Get lexer warnings accumulated so farCabal0Set Alex code i.e. the mode "state" lexer is in.CabalParse cabal style  into list of us, i.e. the cabal AST.CabalLike  but also return lexer warnings lmopqrstuwv uwvlmstopqrBSD3cabal-dev@haskell.org experimentalportableNone|&None>SXNoneP &' (C)* +,-.3/%$  #"0LKJIED12345678$#%49:dc;<= !">RU?@ABCDEFGHSTIXYZJKLMNOPVW[\]^_`abhgfijklmnopqrstwxyz}~      !&'()*+,-./01298765<;:>=?@ABFGHPNOMQUWVP &' (C)* +,.3/%$  #"0LKJIED123458$#%4= !">RU?@ABGHSTIXYZJPVWijklmnopqrstwxyz      !&'()*+,2?@ABFGH<6~}-;WVPNOM98765<;:7QUhgf>=^]\[9:dcb0/_1.`a-KLMNOCDEF(c) Edward Kmett 2011-2012BSD3ekmett@gmail.com experimental non-portableNone&'CabalNAdditional functionality needed to describe parsers independent of input type.CabalzTake a parser that may consume input, and on failure, go back to where we started and fail as if we didn't consume input.CabalGive a parser a nameCabaliA version of many that discards its input. Specialized because it can often be implemented more cheaply.Cabal skipSome p applies the parser p one? or more times, skipping its result. (aka skipMany1 in parsec)Cabal,Used to emit an error on an unexpected tokenCabalkThis parser only succeeds at the end of the input. This is not a primitive parser but it is defined using . 0 eof = notFollowedBy anyChar <?> "end of input"CabalnotFollowedBy p only succeeds when parser p fails. This parser does not consume any input. This parser can be used to implement the 'longest match' rule. For example, when recognizing keywords (for example let), we want to make sure that a keyword is not followed by a legal identifier character, in which case the keyword is actually an identifier (for example lets-). We can program this behaviour as follows: ; keywordLet = try $ string "let" <* notFollowedBy alphaNumCabal choice ps( tries to apply the parsers in the list psT in order, until one of them succeeds. Returns the value of the succeeding parser.Cabal option x p tries to apply parser p. If p6 fails without consuming input, it returns the value x#, otherwise the value returned by p. + priority = option 0 (digitToInt <$> digit)CabalskipOptional p tries to apply parser p. It will parse p or nothing. It only fails if p9 fails after consuming input. It discards the result of pT. (Plays the role of parsec's optional, which conflicts with Applicative's optional)Cabalbetween open close p parses open, followed by p and close!. Returns the value returned by p. , braces = between (symbol "{") (symbol "}")Cabal sepBy p sep parses zero or more occurrences of p, separated by sep'. Returns a list of values returned by p. % commaSep p = p `sepBy` (symbol ",")CabalsepByNonEmpty p sep parses one or more occurrences of p, separated by sep1. Returns a non-empty list of values returned by p.CabalsepEndByNonEmpty p sep parses one or more occurrences of p%, separated and optionally ended by sep2. Returns a non-empty list of values returned by p.CabalsepEndBy p sep parses zero or more occurrences of p%, separated and optionally ended by sepF, ie. haskell style statements. Returns a list of values returned by p. 6 haskellStatements = haskellStatement `sepEndBy` semiCabalendByNonEmpty p sep parses one or more occurrences of p, separated and ended by sep1. Returns a non-empty list of values returned by p.Cabal endBy p sep parses zero or more occurrences of p, separated and ended by sep'. Returns a list of values returned by p. ( cStatements = cStatement `endBy` semiCabal count n p parses n occurrences of p. If n4 is smaller or equal to zero, the parser equals to  return []. Returns a list of n values returned by p.Cabal chainr p op x parses zero or more occurrences of p, separated by op Returns a value obtained by a right7 associative application of all functions returned by op to the values returned by p!. If there are no occurrences of p , the value x is returned.Cabal chainl p op x parses zero or more occurrences of p, separated by op . Returns a value obtained by a left7 associative application of all functions returned by op to the values returned by p#. If there are zero occurrences of p , the value x is returned.Cabalchainl1 p op x parses one or more occurrences of p, separated by op Returns a value obtained by a left7 associative application of all functions returned by op to the values returned by ps. . This parser can for example be used to eliminate left recursion which typically occurs in expression grammars.  expr = term `chainl1` addop term = factor `chainl1` mulop factor = parens expr <|> integer mulop = (*) <$ symbol "*" <|> div <$ symbol "/" addop = (+) <$ symbol "+" <|> (-) <$ symbol "-"Cabalchainr1 p op x parses one or more occurrences of p, separated by op Returns a value obtained by a right7 associative application of all functions returned by op to the values returned by p.CabalmanyTill p end applies parser p zero or more times until parser end2 succeeds. Returns the list of values returned by p,. This parser can be used to scan comments: x simpleComment = do{ string "<!--" ; manyTill anyChar (try (string "-->")) }Note the overlapping parsers anyChar and  string "-->"#, and therefore the use of the  combinator.e56e650cabal-devel@haskell.org Windows-onlyNoneNone>SXCabalsetEnv name value, sets the specified environment variable to value.Throws  if either name or value1 is the empty string or contains an equals sign.'(c) Ben Gamari 2015-2019BSD3cabal-dev@haskell.org experimentalportableNone<CabalDifference list.CabalMake  with containing single element.Ben Gamari 2015-2019cabal-devel@haskell.orgportableNoneq(NoneSX+Caballens, variant is also parametrised by profunctor.Cabal)(3 :: Int) ^. getting (+2) . getting show"5"Cabal" is a reverse application operator%% 18444444844)None24567X CabalA ( represents a conditional branch, e.g.,  if flag(foo) on some syntax a). It also has an optional false branch.CabalA  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.)Cabal@ Traversal@ for the variablesCabal@ Traversal@ for the variablesCabal@ Traversal @ for the aggregated constraintsCabal@ Traversal @ for the aggregated constraintsCabalFExtract 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.CabalwFlattens a CondTree using a partial flag assignment. When a condition cannot be evaluated, both branches are ignored.CabalFlatten 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.*None>SX,NoneCabal:Copies a file to a new destination. Often you should use  instead.CabalLike , but does not touch the target if source and destination are already byte-identical. This is recommended as it is useful for time-stamp based recompilation avoidance.Cabal~Checks if two files are byte-identical. Returns False if either of the files do not exist or if files are of different size.+(c) Edward Kmett 2011BSD3ekmett@gmail.com experimental non-portableNone&'>XACabal;Additional functionality needed to parse character streams.Cabal:Parse a single character of the input, with UTF-8 decodingCabalchar c parses a single character c&. Returns the parsed character (i.e. c).e.g.  semiColon =  ';'Cabal notChar c( parses any single character other than c . Returns the parsed character.CabalEThis parser succeeds for any character. Returns the parsed character.Cabalstring s* parses a sequence of characters given by s#. Returns the parsed string (i.e. s). ; divOrMod = string "div" <|> string "mod"Cabaltext t8 parses a sequence of characters determined by the text t) Returns the parsed text fragment (i.e. t).Using OverloadedStrings: 7 divOrMod = text "div" <|> text "mod"CabaloneOf csJ succeeds if the current character is in the supplied list of characters cs*. Returns the parsed character. See also .  vowel = oneOf "aeiou"CabalAs the dual of ,  noneOf cs' succeeds if the current character is not$ in the supplied list of characters cs . Returns the parsed character.  consonant = noneOf "aeiou"CabalSkips zero* or more white space characters. See also . Cabal>Parses a white space character (any character which satisfies  ) Returns the parsed character.!Cabal?Parses a newline character ('\n'). Returns a newline character."Cabal7Parses a tab character ('\t'). Returns a tab character.#Cabal:Parses an upper case letter. Returns the parsed character.$Cabal<Parses a lower case character. Returns the parsed character.%Cabal7Parses a letter or digit. Returns the parsed character.&CabalWParses a letter (an upper case or lower case character). Returns the parsed character.'Cabal-Parses a digit. Returns the parsed character.(CabalsParses a hexadecimal digit (a digit or a letter between 'a' and 'f' or 'A' and 'F'). Returns the parsed character.)CabalWParses an octal digit (a character between '0' and '7'). Returns the parsed character.,CabalQGreedily munch characters while predicate holds. Require at least one character.-CabalBGreedely munch characters while predicate holds. Always succeeds.4e65 !"#$%&'()*+,-. !"#$%&'()*+,-.,None27K/ACabal"Different Cabal-the-spec versions./We branch based on this at least in the parser.BCabalthis is older than CCCabalnew syntax (sections)QCabal<Show cabal spec version, but not the way in the .cabal filesVCabalTWhat is the minimum Cabal library version which knows how handle this spec version.Note:^ this is a point where we could decouple cabal-spec and Cabal versions, if we ever want that.,cabalSpecMinimumLibraryVersion CabalSpecV3_0[2,5],cabalSpecMinimumLibraryVersion CabalSpecV2_4[2,3]!8:9;=<>@?APONMLKJIHGFEDCBQRSTUVWX!APONMLKJIHGFEDCBQRSTUVWX>@?;=<8:9-NoneMBeCabalSPDX License List version Cabal is aware of.efghiefghi.NoneVLtCabal}The default rendering style used in Cabal for console output. It has a fixed page width and adds line breaks automatically.uCabal&A style for rendering all on one line.xCabalPretty-print free-format text, ensuring that it is vertically aligned, and with blank lines replaced by dots for correct re-parsing.yCabal&Pretty-print free-format text. Since cabal-version: 3.0( we don't replace blank lines with dots.Cabalr breaks a string up into a list of strings at newline characters. The resulting strings do not contain newlines. opqrstuvwxy pqrstuvwxyo/None&'>SXfCabalParsing class which!can report Cabal parser warnings.knows  cabal-version we work withCabalClass for parsing with parsec. Mainly used for .cabal file fields. For parsing .cabal like file structure, see Distribution.Fields.Cabal could( consume trailing spaces, this function will consume.CabalParse a ? with .CabalParse a ? with .CabalParse a ? with given }". Trailing whitespace is accepted.CabalRun } with R.CabalLike  but lets specify A used.Cabal [^ ,]Cabal [^ ]Cabal#Parse a benchmark/test-suite types.CabalLike & but accept leading or trailing comma. p (comma p)* -- p sepByF comma (comma p)* -- leading comma (p comma)* -- trailing comma CabalLike  butrequire all or none commas!accept leading or trailing comma. p (comma p)* -- p sepByi comma (comma p)* -- leading comma (p comma)* -- trailing comma p* -- no commas: many p CabalContent isn't unquotedCabalparsecMaybeQuoted p =  p  | p.<     +,-}~<}~     +,-0None27|CabalA - represents the version of a software entity. Instances of ( and 0 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 P8 instance using a different (and more compact) encoding.Cabal#An integral without leading zeroes.Cabal 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 .CabalVersion 0. A lower bound of .Cabal Variant of  which converts a  Data.Version  into Cabal's  type.CabalUnpack ( into list of version number components.This is the inverse to , so the following holds: %(versionNumbers . mkVersion) vs == vsCabal"Constant representing the special null The  compares (via 0) as less than every proper  value.Cabal3Apply function to list of version number components 0alterVersion f == mkVersion . f . versionNumbers  1None24567>XCabal F-Algebra of . See .CabalThe version range -any4. That is, a version range containing all versions. withinRange v anyVersion = TrueCabalHThe 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 = FalseCabalThe version range == v (withinRange v' (thisVersion v) = v' == vCabalThe version range  v|| v +withinRange v' (notThisVersion v) = v' /= vCabalThe version range > v (withinRange v' (laterVersion v) = v' > vCabalThe version range >= v +withinRange v' (orLaterVersion v) = v' >= vCabalThe version range < v *withinRange v' (earlierVersion v) = v' < vCabalThe version range <= v -withinRange v' (orEarlierVersion v) = v' <= vCabalThe version range  vr1 || vr2 X withinRange v' (unionVersionRanges vr1 vr2) = withinRange v' vr1 || withinRange v' vr2CabalThe version range  vr1 && vr2 \ withinRange v' (intersectVersionRanges vr1 vr2) = withinRange v' vr1 && withinRange v' vr2CabalThe 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]) tCabalThe 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.CabalCabalFold .CabalCabalUnfold .CabalRefold Cabal, parser parametrised by version digit parser is used for all .+ is used for backward-compat pkgconfig-depends versions, PkgConfigVersionRange.Cabal<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++2NoneCabal-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 asVersionIntervals.Cabal Normalise .In particular collapse  (== v || > v) into >= v , and so on.CabalRemove  constructors.Cabal.Does this version fall within the given range?(This is the evaluation function for the  type.CabalCabal+Does the version range have an upper bound?Cabal4Does 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.Cabal"-any" versionCabal "== v"Cabal "> v"Cabal "< v"Cabal"_ || _" unionCabal"_ && _" intersection((3None2δCabal$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.CabalView 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 = NothingCabal&Inspect the list of version intervals.CabalDirectly construct a  from a list of intervals.In  Cabal-2.2 the H! is dropped from the result type.Cabal6Check an upper bound does not intersect a lower bound:--| or ---) or ---] or ---) but not ---] |--- (--- (--- [--- [---Cabal5Test 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) Cabal Convert a $ to a sequence of version intervals. Cabal Convert a  value back into a 0 expression representing the version intervals.          4None27V CabalIAn 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.$Cabal/What this repo info is for, what it represents.%CabalThe 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.&CabalThe 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.(CabalCInformation 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.*Cabal)The kind of repo. This field is required.+Cabal;The type of the source repository system for this repo, eg  or . This field is required.,Cabal)The location of the repository. For most )s this is a URL. This field is required.-Cabal 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..CabalThe 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./CabalUThe tag identify a particular state of the repository. This should be given for the & repo kind and not for % kind.0CabalSome 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. !"#$%&'()*+,-./01234()*+,-./0$%&' !"#21435Noned(TUVWXYZ(TUVWXYZ6None27[Cabal pkg-config versions.In fact, this can be arbitrary , but  instance is a little pickier.]CabalCompare two version strings as  pkg-config would compare them.^Cabal/simpleParsec "1.0.2n" :: Maybe PkgconfigVersion Just (PkgconfigVersion "1.0.2n")1simpleParsec "0.3.5+ds" :: Maybe PkgconfigVersionNothing[\][\]7None27iCabalsCabal<TODO: this is not precise, but used only to prettify output.ijklmnopqrstuvijklmnopqrstuv8None27MCabalA pkg-config library name?This is parsed as any valid argument to the pkg-config utility.CabalConvert  to ?Cabal Construct a  from a ? is the inverse to ANote: No validations are performed to ensure that the resulting  is validCabal9None27 =Cabal.Describes a dependency on a pkg-config library:None27MCabalA package name.Use  and  to convert from/to a ?.This type is opaque since  Cabal-2.0CabalConvert  to ?Cabal Construct a  from a ? is the inverse to ANote: No validations are performed to ensure that the resulting  is validCabal;None27MCabal9An 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.CabalConvert  to ?Cabal Construct a  from a ? is the inverse to ANote: No validations are performed to ensure that the resulting  is validCabal8Converts 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.>2018-12-21: These "legacy" situations are not legacy. We can  build-depends; on the internal library. However Now dependency contains Set LibraryName, and we should use that.Cabal8Converts 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.Cabal<None27$Cabal2A version constraint on a package. Different from  ExeDependency and  Dependency since it does not specify the need for a component, not even the main library. There are a few places in the codebase where  Dependency is used where  should be used instead (#5570).=None27&CabalMulti-lib visibilityCabal&Can be depenendent from other packagesCabalInternal library, default>None27*XCabal Pretty print  in build-target-ish syntax.Note: there are no p or / instances, as there's other way to represent , namely as bare . Cabal Convert the  of a library into a .  ?None27W@CabaltA 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 mkMungedPackageName and unMungedPackageName to convert from/to a ?.In 3.0.0.0L representation was changed from opaque (string) to semantic representation.CabalIntended for internal use only,decodeCompatPackageName "z-servant-z-lackey"VMungedPackageName (PackageName "servant") (LSubLibName (UnqualComponentName "lackey"))CabalIntended for internal use onlyLencodeCompatPackageName $ MungedPackageName "servant" (LSubLibName "lackey") PackageName "z-servant-z-lackey"This is used in  cabal-installN in the Solver. May become obsolete as solver moves to per-component solving.Cabal1simpleParsec "servant" :: Maybe MungedPackageName=Just (MungedPackageName (PackageName "servant") LMainLibName)<simpleParsec "z-servant-z-lackey" :: Maybe MungedPackageName]Just (MungedPackageName (PackageName "servant") (LSubLibName (UnqualComponentName "lackey")))6simpleParsec "z-servant-zz" :: Maybe MungedPackageNameBJust (MungedPackageName (PackageName "z-servant-zz") LMainLibName)CabalComputes 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!5prettyShow $ MungedPackageName "servant" LMainLibName "servant"?prettyShow $ MungedPackageName "servant" (LSubLibName "lackey")"z-servant-z-lackey"@None27ZCabal,What kind of foreign library is to be built?CabalA native shared library (.so on Linux, .dylib on OSX, or .dll on Windows).Cabal2A native static library (not currently supported.)ANone27^Cabal-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.  BNone27M$CabalA " 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)]CabalA 1 is the name of a user-defined configuration flagUse " and # to convert from/to a ?.This type is opaque since  Cabal-2.0CabalA 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.!CabalA % initialized with default parameters."Cabal Construct a  from a ?" is the inverse to #ANote: No validations are performed to ensure that the resulting  is valid#CabalConvert  to ?Cabal*Combines pairs of values contained in the  Map.cThe last flag specified takes precedence, and we record the number of times we have seen the flag.$Cabal Construct a ! from a list of flag/value pairs.`If duplicate flags occur in the input list, the later entries in the list will take precedence.%CabalDeconstruct a ! into a list of flag/value pairs.   (* fa) ==> ($ . % ) fa == fa&Cabal Test whether  is empty.'CabalLookup the value for a flagReturns S$ if the flag isn't contained in the .(Cabal-Insert or update the boolean value of a flag.&If the flag is already present in the  FlagAssigment, the value will be updated and the fact that multiple values have been provided for that flag will be recorded so that a warning can be generated later on.)Cabal+Remove all flag-assignments from the first # that are contained in the second NB/TODO: This currently only removes flag assignments which also match the value assignment! We should review the code which uses this operation to figure out if this it's not enough to only compare the flagnames without the values.*Cabal Find the 's that have been listed more than once.+Cabal+String representation of a flag-value pair.,Cabal Pretty-prints a flag assignment.-CabalParses a flag assignment.2Cabal"6Cabal7Cabal !"#$%&'()*+,- !"#$%'()*&+,-CNone27NCabal  = LOCabalAny like semigroup, where M is 'Any True'KLMKLMDNone27CbCabal}This gets the underlying unqualified component name. In fact, it is guaranteed to uniquely identify a component, returning Nothing if the Z was for the public library. Z[\]^_`ab Z[\]^_`abENone27M&lCabalA lf 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 m and n to convert from/to a ?.This type is opaque since  Cabal-2.0mCabal Construct a l from a ?m is the inverse to nANote: No validations are performed to ensure that the resulting l is validnCabalConvert l to ?tCabalmlmnlnmFNone27Q{CabalA {T represents a library depended on and explicitly specified by the user/client with  --dependencyIt enables Cabal to know which l to associate with a library{|}~{|}~GNone27}Cabal.The type of build system used by this package.Cabalcalls Distribution.Simple.defaultMainCabalcalls 9Distribution.Simple.defaultMainWithHooks defaultUserHooks, which invokes  configure@ to generate additional build information used by later phases.Cabalcalls Distribution.Make.defaultMainCabaluses user-supplied Setup.hs or  Setup.lhs (default)HNone27MCabal ABI HashesUse  and  to convert from/to a ?.This type is opaque since  Cabal-2.0Cabal Construct a  from a ? is the inverse to ANote: No validations are performed to ensure that the resulting  is validCabalConvert  to ?CabalINoneJDuncan Coutts 2007-2008cabal-devel@haskell.orgportableNone27>QCabalThese are the known Arches: I386, X86_64, PPC, PPC64, Sparc, Arm, AArch64, Mips, SH, IA64, S39, Alpha, Hppa, Rs6000, M68k, Vax, and JavaScript.The following aliases can also be used: * PPC alias: powerpc * PPC64 alias : powerpc64, powerpc64le * Sparc aliases: sparc64, sun4 * Mips aliases: mipsel, mipseb * Arm aliases: armeb, armel * AArch64 aliases: arm64CabalThese 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: solaris2Cabal3How strict to be when classifying strings into the  and  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  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.Cabal4The platform Cabal was compiled on. In most cases, LocalBuildInfo.hostPlatform8 should be used instead (the platform we're targeting).33KNone27Cabal,AuserdefinedlicensereferencedenotedbyLicenseRef-[idstring].(foralicensenotontheSPDX LicenseList)~CabalLicense reference.CabalDocument reference.CabalCreate % from optional document ref and name.CabalLike % but convert invalid characters into -.LNone27 x CabalSPDX License identifier Cabal0BSD, BSD Zero Clause License CabalAAL, Attribution Assurance License CabalAbstyles, Abstyles License Cabal Adobe-2006:, Adobe Systems Incorporated Source Code License AgreementCabal Adobe-Glyph, Adobe Glyph List LicenseCabalADSL!, Amazon Digital Services LicenseCabalAFL-1.1, Academic Free License v1.1CabalAFL-1.2, Academic Free License v1.2CabalAFL-2.0, Academic Free License v2.0CabalAFL-2.1, Academic Free License v2.1CabalAFL-3.0, Academic Free License v3.0CabalAfmparse, Afmparse LicenseCabalAGPL-1.0;, Affero General Public License v1.0, SPDX License List 3.0Cabal AGPL-1.0-onlyW, Affero General Public License v1.0 only, SPDX License List 3.2, SPDX License List 3.6CabalAGPL-1.0-or-later[, Affero General Public License v1.0 or later, SPDX License List 3.2, SPDX License List 3.6Cabal AGPL-3.0-only-, GNU Affero General Public License v3.0 onlyCabalAGPL-3.0-or-later1, GNU Affero General Public License v3.0 or laterCabalAladdin, Aladdin Free Public LicenseCabalAMDPLPA, AMD's plpa_map.c LicenseCabalAML, Apple MIT LicenseCabalAMPAS1, Academy of Motion Picture Arts and Sciences BSDCabalANTLR-PD, ANTLR Software Rights Notice Cabal Apache-1.0, Apache License 1.0!Cabal Apache-1.1, Apache License 1.1"Cabal Apache-2.0, Apache License 2.0#CabalAPAFML, Adobe Postscript AFM License$CabalAPL-1.0, Adaptive Public License 1.0%CabalAPSL-1.0!, Apple Public Source License 1.0&CabalAPSL-1.1!, Apple Public Source License 1.1'CabalAPSL-1.2!, Apple Public Source License 1.2(CabalAPSL-2.0!, Apple Public Source License 2.0)CabalArtistic-1.0-cl8!, Artistic License 1.0 w/clause 8*CabalArtistic-1.0-Perl, Artistic License 1.0 (Perl)+Cabal Artistic-1.0, Artistic License 1.0,Cabal Artistic-2.0, Artistic License 2.0-CabalBahyph, Bahyph License.CabalBarr, Barr License/CabalBeerware, Beerware License0CabalBitTorrent-1.0%, BitTorrent Open Source License v1.01CabalBitTorrent-1.1%, BitTorrent Open Source License v1.12Cabalblessing(, SQLite Blessing, SPDX License List 3.63Cabal BlueOak-1.0.05, Blue Oak Model License 1.0.0, SPDX License List 3.64CabalBorceux, Borceux license5Cabal BSD-1-Clause, BSD 1-Clause License6CabalBSD-2-Clause-FreeBSD, BSD 2-Clause FreeBSD License7CabalBSD-2-Clause-NetBSD, BSD 2-Clause NetBSD License8CabalBSD-2-Clause-Patent", BSD-2-Clause Plus Patent License9Cabal BSD-2-Clause, BSD 2-Clause  Simplified License:CabalBSD-3-Clause-Attribution, BSD with attribution;CabalBSD-3-Clause-Clear, BSD 3-Clause Clear License<CabalBSD-3-Clause-LBNL5, Lawrence Berkeley National Labs BSD variant license=Cabal$BSD-3-Clause-No-Nuclear-License-2014&, BSD 3-Clause No Nuclear License 2014>CabalBSD-3-Clause-No-Nuclear-License!, BSD 3-Clause No Nuclear License?Cabal BSD-3-Clause-No-Nuclear-Warranty", BSD 3-Clause No Nuclear Warranty@CabalBSD-3-Clause-Open-MPI6, BSD 3-Clause Open MPI variant, SPDX License List 3.6ACabal BSD-3-Clause, BSD 3-Clause New or Revised LicenseBCabalBSD-4-Clause-UC2, BSD-4-Clause (University of California-Specific)CCabal BSD-4-Clause, BSD 4-Clause Original or Old LicenseDCabalBSD-Protection, BSD Protection LicenseECabalBSD-Source-Code, BSD Source Code AttributionFCabalBSL-1.0, Boost Software License 1.0GCabal bzip2-1.0.5#, bzip2 and libbzip2 License v1.0.5HCabal bzip2-1.0.6#, bzip2 and libbzip2 License v1.0.6ICabalCaldera, Caldera LicenseJCabal CATOSL-1.15, Computer Associates Trusted Open Source License 1.1KCabal CC-BY-1.0*, Creative Commons Attribution 1.0 GenericLCabal CC-BY-2.0*, Creative Commons Attribution 2.0 GenericMCabal CC-BY-2.5*, Creative Commons Attribution 2.5 GenericNCabal CC-BY-3.0+, Creative Commons Attribution 3.0 UnportedOCabal CC-BY-4.00, Creative Commons Attribution 4.0 InternationalPCabal CC-BY-NC-1.09, Creative Commons Attribution Non Commercial 1.0 GenericQCabal CC-BY-NC-2.09, Creative Commons Attribution Non Commercial 2.0 GenericRCabal CC-BY-NC-2.59, Creative Commons Attribution Non Commercial 2.5 GenericSCabal CC-BY-NC-3.0:, Creative Commons Attribution Non Commercial 3.0 UnportedTCabal CC-BY-NC-4.0?, Creative Commons Attribution Non Commercial 4.0 InternationalUCabalCC-BY-NC-ND-1.0H, Creative Commons Attribution Non Commercial No Derivatives 1.0 GenericVCabalCC-BY-NC-ND-2.0H, Creative Commons Attribution Non Commercial No Derivatives 2.0 GenericWCabalCC-BY-NC-ND-2.5H, Creative Commons Attribution Non Commercial No Derivatives 2.5 GenericXCabalCC-BY-NC-ND-3.0I, Creative Commons Attribution Non Commercial No Derivatives 3.0 UnportedYCabalCC-BY-NC-ND-4.0N, Creative Commons Attribution Non Commercial No Derivatives 4.0 InternationalZCabalCC-BY-NC-SA-1.0E, Creative Commons Attribution Non Commercial Share Alike 1.0 Generic[CabalCC-BY-NC-SA-2.0E, Creative Commons Attribution Non Commercial Share Alike 2.0 Generic\CabalCC-BY-NC-SA-2.5E, Creative Commons Attribution Non Commercial Share Alike 2.5 Generic]CabalCC-BY-NC-SA-3.0F, Creative Commons Attribution Non Commercial Share Alike 3.0 Unported^CabalCC-BY-NC-SA-4.0K, Creative Commons Attribution Non Commercial Share Alike 4.0 International_Cabal CC-BY-ND-1.09, Creative Commons Attribution No Derivatives 1.0 Generic`Cabal CC-BY-ND-2.09, Creative Commons Attribution No Derivatives 2.0 GenericaCabal CC-BY-ND-2.59, Creative Commons Attribution No Derivatives 2.5 GenericbCabal CC-BY-ND-3.0:, Creative Commons Attribution No Derivatives 3.0 UnportedcCabal CC-BY-ND-4.0?, Creative Commons Attribution No Derivatives 4.0 InternationaldCabal CC-BY-SA-1.06, Creative Commons Attribution Share Alike 1.0 GenericeCabal CC-BY-SA-2.06, Creative Commons Attribution Share Alike 2.0 GenericfCabal CC-BY-SA-2.56, Creative Commons Attribution Share Alike 2.5 GenericgCabal CC-BY-SA-3.07, Creative Commons Attribution Share Alike 3.0 UnportedhCabal CC-BY-SA-4.0<, Creative Commons Attribution Share Alike 4.0 InternationaliCabalCC-PDDCT, Creative Commons Public Domain Dedication and Certification, SPDX License List 3.6jCabalCC0-1.0&, Creative Commons Zero v1.0 UniversalkCabalCDDL-1.01, Common Development and Distribution License 1.0lCabalCDDL-1.11, Common Development and Distribution License 1.1mCabalCDLA-Permissive-1.01, Community Data License Agreement Permissive 1.0nCabalCDLA-Sharing-1.0., Community Data License Agreement Sharing 1.0oCabal CECILL-1.0-, CeCILL Free Software License Agreement v1.0pCabal CECILL-1.1-, CeCILL Free Software License Agreement v1.1qCabal CECILL-2.0-, CeCILL Free Software License Agreement v2.0rCabal CECILL-2.1-, CeCILL Free Software License Agreement v2.1sCabalCECILL-B*, CeCILL-B Free Software License AgreementtCabalCECILL-C*, CeCILL-C Free Software License AgreementuCabal CERN-OHL-1.18, CERN Open Hardware License v1.1, SPDX License List 3.6vCabal CERN-OHL-1.28, CERN Open Hardware Licence v1.2, SPDX License List 3.6wCabal ClArtistic, Clarified Artistic LicensexCabal CNRI-Jython, CNRI Jython LicenseyCabalCNRI-Python-GPL-Compatible:, CNRI Python Open Source GPL Compatible License AgreementzCabal CNRI-Python, CNRI Python License{Cabal Condor-1.1, Condor Public License v1.1|Cabalcopyleft-next-0.3.0,, copyleft-next 0.3.0, SPDX License List 3.6}Cabalcopyleft-next-0.3.1,, copyleft-next 0.3.1, SPDX License List 3.6~CabalCPAL-1.0', Common Public Attribution License 1.0CabalCPL-1.0, Common Public License 1.0Cabal CPOL-1.02 , Code Project Open License 1.02Cabal Crossword, Crossword LicenseCabalCrystalStacker, CrystalStacker LicenseCabal CUA-OPL-1.0 , CUA Office Public License v1.0CabalCube, Cube LicenseCabalcurl, curl LicenseCabal D-FSL-1.0 , Deutsche Freie Software LizenzCabaldiffmark, diffmark licenseCabalDOC , DOC LicenseCabalDotseqn, Dotseqn LicenseCabalDSDP, DSDP LicenseCabaldvipdfm, dvipdfm LicenseCabalECL-1.0$, Educational Community License v1.0CabalECL-2.0$, Educational Community License v2.0CabalEFL-1.0, Eiffel Forum License v1.0CabalEFL-2.0, Eiffel Forum License v2.0CabaleGenix!, eGenix.com Public License 1.1.0CabalEntessa, Entessa Public License v1.0CabalEPL-1.0, Eclipse Public License 1.0CabalEPL-2.0, Eclipse Public License 2.0Cabal ErlPL-1.1, Erlang Public License v1.1Cabal EUDatagrid, EU DataGrid Software LicenseCabalEUPL-1.0#, European Union Public License 1.0CabalEUPL-1.1#, European Union Public License 1.1CabalEUPL-1.2#, European Union Public License 1.2CabalEurosym, Eurosym LicenseCabalFair, Fair LicenseCabal Frameworx-1.0, Frameworx Open License 1.0Cabal FreeImage, FreeImage Public License v1.0CabalFSFAP, FSF All Permissive LicenseCabalFSFULLR0, FSF Unlimited License (with License Retention)CabalFSFUL, FSF Unlimited LicenseCabalFTL, Freetype Project LicenseCabal GFDL-1.1-only*, GNU Free Documentation License v1.1 onlyCabalGFDL-1.1-or-later., GNU Free Documentation License v1.1 or laterCabal GFDL-1.2-only*, GNU Free Documentation License v1.2 onlyCabalGFDL-1.2-or-later., GNU Free Documentation License v1.2 or laterCabal GFDL-1.3-only*, GNU Free Documentation License v1.3 onlyCabalGFDL-1.3-or-later., GNU Free Documentation License v1.3 or laterCabalGiftware, Giftware LicenseCabalGL2PS, GL2PS LicenseCabalGlide, 3dfx Glide LicenseCabalGlulxe, Glulxe LicenseCabalgnuplot, gnuplot LicenseCabal GPL-1.0-only&, GNU General Public License v1.0 onlyCabalGPL-1.0-or-later*, GNU General Public License v1.0 or laterCabal GPL-2.0-only&, GNU General Public License v2.0 onlyCabalGPL-2.0-or-later*, GNU General Public License v2.0 or laterCabal GPL-3.0-only&, GNU General Public License v3.0 onlyCabalGPL-3.0-or-later*, GNU General Public License v3.0 or laterCabal gSOAP-1.3b, gSOAP Public License v1.3bCabal HaskellReport!, Haskell Language Report LicenseCabalHPND-sell-variantS, Historical Permission Notice and Disclaimer - sell variant, SPDX License List 3.6CabalHPND-, Historical Permission Notice and DisclaimerCabalIBM-pibs., IBM PowerPC Initialization and Boot SoftwareCabalICU , ICU LicenseCabalIJG , Independent JPEG Group LicenseCabal ImageMagick, ImageMagick LicenseCabaliMatix,, iMatix Standard Function Library AgreementCabalImlib2, Imlib2 LicenseCabalInfo-ZIP, Info-ZIP LicenseCabal Intel-ACPI', Intel ACPI Software License AgreementCabalIntel, Intel Open Source LicenseCabal Interbase-1.0, Interbase Public License v1.0CabalIPA, IPA Font LicenseCabalIPL-1.0, IBM Public License v1.0CabalISC , ISC LicenseCabal JasPer-2.0, JasPer LicenseCabalJPNICA, Japan Network Information Center License, SPDX License List 3.6CabalJSON, JSON LicenseCabalLAL-1.2, Licence Art Libre 1.2CabalLAL-1.3, Licence Art Libre 1.3CabalLatex2e, Latex2e LicenseCabal Leptonica, Leptonica LicenseCabal LGPL-2.0-only,, GNU Library General Public License v2 onlyCabalLGPL-2.0-or-later0, GNU Library General Public License v2 or laterCabal LGPL-2.1-only-, GNU Lesser General Public License v2.1 onlyCabalLGPL-2.1-or-later1, GNU Lesser General Public License v2.1 or laterCabal LGPL-3.0-only-, GNU Lesser General Public License v3.0 onlyCabalLGPL-3.0-or-later1, GNU Lesser General Public License v3.0 or laterCabalLGPLLR8, Lesser General Public License For Linguistic ResourcesCabal libpng-2.08, PNG Reference Library version 2, SPDX License List 3.6CabalLibpng, libpng LicenseCaballibtiff, libtiff LicenseCabal LiLiQ-P-1.12, Licence Libre du Qubec  Permissive version 1.1Cabal LiLiQ-R-1.13, Licence Libre du Qubec  Rciprocit version 1.1CabalLiLiQ-Rplus-1.19, Licence Libre du Qubec  Rciprocit forte version 1.1Cabal Linux-OpenIBZ, Linux Kernel Variant of OpenIB.org license, SPDX License List 3.2, SPDX License List 3.6CabalLPL-1.02, Lucent Public License v1.02CabalLPL-1.0#, Lucent Public License Version 1.0CabalLPPL-1.0#, LaTeX Project Public License v1.0CabalLPPL-1.1#, LaTeX Project Public License v1.1CabalLPPL-1.2#, LaTeX Project Public License v1.2Cabal LPPL-1.3a$, LaTeX Project Public License v1.3aCabal LPPL-1.3c$, LaTeX Project Public License v1.3cCabal MakeIndex, MakeIndex LicenseCabalMirOS, MirOS LicenseCabalMIT-0B, MIT No Attribution, SPDX License List 3.2, SPDX License List 3.6CabalMIT-advertising, Enlightenment License (e16)CabalMIT-CMU , CMU LicenseCabalMIT-enna, enna LicenseCabalMIT-feh , feh LicenseCabalMITNFA, MIT +no-false-attribs licenseCabalMIT , MIT LicenseCabalMotosoto, Motosoto LicenseCabalmpich2, mpich2 LicenseCabalMPL-1.0, Mozilla Public License 1.0CabalMPL-1.1, Mozilla Public License 1.1CabalMPL-2.0-no-copyleft-exception4, Mozilla Public License 2.0 (no copyleft exception)CabalMPL-2.0, Mozilla Public License 2.0CabalMS-PL, Microsoft Public LicenseCabalMS-RL, Microsoft Reciprocal LicenseCabalMTLL!, Matrix Template Library LicenseCabalMultics, Multics LicenseCabalMup , Mup LicenseCabalNASA-1.3 , NASA Open Source Agreement 1.3CabalNaumen, Naumen Public LicenseCabalNBPL-1.0, Net Boolean Public License v1CabalNCSA1, University of Illinois/NCSA Open Source LicenseCabalNet-SNMP, Net-SNMP LicenseCabalNetCDF, NetCDF licenseCabalNewsletr, Newsletr LicenseCabalNGPL , Nethack General Public LicenseCabalNLOD-1.0,, Norwegian Licence for Open Government DataCabalNLPL, No Limit Public LicenseCabalNokia, Nokia Open Source LicenseCabalNOSL, Netizen Open Source LicenseCabalNoweb, Noweb LicenseCabalNPL-1.0, Netscape Public License v1.0CabalNPL-1.1, Netscape Public License v1.1Cabal NPOSL-3.0&, Non-Profit Open Software License 3.0CabalNRL , NRL LicenseCabalNTP , NTP LicenseCabalOCCT-PL(, Open CASCADE Technology Public LicenseCabalOCLC-2.0", OCLC Research Public License 2.0CabalODbL-1.0 , ODC Open Database License v1.0Cabal ODC-By-1.0Z, Open Data Commons Attribution License v1.0, SPDX License List 3.2, SPDX License List 3.6 CabalOFL-1.0, SIL Open Font License 1.0 CabalOFL-1.1, SIL Open Font License 1.1 Cabal OGL-UK-1.05, Open Government Licence v1.0, SPDX License List 3.6 Cabal OGL-UK-2.05, Open Government Licence v2.0, SPDX License List 3.6 Cabal OGL-UK-3.05, Open Government Licence v3.0, SPDX License List 3.6CabalOGTSL, Open Group Test Suite LicenseCabal OLDAP-1.1, Open LDAP Public License v1.1Cabal OLDAP-1.2, Open LDAP Public License v1.2Cabal OLDAP-1.3, Open LDAP Public License v1.3Cabal OLDAP-1.4, Open LDAP Public License v1.4Cabal OLDAP-2.0.1!, Open LDAP Public License v2.0.1Cabal OLDAP-2.0;, Open LDAP Public License v2.0 (or possibly 2.0A and 2.0B)Cabal OLDAP-2.1, Open LDAP Public License v2.1Cabal OLDAP-2.2.1!, Open LDAP Public License v2.2.1Cabal OLDAP-2.2.2 , Open LDAP Public License 2.2.2Cabal OLDAP-2.2, Open LDAP Public License v2.2Cabal OLDAP-2.3, Open LDAP Public License v2.3Cabal OLDAP-2.4, Open LDAP Public License v2.4Cabal OLDAP-2.5, Open LDAP Public License v2.5Cabal OLDAP-2.6, Open LDAP Public License v2.6Cabal OLDAP-2.7, Open LDAP Public License v2.7Cabal OLDAP-2.8, Open LDAP Public License v2.8CabalOML, Open Market License CabalOpenSSL, OpenSSL License!CabalOPL-1.0, Open Public License v1.0"Cabal OSET-PL-2.1!, OSET Public License version 2.1#CabalOSL-1.0, Open Software License 1.0$CabalOSL-1.1, Open Software License 1.1%CabalOSL-2.0, Open Software License 2.0&CabalOSL-2.1, Open Software License 2.1'CabalOSL-3.0, Open Software License 3.0(Cabal Parity-6.0.08, The Parity Public License 6.0.0, SPDX License List 3.6)CabalPDDL-1.0,, ODC Public Domain Dedication & License 1.0*CabalPHP-3.01, PHP License v3.01+CabalPHP-3.0, PHP License v3.0,CabalPlexus, Plexus Classworlds License-Cabal PostgreSQL, PostgreSQL License.Cabalpsfrag, psfrag License/Cabalpsutils, psutils License0Cabal Python-2.0, Python License 2.01CabalQhull, Qhull License2CabalQPL-1.0, Q Public License 1.03CabalRdisc, Rdisc License4Cabal RHeCos-1.1", Red Hat eCos Public License v1.15CabalRPL-1.1, Reciprocal Public License 1.16CabalRPL-1.5, Reciprocal Public License 1.57CabalRPSL-1.0), RealNetworks Public Source License v1.08CabalRSA-MD, RSA Message-Digest License 9CabalRSCPL", Ricoh Source Code Public License:CabalRuby, Ruby License;CabalSAX-PD, Sax Public Domain Notice<CabalSaxpath, Saxpath License=CabalSCEA, SCEA Shared Source License>Cabal Sendmail-8.23., Sendmail License 8.23, SPDX License List 3.6?CabalSendmail, Sendmail License@Cabal SGI-B-1.0", SGI Free Software License B v1.0ACabal SGI-B-1.1", SGI Free Software License B v1.1BCabal SGI-B-2.0", SGI Free Software License B v2.0CCabalSHL-0.51A, Solderpad Hardware License, Version 0.51, SPDX License List 3.6DCabalSHL-0.58, Solderpad Hardware License v0.5, SPDX License List 3.6ECabal SimPL-2.0, Simple Public License 2.0FCabal SISSL-1.2,, Sun Industry Standards Source License v1.2GCabalSISSL,, Sun Industry Standards Source License v1.1HCabal Sleepycat, Sleepycat LicenseICabalSMLNJ#, Standard ML of New Jersey LicenseJCabalSMPPL*, Secure Messaging Protocol Public LicenseKCabalSNIA, SNIA Public License 1.1LCabal Spencer-86, Spencer License 86MCabal Spencer-94, Spencer License 94NCabal Spencer-99, Spencer License 99OCabalSPL-1.0, Sun Public License v1.0PCabalSSPL-1.08, Server Side Public License, v 1, SPDX License List 3.6QCabalSugarCRM-1.1.3 , SugarCRM Public License v1.1.3RCabalSWL8, Scheme Widget Library (SWL) Software License AgreementSCabal TAPR-OHL-1.08, TAPR Open Hardware License v1.0, SPDX License List 3.6TCabalTCL, TCL/TK LicenseUCabal TCP-wrappers, TCP Wrappers LicenseVCabalTMate, TMate Open Source LicenseWCabal TORQUE-1.1$, TORQUE v2.5+ Software License v1.1XCabalTOSL, Trusster Open Source LicenseYCabal TU-Berlin-1.0Z, Technische Universitaet Berlin License 1.0, SPDX License List 3.2, SPDX License List 3.6ZCabal TU-Berlin-2.0Z, Technische Universitaet Berlin License 2.0, SPDX License List 3.2, SPDX License List 3.6[CabalUnicode-DFS-2015<, Unicode License Agreement - Data Files and Software (2015)\CabalUnicode-DFS-2016<, Unicode License Agreement - Data Files and Software (2016)]Cabal Unicode-TOU, Unicode Terms of Use^Cabal Unlicense, The Unlicense_CabalUPL-1.0#, Universal Permissive License v1.0`CabalVim , Vim LicenseaCabalVOSTROM(, VOSTROM Public License for Open SourcebCabalVSL-1.0, Vovida Software License v1.0cCabal W3C-19980720., W3C Software Notice and License (1998-07-20)dCabal W3C-201505137, W3C Software Notice and Document License (2015-05-13)eCabalW3C., W3C Software Notice and License (2002-12-31)fCabal Watcom-1.0', Sybase Open Watcom Public License 1.0gCabalWsuipa, Wsuipa LicensehCabalWTFPL-, Do What The F*ck You Want To Public LicenseiCabalX11 , X11 LicensejCabalXerox, Xerox LicensekCabal XFree86-1.1, XFree86 License 1.1lCabalxinetd, xinetd LicensemCabalXnet, X.Net LicensenCabalxpp , XPP LicenseoCabalXSkat, XSkat LicensepCabalYPL-1.0, Yahoo! Public License v1.0qCabalYPL-1.1, Yahoo! Public License v1.1rCabalZed , Zed LicensesCabalZend-2.0, Zend License v2.0tCabal Zimbra-1.3, Zimbra Public License v1.3uCabal Zimbra-1.4, Zimbra Public License v1.4vCabalzlib-acknowledgement*, zlib/libpng License with AcknowledgementwCabalZlib, zlib LicensexCabalZPL-1.1, Zope Public License 1.1yCabalZPL-2.0, Zope Public License 2.0zCabalZPL-2.1, Zope Public License 2.1{Cabal=Help message for migrating from non-SPDX license identifiers.Old License is almost SPDX, except for BSD2, BSD3'. This function suggests SPDX variant: licenseIdMigrationMessage "BSD3""Do you mean BSD-3-Clause?"Also  OtherLicense, AllRightsReserved, and  PublicDomain aren't valid SPDX identifiersetraverse_ (print . licenseIdMigrationMessage) [ "OtherLicense", "AllRightsReserved", "PublicDomain" ]"SPDX license list contains plenty of licenses. See https://spdx.org/licenses/. Also they can be combined into complex expressions with AND and OR."/"You can use NONE as a value of license field.""Public Domain is a complex matter. See https://wiki.spdx.org/view/Legal_Team/Decisions/Dealing_with_Public_Domain_within_SPDX_Files. Consider using a proper license."kSPDX License list version 3.0 introduced "-only" and "-or-later" variants for GNU family of licenses. See  ;https://spdx.org/news/news/2018/01/license-list-30-released >>> licenseIdMigrationMessage "GPL-2.0" "SPDX license list 3.0 deprecated suffixless variants of GNU family of licenses. Use GPL-2.0-only or GPL-2.0-or-later."WFor other common licenses their old license format coincides with the SPDX identifiers:traverse eitherParsec ["GPL-2.0-only", "GPL-3.0-only", "LGPL-2.1-only", "MIT", "ISC", "MPL-2.0", "Apache-2.0"] :: Either String [LicenseId]JRight [GPL_2_0_only,GPL_3_0_only,LGPL_2_1_only,MIT,ISC,MPL_2_0,Apache_2_0]|CabalLicense SPDX identifier, e.g. "BSD-3-Clause".}CabalLicense name, e.g. &"GNU General Public License v2.0 only"~Cabal@Whether the license is approved by Open Source Initiative (OSI).See  ,https://opensource.org/licenses/alphabetical.Cabal Create a   from a ?.Cabal6eitherParsec "BSD-3-Clause" :: Either String LicenseIdRight BSD_3_Clause.eitherParsec "BSD3" :: Either String LicenseIdKLeft "...Unknown SPDX license identifier: 'BSD3' Do you mean BSD-3-Clause?"x      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~x      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz|}~{MNone27@(CabalSPDX License identifierCabal 389-exception , 389 Directory Server ExceptionCabalAutoconf-exception-2.0, Autoconf exception 2.0CabalAutoconf-exception-3.0, Autoconf exception 3.0CabalBison-exception-2.2, Bison exception 2.2CabalBootloader-exception#, Bootloader Distribution ExceptionCabalClasspath-exception-2.0, Classpath exception 2.0CabalCLISP-exception-2.0, CLISP exception 2.0CabalDigiRule-FOSS-exception!, DigiRule FOSS License ExceptionCabaleCos-exception-2.0, eCos exception 2.0CabalFawkes-Runtime-exception, Fawkes Runtime ExceptionCabalFLTK-exception, FLTK exceptionCabalFont-exception-2.0, Font exception 2.0Cabalfreertos-exception-2.0, FreeRTOS Exception 2.0CabalGCC-exception-2.0#, GCC Runtime Library exception 2.0CabalGCC-exception-3.1#, GCC Runtime Library exception 3.1Cabalgnu-javamail-exception, GNU JavaMail exceptionCabal GPL-CC-1.07, GPL Cooperation Commitment 1.0, SPDX License List 3.6Cabali2p-gpl-java-exception, i2p GPL+Java ExceptionCabalLibtool-exception, Libtool ExceptionCabalLinux-syscall-note, Linux Syscall NoteCabalLLVM-exception>, LLVM Exception, SPDX License List 3.2, SPDX License List 3.6CabalLZMA-exception, LZMA exceptionCabal mif-exception', Macros and Inline Functions ExceptionCabalNokia-Qt-exception-1.1K, Nokia Qt LGPL exception 1.1, SPDX License List 3.0, SPDX License List 3.2CabalOCaml-LGPL-linking-exception5, OCaml LGPL Linking Exception, SPDX License List 3.6CabalOCCT-exception-1.0, Open CASCADE Exception 1.0CabalOpenJDK-assembly-exception-1.0N, OpenJDK Assembly exception 1.0, SPDX License List 3.2, SPDX License List 3.6Cabalopenvpn-openssl-exception, OpenVPN OpenSSL ExceptionCabal!PS-or-PDF-font-exception-20170817R, PS/PDF font exception (2017-08-17), SPDX License List 3.2, SPDX License List 3.6CabalQt-GPL-exception-1.0D, Qt GPL exception 1.0, SPDX License List 3.2, SPDX License List 3.6CabalQt-LGPL-exception-1.1E, Qt LGPL exception 1.1, SPDX License List 3.2, SPDX License List 3.6CabalQwt-exception-1.0, Qwt exception 1.0CabalSwift-exception(, Swift Exception, SPDX License List 3.6Cabalu-boot-exception-2.0, U-Boot exception 2.0CabalUniversal-FOSS-exception-1.0>, Universal FOSS Exception, Version 1.0, SPDX License List 3.6CabalWxWindows-exception-3.1!, WxWindows Library Exception 3.1CabalLicense SPDX identifier, e.g. "BSD-3-Clause".CabalLicense name, e.g. &"GNU General Public License v2.0 only"Cabal Create a  from a ?.))NNone27TCabalSimple License Expressions.Cabal9An SPDX License List Short Form Identifier. For example:  GPL-2.0-onlyCabalAn SPDX License List Short Form Identifier with a unary"+" operator suffix to represent the current version of the license or any later version. For example: GPL-2.0+Cabal4A SPDX user defined license reference: For example:  LicenseRef-23, LicenseRef-MIT-Style-1, or 0DocumentRef-spdx-tool-1.2:LicenseRef-MIT-Style-2CabalSPDX License Expression. idstring = 1*(ALPHA / DIGIT / "-" / "." ) license id = <short form license identifier inAppendix I.1> license exception id = <short form license exception identifier inAppendix I.2> license ref = ["DocumentRef-"1*(idstring)":"]"LicenseRef-"1*(idstring) simple expression = license id / license id"+" / license ref compound expression = 1*1(simple expression / simple expression "WITH" license exception id / compound expression "AND" compound expression / compound expression "OR" compound expression ) / "(" compound expression ")" ) license expression = 1*1(simple expression / compound expression)  ONone27gCabalDeclared license. See <https://spdx.org/spdx-specification-21-web-version#h.1hmsyys&section 3.15 of SPDX Specification 2.1Note:! the NOASSERTION case is omitted.Old ' can be migrated using following rules:AllRightsReserved and UnspecifiedLicense to 4. No license specified which legally defaults to All Rights Reserved`. The package may not be legally modified or redistributed by anyone but the rightsholder. OtherLicense can be converted to  LicenseRef( pointing to the file in the package.UnknownLicense! i.e. other licenses of the form name-x.y;, should be covered by SPDX license list, otherwise use  LicenseRef. PublicDomain+ isn't covered. Consider using CC0. See  \https://wiki.spdx.org/view/Legal_Team/Decisions/Dealing_with_Public_Domain_within_SPDX_Files for more information.Cabal=if the package contains no license information whatsoever; orCabal:A valid SPDX License Expression as defined in Appendix IV.Cabal<eitherParsec "BSD-3-Clause AND MIT" :: Either String LicensegRight (License (EAnd (ELicense (ELicenseId BSD_3_Clause) Nothing) (ELicense (ELicenseId MIT) Nothing))),eitherParsec "NONE" :: Either String License Right NONENoneh#efghi      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz|}~efghiPJose Iborra 2008BSD3cabal-devel@haskell.orgportableNonewCabal"Parser with simple error reportingQDuncan Coutts 2008BSD3cabal-devel@haskell.orgportableNone27Cabal"Strict/unpacked representation of  [ShortText]CabalA valid Haskell module name.Cabal Construct a = from valid module components, i.e. parts separated by dots.CabalThe module name Main.CabalDThe individual components of a hierarchical module name. For example 1components (fromString "A.B.C") = ["A", "B", "C"]CabalSConvert a module name to a file path, but without any file extension. For example: )toFilePath (fromString "A.B.C") = "A/B/C" Cabal Construct a  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 I instead.RNone27SXJ CabalRenaming 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.) Cabal"A module renaming/thinning; e.g., (A as B, C as C) brings B and C into scope. Cabal@The default renaming, bringing all exported modules into scope. CabalHiding renaming, e.g.,  hiding (A, B)C, bringing all exported modules into scope except the hidden ones. Cabal Interpret a   as a partial map from  to 7. For efficiency, you should partially apply it with   and then reuse it. Cabal3The default renaming, if something is specified in  build-depends only. CabalHTests if its the default renaming; we can use a more compact syntax in S in this case.Cabalbetween parensCabalmodule name parser              SNone27s 'Cabal@A renaming on an include: (provides renaming, requires renaming) +CabalThe  + applied when you only  build-depends on a package. ,CabalIs an  ' the default one? ' ( ) * + , ' ( ) * + ,TNone27 8 9 : ; 8 9 : ;UNone27O G H I J K G H I J KVNone  VCabal V is parametrised bysZ which is a structure we are parsing. We need this to provide prettyprinter functionalitya type of the field.Note: We'd like to have forall s. Applicative (f s) context. WCabalUnfocus, zoom out, blur  V. XCabal,Field which should be defined, exactly once. YCabal#Boolean field with a default value. ZCabalOptional field. [Cabal"Optional field with default value. ^Cabal _CabalMonoidal field.Values are combined with !.Note:  Z is a  monoidalField with Last monoid. `Cabal>Parser matching all fields with a name starting with a prefix. aCabal8Known field, which we don't parse, neither pretty print. bCabal-Field which is parsed but not pretty printed. cCabalDeprecated since dCabal5Removed in. If we occur removed field, parsing fails. eCabal'Annotate field with since spec-version. fCabal(Field which can be defined at most once. gCabal(Field which can be defined at most once. hCabal"Optional field with default value. iCabal>Field which can be define multiple times, and the results are mappended. jCabalDefault implementation for  ^. XCabal field nameCabalc packCaballens into the field YCabal field nameCaballens into the fieldCabaldefault ZCabal field nameCabalpackCaballens into the field [Cabal field nameCabalc packCabal s a: lens into the fieldCabal default value \Caballens into the field ]Caballens into the field ^Caballens into the field _Cabal field nameCabalpackCaballens into the field `Cabalfield name prefixCaballens into the field cCabalversionCabaldeprecation message dCabalversionCabalremoval message eCabal spec versionCabal default value fCabal field nameCaballens into the field gCabal field nameCaballens into the field hCabal field nameCabal s a: lens into the fieldCabal default value iCabal field nameCaballens into the field jCaballens into the field V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j(c) Edward Z. Yang 2016BSD3cabal-dev@haskell.org experimentalportableNone 2>HVX) kCabal,A simple, trivial data type which admits an  m instance. mCabalThe  mT class is used for datatypes which represent directed graph nodes. A node of type a- is associated with some unique key of type  n a); given a node we can determine its key ( o") and the keys of its neighbors ( p). qCabalA graph of nodes a5. The nodes are expected to have instance of class  m. rCabalGet the value from a  k. sCabalO(1). Is the graph empty? tCabalO(1)#. The number of nodes in the graph. uCabalO(log V)#. Check if the key is in the graph. vCabalO(log V)(. Lookup the node at a key in the graph. wCabalO(1). The empty graph. xCabalO(log V). Insert a node into a graph. yCabalO(log V)*. Delete the node at a key from the graph. zCabalO(log V)M. Lookup and delete. This function returns the deleted value if it existed. {Cabal O(V + V')U. Right-biased union, preferring entries from the second map when conflicts occur.  o x =  o (f x). |Cabal O(V + V')Q. Left-biased union, preferring entries from the first map when conflicts occur. }Cabal(V + E)b. Compute the strongly connected components of a graph. Requires amortized construction of graph. ~Cabal(V + E)K. Compute the cycles of a graph. Requires amortized construction of graph. CabalO(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. CabalbLookup the immediate neighbors from a key in the graph. Requires amortized construction of graph. CabaljLookup the immediate reverse neighbors from a key in the graph. Requires amortized construction of graph. CabalHCompute 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. CabalHCompute 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. CabalSTopologically sort the nodes of a graph. Requires amortized construction of graph. Cabal[Reverse topologically sort the nodes of a graph. Requires amortized construction of graph.CabalO(1)[. Convert a map from keys to nodes into a graph. The map must satisfy the invariant that  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. Cabal O(V log V)<. Convert a list of nodes (with distinct keys) into a graph. CabalO(V)'. Convert a graph into a list of nodes. CabalO(V)&. Convert a graph into a list of keys. CabalO(V)%. Convert a graph into a set of keys. CabalO(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 ==  o n) ( m). CabalO(1). Convert a graph into a ,. Requires amortized construction of graph.$TSR k l m n o p q r s t u v w x y z { | } ~  $ q m n o p s t u v w x y z | { }TSR ~  k l rSafe\ Cabal"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.CabalA variable which can be unified; alternately, this can be thought of as an equivalence class with a distinguished representative.CabalMutable write to a CabalRead the current value of .Cabal2Create a fresh equivalence class with one element.Cabal)Flatten any chains of links, returning a 8 which points directly to the canonical representation.Cabal6Return the canonical element of an equivalence class .CabalgUnify two equivalence classes, so that they share a canonical element. Keeps the descriptor of point2.Cabal5Test if two points are in the same equivalence class.WNone273 XIan Lynagh 2007BSD3cabal-devel@haskell.orgportableNone27 CabalWCombinator for transforming verbosity level while retaining the original hidden state.*For instance, the following property holdsFisVerboseNoWrap (modifyVerbosity (max verbose) v) == isVerboseNoWrap vNote: you can use modifyVerbosity (const v1) v0 to overwrite v1's flags with v0 's flags. CabalParser verbosity-explicitEitherParsec parsecVerbosity "normal"QRight (Right (Verbosity {vLevel = Normal, vFlags = fromList [], vQuiet = False}))6explicitEitherParsec parsecVerbosity "normal+nowrap "XRight (Right (Verbosity {vLevel = Normal, vFlags = fromList [VNoWrap], vQuiet = False}))@explicitEitherParsec parsecVerbosity "normal+nowrap +markoutput"dRight (Right (Verbosity {vLevel = Normal, vFlags = fromList [VNoWrap,VMarkOutput], vQuiet = False}))AexplicitEitherParsec parsecVerbosity "normal +nowrap +markoutput"dRight (Right (Verbosity {vLevel = Normal, vFlags = fromList [VNoWrap,VMarkOutput], vQuiet = False}))?explicitEitherParsec parsecVerbosity "normal+nowrap+markoutput"dRight (Right (Verbosity {vLevel = Normal, vFlags = fromList [VNoWrap,VMarkOutput], vQuiet = False}))Note:& this parser will eat trailing spaces. Cabal/Turn on verbose call-site printing when we log. Cabal0Turn on verbose call-stack printing when we log. CabalTurn on -----BEGIN CABAL OUTPUT-----I markers for output from Cabal (as opposed to GHC, or system dependent). CabalATurn off marking; useful for suppressing nondeterministic output. Cabal'Disable line-wrapping for log messages. CabalMark the verbosity as quiet Cabal$Turn on timestamps for log messages. Cabal%Turn off timestamps for log messages. Cabal+Helper function for flag enabling functions Cabal,Helper function for flag disabling functions CabalTurn off all flags Cabal0Test if we should output call sites when we log. Cabal1Test if we should output call stacks when we log. Cabal!Test if we should output markets. Cabal3Test if line-wrapping is disabled for log messages. CabalTest if we had called   on the verbosity Cabal3Test if if we should output timestamps when we log. Cabal+Helper function for flag testing functions.  YFIsaac Jones, Simon Marlow 2003-2004 Duncan Coutts 2008BSD3cabal-devel@haskell.orgportableNone68 Cabal Does this  place any restriction on the ! or is it in fact equivalent to  AnyVersion.^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) CabalThis 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) Cabal6Is this version range in fact just a specific version?For example the version range ">= 3 && <= 3" contains only the version 3. Cabal 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' Cabal$The difference of two version ranges c withinRange v' (differenceVersionRanges vr1 vr2) = withinRange v' vr1 && not (withinRange v' vr2) CabalThe inverse of a version range B withinRange v' (invertVersionRange vr) = not (withinRange v' vr) Cabal@Given a version range, remove the highest upper bound. Example: (>= 1 && < 3) || (>= 4 && < 5) is converted to  (>= 1 &&  3)|| (= 4). Cabal@Given a version range, remove the lowest lower bound. Example:  (>= 1 &&  3)|| ( = 4 && < 5) is converted to  (>= 0 &&  3)|| ( = 4 && < 5).H     H        ZNone27;F Cabal/The "test-type" field in the test suite stanza. Cabal"type: exitcode-stdio-x.y" Cabal"type: detailed-x.y" Cabal'Some unknown test type e.g. "type: foo"  [None27G8 CabalpThe 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. CabalTest 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. CabalTest interface "detailed-0.9". The test-suite takes the form of a library containing a designated module that exports "tests :: [Test]". CabalqA test suite that does not conform to one of the above interfaces for the given reason (e.g. unknown test type).  \None27S+ Cabal"The name and version of a package. Cabal!The name of this package, eg. foo Cabal#the version of this package, eg 1.2 Cabal4Type alias so we can use the shorter name PackageId. Cabal3simpleParsec "foo-bar-0" :: Maybe PackageIdentifierVJust (PackageIdentifier {pkgName = PackageName "foo-bar", pkgVersion = mkVersion [0]})1simpleParsec "foo-bar" :: Maybe PackageIdentifierUJust (PackageIdentifier {pkgName = PackageName "foo-bar", pkgVersion = mkVersion []})Note: Stricter than Text instance5simpleParsec "foo-bar-0-0" :: Maybe PackageIdentifierNothing3simpleParsec "foo-bar.0" :: Maybe PackageIdentifierNothing5simpleParsec "foo-bar.4-2" :: Maybe PackageIdentifierNothing/simpleParsec "1.2.3" :: Maybe PackageIdentifierNothing    ]None27>My CabalA   for a definite package. The   invariant says that a  B identified this way is definite; i.e., it has no unfilled holes. CabalA 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 l.?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 display5 function, which will work on all versions of Cabal. Cabal4If you need backwards compatibility, consider using display7 instead, which is supported by all versions of Cabal. Cabal@Create a unit identity with no associated hash directly from a l. CabalYMake an old-style UnitId from a package identifier. Assumed to be for the public library Cabal=Returns library name prefixed with HS, suitable for filenames CabalUnsafely create a   from a  .. Your responsibility is to ensure that the   invariant holds. Cabal  CabalThe textual format for  , coincides with the format GHC accepts for  -package-id. CabalThe textual format for  , coincides with the format GHC accepts for  -package-id.                  ^None27MJ .CabalHA module identity uniquely identifies a Haskell module by qualifying a  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. . / . /_None27=?MSX- ;Cabal$An explicit substitution on modules.cNB: These substitutions are NOT idempotent, for example, a valid substitution is (A -> B, B -> A). <Cabal 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. ?CabalAn  ? 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.rst @CabalKIdentifies a component which may have some unfilled holes; specifying its l and its  ;. TODO: Invariant that  ;+ is non-empty? See also the Text instance. ACabalmIdentifies 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. BCabalGet the set of holes ( ModuleVar) embedded in a  . CCabaleSafe constructor from a UnitId. The only way to do this safely is if the instantiation is provided. DCabal Create a   from a l% and an instantiation with no holes. ECabalGet the set of holes ( ModuleVar) embedded in a  .. FCabalRPretty-print the entries of a module substitution, suitable for embedding into a  ? or passing to GHC via --instantiate-with. GCabal5Pretty-print a single entry of a module substitution. HCabal Inverse to  dispModSubst. ICabal Inverse to dispModSubstEntry. JCabalGet the set of holes ( ModuleVar) embedded in a  ;.. This is NOT the domain of the substitution. KCabal@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 l. LCabalCTake 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. MCabalYeitherParsec "Includes2-0.1.0.0-inplace-mysql:Database.MySQL" :: Either String OpenModuleRight (OpenModule (DefiniteUnitId (DefUnitId {unDefUnitId = UnitId "Includes2-0.1.0.0-inplace-mysql"})) (ModuleName ["Database","MySQL"])) RCabal1eitherParsec "foobar" :: Either String OpenUnitIdBRight (DefiniteUnitId (DefUnitId {unDefUnitId = UnitId "foobar"}))MeitherParsec "foo[Str=text-1.2.3:Data.Text.Text]" :: Either String OpenUnitIdRight (IndefFullUnitId (ComponentId "foo") (fromList [(ModuleName ["Str"],OpenModule (DefiniteUnitId (DefUnitId {unDefUnitId = UnitId "text-1.2.3"})) (ModuleName ["Data","Text","Text"]))]))   ; < = > ? @ A B C D E F G H I J K L ? @ A B C   D < = > E ; F G H I J K L`None27 c d f e c d f eaNone=?_ pCabal2Applying module substitutions to semantic objects. p q p qNone456CabalAn  <4, annotated with where it came from in a Cabal file.CabalHDescription of where a module participating in mixin linking came from.CabalHINVARIANT: entries for ModuleName m, have msrc_module is OpenModuleVar mCabalEvery Module in scope at a  is annotated with the  it comes from.CabalA 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 V; this is only an error if we attempt to use those modules to fill a requirement. A  can influence the  ModuleShape via a reexport.Cabal An empty . bNone7l x y z { | y z x { |cNone CabalUsed as a placeholder in $Distribution.Backpack.ReadyComponent CabalUsed by cabal new-repl and  cabal new-run Cabal  with .    dNone?  eNone27م CabalA simple pair of a  and .  is to   as  PackageName is to  . See  for more info. Cabal@The combined package and component name. see documentation for . Cabal/The version of this package / component, eg 1.2 Cabal1simpleParsec "foo-bar-0" :: Maybe MungedPackageId{Just (MungedPackageId {mungedName = MungedPackageName (PackageName "foo-bar") LMainLibName, mungedVersion = mkVersion [0]})/simpleParsec "foo-bar" :: Maybe MungedPackageIdzJust (MungedPackageId {mungedName = MungedPackageName (PackageName "foo-bar") LMainLibName, mungedVersion = mkVersion []})9simpleParsec "z-foo-bar-z-baz-0" :: Maybe MungedPackageIdJust (MungedPackageId {mungedName = MungedPackageName (PackageName "foo-bar") (LSubLibName (UnqualComponentName "baz")), mungedVersion = mkVersion [0]})3simpleParsec "foo-bar-0-0" :: Maybe MungedPackageIdNothing1simpleParsec "foo-bar.0" :: Maybe MungedPackageIdNothing3simpleParsec "foo-bar.4-2" :: Maybe MungedPackageIdNothing Cabal[prettyShow $ MungedPackageId (MungedPackageName "servant" LMainLibName) (mkVersion [1,2,3])"servant-1.2.3"eprettyShow $ MungedPackageId (MungedPackageName "servant" (LSubLibName "lackey")) (mkVersion [0,1,2])"z-servant-z-lackey-0.1.2"  fNone27ޘ CabalDescribes 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.  gNone27 Cabal6Describes a dependency on an executable from a package CabalExamples1simpleParsec "happy:happy" :: Maybe ExeDependencySJust (ExeDependency (PackageName "happy") (UnqualComponentName "happy") AnyVersion)<simpleParsec "happy:happy >= 1.19.12" :: Maybe ExeDependencyoJust (ExeDependency (PackageName "happy") (UnqualComponentName "happy") (OrLaterVersion (mkVersion [1,19,12]))):simpleParsec "happy:happy>=1.19.12" :: Maybe ExeDependencyoJust (ExeDependency (PackageName "happy") (UnqualComponentName "happy") (OrLaterVersion (mkVersion [1,19,12])))>simpleParsec "happy : happy >= 1.19.12" :: Maybe ExeDependencyNothing=simpleParsec "happy: happy >= 1.19.12" :: Maybe ExeDependencyNothing=simpleParsec "happy :happy >= 1.19.12" :: Maybe ExeDependencyNothing  hNone27 Cabal0Describes a dependency on a source package (API) CabalThe set of libraries required from the package. Only the selected libraries will be built. It does not affect the cabal-install solver yet. Cabal Simplify the  expression in a  . See  . Cabal,simpleParsec "mylib:sub" :: Maybe DependencygJust (Dependency (PackageName "mylib") AnyVersion (fromList [LSubLibName (UnqualComponentName "sub")]))4simpleParsec "mylib:{sub1,sub2}" :: Maybe DependencyJust (Dependency (PackageName "mylib") AnyVersion (fromList [LSubLibName (UnqualComponentName "sub1"),LSubLibName (UnqualComponentName "sub2")]))8simpleParsec "mylib:{ sub1 , sub2 }" :: Maybe DependencyJust (Dependency (PackageName "mylib") AnyVersion (fromList [LSubLibName (UnqualComponentName "sub1"),LSubLibName (UnqualComponentName "sub2")]))?simpleParsec "mylib:{ sub1 , sub2 } ^>= 42" :: Maybe DependencyJust (Dependency (PackageName "mylib") (MajorBoundVersion (mkVersion [42])) (fromList [LSubLibName (UnqualComponentName "sub1"),LSubLibName (UnqualComponentName "sub2")]))$Spaces around colon are not allowed:-simpleParsec "mylib: sub" :: Maybe DependencyNothing-simpleParsec "mylib :sub" :: Maybe DependencyNothing5simpleParsec "mylib: {sub1,sub2}" :: Maybe DependencyNothing5simpleParsec "mylib :{sub1,sub2}" :: Maybe DependencyNothing  iNone27 CabalIs 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.  jNone  kNone CabaltA map of dependencies. Newtyped since the default monoid instance is not appropriate. The monoid instance uses . Cabal Input mapCabalExtra constraints  lNone27  Cabal3The "benchmark-type" field in the benchmark stanza. Cabal"type: exitcode-stdio-x.y" Cabal,Some unknown benchmark type e.g. "type: foo"  mNone27i CabalnThe 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. CabalBenchmark 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. CabaluA benchmark that does not conform to one of the above interfaces for the given reason (e.g. unknown benchmark type).  nIsaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone27M  CabalClass 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  . Cabal'Packages that have an installed unit ID CabalClass 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.0lmn            . / oNone% CabalAn   is a l,  i, etc. which is annotated with some other useful information that is useful for printing to users, etc._Invariant: if ann_id x == ann_id y, then ann_pid x == ann_pid y and ann_cname x == ann_cname y        pNone(, CabalDid this come from an entry in mixins", or was implicitly generated by  build-depends? CabalThis should always return [ or  CSubLibName        qNone270  CabalQAn ABI dependency is a dependency on a library which also records the ABI hash (abiHash ) 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.        rThe License data type.8Isaac Jones 2003-2005 Duncan Coutts 2008BSD3cabal-devel@haskell.orgportableNone27] CabalIndicates 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. CabalGNU 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. !Cabal &https://www.gnu.org/licenses/agpl.html,GNU Affero General Public License, version 3. "Cabal$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. #Cabal .http://www.opensource.org/licenses/bsd-license2-clause BSD license. $Cabal /http://www.opensource.org/licenses/bsd-3-clause3-clause BSD license. %Cabal 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. &Cabal &http://www.opensource.org/licenses/MIT MIT license. 'Cabal Ahttp://www.isc.org/downloads/software-support-policy/isc-license/ ISC license (Cabal https://www.mozilla.org/MPL/#Mozilla Public License, version 2.0. )Cabal https://www.apache.org/licenses/Apache License, version 2.0. *CabalZThe 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. +CabalExplicitly 'All Rights Reserved', eg for proprietary software. The package may not be legally modified or redistributed by anyone but the rightsholder. ,CabalNo license specified which legally defaults to 'All Rights Reserved'. The package may not be legally modified or redistributed by anyone but the rightsholder. -CabalAny other software license. .Cabal$Indicates an erroneous license name. /Cabal.The list of all currently recognised licenses. 0Cabal Convert old   to SPDX &. Non-SPDX licenses are converted to . 1CabalConvert  to  ,*This is lossy conversion. We try our best.&licenseFromSPDX . licenseToSPDX $ BSD3BSD3<licenseFromSPDX . licenseToSPDX $ GPL (Just (mkVersion [3]))GPL (Just (mkVersion [3])).licenseFromSPDX . licenseToSPDX $ PublicDomain'UnknownLicense "LicenseRefPublicDomain"KlicenseFromSPDX $ SPDX.License $ SPDX.simpleLicenseExpression SPDX.EUPL_1_1UnknownLicense "EUPL-1.1"3licenseFromSPDX . licenseToSPDX $ AllRightsReservedAllRightsReserved?licenseFromSPDX <$> simpleParsec "BSD-3-Clause OR GPL-3.0-only"-Just (UnknownLicense "BSD3ClauseORGPL30only")  ' & $ # + - * ! " % ( ) , . / 0 1  ' & $ # + - * ! " % ( ) , . / 0 1sNone27HV` WCabal overrides  V iCabal5Returns the munged package name, which we write into name- for compatibility with old versions of GHC.7 c d e f     < = B E g \ O > ? @ A C D F G H I J K L M N P Q R S T U V W X Y Z [ ] ^ _ ` a b c d e f h i j7 < = B E g \ O > ? @ A C D F G H I J K L M N P Q R S T U V W X Y Z [ ] ^ _ ` a b c d e f j h i     c d e ftNoneb+ < w x y z { | } ~  + < w x y z { | } ~  uIsaac Jones 2003-2004BSD3libraries@haskell.orgportableNone27 D CabalcAllow overlapping class instances, provided there is a unique most specific instance for each use. jhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XOverlappingInstances CabalIgnore 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. jhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XUndecidableInstances CabalImplies  . 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. ihttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XIncoherentInstances Cabal (deprecated) Deprecated in favour of  .-Old description: Allow recursive bindings in do blocks, using the rec keyword. See also  . CabalAllow recursive bindings in do blocks, using the rec keyword, or mdo, a variant of do. ahttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XRecursiveDo CabaldProvide syntax for writing list comprehensions which iterate over several lists together, like the  family of functions. fhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XParallelListComp Cabal*Allow multiple parameters in a type class. khttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XMultiParamTypeClasses Cabal,Enable the dreaded monomorphism restriction. ohttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XNoMonomorphismRestriction Cabal$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. lhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XFunctionalDependencies Cabal (deprecated) A synonym for  .Old description: Like  Z but does not allow a higher-rank type to itself appear on the left of a function arrow. `https://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XRank2Types CabalNAllow a universally-quantified type to occur on the left of a function arrow. `https://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XRankNTypes Cabal (deprecated) A synonym for  .QOld description: Allow data constructors to have polymorphic arguments. Unlike  ., does not allow this for ordinary functions. fhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#arbitrary-rank-polymorphism Cabal1Allow existentially-quantified data constructors. ohttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XExistentialQuantification Cabal=Cause a type variable in a signature, which has an explicit forallQ quantifier, to scope over the definition of the accompanying value declaration. ihttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XScopedTypeVariables CabalDeprecated, use   instead. Cabal7Enable implicit function parameters with dynamic scope. dhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XImplicitParams CabalHRelax some restrictions on the form of the context of a type signature. fhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XFlexibleContexts CabalORelax some restrictions on the form of the context of an instance declaration. ghttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XFlexibleInstances Cabal2Allow data type declarations with no constructors. dhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XEmptyDataDecls Cabal.Run the C preprocessor on Haskell source code. Zhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#language-pragma Cabal]Allow an explicit kind signature giving the kind of types over which a type variable ranges. dhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XKindSignatures CabalbEnable a form of pattern which forces evaluation before an attempted match, and a form of strict let/where binding. bhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XBangPatterns Cabal&Allow type synonyms in instance heads. jhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XTypeSynonymInstances CabalDEnable Template Haskell, a system for compile-time metaprogramming. ehttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XTemplateHaskell CabalEnable the Foreign Function Interface. In GHC, implements the standard Haskell 98 Foreign Function Interface Addendum, plus some GHC-specific extensions. Zhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#language-pragma CabalEnable arrow notation. \https://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XArrows Cabal (deprecated)l Enable generic type classes, with default instances defined in terms of the algebraic structure of a type. Vhttps://haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#generic-classes Cabal,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. xhttps://haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#rebindable-syntax-and-the-implicit-prelude-import CabalEnable syntax for implicitly binding local names corresponding to the field names of a record. Puns bind specific names, unlike  . dhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XNamedFieldPuns CabalDEnable a form of guard which matches a pattern and binds variables. chttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XPatternGuards CabalAllow a type declared with newtype to use deriving9 for any class with an instance for the underlying type. phttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XGeneralizedNewtypeDeriving Cabal,Enable the "Trex" extensible records system. =http://haskell.org/hugs/pages/users_guide/hugs-only.html#TREX CabalEnable type synonyms which are transparent in some definitions and opaque elsewhere, as a way of implementing abstract datatypes. Bhttp://haskell.org/hugs/pages/users_guide/restricted-synonyms.html CabalHEnable an alternate syntax for string literals, with string templating. =http://haskell.org/hugs/pages/users_guide/here-documents.html CabalAllow the character #W as a postfix modifier on identifiers. Also enables literal syntax for unboxed values. _https://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XMagicHash CabalcAllow data types and type synonyms which are indexed by types, i.e. ad-hoc polymorphism for types. bhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XTypeFamilies Cabal=Allow a standalone declaration which invokes the type class deriving mechanism. hhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XStandaloneDeriving CabalpAllow certain Unicode characters to stand for certain ASCII character sequences, e.g. keywords and punctuation. chttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XUnicodeSyntax Cabal:Allow the use of unboxed types as foreign types, e.g. in foreign import and foreign export. [https://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#language-options CabalEnable interruptible FFI. ^https://haskell.org/ghc/docs/latest/html/users_guide/ffi-chap.html#interruptible-foreign-calls Cabal*Allow use of CAPI FFI calling convention (foreign import capi). ^https://haskell.org/ghc/docs/latest/html/users_guide/ffi-chap.html#the-capi-calling-convention Cabal|Defer validity checking of types until after expanding type synonyms, relaxing the constraints on how synonyms may be used. ihttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XLiberalTypeSynonyms Cabal`Allow the name of a type constructor, type class, or type variable to be an infix operator. * chttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XTypeOperators CabalEnable syntax for implicitly binding local names corresponding to the field names of a record. A wildcard binds all unmentioned names, unlike  . ehttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XRecordWildCards CabalDeprecated, use   instead. CabalQAllow a record field name to be disambiguated by the type of the record it's in. nhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XDisambiguateRecordFields Cabal=Enable traditional record syntax (as supported by Haskell 98) `https://haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#traditional-record-syntax CabalVEnable overloading of string literals using a type class, much like integer literals. ghttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XOverloadedStrings Cabal{Enable generalized algebraic data types, in which type variables may be instantiated on a per-constructor basis. Implies  . mhttps://haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#generalised-algebraic-data-types-gadts Cabal>Enable GADT syntax for declaring ordinary algebraic datatypes. `https://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XGADTSyntax Cabal (deprecated) Has no effect.3Old description: Make pattern bindings monomorphic. Phttps://downloads.haskell.org/~ghc/7.6.3/docs/html/users_guide/monomorphism.html CabalDRelax the requirements on mutually-recursive polymorphic functions. dhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XRelaxedPolyRec CabalEAllow default instantiation of polymorphic types in more situations. `http://downloads.haskell.org/~ghc/latest/docs/html/users_guide/ghci.html#type-defaulting-in-ghci CabalEnable unboxed tuples. chttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XUnboxedTuples CabalEnable deriving for classes  and . hhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XDeriveDataTypeable CabalEnable deriving for  and . chttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XDeriveGeneric Cabal&Enable support for default signatures. ghttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XDefaultSignatures Cabal?Allow type signatures to be specified in instance declarations. bhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XInstanceSigs CabalVAllow a class method's type to place additional constraints on a class type variable. mhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XConstrainedClassMethods CabalcAllow imports to be qualified by the package name the module is intended to be imported from, e.g. import "network" Network.Socket dhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XPackageImports Cabal (deprecated)A Allow a type variable to be instantiated at a polymorphic type. hhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XImpredicativeTypes Cabal (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-operators CabalURelax the interpretation of left operator sections to allow unary postfix operators. fhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XPostfixOperators CabalcEnable quasi-quotation, a mechanism for defining new concrete syntax for expressions and patterns. ahttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XQuasiQuotes Cabal\Enable generalized list comprehensions, supporting operations such as sorting and grouping. ghttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XTransformListComp CabalcEnable monad comprehensions, which generalise the list comprehension syntax to work for any monad. ihttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XMonadComprehensions Cabal]Enable view patterns, which match a value by applying a function and matching on the result. bhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XViewPatterns CabalxAllow 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. CabalAllow regular pattern matching over lists, as discussed in the paper "Regular Expression Patterns" by Niklas Broberg, Andreas Farre and Josef Svenningsson, from ICFP '04. Cabal'Enable the use of tuple sections, e.g. (, True) desugars into x -> (x, True). chttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XTupleSections CabalGAllow GHC primops, written in C--, to be imported into a Haskell file. Cabal!Support for patterns of the form n + k, where k is an integer literal. dhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XNPlusKPatterns CabalImprove the layout rule when if expressions are used in a do block. CabalEnable support for multi-way if -expressions. `https://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XMultiWayIf CabalEnable support lambda-case expressions. `https://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XLambdaCase CabalqMakes much of the Haskell sugar be desugared into calls to the function with a particular name that is in scope. fhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XRebindableSyntax CabalMake forallN a keyword in types, which can be used to give the generalisation explicitly. dhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XExplicitForAll Cabal0Allow contexts to be put on datatypes, e.g. the Eq a in /data Eq a => Set a = NilSet | ConsSet a (Set a). fhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XDatatypeContexts CabalLocal (let and where) bindings are monomorphic. dhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XMonoLocalBinds CabalEnable deriving for the  class. chttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XDeriveFunctor CabalEnable deriving for the    class. ghttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XDeriveTraversable CabalEnable deriving for the    class. dhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XDeriveFoldable Cabal&Enable non-decreasing indentation for do blocks. Rhttps://haskell.org/ghc/docs/latest/html/users_guide/bugs.html#context-free-syntax CabalAllow 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 Shttps://haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#safe-imports CabaltCompile a module in the Safe, Safe Haskell mode -- a restricted form of the Haskell language to ensure type safety. Zhttps://www.haskell.org/ghc/docs/latest/html/users_guide/safe_haskell.html#ghc-flag--XSafe CabalCompile 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. ahttps://www.haskell.org/ghc/docs/latest/html/users_guide/safe_haskell.html#ghc-flag--XTrustworthy CabalzCompile a module in the Unsafe, Safe Haskell mode so that modules compiled using Safe, Safe Haskell mode can't import it. \https://www.haskell.org/ghc/docs/latest/html/users_guide/safe_haskell.html#ghc-flag--XUnsafe CabalAllow 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. ehttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XConstraintKinds CabalEnable kind polymorphism. _https://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XPolyKinds CabalEnable datatype promotion. _https://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XDataKinds CabalEnable parallel arrays syntax ([:, :]) for Data Parallel Haskell. <http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell Cabal+Enable explicit role annotations, like in (/type role Foo representational representational). ehttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XRoleAnnotations CabalWEnable overloading of list literals, arithmetic sequences and list patterns using the IsList type class. ehttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XOverloadedLists CabaloEnable case expressions that have no alternatives. Also applies to lambda-case expressions if they are enabled. _https://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XEmptyCase Cabal (deprecated) Deprecated in favour of  .4Old description: Triggers the generation of derived 6: instances for every datatype and type class declaration. Vhttps://haskell.org/ghc/docs/7.8.4/html/users_guide/deriving.html#auto-derive-typeable Cabal;Desugars negative literals directly (without using negate). fhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XNegativeLiterals Cabal5Allow the use of binary integer literal syntax (e.g.  0b11001001 to denote 201). dhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XBinaryLiterals Cabal>Allow the use of floating literal syntax for all instances of / , including B and G. ahttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XNumDecimals Cabal7Enable support for type classes with no type parameter. hhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XNullaryTypeClasses Cabal9Enable explicit namespaces in module import/export lists. hhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XExplicitNamespaces CabalUAllow the user to write ambiguous types, and the type inference engine to infer them. ihttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XAllowAmbiguousTypes CabalEnable foreign import javascript. Cabal4Allow giving names to and abstracting over patterns. ehttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XPatternSynonyms CabalAllow anonymous placeholders (underscore) inside type signatures. The type inference engine will generate a message describing the type inferred at the hole's location. khttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XPartialTypeSignatures CabalAllow named placeholders written with a leading underscore inside type signatures. Wildcards with the same name unify to the same type. dhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XNamedWildCards CabalEnable deriving for any class. dhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XDeriveAnyClass CabalEnable deriving for the   class. `https://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XDeriveLift Cabal.Enable support for 'static pointers' (and the staticN keyword) to refer to globally stable names, even across different programs. dhttps://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#ghc-flag--XStaticPointers CabalVSwitches data type declarations to be strict by default (as if they had a bang using  BangPatterns*), and allow opt-in field laziness using ~. ghttps://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#ghc-flag--XStrictData CabalTSwitches all pattern bindings to be strict by default (as if they had a bang using  BangPatterns*), ordinary patterns are recovered using ~ . Implies  StrictData. chttps://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#ghc-flag--XStrict CabalAllows do-notation for types that are 8 as well as ,. When enabled, desugaring do notation tries to use ( *) and  and join as far as possible. Cabal;Allow records to use duplicated field labels for accessors. Cabal2Enable explicit type applications with the syntax id @Int. CabalDissolve 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. CabalFAllow recursive (and therefore undecidable) super-class relationships. CabalxA temporary extension to help library authors check if their code will compile with the new planned desugaring of fail. Cabal A subset of TemplateHaskell including only quoting. CabalAllows use of the #label syntax. CabalWAllow functional dependency annotations on type families to declare them as injective. CabalAllow multiple deriving, clauses, each optionally qualified with a strategy. CabalQEnable deriving instances via types of the same runtime representation. Implies  . Cabal%Enable the use of unboxed sum syntax. CabalDAllow use of hexadecimal literal notation for floating-point values. CabalAllow do" blocks etc. in argument position. Cabal-Allow use of underscores in numeric literals. CabalAllow forall in constraints. !CabalHave * refer to Type. "Cabal?Liberalises deriving to provide instances for empty data types. yhttps://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#deriving-instances-for-empty-data-types #Cabal;Enable detection of complete user-supplied kind signatures. $CabalAllows the syntax import M qualified. %Cabal,Allow the use of standalone kind signatures. &CabalEnable unlifted newtypes. 'Cabal2This 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. (CabalEnable a known extension )CabalDisable a known extension *Cabal4An unknown extension, identified by the name of its LANGUAGE pragma. +Cabal+This represents a Haskell language dialect. Language  ';s are interpreted relative to one of these base languages. ,Cabal>The Haskell 98 language as defined by the Haskell 98 report. http://haskell.org/onlinereport/ -CabalBThe Haskell 2010 language as defined by the Haskell 2010 report. /http://www.haskell.org/onlinereport/haskell2010 .Cabal,An unknown language, identified by its name. 1Cabal_Extensions that have been deprecated, possibly paired with another extension that replaces it.!Cabalread 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.                           ! " # $ % & ' ( ) * + , - . / 0 1 2 + , - . / 0 ' ( ) *                           ! " # $ % & 1 2vIsaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone27 WCabalCompiler information used for resolving configurations. Some fields can be set to Nothing to indicate that the information is unknown. YCabalCompiler flavour and version. ZCabalGTag for distinguishing incompatible ABI's on the same architecture/os. [CabalQOther implementations that this compiler claims to be compatible with, if known. \Cabal'Supported language standards, if known. ]CabalSupported extensions, if known. `Cabal `$ carries only info per GHC and GHCJSCabal parses only  ghc-options and  ghcjs-options, others are omitted. tCabalvThe 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 S= and the user will have to specify which compiler they want. wCabalMake 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.$ T V U W X Y Z [ \ ] ^ _ ` a b c d l n e f g h i j k m o p q r s t u v w$ b c d l n e f g h i j k m o s r t q p ` a u ^ _ W X Y Z [ \ ] w T V U vwNone27 H CabalA ConfVar# represents the variable type used.  xNone27 +' Cabalcomponent is buildable here CabalTools needed to build this bit.This is a legacy field that   largely supersedes.CUnless use are very sure what you are doing, use the functions in $Distribution.Simple.BuildToolDepends, rather than accessing this field directly. Cabal&Haskell tools needed to build this bitThis field is better than  H 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 $Distribution.Simple.BuildToolDepends, rather than accessing this field directly. Cabal'options for pre-processing Haskell code Cabaloptions for assmebler Cabaloptions for C-- compiler Cabaloptions for C compiler Cabaloptions for C++ compiler Cabaloptions for linker Cabal!pkg-config packages that are used Cabalsupport frameworks for Mac OS X Cabal#extra locations to find frameworks. CabalAssembly files. Cabal C-- files. Cabal.where to look for the Haskell module hierarchy Cabalnon-exposed or non-main modules Cabal5exposed modules that do not have a source file (e.g. GHC.Prim from ghc-prim package) CabalFnot present on sdist, Paths_* or user-generated with a custom Setup.hs Cabal+language used when not explicitly specified Cabal'other languages used within the package Cabal'language extensions used by all modules Cabal1other language extensions used within the package Cabal*the old extensions field, treated same as  CabalKwhat libraries to link with when compiling a program that uses your package CabalAif present, overrides extraLibs when package is loaded with GHCi. Cabalif present, adds libs to hs-libraries, which become part of the package. Example: the Cffi library shipping with the rts, alognside the HSrts-1.0.a,.o,... Example 2: a library that is being built by a foreing tool (e.g. rust) and copied and registered together with this library. The logic on how this library is built will have to be encoded in a custom Setup for now. Otherwise cabal would need to lear how to call arbitrary library builders. CabalaHidden Flag. This set of strings, will be appended to all libraries when copying. E.g. [libHS name_ flavour` | flavour <- extraLibFlavours]. This should only be needed in very specific cases, e.g. the rtsP package, where there are multiple copies of slightly differently built libs. Cabal<Hidden Flag. This set of strings will be be appended to all dynamicA libraries when copying. This is particularly useful with the rtsY package, where we want different dynamic flavours of the RTS library to be installed. Cabaldirectories to find .h files Cabal'The .h files to be found in includeDirs Cabal&The .h files to be generated (e.g. by autoconf) Cabal$.h files to install with the package Cabal@Custom fields starting with x-, stored in a simple assoc-list. Cabal7Dependencies specific to a library or executable target CabalThe  +s used by this component CabalThe  '+s that are used somewhere by this component CabalThe  Extensions/ that are used by all modules in this component CabalKWhether any modules in this component use Template Haskell or Quasi Quotes Cabal1Select options for a particular Haskell compiler.6 6 yNone27 T Cabal 2 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  ' 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   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  D (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  1 applied at configure time is persistent to the LocalBuildInfo. The fact that   is passed to confHook MIGHT SUGGEST that the   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   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  y 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.  zNone U CabalClassy lenses for  .0                           0                           {None27 Z@ !Cabal&A "test-suite" stanza in a cabal file. (Cabal+Get all the module names from a test suite. )CabalQGet all the auto generated module names from a test suite. This are a subset of  (. ! " % # $ & ' ( ) ! " % # $ & ' ( )|None Z ! 5 6 7 ! 5 6 7}None27 kM =CabalWhat sigs need implementations? >Cabal]Is the lib to be exposed by default? (i.e. whether its modules available in GHCi for example) ?Cabal4Whether this multilib can be dependent from outside. BCabalNGet 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.) CCabal`Get all the auto generated module names from the library, exposed or not. This are a subset of  libModules."CabalCombine 1. in parsing we prefer value coming from munged name field over the lib-name.Should be irrelevant. ECabalThis instance is not good.We need it for B. More correct method would be some kind of "create empty clone".More concretely, addBuildableCondition_ will make `libVisibility = False` libraries when `buildable: false`. This may cause problems. 8 9 : @ ? ; < = > A B C 8 9 : @ ? ; < = > A B C~None k 8 O P Q R S T U 8 O P Q R S T UNone27 - WCabalA foreign library stanza is like a library stanza, except that the built code is intended for consumption by a non-Haskell client. YCabalName of the foreign library ZCabal9What kind of foreign library is this (static or dynamic). [Cabal_What options apply to this foreign library (e.g., are we merging in all foreign dependencies.) \Cabal+Build information for this foreign library. ]CabalLibtool-style version-info data to compute library version. Refer to the libtool documentation on the current:revision:age versioning scheme. ^CabalLinux library version _Cabal*(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) `Cabal Construct  V from (current, revision, age) numbers.For instance, mkLibVersionInfo (3,0,0) constructs a  V representing the version-info 3:0:0.,All version components must be non-negative. aCabal From a given  V, extract the (current, revision, age) numbers. bCabal&Given a version-info field, produce a major.minor.build version cCabal#Given a version-info field, return "major.minor.build" as a ? dCabal Return the major! version of a version-info field. eCabalAn empty foreign library. fCabal%Modules defined by a foreign library. gCabalIs the foreign library shared? hCabal1Get 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. V W X Y \ Z [ ] ^ _ ` a b c d e f g h W X Y \ Z [ ] ^ _ e f g h V ` a b c dNone  W   W  None27  Cabal$Get all the module names from an exe CabalJGet all the auto generated module names from an exe This are a subset of  . None   None27 Q Cabal%A "benchmark" stanza in a cabal file. Cabal*Get all the module names from a benchmark. CabalPGet all the auto generated module names from a benchmark. This are a subset of  . None7  Cabal0Is a component buildable (i.e., not marked with buildable: False)? See also this note in IDistribution.Types.ComponentRequestedSpec#buildable_vs_enabled_components. None27 T Cabal0A reason explaining why a component is disabled. CabalSDescribes what components are enabled by user-interaction. See also this note in IDistribution.Types.ComponentRequestedSpec#buildable_vs_enabled_components. CabalfThe default set of enabled components. Historically tests and benchmarks are NOT enabled by default. Cabal3Is this component enabled? See also this note in IDistribution.Types.ComponentRequestedSpec#buildable_vs_enabled_components. Cabal8Is this component name enabled? See also this note in IDistribution.Types.ComponentRequestedSpec#buildable_vs_enabled_components. Cabal+Is this component disabled, and if so, why?#Cabal0Is this component name disabled, and if so, why?  Isaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone27>SX Q Cabal: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. CabalThe 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 >= vq make sense. We are in the process of transitioning to specifying just a single version, not a range. See also  . Cabal"A one-line summary of this package Cabal*A more verbose description of this package Cabal@Custom fields starting with x-, stored in a simple assoc-list. Cabal The original  build-type value as parsed from the .cabal# file without defaulting. See also  . CabalOThe 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. Cabal Cabal The SPDX LicenseExpression of the package. CabalSee  . CabalThe effective  build-type! after applying defaulting rules. The original  build-type value parsed is stored in the   field. However, the  build-typeU field is optional and can therefore be empty in which case we need to compute the  effective  build-type;. This function implements the following defaulting rules:For cabal-version:2.0 and below, default to the Custom build-type unconditionally.Otherwise, if a  custom-setup' stanza is defined, default to the Custom build-type; else default to Simple build-type. Cabal2Does this package have a buildable PUBLIC library? Cabal%Does this package have any libraries? CabalIf 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.Cabal'does this package have any executables?Cabal%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.Cabal'Does this package have any test suites?Cabal$Perform an action on each buildable  !" 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.Cabal&Does this package have any benchmarks?Cabal$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.Cabal-Does this package have any foreign libraries?Cabal%Perform the action on each buildable  W in the package description.CabalAll   in the  6: libraries, executables, test-suites and benchmarks.'Useful for implementing package checks. CabalReturn all of the  Os of enabled components, i.e., all of the ones that would be built if you run  ./Setup build. Cabal9Get the combined build-depends entries of all components. Cabal^Get the combined build-depends entries of all enabled components, per the given request spec. Cabal"All the components in the package.CabalXA 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.Cabal9A list of all components in the package that are enabled.<      <      None27>M ߇  !"#$%&  !"#$%&NoneSX % 0123456789:;<=>?@ 0123456789:;<=>?@None # ABC ABCNoneSX (bCabalcCabaldCabal" DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd" DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdNone n(TUVWXYZ                           ! 5 6 7 8 O P Q R S T U W  0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdIsaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone  RSTUVWXYZ !"#$%&'()*+,-./012 !"#$%&'()*+,-Z[\]^_      G H I J K ! " % # $ & ' ( ) 8 9 : @ ? ; < = > A B C     !"#$%       8 9 : @ ? ; < = > G H I J K A B C  ! " % # $ ' & ( )     Z[\]^_   !"#$% !"#$%&+)'(,-* RSTUVWXYZ()*+,-./0$%&' !"#21 None eCabalODesugar 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.fCabalmGet 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.gCabalADoes 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 n}) 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.hCabalDGet 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 g also apply to this function.efghefghIsaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone247>SX =R jCabal_An abstract path, possibly containing variables that need to be substituted for to get a real x.kCabalThe location prefix for the copy command.nCabalwhen using the ${pkgroot} as prefix. The CopyToDb will adjust the paths to be relative to the provided package database when copying / installing.oCabal)The installation directories in terms of js 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.pCabal9The 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.wCabalforeign librariesCabal5Substitute the install dir templates into each other.To prevent cyclic substitutions, only some variables are allowed in particular dir templates. If out of scope vars are present, they are not substituted for. Checking for any remaining unsubstituted vars can be done as a subsequent operation.-The reason it is done this way is so that in  we can replace r with the  and get resulting js that still have the U in them. Doing this makes it each to check which paths are relative to the $prefix.CabalConvert from abstract install directories to actual absolute ones by substituting for all the variables in the abstract paths, to get real absolute path.CabalBCheck which of the paths are relative to the installation $prefix.If any of the paths are not relative, ie they are absolute paths, then it prevents us from making a relocatable package (also known as a "prefix independent" package).Cabal Convert a x to a j including any template vars.Cabal7Convert back to a path, any remaining vars are includedCabal=The initial environment has all the static stuff but no paths@ijkmnlopqrstuv{|}wxyz~@pqrstuv{|}wxyz~okmnljiNone =>?@ACSX ZCabalFilepath are parsed as .CabalVersion range or just versionCabal)SPDX License expression or legacy licenseCabal$Version range or just version, i.e.  cabal-version field.!There are few things to consider:Starting with 2.2 the cabal-version field should be the first field in the file and only exact version is accepted. Therefore if we get e.g. >= 2.2, we fail. See ,https://github.com/haskell/cabal/issues/4899CabalEither "quoted" or  un-quoted.CabalHaskell string or [^ ]+CabalHaskell string or [^ ,]+CabalLike  , but for U.Cabal4List separated with optional commas. Displayed with sep, arguments of type a" are parsed and pretty-printed as b.Cabal3Paragraph fill list without commas. Displayed with $.Cabal9Paragraph fill list with optional commas. Displayed with $.Cabal3Vertical list with optional commas. Displayed with %.Cabal0Paragraph fill list with commas. Displayed with $Cabal*Vertical list with commas. Displayed with %Cabal and  are simply E, with additional phantom arguments to constraint the resulting type:t alaList VCat/alaList VCat :: [a] -> List VCat (Identity a) a:t alaList' FSep Token9alaList' FSep Token :: [String] -> List FSep Token StringCabalMore general version of .Cabal and  are simply Q constructor, with additional phantom arguments to constraint the resulting type:t alaSet VCat0alaSet VCat :: Set a -> Set' VCat (Identity a) a:t alaSet' FSep Token:alaSet' FSep Token :: Set String -> Set' FSep Token String;unpack' (alaSet' FSep Token) <$> eitherParsec "foo bar foo"Right (fromList ["bar","foo"])CabalMore general version of .((Safe [&'()*+,- #Isaac Jones, Simon Marlow 2003-2004=BSD3 portions Copyright (c) 2007, Galois Inc.cabal-devel@haskell.orgportableNone &'7>SX ACabalAdvanced options for . and 0.CabalKeep temporary files?.Cabal/When should we output the marker? Things like die always get marked, but a /5 will only be output if we're not a quiet verbosity.0CabalWhen 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, 1 is not used.2CabalTag an z= whose error string should be output to the screen verbatim.3Cabal Check if an z% should be output verbatim to screen.4Cabal Create a y) whose error text will be output verbatimCabalGiven 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.)5CabalBC wrapper around |.CabalCNon fatal conditions that may be indicative of an error or problem.We display these at the   verbosity level.CabalUseful status messages.We display these at the   verbosity level.This is for the ordinary helpful status messages that users see. Just enough information to know that things are working but not floods of detail.CabalDisplay a message at  ( verbosity level, but without wrapping.CabalPretty-print a 6 status message at  : verbosity level. Use this if you need fancy formatting.CabalKDisplay a "setup status message". Prefer using setupMessage' if possible.Cabal,More detail on the operation of some action.6We display these messages when the verbosity level is  Cabal'Detailed internal debugging information6We display these messages when the verbosity level is  Cabal A variant of Y that doesn't perform the automatic line wrapping. Produces better output in some cases.CabalXPerform an IO action, catching any IO exceptions and printing an error if one occurs.Cabal!Run an IO computation, returning e- if it raises a "file does not exist" error.7CabalWraps text unless the +nowrap verbosity flag is active8CabalPrepends a timestamp if  +timestamp verbosity flag is setThis is used by 9CabalWrap output with a marker if  +markoutput verbosity flag is set.NB: Why is markoutput done with start/end markers, and not prefixes? Markers are more convenient to add (if we want to add prefixes, we have to  and then ; here's it's just some concatenates). Note that even in the prefix case, we can't guarantee that the markers are unambiguous, because some of Cabal's output comes straight from external programs, where we don't have the ability to interpose on the output.This is used by 9:CabalVAppend a trailing newline to a string if it does not already have a trailing newline.;Cabal8Prepend a call-site and/or call-stack based on Verbosity<CabalbDetermine if we should emit a call stack. If we trace, it also emits any prefix we should append.9Cabal/Add all necessary metadata to a logging message Cabal$Run a command and return its output.8The output is assumed to be text in the locale encoding.CabalRun a command and return its output, errors and exit status. Optionally also supply some input. Also provides control over whether the binary/text mode of the input and output.CabalLook for a program and try to find it's version number. It can accept either an absolute path or the name of a program binary, in which case we will look for the program on the path.CabalLike the Unix xargs program. Useful for when we've got very long command lines that might overflow an OS limit on command line length and so you need to invoke a command multiple times to get all the args in.@Use it with either of the rawSystem variants above. For example: @xargs (32*1024) (rawSystemExit verbosity) prog fixedArgs bigArgsCabalJFind a file by looking in a search path. The file path must match exactly.CabalFind a file by looking in a search path with one of a list of possible file extensions. The file base name should be given and it will be tried with each of the extensions in each element of the search path.CabalLike x but returns which element of the search path the file was found in, and the file path relative to that base directory.Cabal@Finds the files corresponding to a list of Haskell module names.As  but for a list of module names.Cabal5Find 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.Cabal9List all the files in a directory and all subdirectories.The order places files in sub-directories after all the files in their parent directories. The list is generated lazily so is not well defined if the source directory structure changes before the list is used.Cabal,Is this directory in the system search path?Cabal(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.CabalLike -, but also checks that the first file exists. CabalSame as createDirectoryIfMissing% but logs at higher verbosity levels.!CabalCopies a file without copying file permissions. The target file is created with default permissions. Any existing target file is replaced.3At higher verbosity levels it logs an info message."CabalInstall an ordinary file. This is like a file copy but the permissions are set appropriately for an installed file. On Unix it is "-rw-r--r--" while on Windows it uses the default permissions for the target directory.#CabalInstall an executable file. This is like a file copy but the permissions are set appropriately for an installed file. On Unix it is "-rwxr-xr-x" while on Windows it uses the default permissions for the target directory.$CabalEInstall a file that may or not be executable, preserving permissions.%CabalGiven a relative path to a file, copy it to the given directory, preserving the relative path and creating the parent directories if needed.=CabalCommon implementation of &, ', ( and ).&CabalCopies a bunch of files to a target directory, preserving the directory structure in the target location. The target directories are created if they do not exist.The files are identified by a pair of base directory and a path relative to that base. It is only the relative part that is preserved in the destination. For example: 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.'Cabal This is like & but uses ".(Cabal This is like & but uses #.)Cabal This is like & but uses $.*CabalThis installs all the files in a directory to a target location, preserving the directory layout. All the files are assumed to be ordinary rather than executable files.+Cabal?Recursively copy the contents of one directory to another path.,CabalLike >., but also checks that the file is executable..Cabal4Use a temporary filename that doesn't already exist./Cabal A version of . that additionally takes a  argument.0Cabal%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.1Cabal A version of 0 that additionally takes a  argument.2CabalWrite a file but only if it would have new content. If we would be writing the same as the existing content then leave the file as is so that we do not update the file's modification time.NB: Before Cabal-3.0 the file content was assumed to be ASCII-representable. Since Cabal-3.0 the file is assumed to be UTF-8 encoded.3CabalDThe 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.)5Cabal"Drop the extension if it's one of 6 , or return the path unchanged.6CabalKList of possible executable file extensions on the current build platform.7CabalPackage description file (pkgname.cabal)8CabalDFind a package description file in the given directory. Looks for .cabal files.9CabalLike 8 , but calls die in case of error.:CabalFFind auxiliary package information in the given directory. Looks for  .buildinfo files.Cabal.a description of the action we were attemptingCabalthe action itself CabalNew working dir or inheritCabalNew environment or inheritCabalstdinCabalstdoutCabalstderr CabalNew working dir or inheritCabalNew environment or inheritCabalstdinCabalstdoutCabalstderrCabal7Any handles created for stdin, stdout, or stderr with  CreateProcess, and a handle to the process.CabalProgram locationCabal ArgumentsCabalNew working dir or inheritCabalNew environment or inheritCabalinput text and binary modeCabaliodata mode, acts as proxyCabaloutput, errors, exitCabal version argsCabal8function to select version number from program outputCaballocationCabalsearch locationsCabal File NameCabalsearch locationsCabal File NameCabal"build prefix (location of objects)Cabalsearch suffixesCabalmodulesCabal"build prefix (location of objects)Cabalsearch suffixesCabalmodulesCabal"build prefix (location of objects)Cabalsearch suffixesCabalmoduleCabal"build prefix (location of objects)Cabalsearch suffixesCabalmodule CabalCreate its parents too?.CabalTemp dir to create the file inCabalFile name template. See ./CabalTemp dir to create the file inCabalFile name template. See .8Cabal Where to lookCabal pkgname.cabal:CabalDirectory to searchCabaldir/pkgname .buildinfo , if presentzb !"#$%,-./012356789:;<=>?@ABCDEFJPQ      !"#$%&'()*+,-./0123456789:z     #$% !" !&%"#$'()*+,3456-./01b789:./2012367895:;EF>@<=?ABCDJ,-PQNone27X  <Cabal%NubListR : A right-biased version of > . That is +toNubListR ["-XNoFoo", "-XFoo", "-XNoFoo"] will result in ["-XFoo", "-XNoFoo"], unlike the normal >), which is left-biased. Built on top of ? and @.>CabalANubList : A de-duplicated list that maintains the original order.@Cabal'Smart constructor for the NubList type.ACabal7Lift a function over lists to a function over NubLists.?Cabal1Helper used by NubList/NubListR's Read instances.BCabal(Smart constructor for the NubListR type.CCabal8Lift a function over lists to a function over NubListRs.ECabal>Binary instance for 'NubList a' is the same as for '[a]'. For O6, we just pull off constructor and put the list. For N, we get the list and make a > out of it using @.ICabalMonoid 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.<=>?@ABC>@?A<B=CNone>MSX QCabalThe 4 monad with specialized logging and error messages.RCabalRun Q!, outputting traces according to  , die if there is an error.SCabal"Output a warning trace message in Q.TCabal)Output an informational trace message in Q.UCabal+Fail the computation with an error message.@Cabal:Format a message with context. (Something simple for now.)VCabal+Add a message to the error/warning context.QRSTUVQRSTUV(c) Sergey Vinokurov 2017 BSD3-stylecabal-devel@haskell.orgNone>SX $ ZCabal-Working directory to create response file in.Cabal Template for response file name.Cabal+Encoding to use for response file contents.Cabal$Arguments to put into response file.ZZDuncan Coutts 2013cabal-devel@haskell.orgportableNone27>SX 3\CabalA specific dir]CabalThe system default^CabalOA 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 (A) 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]aCabal 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%.bCabal=Get the system search path. On Unix systems this is just the $PATH6 env var, but on windows it's a bit more complicated.[\]^_`ab^[\]_`ab)Isaac Jones 2006, Duncan Coutts 2007-2009cabal-devel@haskell.orgportableNone27>SX eYgCabalWhere 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.hCabalHThe user gave the path to this program, eg. --ghc-path=/usr/bin/ghc-6.6iCabal$The program was found automatically.kCabalKRepresents a program which has been configured and is thus ready to be run.(These are usually made by configuring a v=, but if you have to construct one directly then start with  and override any extra fields.mCabalJust the name againnCabal,The version of this program, if it is known.oCabalDefault command-line args for this program. These flags will appear first on the command line, so they can be overridden by subsequent flags.pCabalOverride command-line args for this program. These flags will appear last on the command line, so they override all earlier flags.qCabalOverride 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.rCabalA 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.sCabalLocation of the program. eg. /usr/bin/ghc-6.4tCabalIn addition to the s" 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).vCabal-Represents a program which can be configured.9Note: rather than constructing this directly, start with  and override any extra fields.xCabal'The simple name of the program, eg. ghcyCabalzA 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.zCabalTry to find the version of the program. For many programs this is not possible or is not necessary so it's OK to return Nothing.{CabalA function to do any additional configuration after we have located the program (and perhaps identified its version). For example it could add args, or environment vars.|CabalA function that filters any arguments that don't impact the output from a commandline. Used to limit the volatility of dependency hashes when using new-build.}Cabal&The full path of a configured program.~Cabal/Suppress any extra arguments added by the user.CabalMake a simple named program.By default we'll just search for it in the path and not try to find the version name. You can override these behaviours if necessary, eg: L(simpleProgram "foo") { programFindLocation = ... , programFindVersion ... }CabalMake a simple k. 2simpleConfiguredProgram "foo" (FoundOnSystem path)[\]^ghijklmnopqrstuvwxyz{|}~vwxyz{|^[\]klmnopqrst}~ughijDuncan Coutts 2009cabal-devel@haskell.orgportableNone&'>SX zCabal7Represents a specific invocation of a specific program.This is used as an intermediate type between deciding how to call a program and actually doing it. This provides the opportunity to the caller to adjust how the program will be called. These invocations can either be run directly or turned into shell or batch scripts.Cabal6TODO: remove this, make user decide when constructing .CabaleReturn the current environment extended with the given overrides. If an entry is specified twice in  overrides%, the second entry takes precedence.CabalLike the unix xargs program. Useful for when we've got very long command lines that might overflow an OS limit on command line length and so you need to invoke a command multiple times to get all the args in.It takes four template invocations corresponding to the simple, initial, middle and last invocations. If the number of args given is small enough that we can get away with just a single invocation then the simple one is used:  $ simple argsIf the number of args given means that we need to use multiple invocations then the templates for the initial, middle and last invocations are used: I$ initial args_0 $ middle args_1 $ middle args_2 ... $ final args_nDuncan Coutts 2009cabal-devel@haskell.orgportableNone&' ]CabaloGenerate a system script, either POSIX shell script or Windows batch file as appropriate for the given system.Cabal5Generate a POSIX shell script that invokes a program.Cabal5Generate a Windows batch file that invokes a program.Thomas Tuegel 2011cabal-devel@haskell.orgportableNone>SX Cabal%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.CabalPath to .tix fileCabalPaths to .mix file directoriesCabal(Path where html output should be locatedCabal&List of modules to exclude from reportBCabalPath to .tix fileCabalPaths to .mix file directoriesCabal)Path where html output should be locatedCabal'List of modules to exclude from reportCabalPaths to .tix filesCabalPath to resultant .tix fileCabal%List of modules to exclude from unionCCabalPaths to .tix filesCabalPath to resultant .tix fileCabal%List of modules to exclude from union#Isaac Jones, Simon Marlow 2003-2004=BSD3 portions Copyright (c) 2007, Galois Inc.cabal-devel@haskell.orgportableNone4>SX DCabalFirst argument: Is this a **/*.ext pattern? Second argument: should we match against the exact extensions, or accept a suffix? Third argument: the extensions to accept.ECabalLiteral file name.FCabal,A single subdirectory component + remainder.Cabal$The glob matched the value supplied.Cabal)The glob did not match the value supplied because the cabal-version is too low and the extensions on the file did not precisely match the glob's extensions, but rather the glob was a proper suffix of the file's extensions; i.e., if not for the low cabal-version, it would have matched.CabalThe glob couldn't match because the directory named doesn't exist. The directory will be as it appears in the glob (i.e., relative to the directory passed to , and, for  'data-files', relative to  'data-dir').GCabal#Extract the matches from a list of s.Note: throws away the Y results; chances are that you want to check for these and error out if any are present.CabalReturns S% if the glob didn't match at all, or TZ the result if the glob matched (or would have matched with a higher cabal-version).Cabal This will n when the glob matches no files, or if the glob refers to a missing directory, or if the glob fails to parse.The  argument must be the spec version of the package description being processed, as globs behave slightly differently in different spec versions. The first x argument is the directory that the glob is relative to. It must be a valid directory (and hence it can't be the empty string). The returned values will not include this prefix. The second x is the glob itself.Cabal?Match files against a pre-parsed glob, starting in a directory.The  argument must be the spec version of the package description being processed, as globs behave slightly differently in different spec versions.The x argument is the directory that the glob is relative to. It must be a valid directory (and hence it can't be the empty string). The returned values will not include this prefix.HCabal^Extract the (possibly null) constant prefix from the pattern. This has the property that, if '(pref, final) = splitConstantPrefix pat, then -pat === foldr GlobStem (GlobFinal final) pref.ICabalThe pattern's extensionCabalThe candidate file's extensionIsaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone27 CabalnSome compilers (notably GHC) support profiling and can instrument programs so the system can account costs to different functions. There are different levels of detail that can be used for this accounting. For compilers that do not support this notion or the particular detail levels, this is either ignored or just capped to some similar level they do support.CabalSome compilers support emitting debug info. Some have different levels. For compilers that do not the level is just capped to the level they do support.CabalSome compilers support optimising. Some have different levels. For compilers that do not the level is just capped to the level they do support.CabalWe typically get packages from several databases, and stack them together. This type lets us be explicit about that stacking. For example typical stacks include: 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.CabalrSome 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.CabalCompiler flavour and version.CabalGTag for distinguishing incompatible ABI's on the same architecture/os.CabalGOther implementations that this compiler claims to be compatible with.CabalSupported language standards.CabalSupported extensions.Cabal?A key-value map for properties not covered by the above fields.CabalJIs this compiler compatible with the compiler flavour we're interested in?For example this checks if the compiler is actually GHC or is another compiler that claims to be compatible with some version of GHC, e.g. GHCJS. 6if compilerCompatFlavor GHC compiler then ... else ...CabalIs this compiler compatible with the compiler flavour we're interested in, and if so what version does it claim to be compatible with.For example this checks if the compiler is actually GHC-7.x or is another compiler that claims to be compatible with some GHC-7.x version. fcase compilerCompatVersion GHC compiler of Just (Version (7:_)) -> ... _ -> ...CabalaReturn the package that we should register into. This is the package db at the top of the stack.CabalMake package paths absoluteCabalBFor the given compiler, return the extensions it does not support.CabalFFor the given compiler, return the flags for the supported extensions.JCabalLooks up the flag for a given extension, for a given compiler. Ignores the subtlety of extensions which lack associated flags.KCabalLooks up the flag for a given extension, for a given compiler. However, the extension may be valid for the compiler but not have a flag. For example, NondecreasingIndentation is enabled by default on GHC 7.0.4, hence it is considered a supported extension but not an accepted flag.The outer layer of Maybe indicates whether the extensions is supported, while the inner layer indicates whether it has a flag. When building strings, it is often more convenient to use J , which ignores the difference.Cabal0Does this compiler support parallel --make mode?Cabal.Does this compiler support reexported-modules?Cabal>Does this compiler support thinning/renaming on package flags?Cabal:Does this compiler have unified IPIDs (so no package keys)Cabal(Does this compiler support package keys?Cabal$Does this compiler support unit IDs?Cabal$Does this compiler support Backpack?CabalRDoes this compiler support a package database entry with: "dynamic-library-dirs"?CabalaDoes this compiler's "ar" command supports response file arguments (i.e. @file-style arguments).Cabal4Does this compiler support Haskell program coverage?Cabal%Does this compiler support profiling?LCabal&Utility function for GHC only features` T V U W X Y Z [ \ ] ^ _ ` a b c d l n e f g h i j k m o p q r s t u v w<cabal-devel@haskell.orgportableNone  !CabalDInformation 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.#Cabal"XHaskell2010 and -XHaskell98 flags$Cabal(-supported-languages gives Ext and NoExt%Cabal%NondecreasingIndentation is always on&Cabalghci-script flag supported'Cabalnew style -fprof-auto* flags(Cabal&use package-conf instead of package-db)Cabalg flag supported*Cabalsupports numeric -g levels+Cabal picks up .ghc.environment files,Cabal"Wmissing-home-modules is supportedMCabalThe GHCJS versionCabalThe GHC version!"#$%&'()*+,-NMNone"#7>SX [XD/Cabal  -fprof-auto0Cabal -fprof-auto-top1Cabal -fprof-auto-exported3Cabal -static4Cabal -dynamic5Cabal -static -dynamic-too7Cabal -O08Cabal -O9Cabal -O2:Cabale.g. -Odph<Cabal ghc -c=Cabal ghc>Cabal  ghc --make?Cabalghci / ghc --interactive@Cabalghc --abi-hash( | GhcModeDepAnalysis -- ^ ghc -M( | GhcModeEvaluate -- ^ ghc -eACabal%A structured set of GHC options/flags<Note that options containing lists fall into two categories:Voptions that can be safely deduplicated, e.g. input modules or enabled extensions;yoptions that cannot be deduplicated in general without changing semantics, e.g. extra ghc options or linking options.CCabal&The major mode for the ghc invocation.DCabal_Any extra options to pass directly to ghc. These go at the end and hence override other stuff.ECabalpExtra default flags to pass directly to ghc. These go at the beginning and so can be overridden by other stuff.FCabalCThe main input files; could be .hs, .hi, .c, .o, depending on mode.GCabal/The names of input Haskell modules, mainly for --make mode.HCabalLocation for output file; the ghc -o flag.ICabal$Location for dynamic output file in 5 mode; the  ghc -dyno flag.JCabal?Start with an empty search path for Haskell source files; the ghc -i flag (-i# on its own with no path argument).KCabal*Search path for Haskell source files; the ghc -i flag.LCabal,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.)MCabalGHC 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 N is non-emptyNCabaltHow 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.OCabal*No code? (But we turn on interface writingPCabal"GHC package databases to use, the ghc -package-conf flag.QCabal:The GHC packages to bring into scope when compiling, the ghc -package-id flags.RCabal$Start with a clean package set; the ghc -hide-all-packages flagSCabal.Warn about modules, not listed in command lineTCabal/Don't automatically link in Haskell98 etc; the ghc -no-auto-link-packages flag.UCabal#Names of libraries to link in; the ghc -l flag.VCabal*Search path for libraries to link in; the ghc -L flag.WCabal+Options to pass through to the linker; the  ghc -optl flag.XCabal%OSX only: frameworks to link in; the ghc -framework flag.YCabal6OSX only: Search path for frameworks to link in; the ghc -framework-path flag.ZCabal1Don't do the link step, useful in make mode; the  ghc -no-link flag.[CabalDon't link in the normal RTS main entry point; the ghc -no-hs-main flag.\Cabal*Module definition files (Windows specific)]Cabal/Options to pass through to the C compiler; the  ghc -optc flag.^Cabal,Options to pass through to the C++ compiler._Cabal)Options to pass through to the Assembler.`Cabal$Options to pass through to CPP; the  ghc -optP flag.aCabal4Search path for CPP includes like header files; the ghc -I flag.bCabal0Extra header files to include at CPP stage; the ghc -optP-include flag.cCabal5Extra header files to include for old-style FFI; the  ghc -#include flag.dCabalThe base language; the ghc -XHaskell98 or  -XHaskell2010 flag.eCabalThe language extensions; the ghc -X flag.fCabalhA GHC version-dependent mapping of extensions to flags. This must be set to be able to make use of the e.gCabal$What optimisation level to use; the ghc -O flag.hCabalEmit debug info; the ghc -g flag.iCabalCompile in profiling mode; the  ghc -prof flag.jCabal.Automatically add profiling cost centers; the ghc -fprof-auto* flags.kCabal&Use the "split sections" feature; the ghc -split-sections flag.lCabal*Use the "split object files" feature; the ghc -split-objs flag.mCabal(Run N jobs simultaneously (if possible).nCabalEnable coverage analysis; the ghc -fhpc -hpcdir flags.oCabal Extra GHCi startup scripts; the  -ghci-script flagrCabalonly in 5 modesCabalonly in 5 mode~Cabal9Get GHC to be quiet or verbose with what it's doing; the ghc -v flag.CabalJPut the extra folders in the PATH environment variable we invoke GHC withCabalZLet GHC know that it is Cabal that's calling it. Modifies some of the GHC error messages.OCabalGHC <7.6 uses '-package-conf' instead of  '-package-db'.CabalGHC >= 7.6 uses the  '-package-db' flag. See  ,https://ghc.haskell.org/trac/ghc/ticket/5977.X./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~XABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~;<=>?@6789:2345./01)Isaac Jones 2006, Duncan Coutts 2007-2009cabal-devel@haskell.orgportableNone `CabalUThe default list of programs. These programs are typically used internally to Cabal.)Isaac Jones 2006, Duncan Coutts 2007-2009cabal-devel@haskell.orgportableNone2>SX CabalThe 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 vC but also any user-provided arguments and location for the program.CabalThe 'Read'\/'Show' and P1 instances do not preserve all the unconfigured Programs because v 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 vs.IIt does not add the default programs, but you probably want them, use ) in addition to any extra you might need.Cabal/Add a known program that we may configure laterCabalGet the current ^ used by the . This is the default list of locations where programs are looked for when configuring them. This can be overridden for specific programs (with f), and specific known programs can modify or ignore this search path in their own configuration code.CabalChange the current ^ used by the }. This will affect programs that are configured from here on, so you should usually set it before configuring any programs.CabalModify the current ^ used by the . This will affect programs that are configured from here on, so you should usually modify it before configuring any programs.CabalUser-specify this path. Basically override any path information for this program in the configuration. If it's not a known program ignore it.CabalUser-specify the arguments for this program. Basically override any args information for this program in the configuration. If it's not a known program, ignore it..CabalLike ) but for a list of progs and their paths.CabalLike ( but for a list of progs and their args.PCabalFGet the path that has been previously specified for a program, if any.CabalEGet any extra args that have been previously specified for a program.Cabal Try to find a configured programCabal,Update a configured program in the database.CabalList all configured programs.CabalTry to configure a specific program. If the program is already included in the collection of unconfigured programs then we use any user-supplied location and arguments. If the program gets configured successfully it gets added to the configured collection.Note that it is not a failure if the program cannot be configured. It's only a failure if the user supplied a location and the program could not be found at that location.The reason for it not being a failure at this stage is that we don't know up front all the programs we will need, so we try to configure them all. To verify that a program was actually successfully configured use .QCabal$Configure a bunch of programs using  . Just a `.CabalrUnconfigure a program. This is basically a hack and you shouldn't use it, but it can be handy for making sure a  actually reconfigures.CabalJTry to configure all the known programs that have not yet been configured.Cabal\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 .Cabal;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.Cabal;Check that a program is configured and available to be run. It returns S9 if the program couldn't be configured, or is not found.Cabal;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  AnyVersion 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.CabalLike O, but raises an exception in case of error instead of returning 'Left errMsg'.Cabal4Note that this instance does not preserve the known vs. See  for details.Cabal4Note that this instance does not preserve the known vs. See  for details.Cabal4Note that this instance does not preserve the known vs. See  for details.Cabal Program nameCabal"user-specified path to the programCabal Program nameCabaluser-specified args)Isaac Jones 2006, Duncan Coutts 2007-2009cabal-devel@haskell.orgportableNone>SX 8Cabal"Runs the given configured program.Cabal6Runs the given configured program and gets the output.Cabal?Looks up the given program in the program database and runs it.Cabal?Looks up the given program in the program database and runs it.Cabal VerbosityCabalThe program to runCabalAny extra arguments to addCabal VerbosityCabalThe program to runCabalAny extra arguments to addCabal verbosityCabalThe program to runCaballook up the program hereCabalAny extra arguments to addCabal verbosityCabalThe program to runCaballook up the program hereCabalAny extra arguments to addf[\]^_`ghijklmnopqrstuvwxyz{|}~fvwxyz{|^[\]`_klmnopqrst}ughij~cabal-devel@haskell.orgportableNone>SX 4Duncan Coutts 2007BSD3cabal-devel@haskell.org(non-portable (ExistentialQuantification)None>ESX Cabalwraps 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.RCabal(Common flags that apply to every commandCabal Long command line option stringsCabal!Short command line option stringsCabalaAn OptionField takes one or more OptDescrs, describing the command line interface for the field.CabalLWe 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.CabalQThe name of the command as it would be entered on the command line. For example "build".CabalBA short, one line description of the command to use in help texts.CabalIA function that maps a program name to a usage summary for this command.Cabal;Additional explanation of the command to use in help texts.Cabal+Post-Usage notes and examples in help textsCabalInitial / empty flagsCabal&All the Option fields for this commandCabalzCreate an option taking a single OptDescr. No explicit Name is given for the Option, the name is the first LFlag given.CabalCreate an option taking several OptDescrs. You will have to give the flags and description individually to the OptDescr constructor.Cabal.Create a string-valued command line interface.CabalCCreate a string-valued command line interface with a default value.Cabal!(String -> a) variant of "reqArg"Cabal!(String -> a) variant of "optArg"Cabalcreate a Choice optionCabalcreate a Choice option out of an enumeration type. As long flags, the Show output is used. As short flags, the first character which does not conflict with a previous one is used.Cabal:Show flags in the standard long option command line formatSCabalDThe help text for this command with descriptions of all the options.Cabal0Default "usage" documentation text for commands. CabalHCreate "usage" documentation from a list of parameter configurations. CabalMake a Command from standard GetOpt options. Cabal'Parse a bunch of command line arguments CabaljMark command as hidden. Hidden commands don't show up in the 'progname help' or 'progname --help' output.CabalUtility function, many commands do not accept additional flags. This action fails with a helpful error message if the user supplies any extra.Cabal6Helper function for creating globalCommand descriptionCabalDMkOptDescr constructors partially applied to flags and description. CabalnameCabalsynopsisCabalusage alternativesCabalinitial/empty flagsCabaloptions Cabal&Is the command a global or subcommand??     ?     8Isaac Jones 2003-2004 Duncan Coutts 2007BSD3cabal-devel@haskell.orgportableNone27>SX2>C\Cabal9When we build haddock documentation, there are two cases: We build haddocks only for the current development version, intended for local use and not for distribution. In this case, we store the generated documentation in  distdochtml/ packagename..We build haddocks for intended for uploading them to hackage. In this case, we need to follow the layout that hackage expects from documentation tarballs, and we might also want to use different flags than for development builds, so in this case we store the generated documentation in  distdochtml/ packageid-docs.oCabal Flags to register and  unregister2: (user package, gen-script, in-place, verbosity)zCabal Flags to sdist: (snapshot, verbosity)Cabal Flags to install: (package db, verbosity)Cabal Flags to copy6: (destdir, copy-prefix (backwards compat), verbosity)Cabal Flags to  configure command.+IMPORTANT: every time a new flag is added, f should be updated. IMPORTANT: every time a new flag is added, it should be added to the Eq instanceCabalAll programs that cabal may runCabaluser specified programs pathsCabaluser specified programs argsCabalExtend the $PATHCabal(The "flavor" of the compiler, e.g. GHC.Cabalgiven compiler locationCabalgiven hc-pkg locationCabalEnable vanilla libraryCabalEnable profiling in the libraryCabalBuild shared libraryCabalBuild static libraryCabal+Enable dynamic linking of the executables.Cabal0Enable fully static linking of the executables.Cabal%Enable profiling in the executables.Cabal1Enable profiling in the library and executables.Cabal8Profiling detail level in the library and executables.Cabal'Profiling detail level in the libraryCabalExtra arguments to  configureCabalEnable optimization.CabalInstalled executable prefix.CabalInstalled executable suffix.CabalInstallation pathsCabal"path to search for extra librariesCabal0path to search for extra frameworks (OS X only)Cabalpath to search for header filesCabalexplicit IPID to be usedCabalexplicit CID to be usedCabaldbe as deterministic as possible (e.g., invariant over GHC, database, etc). Used by the test suiteCabal "dist" prefixCabalCabal file to useCabalverbosity levelCabalThe --user/--global flagCabalWhich package DBs to useCabal!Enable compiling library for GHCiCabalEnable -split-sections with GHCCabalEnable -split-objs with GHCCabalEnable executable strippingCabalEnable library strippingCabal)Additional constraints for dependencies.CabalThe packages depended on.CabalThe requested Backpack instantiation. If empty, either this package does not use Backpack, or we just want to typecheck the indefinite package.CabalEnable test suite compilationCabalEnable benchmark compilationCabalEnable program coverageCabal$Enable program coverage (deprecated)CabalXAll direct dependencies and flags are provided on the command line by the user via the '--dependency' and  '--flags' options.CabalEHalt and show an error message indicating an error in flag assignmentCabal Enable relocatable package builtCabalEmit debug info.CabalXWhether to use response files at all. They're used for such tools as haddock, or or ld.CabalAllow depending on private sublibraries. This is used by external tools (like cabal-install) so they can add multiple-public-libraries compatibility to older ghcs by checking visibility externally.Cabal:Flags that apply at the top level, not to any sub-command.CabalMore convenient version of . Results in an B# if internal invariant is violated.TCabal Inverse to U.UCabal5Pretty-print a single entry of a module substitution.VCabalFor each known program PROG in progDb , produce a  with-PROG .CabalLike V*, but allows to customise the option name.WCabalFor each known program PROG in progDb , produce a  PROG-option .CabalFor each known program PROG in progDb , produce a  PROG-options .CabalArguments to pass to a  configure script, e.g. generated by autoconf.CabalpHelper 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"]kmnl !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\^]_`abcdefghijklmnopqrstuvwxyz{|}~     _`abcd\^]EFGHIJKLMNOPQRSTUVWXYZ[efghijklmn6789:;<=> ./012345?@ABCDopqrstuvwxyz{|}~ !"#$%&'()*+,-kmnl    Thomas Schilling, 2007BSD3cabal-devel@haskell.orgportableNoneXCabal0A set of targets with their package dependenciesYCabal9A map of dependencies that combines version ranges using .ZCabal)Result of dependency test. Isomorphic to Maybe d but renamed for clarity.[CabalSimplify a configuration condition using the OS and arch names. Returns the names of all the flags occurring in the condition.aCabal.Parse a configuration condition from a string.\CabalJTry 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.bCabal Transforms a h by putting the input under the "then" branch of a conditional that is True when Buildable is True. If b can determine that Buildable is always True, it returns the input unchanged. If Buildable is always False, it returns the empty .]CabalThis is a special version of b for the ^ type.fIt is not simply a specialisation. It is more complicated than it ought to be because of the way the ^ monoid instance works. The  mempty = _l 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.cCabalLExtract conditions matched by the given predicate from all cond trees in a .`CabalmCombine the target-specific dependencies in a TargetSet to give the dependencies for the package as a whole.aCabal\Collect up the targets in a TargetSet of tagged targets, storing the dependencies as we go.eCabal>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.fCabalhFlatten 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.hCabalWalk a  and apply f to all nested  build-depends fields.\Cabal3Domain for each flag name, will be tested in order.Cabal-OS as returned by Distribution.System.buildOSCabal1Arch as returned by Distribution.System.buildArchCabalCompiler informationCabalAdditional constraintsCabalDependency test function.Cabal}Either the missing dependencies (error case), or a pair of (set of build targets with dependencies, chosen flag assignments)eCabal%Explicitly specified flag assignmentsCabaljIs a given dependency satisfiable from the set of available packages? If this is unknown then use True.CabalThe   and  CabalCompiler informationCabalAdditional constraintsCabalhEither missing dependencies or the resolved package description along with the flag assignments chosen. abcdefgh efadcbghMartin Sj&#xF6;gren 2004BSD3cabal-devel@haskell.orgportableNone>SX}Clmn            . /  ' & $ # + - * ! " % ( ) , .no  ' & $ # + - * ! " % ( ) , .noNone456FbCabalZBlock of lines, Boolean parameter tells whether block should be surrounded by empty linessCabalPrettyprint a list of fields.'Note: the first argument should return ?0s without newlines and properly prefixes (with --q) to count as comments. This unsafety is left in place so one could generate empty lines between comment lines.tCabals! with user specified indentation.vCabalUsed in x.wCabalUsed in x.xCabalSimple variant of genericFromParsecFieldyCabal%Collapse margins, any margin = marginuCabaltransform field contentsCabaltransform section arguments pqrstuvwx pqrstxuvwNone>SXu ~Cabal:A monad with failure and accumulating errors and warnings.Cabal Destruct a ~ into the emitted warnings and either a successful value or list of errors and possibly recovered a spec-version declaration.CabalRecover/ the parse result, so we can proceed parsing.  will still result in S, if there are recorded errors.CabalSet cabal spec version.CabalGet cabal spec version.Cabal5Add a warning. This doesn't fail the parsing process.CabalAdd multiple warnings at once.Cabal*Add an error, but not fail the parser yet.For fatal failure use CabalAdd an fatal error.CabalA ;.Cabal3Helper combinator to do parsing plumbing for files.`Given a parser and a filename, return the parse of the file, after checking if the file exists.:Argument order is chosen to encourage partial application.Cabal#File contents to final value parserCabalVerbosity levelCabal File to readCabal#File contents to final value parserCabalVerbosity levelCabal File name ~ ~NonedCabalParse R  A from section arguments provided by parsec based outline parser.None7     +,-lmnopqrstuwvpqrsux~7uwvlmstopqrn~     +,-pqrsuxNone4Cabal We can use  to pp print the s.Note: there is not trailing  ($+$ text "").None4XCabalThe  constructor of u.Cabal4Single field, without name, but with its annotation.  None=>?XcCabalPartitioning stateCabal6Reverse function application which binds tighter than  and #-. Useful for refining grammar specification. <*>  _L "extensions" (alaList' FSep MQuoted) oldExtensions ^^^  c [1,12] "Please use 'default-extensions' or 'other-extensions' fields." Cabal;Partition field list into field map and groups of sections.CabalTake all fields from the front.$ V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j$ V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j5NonerCabalsAn intermediate type just used for parsing the benchmark stanza. After validation it is converted into the proper   type.CabaltAn intermediate type just used for parsing the test-suite stanza. After validation it is converted into the proper  ! type.""Jrgen Nicklisch-Franken 2010BSD3cabal-devel@haskell.org provisionalportableNoneCabal7Writes a .cabal file from a generic package descriptionCabal0Writes a generic package description to a stringCabal)Convert a generic package description to ps.CabalCabalCabalCabalIsaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone>SX dCabalSee e.fCabalCreate a from  9. This class is used to implement common stanza parsing.Law: #view buildInfo . fromBuildInfo = idThis takes name, as  Vs take names too.gCabalState of section parserCabalParse the given package file.CabalParses 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.CabalH variant of hCabal%Parse a non-recursive list of fields.iCabalPWarn on "import" fields, also map to Maybe, so errorneous fields can be filteredjCabalCheck that we $don't use undefined flags (very bad)(define flags which are unused (just bad)kCabalSince cabal-version: 1.24 one can specify  custom-setup. Let us require it.eCabal Sectionize2 an old-style Cabal file. A sectionized file has:/all global fields at the beginning, followed by"all flag declarations, followed by_an optional library section, and an arbitrary number of executable sections (in any order).The current implementation just gathers all library-specific fields in a library section and wraps all executable stanzas in an executable section.Cabal#Quickly scan new-style spec-versionA new-style spec-version declaration begins the .cabal file and follow the following case-insensitive grammar (expressed in RFC5234 ABNF): newstyle-spec-version-decl = "cabal-version" *WS ":" *WS newstyle-pec-version *WS spec-version = NUM "." NUM [ "." NUM ] NUM = DIGIT0 / DIGITP 1*DIGIT0 DIGIT0 = %x30-39 DIGITP = %x31-39 WS = %20 hCabalfields to be parsedlCabalaccept elifCabalgrammarCabalcommon stanzasCabalconstructor from buildInfoCabalcondition extractormCabalgrammarCabalconstruct fromBuildInfoCabalcommon stanzasnCabalconstruct fromBuildInfoCabalcommon stanzas~~None4SXCabal/A collection field parsers and pretty-printers.Cabal$Lookup a field value pretty-printer.CabalLookup a field value parser.CabalNote: default values are printed.None"#=?@AoCabal[This type is used to mangle fields as in serialised textual representation to the actual  < fields.pCabalJSPDX License expression or legacy license. Lenient parser, accepts either.qCabalCombine 1. in parsing we prefer value coming from munged name field over the lib-name.Should be irrelevant.rCabalSetter for the  package-name9 field. It should be acceptable for this to be a no-op.s4"(c) The University of Glasgow 2004libraries@haskell.orgportableNoneCabalGet 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  ;.CabalReturns the set of module names which need to be filled for an indefinite package, or the empty set if the package is definite.Cabal2Return either errors, or IPI with list of warningsCabal Pretty print  <.pkgRoot; isn't printed, as ghc-pkg prints it manually (as GHC-8.4).CabalThe variant of  which outputs pkgroot field too.Cabal=let ipi = emptyInstalledPackageInfo { maintainer = "Tester" }9fmap ($ ipi) $ showInstalledPackageInfoField "maintainer"Just "maintainer: Tester"> c d e f     < = B E g \ O > ? @ A C D F G H I J K L M N P Q R S T U V W X Y Z [ ] ^ _ ` a b c d e f j> < = B E g \ O > ? @ A C D F G H I J K L M N P Q R S T U V W X Y Z [ ] ^ _ ` a b c d e f c d e f     jNone27HV{ Cabal?The first five fields are common across all algebraic variants.CabalNIt would be very convenient to store the literal Library here, but if we do that, it will get serialized (via the Binary) instance twice. So instead we just provide the ComponentName, which can be used to find the Component in the PackageDescription. NB: eventually, this will NOT uniquely identify the ComponentLocalBuildInfo. Cabal The computed l of this component. Cabal The computed  = which uniquely identifies this component. Might be hashed. Cabal:Is this an indefinite component (i.e. has unfilled holes)? Cabal"How the component was instantiated CabalMResolved 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.CabalQThe 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.Cabal7The internal dependencies which induce a graph on the 0 of this package. This does NOT coincide with   because it ALSO records  'build-tool'. dependencies on executables. Maybe one day  cabal-install& will also handle these correctly too!CabalBCompatibility "package key" that we pass to older versions of GHC.Cabal@Compatibility "package name" that we register this component as.CabaldA list of exposed modules (either defined in this component, or reexported from another component.)CabalqConvenience field, specifying whether or not this is the "public library" that has the same name as the package.          NoneHVxCabalThe 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.  Duncan Coutts 2009, 2013cabal-devel@haskell.orgportableNone>SXA1"Cabal+Additional variations in the behaviour for 5.$Cabal7Allows re-registering / overwriting an existing package%CabaluInsist on the ability to register multiple instances of a single version of a single package. This will fail if the hc-pkg does not support it, see / and 0.&CabalRequire that no checks are performed on the existence of package files mentioned in the registration info. This must be used if registering prior to putting the files in their final place. This will fail if the hc-pkg does not support it, see 1.'Cabal6Information about the features and capabilities of an hc-pkg program.*Cabalno package DB stack supported+Cabal'hc-pkg does not support verbosity flags,Cabal-use package-conf option instead of package-db-Cabal*supports directory style package databases.Cabal*requires directory style package databases/Cabal%supports --enable-multi-instance flag0Cabal#supports multi-instance via recache1Cabal$supports --force-files or equivalent2CabalCall hc-pkg9 to initialise a package database at the location {path}. hc-pkg init {path}3CabalRun hc-pkg` using a given package DB stack, directly forwarding the provided command-line arguments to it.4Cabal Defaults are True, False and False5CabalCall hc-pkg to register a package. Ahc-pkg register {filename | -} [--user | --global | --package-db]6CabalCall hc-pkg to unregister a package <hc-pkg unregister [pkgid] [--user | --global | --package-db]7CabalCall hc-pkg$ to recache the registered packages. 1hc-pkg recache [--user | --global | --package-db]8CabalCall hc-pkg to expose a package. 8hc-pkg expose [pkgid] [--user | --global | --package-db]9CabalCall hc-pkg to retrieve a specific package :hc-pkg describe [pkgid] [--user | --global | --package-db]:CabalCall hc-pkg to hide a package. 6hc-pkg hide [pkgid] [--user | --global | --package-db];CabalCall hc-pkgK to get all the details of all the packages in the given package database.<CabalCall hc-pkgQ to get the source package Id of all the packages in the given package database.(This is much less information than with ;L, 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.$"#$%&'(,)*+-./0123456789:;<=>?@ABCDE$'(,)*+-./01"#$%&4235678:;9<=>?@ACDBEp(c) David Himmelstrup 2005, Bjorn Bringert 2007, Duncan Coutts 2008-2009cabal-devel@haskell.orgportableNone27=>?OtCabal(We maintain the invariant that, for any t=, there is only one instance of the package in our database.JCabal)The default package index which contains InstalledPackageInfo. Normally use this.KCabal>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.LCabal*Build an index out of a bunch of packages.If there are duplicates by  $ then later ones mask earlier ones.MCabalMerge 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.NCabal(Inserts a single package into the index.8This is equivalent to (but slightly quicker than) using ! or M with a singleton index.OCabal2Removes a single installed package from the index.PCabal&Removes all packages with this source   from the index.QCabalDRemoves all packages with this (case-sensitive) name from the index.9NB: Does NOT delete internal libraries from this package.RCabal$Get all the packages from the index.SCabal$Get all the packages from the index.4They are grouped by package name (case-sensitively).$(Doesn't include private libraries.)TCabal$Get all the packages from the index.AThey are grouped by source package id (package name and version).#(Doesn't include private libraries)UCabal$Get all the packages from the index.7They are grouped by source package id and library name.%This DOES include internal libraries.VCabal!Does a lookup by unit identifier..Since multiple package DBs mask each other by  (, then we get back at most one package.WCabalTDoes a lookup by component identifier. In the absence of Backpack, this is just a V.XCabal4Does 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.YCabalConvenient alias of X0, but assuming only one package per package ID.ZCabal%Does a lookup by source package name.[Cabal=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.\Cabal=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.]Cabal/Does a case-insensitive search by package name.If there is only one package that compares case-insensitively to this name then the search is unambiguous and we get back all versions of that package. If several match case-insensitively but one matches exactly then it is also unambiguous. If however several match case-insensitively and none match exactly then we have an ambiguous result, and we get back all the versions of all the packages. The list of ambiguous results is split by exact package name. So it is a non-empty list of non-empty lists.^Cabal9Does a case-insensitive substring search by package name.BThat is, all packages that contain the given string in their name._Cabal\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.`CabalHAll packages that have immediate dependencies that are not in the index.GReturns such packages along with the dependencies that they're missing.aCabalATries 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.bCabalBTakes the transitive closure of the packages reverse dependencies. The given  s must be in the index.eCabal+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 `.fCabalLGiven a package index where we assume we want to use all the packages (use a 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.gCabal7A rough approximation of GHC's module finder, takes a Jc 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."FGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg"JKLMNOPQVWXYZ[\]FGHI^RSTU`abcdf_egNone27>SX1pCabal1Data cached after configuration step. See also .rCabaldOptions passed to the configuration step. Needed to re-run configuration when .cabal is out of datesCabal9The final set of flags which were picked for this packagetCabal;What components were enabled during configuration, and why.uCabaluExtra args on the command line for the configuration step. Needed to re-run configuration when .cabal is out of datevCabalxThe installation directories for the various different kinds of files TODO: inplaceDirTemplates :: InstallDirs FilePathwCabal The compiler we're building withxCabalThe platform we're building foryCabalWhere to build the package.zCabal6Path to the cabal file, if given during configuration.{CabalAll the components to build, ordered by topological sort, and with their INTERNAL dependencies over the intrapackage dependency graph. TODO: this is assumed to be short; otherwise we want some sort of ordered map.|CabalLA map from component name to all matching components. These coincide with {}CabalAll the info about the installed packages that the current package depends on (directly or indirectly). The copy saved on disk does NOT include internal dependencies (because we just don't have enough information at this point to have an 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.)~Cabal5the filename containing the .cabal file, if availableCabalWARNING WARNING WARNING Be VERY careful about using this function; we haven't deprecated it but using it could introduce subtle bugs related to  .In principle, this is supposed to contain the resolved package description, that does not contain any conditionals. However, it MAY NOT contain the description with a   applied to it; see  c for the whole sordid saga. As much as possible, Cabal library should avoid using this parameter.Cabal"Location and args for all programsCabal)What package database to use, global/userCabalWhether to build normal libs.Cabal,Whether to build profiling versions of libs.Cabal)Whether to build shared versions of libs.CabalHWhether to build static versions of libs (with all other libs rolled in)Cabal'Whether to link executables dynamicallyCabal,Whether to link executables fully staticallyCabal+Whether to build executables for profiling.Cabal"Level of automatic profile detail.Cabal"Level of automatic profile detail.Cabal2Whether to build with optimization (if available).Cabal*Whether to emit debug info (if available).Cabal1Whether to build libs suitable for use with GHCi.Cabal*Use -split-sections with GHC, if availableCabal&Use -split-objs with GHC, if availableCabal+Whether to strip executables during installCabal)Whether to strip libraries during installCabal-Whether to enable executable program coverageCabal*Whether to enable library program coverageCabal/Prefix to be prepended to installed executablesCabal.Suffix to be appended to installed executablesCabal Extract the l) from the public library component of a pD if it exists, or make a fake component ID based on the package ID.Cabal Extract the   of a p. This is a "safe" use of Cabal Extract the  " from the library component of a p? if it exists, or make a fake unit ID based on the package ID.CabalNExtract the compatibility package key from the public library component of a pC if it exists, or make a fake package key based on the package ID.uCabal+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.Cabal Return all s associated with Z[. In the presence of Backpack there may be more than one! Has a prime because it takes a  # argument which may disagree with  in p.Cabal Return all s associated with Z:. In the presence of Backpack there may be more than one!CabalReturn 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 p.CabalExecute 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 p.Cabal3Return 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 p.CabalExecute 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 p.CabalpIs coverage enabled for test suites? In practice, this requires library and executable profiling to be enabled.9pqwrstuvxyz{|}~9pqwrstuvxyz{|}~Isaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone7>SXK Cabal#Perform the action on each enabled  & in the package description with the .Cabal#Perform the action on each enabled  3 in the package description. Extended version of + that also gives corresponding build info.Cabal#Perform the action on each enabled   in the package description.Cabal%Perform the action on each buildable  8 or  V (Component) in the PackageDescription, subject to the build order specified by the compBuildOrder field of the given pCabal|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 rCabalIGet all module names that needed to be built by GHC; i.e., all of these Gs have interface files associated with them that need to be installed.CabalOBackwards compatibility function which computes the InstallDirs assuming that $libname points to the public library (or some fake package identifier if there is no public library.) IF AT ALL POSSIBLE, please use  instead.CabalSee .CabalOBackwards compatibility function which computes the InstallDirs assuming that $libname points to the public library (or some fake package identifier if there is no public library.) IF AT ALL POSSIBLE, please use  instead.CabalSee CabalBuilding for inplace?Cabal&Generate prefix-relative library pathsCabalComponent that is being builtZ[\]^_`b  ijkmnlopqrstuv{|}wxyz~     pqwrstuvxyz{|}~pqwrstuvxyz{|}~ Z[\]^_`b       ijkmnlopqrstuv{|}wxyz~None>SX Cabal/Logs test suite results, itemized by test case.Cabal\Logs all test results for a package, broken down first by test suite and then by test case.CabalA 1 with package and platform information specified.Cabal<Count the number of pass, fail, and error test results in a  tree.CabalFrom a %, determine if the test suite passed.CabalFrom a %, determine if the test suite failed.CabalFrom a 1, determine if the test suite encountered errors.CabalPrint a summary to the console after all test suites have been run indicating the number of successful test suites and cases. Returns U if all test suites passed and R otherwise.CabalPrint a summary of a single test case's result to the console, suppressing output for certain verbosity or test filter levels.Cabal|Print a summary of the test suite's results on the console, suppressing output for certain verbosity or test filter levels.Cabal)Passes, fails, and errors, respectively.Cabaltest suite nameCabaltest suite resultsDuncan Coutts 2009cabal-devel@haskell.orgportableNone>SXCabalCall ld -r* to link a bunch of object files together.Duncan Coutts 2009cabal-devel@haskell.orgportableNone>SX\ CabalCall ar: to create a library archive from a bunch of object files.vCabalar 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.Thomas Tuegel 2011BSD3cabal-devel@haskell.orgportableNone>SX/Cabal?Path to the .tix file containing a test suite's sum statistics.CabalAttempt to guess the way the test suites in this package were compiled and linked with the library so the correct module interfaces are found.Cabal*Generate the HTML markup for a test suite.Cabal<Generate the HTML markup for all of a package's test suites.wCabal"dist/" prefixCabal/Directory containing component's HPC .mix filesCabal"dist/" prefixCabalComponent nameCabal,Directory containing test suite's .mix filesCabal"dist/" prefixCabalComponent nameCabal,Directory containing test suite's .tix filesCabal"dist/" prefixCabalComponent nameCabalPath to test suite's .tix fileCabal"dist/" prefixCabalComponent nameCabal*Path to test suite's HTML markup directoryCabal"dist/" prefixCabal Library nameCabal"dist/" prefixCabal Library name  (c) Duncan Coutts 2012BSD-likeduncan@community.haskell.orgNone7>SXjxCabalA 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, y), ways to combine matchers ( ambiguousWith, shadows;) and finally we can run a matcher against an input using z.Cabal expected thing(actually got)Cabal (no such thing, actually got)CabalA fully resolved build target.CabalA specific componentCabal.A specific module within a specific component.Cabal,A specific file within a specific component.Cabal4Various ways that a user may specify a build target.{CabalOA 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.hsc|CabalA 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.hs}CabalsA 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.FooCabalTake a list of ?9 build targets, and parse and validate them into actual  s to be built registered whatever.CabalGRead a list of user-supplied build target strings and resolve them to s 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.~CabalreadUserBuildTarget "comp"$Right (UserBuildTargetSingle "comp")readUserBuildTarget "lib:comp"*Right (UserBuildTargetDouble "lib" "comp")"readUserBuildTarget "pkg:lib:comp"0Right (UserBuildTargetTriple "pkg" "lib" "comp")readUserBuildTarget "\"comp\""$Right (UserBuildTargetSingle "comp")"readUserBuildTarget "lib:\"comp\""*Right (UserBuildTargetDouble "lib" "comp")&readUserBuildTarget "pkg:lib:\"comp\""0Right (UserBuildTargetTriple "pkg" "lib" "comp")'readUserBuildTarget "pkg:lib:comp:more"6Left (UserBuildTargetUnrecognised "pkg:lib:comp:more")&readUserBuildTarget "pkg:\"lib\":comp"5Left (UserBuildTargetUnrecognised "pkg:\"lib\":comp")CabalUnless you use !, this function is PARTIAL; use   instead. CabalUnambiguously render a ., so that it can be parsed in all situations. CabalRGiven a bunch of user-specified targets, try to resolve what it is they refer to.CabalCombine 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.Cabal)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.Cabal)Lift a list of matches to an exact match.Cabal)Lift a list of matches to an exact match.zCabalfGiven 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.yCabal6A primitive matcher that looks up a value in a finite Q. 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).CabalDCheck that the given build targets are valid in the current context.)Also swizzle into a more convenient form.        9Isaac Jones 2003-2004, Duncan Coutts 2008BSD3cabal-devel@haskell.orgportableNone>SX &CabalmThis is the name of the directory in which the generated haddocks should be stored. It does not include the  distdochtml prefix.'CabalIThe directory to which generated haddock documentation should be written.(CabalYThe directory in which we put auto-generated modules for EVERY component in the package.)CabalQThe directory in which we put auto-generated modules for a particular component.+CabalGThe name of the auto-generated Paths_* module associated with a package1Cabal:The directory where we put build results for an executable2Cabal>The directory where we put build results for a foreign library3CabalHCreate a library name for a static library from a given name. Prepends lib+ and appends the static library extension (.a).6CabalHCreate a library name for a shared library from a given name. Prepends lib and appends the #-<compilerFlavour><compilerVersion>* as well as the shared library extension.9CabalCreate a library name for a bundled shared library from a given name. This matches the naming convention for shared libraries as implemented in GHC's packageHsLibs function in the Packages module. If the given name is prefixed with HS, then this prepends lib and appends the compiler flavour/version and shared library extension e.g.: "HSrts-1.0" -> "libHSrts-1.0-ghc8.7.20190109.so" Otherwise the given name should be prefixed with C, then this strips the C , prepends lib5 and appends the shared library extension e.g.: Cffi -> "libffi.so":CabalLDefault extension for executable files on the current platform. (typically "" on Unix and "exe" on Windows or OS/2);Cabal5Extension for object files. For GHC the extension is "o".<CabalCExtension for dynamically linked (or shared) libraries (typically "so" on Unix and "dll" on Windows)=CabalExtension for static librariesnTODO: Here, as well as in dllExtension, it's really the target OS that we're interested in, not the build OS.$%&'()*+,-./0123456789:;<=$&%'()+*,3456789:;<=0-./12Andres Loeh 2009BSD3cabal-devel@haskell.orgportableNone>SXCabal'The flags for the supported extensions.CaballHack to add version numbers to UHC-built-in packages. This should sooner or later be fixed on the UHC side.Cabal*Name of the installed package config file.CabalCheck 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.Cabal4Create a trivial package info from a directory name.>?@ABCD>?@ABCDLennart Kolmodin 2008BSD3cabal-devel@haskell.orgportableNoneECabalJA record of operations needed to check the contents of packages. Used by U.KCabal-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.LCabalThis package description is no good. There's no way it's going to build sensibly. This should give an error at configure time.MCabalA 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.NCabal$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.OCabalxLike PackageDistSuspicious but will only display warnings rather than causing abnormal exit when you run 'cabal check'.PCabalAn 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.RCabal?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 T.It requires the I and optionally a particular configuration of that package. If you pass S@ then we just check a version of the generic description using f.Cabal,Check that this package description is sane.CabalChecks GHC options from all ghc-*-options fields in the given PackageDescription and reports commonly misused or non-portable flagsCabalExtracts GHC options belonging to the given field from the given PackageDescription using given function and checks them for commonly misused or non-portable flagsCabal3Check that the package declares the version in the "cabal-version" field correctly.CabalACheck the build-depends fields for any weirdness or bad practise.CabalFcabal-version <2.2 + Paths_module + default-extensions: doesn't build.CabalChecks GHC options from all ghc-*-options fields from the given BuildInfo and reports flags that are OK during development process, but are unacceptable in a distrubuted packageCabalChecks the given list of flags belonging to the given field and reports flags that are OK during development process, but are unacceptable in a distributed packageTCabalSanity 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.UCabaleSanity check things that requires looking at files in the package. This is a generalised version of T7 that can work in any monad for which you can provide E operations.zThe point of this extra generality is to allow doing checks in some virtual file system, for example a tarball in memory.CabalDFind a package description file in the given directory. Looks for .cabal files. Like  , but generalized over monads.VCabalCheck the names of all files in a package for portability problems. This should be done for example when creating or validating a package tarball.Cabal=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.Cabal Similar to U,  inspects the files included in the package, but is primarily looking for files in the working tree that may have been missed or other similar problems that can only be detected pre-distribution.Because Hackage necessarily checks the uploaded tarball, it is too late to check these on the server; these checks only make sense in the development and package-creation environment. Hence we can use IO, rather than needing to pass a E dictionary around.Cabal/Discover problems with the package's wildcards.Cabal'Whether a path is a good relative path.jlet test fp = putStrLn $ show (isGoodRelativeDirectoryPath fp) ++ "; " ++ show (isGoodRelativeFilePath fp)test "foo/bar/quu"Nothing; NothingBTrailing slash is not allowed for files, for directories it is ok. test "foo/"Nothing; Just "trailing slash"Leading ./ is fine, but . and ./ are not valid files.'traverse_ test [".", "./", "./foo/bar"]$Nothing; Just "trailing dot segment"Nothing; Just "trailing slash"Nothing; Nothing*Lastly, not good file nor directory cases:Ztraverse_ test ["", "/tmp/src", "foo//bar", "foo/.", "foo/./bar", "foo/../bar", "foo*bar"]$Just "empty path"; Just "empty path"6Just "posix absolute path"; Just "posix absolute path"4Just "empty path segment"; Just "empty path segment"TJust "trailing same directory segment: ."; Just "trailing same directory segment: ."CJust "same directory segment: ."; Just "same directory segment: .."HJust "parent directory segment: .."; Just "parent directory segment: .."<Just "reserved character '*'"; Just "reserved character '*'"For the last case,  doesn't warn:@traverse_ (print . isGoodRelativeGlob) ["foo/../bar", "foo*bar"]#Just "parent directory segment: .."NothingCabalSee .ZThis is barebones function. We check whether the glob is a valid file by replacing stars * with xses.CabalSee .Cabal pkgname.cabalEFIHGJKLMNOPQRSTUVKLMNOPQRSTUEFIHGJVbIsaac Jones 2003-2005, Ross Paterson 2006, Duncan Coutts 2007-2008cabal-devel@haskell.orgportableNoneT[Cabal[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.[CabalTpath component; one of "bindir", "libdir", "datadir", "libexecdir", or "sysconfdir"Cabalenvironment variable nameZ[Z[None>SX ]Cabal:The name of the stub executable associated with a library  TestSuite.^CabalSThe filename of the source file for the stub executable associated with a library  TestSuite._Cabal$Write the source file for a library  TestSuite stub executable.`Cabal2Source code for library test suite stub executableaCabalMain 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.Cabal The test runner used in library  TestSuite$ stub executables. Runs a list of tgs. 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.bCabalFrom a test stub, write the : to temporary file for the calling Cabal process to read._Caballibrary  TestSuite# for which a stub is being createdCabal6path to directory where stub source should be located\]^_`ab\`^a]b_None>SX +ccSimon Marlow 2008cabal-devel@haskell.orgportableNoneCdCabalThe contents of the cabal_macros.h" for the given configured package.eCabal(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).Cabal(Helper function that generates just the TOOL_VERSION_pkg and MIN_TOOL_VERSION_pkg* macros for a list of configured programs.CabalCommon implementation of e and .Cabal Generate the CURRENT_COMPONENT_ID; definition for the component ID of the current package.Cabal Generate the CURRENT_PACKAGE_VERSION? definition for the declared version of the current package.dedeNone=?SX:OfCabal.This method computes a default, "good enough" ll for a package. The intent is that cabal-install (or the user) will specify a more detailed IPID via the --ipid flag if necessary.gCabalIn 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 computeCompatPackageName for more details.The mapping for GHC 7.10:For CLibName: If the IPID is of the form foo-0.1-ABCDEF where foo_ABCDEF would validly parse as a package key, we pass ABCDEF. (NB: not all hashes parse this way, because GHC 7.10 mandated that these hashes be two base-62 encoded 64 bit integers), but hashes that Cabal generated using f, 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.fgNoneU iCabal1A configured component, we know exactly what its l is, and the ls of the things it depends on.kCabal7Unique identifier of component, plus extra useful info.lCabalFThe fragment of syntax from the Cabal file describing this component.mCabalIs 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.)nCabal!Dependencies on executables from  build-tools and build-tool-depends.oCabal?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 ls.pCabal+Uniquely identifies a configured component.qCabal%The package this component came from.rCabalThe Zx of a component; this uniquely identifies a fragment of syntax within a specified Cabal file describing the component.sCabalPretty-print a i.Cabal Construct a i, given that the lc and library/executable dependencies are known. The primary work this does is handling implicit backpack-include fields.CabalAlso computes the lU, and sets cc_public if necessary. This is Cabal-only; cabal-install won't use this.Cabal'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. Multiple public libraries (cabal 3.0) added an unambiguous way of specifying sublibraries, but we still have to support the old syntax for bc reasons.hijklmnopqrstuvwijklmnorpqtvshuwNone_xCabalQA list of components associated with the source level dependencies between them.yCabalFA graph of source-level components by their source-level dependencieszCabal Pretty-print x.{Cabal Create a  q of  +, or report a cycle if there is a problem.|Cabal$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.)}CabalAError message when there is a cycle; takes the SCC of components.xyz{|}yx{|z}None>SXaCabalinstall locationCabal&install location for dynamic librariesCabalBuild location ~ ~Isaac Jones 2003-2007cabal-devel@haskell.orgportableNone>SXzvCabal'The kinds of entries we can stick in a .ghc.environment file.Cabal  -- a commentCabal package-id foo-1.0-4fe301a...Cabalglobal-package-db, user-package-db or package-db blahpackage.conf.dCabal clear-package-dbCabal/Adjust the way we find and configure gcc and ldCabal.Strip out flags that are not supported in ghciCabal&GHC's rendering of its host or target  ` as used in its platform strings and certain file locations (such as user package db location).Cabal&GHC's rendering of its host or target  ` as used in its platform strings and certain file locations (such as user package db location).CabalGHC's rendering of its platform and compiler version string as used in certain file locations (such as user package db location). For example x86_64-linux-7.10.4Cabal3Make entries for a GHC environment file based on a $ and a bunch of package (unit) ids.If you need to do anything more complicated then either use this as a basis and add more entries, or just make all the entries directly.CabalWrite a .ghc.environment-$arch-$os-$ver file in the given directory.The  and GHC % are needed as part of the file name.%Returns the name of the file written.CabalThe .ghc.environment-$arch-$os-$ver file nameCabal.Render a bunch of GHC environment file entriesCabal/Render an individual GHC environment file entryCabaldirectory in which to put itCabalthe GHC target platformCabalthe GHC versionCabal the content None"#2>MSX_{mNone>PSX6CabalhA collection of: * C input files * C++ input files * GHC input files * GHC input modules)Used to correctly build and link sources.CabalsBuilding 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.Cabal9Given a single package DB, return all installed packages.Cabal8Given a package DB stack, return all installed packages.Cabal Return the x$ to the global GHC package database.Cabal Return the x& to the per-user GHC package database.Cabal:Get the packages from specific PackageDBs, not cumulative.Cabal.Start a REPL without loading any source files.CabalBuild a foreign libraryCabalBuild an executable with GHC.Cabal8Target name for a foreign library (the actual file name)We do not use mkLibName and co here because the naming for foreign libraries is slightly different (we don't use "_p" or compiler version suffices, and we don't want the "lib" prefix on Windows).TODO: We do use < and co here, but really that's wrong: they use the OS used to build cabal to determine which extension to use, rather than the target OS (but this is wrong elsewhere in Cabal as well).Cabal#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.CabalMain module name when overridden by ghc-options: -main-is ... or S if no -main-is flag could be found. In case of S, Q can be assumed.CabalDecode argument to  '-main-is'Returns S( 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.CabalLocate and return the  required to build and link.Cabal(Generic build function. See comment for .Cabal Do we need the RPATH workaround?See Note [RPATH].Cabal7Extract (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.CabalReturns 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.Cabal3Finds the object file name of the given source fileCabal7Calculate the RPATHs for the component we are building. Calculates relative RPATHs when  is set.CabalRemove the "-threaded" flag when building a foreign library, as it has no effect when used with "-shared". Returns the updated  x, along with whether or not the flag was present, so we can use it to link against the appropriate RTS on our own.CabalyExtracts a String representing a hash of the ABI of a built library. It can fail if the library has not yet been built.CabalInstall executables for GHCJS.Cabal Install foreign library for GHC.Cabal6Install for ghc, .hi, .a and, if --with-ghci given, .oCabalGet the JavaScript file name and command and arguments to run a program compiled by GHCJS the exe should be the base program name without exe extensionCabal specVersionCabalComponent we are buildingCabalWhere to copy the files toCabalBuild locationCabalExecutable (prefix,suffix)Cabalinstall locationCabalBuild locationCabalinstall locationCabal&install location for dynamic librariesCabalBuild location3!"#$%&'()*+,-3-!"#$%&'()*+,Isaac Jones 2003-2007BSD3cabal-devel@haskell.orgportableNone>PSX`>CabalhA collection of: * C input files * C++ input files * GHC input files * GHC input modules)Used to correctly build and link sources.CabalsBuilding 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.CabalGiven 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)CabalGiven 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)CabalGiven 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)CabalGiven 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)Cabal9Given a single package DB, return all installed packages.Cabal8Given a package DB stack, return all installed packages.CabalGiven a list of !(PackageDB, InstalledPackageInfo) pairs, produce a  PackageIndex. Helper function used by  and .Cabal Return the x$ to the global GHC package database.Cabal Return the x& to the per-user GHC package database.Cabal:Get the packages from specific PackageDBs, not cumulative.Cabal.Start a REPL without loading any source files.CabalBuild a foreign libraryCabalBuild an executable with GHC.Cabal8Target name for a foreign library (the actual file name)We do not use mkLibName and co here because the naming for foreign libraries is slightly different (we don't use "_p" or compiler version suffices, and we don't want the "lib" prefix on Windows).TODO: We do use < and co here, but really that's wrong: they use the OS used to build cabal to determine which extension to use, rather than the target OS (but this is wrong elsewhere in Cabal as well).Cabal#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.CabalMain module name when overridden by ghc-options: -main-is ... or S if no -main-is flag could be found. In case of S, Q can be assumed.CabalDecode argument to  '-main-is'Returns S( 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.CabalLocate and return the  required to build and link.Cabal(Generic build function. See comment for .Cabal Do we need the RPATH workaround?See Note [RPATH].Cabal7Extract (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.CabalReturns 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.Cabal3Finds the object file name of the given source fileCabal7Calculate the RPATHs for the component we are building. Calculates relative RPATHs when  is set.CabalRemove the "-threaded" flag when building a foreign library, as it has no effect when used with "-shared". Returns the updated  x, along with whether or not the flag was present, so we can use it to link against the appropriate RTS on our own.CabalyExtracts a String representing a hash of the ABI of a built library. It can fail if the library has not yet been built.CabalInstall executables for GHC.Cabal Install foreign library for GHC.Cabal6Install for ghc, .hi, .a and, if --with-ghci given, .oCabal specVersionCabalComponent we are buildingCabalWhere to copy the files toCabalBuild locationCabalExecutable (prefix,suffix)Cabalinstall locationCabalBuild locationCabalinstall locationCabal&install location for dynamic librariesCabalBuild location2!"#$%&'()*+,-2-!"#$%&'()*+,NoneCabalJConstruct a JSON document describing the build information for a package.CabalbGet the command-line arguments that would be passed to the compiler to build the given component.Cabal'Mostly information from the .cabal fileCabalConfiguration informationCabal#Flags that the user passed to buildIsaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone>SX%Cabal Perform the "./setup install" and " ./setup copy@" actions. Move files into place based on the prefix argument.2This does NOT register libraries, you should call register to do that.CabalCopy package global files.Cabal'Copy files associated with a component.Cabal&Install the files listed in data-filesCabal:Install the files listed in install-includes for a libraryCabal information from the .cabal fileCabal#information from the configure stepCabalflags sent to copy or installNone27($CabalA L describes the provisions and requirements of a library. We can extract a  from an  <.CabalAThe default module shape, with no provisions and no requirements.NoneSXJw CabalThe mutable counterpart of CabalThe mutable counterpart of .CabalThe mutable counterpart of a  ModuleSubst (not defined here).Cabal!An integer for uniquely labeling A nodes. We need these labels in order to efficiently serialize s into  s (we use the label to check if any parent is the node in question, and if so insert a deBruijn index instead.) These labels must be unique across all 'UnitId's/'Module'$s which participate in unification!CabalA mutable version of  # which can be imperatively unified.CabalA mutable version of  .# which can be imperatively unified.CabalContents of a mutable  reference.CabalContents of a mutable  reference.CabalCA convenient alias for mutable references in the unification monad.CabalThe unification environment.Cabal%A supply of unique integers to label h cells. This is used to determine loops in unit identifiers (which can happen with mutual recursion.)CabalThe set of requirements in scope. When a provision is brought into scope, we unify with the requirement at the same module name to fill it. This mapping grows monotonically.CabalComponent id of the unit we're linking. We use this to detect if we fill a requirement with a local module, which in principle should be OK but is not currently supported by GHC.Cabal'How verbose the error message should beCabalThe error reporting contextCabal0The package index for expanding unit identifiersCabalAccumulated errorsCabalGThe unification monad, this monad encapsulates imperative unification.Cabal+Run a computation in the unification monad.CabalLift a computation from  monad to  monad. Internal use only.CabalImperatively read a .CabalImperatively write a .Cabal(Get the current unification environment.Cabal)Add a fixed message to the error context.CabalAAdd a message to the error context. It may make monadic queries.CabalConversion of  ModuleSubst to CabalConversion of  to  ModuleSubstCabal An empty .Cabal Convert a  into a ", so we can do unification on it.Cabal Convert a  to a .Cabal Convert a  to a Cabal Convert a  to a )      None\PCabalCGiven to scopes of provisions and requirements, link them together.CabalLink 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.CabalImperatively unify two modules.None27P[!NoneX{CabalStripped down version of LinkedComponent0 for things we don't need to know how to build.Cabal7The actual name of the package. This may DISAGREE with pc_pkgid9 for internal dependencies: e.g., an internal component lib may be munged to  z-pkg-z-lib+, but we still want to use it when we see lib in  build-dependsCabal!The actual name of the component.Cabal Convert an  < into a *, which was brought into scope under the 0 (important for a package qualified reference.) NoneHVXl CabalA linked component is a component that has been mix-in linked, at which point we have determined how all the dependencies of the component are explicitly instantiated (in the form of an OpenUnitId). i is mix-in linked into #, which is then instantiated into ReadyComponent.Cabal$Uniquely identifies linked componentCabalCorresponds to l.Cabal build-tools and build-tool-depends dependencies. Corresponds to n.Cabal:Is this the public library of a package? Corresponds to m.CabalCorresponds to oi, but (1) this does not contain includes of signature packages (packages with no exports), and (2) the   for requirements (stored in  '+) has been removed, as it is reflected in  ?.)CabalLike K, but this specifies includes on signature packages which have no exports.CabalKThe module shape computed by mix-in linking. This is newly computed from iCabalUniquely identifies a . Corresponds to p.CabalCorresponds to q.CabalThe  ?= of this component in the "default" instantiation. See also . -s cannot be instantiated (e.g., there is no ModSubst instance for them).CabalThe instantiation of I; this always has the invariant that it is a mapping from a module name A to  A (the hole A).None27>MSX{&CabalAn opaque type representing a file's modification time, represented internally as a 64-bit unsigned integer in the Windows UTC format.Cabal`Return modification time of the given file. Works around the low clock resolution problem that   has on GHC < 7.8.}This is a modified version of the code originally written for Shake by Neil Mitchell. See module Development.Shake.FileInfo.Cabal!Convert POSIX seconds to ModTime.!CabalConvert " to .Cabal!Return age of given file in days.CabalReturn the current time as .Cabal7Based on code written by Neil Mitchell for Shake. See sleepFileTimeCalibrate in "#. Returns a pair of microsecond values: first, the maximum delay seen, and the recommended delay to use before testing for file modification change. The returned delay is never smaller than 10 ms, but never larger than 1 second.$NoneHV|#CabalkA state monad for doing instantiations (can't use actual State because that would be an extra dependency.)$Cabal The state of #; a mapping from   s to their ready component, or Nothing@ if its an external component which we don't know how to build.%CabalAn %> is a library with requirements which we will typecheck only.&Cabal The requirements of the library.'Cabal0The modules exported/reexported by this library.(CabalbThe dependencies which need to be passed to the compiler to bring modules into scope. These are  ?> because these may refer to partially instantiated libraries.)CabalAn )V is a library which is fully instantiated (or, possibly, has no requirements at all.)*Cabal"How this library was instantiated.+CabalDependencies induced by *W. These are recorded here because there isn't a convenient way otherwise to get the   we need to fill componentPackageDeps as needed.,Cabal0The modules exported/reexported by this library.-CabalThe dependencies which need to be passed to the compiler to bring modules into scope. These always refer to installed fully instantiated libraries..CabalA . is one that we can actually generate build products for. We have a ready component for the typecheck-only products of every indefinite package, as well as a ready component for every way these packages can be fully instantiated./CabalThe  ? for this package. At the moment, this is used in only one case, which is to determine if an export is of a module from this library (indefinite libraries record these exports as  <); /9 can be conveniently used to test for equality, whereas  % cannot always be used in this case.0CabalCorresponds to . Invariant: if / records a l, it coincides with this one.1CabalCorresponds to .2CabalCorresponds to N. Build-tools don't participate in mix-in linking. (but what if they could?)3CabalCorresponds to .4CabalExtra metadata depending on whether or not this is an indefinite library (typechecked only) or an instantiated component (can be compiled).5CabalThe final, string  I that will uniquely identify the compilation products of this component.6CabalCorresponds to .7CabalCompute the dependencies of a .! that should be recorded in the depends field of InstalledPackageInfo.8CabalGet the   of a . IF it is a library.9CabalGiven 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.%:&'();*+,-.<=/01234567>9None "#2HVX\gNone>SXCabalPrint a Setup message stating (1) what operation we are doing, for (2) which component (with enough details to uniquely identify the build in question.)Cabal'Operation being done (capitalized), on:CabalPackageCabalComponent nameCabal3Instantiation, if available. Polymorphic to take  OpenModule or ModuleIsaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone>SXCabal Compute the $ of a library that we built inplace.Cabal5Create an empty package DB at the specified location. CabalRun hc-pkg` using a given package DB stack, directly forwarding the provided command-line arguments to it. Cabal Construct  <F for a library in a package, given a set of installation directories.Cabal Construct  <3 for a library that is in place in the build tree.:This function knows about the layout of in place packages.Cabal Construct  <6 for the final install location of a library package.;This function knows about the layout of installed packages.Cabal(Install in the user's database?; verbose Cabal8Translate relative include dir paths to absolute paths.Cabaltop of the build treeCaballocation of the dist tree"#$%&4         "#$%&4 +(c) 2003-2005, Isaac Jones, Malcolm WallaceBSD3cabal-devel@haskell.orgportableNone>SX CabalgA preprocessor for turning non-Haskell files with the given extension into plain Haskell source files.?CabalA newtype around @, useful for storing @] inside of another type constructor (e.g., a list) without impredicativity (recall that the  type, which is contained in @, is a synonym for  HasCallStack => Prelude.IO , which is a polymorphic type).@CabalFunction 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.CabalThe interface to a preprocessor, which may be implemented using an external program, but need not be. The arguments are the name of the input file, the name of the output file and a verbosity level. Here is a simple example that merely prepends a comment to the given source file: 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.Cabal(Apply preprocessors to the sources from  2 for a given component (lib, exe, or test suite).ACabalQFind the first extension of the file that exists, and preprocess it if required.#Cabal>Convenience function; get the suffixes of these preprocessors.$CabalGStandard preprocessors: GreenCard, c2hs, hsc2hs, happy, alex and cpphs.BCabalCStandard preprocessors with possible extra C sources: c2hs, hsc2hs.%CabalsFind any extra C sources generated by preprocessing that need to be added to the component (addresses issue #238).ACabalsource directoriesCabalbuild directoryCabalpreprocess for sdistCabalmodule file nameCabal verbosityCabalbuiltin suffixesCabalpossible preprocessors !"#$%%$#!" Isaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone>SX#j,&CabalHooks allow authors to add specific functionality before and after a command is run, and also to specify additional preprocessors.WARNING: The hooks interface is under rather constant flux as we try to understand users needs. Setup files that depend on this interface may break in future releases.(CabalRead the description file)Cabal3Custom preprocessors in addition to and overriding $.*CabalgThese programs are detected at configure time. Arguments for them are added to the configure command.+Cabal$Hook to run before configure command,Cabal?Over-ride this hook to get different behavior during configure.-Cabal#Hook to run after configure command.CabalHHook to run before build command. Second arg indicates verbosity level./Cabal;Over-ride this hook to get different behavior during build.0CabalGHook to run after build command. Second arg indicates verbosity level.1CabalGHook to run before repl command. Second arg indicates verbosity level.2CabalDOver-ride this hook to get different behavior during interpretation.3CabalFHook to run after repl command. Second arg indicates verbosity level.4CabalHHook to run before clean command. Second arg indicates verbosity level.5Cabal;Over-ride this hook to get different behavior during clean.6CabalGHook to run after clean command. Second arg indicates verbosity level.7CabalHook to run before copy command8Cabal:Over-ride this hook to get different behavior during copy.9CabalHook to run after copy command:Cabal"Hook to run before install command;Cabal=Over-ride this hook to get different behavior during install.<CabaldHook to run after install command. postInst should be run on the target, not on the build machine.=Cabal#Hook to run before register command>CabalBOver-ride this hook to get different behavior during registration.?Cabal"Hook to run after register command@Cabal%Hook to run before unregister commandACabalDOver-ride this hook to get different behavior during unregistration.BCabal$Hook to run after unregister commandCCabalKHook to run before hscolour command. Second arg indicates verbosity level.DCabal>Over-ride this hook to get different behavior during hscolour.ECabalJHook to run after hscolour command. Second arg indicates verbosity level.FCabalJHook to run before doctest command. Second arg indicates verbosity level.GCabal=Over-ride this hook to get different behavior during doctest.HCabalIHook to run after doctest command. Second arg indicates verbosity level.ICabalJHook to run before haddock command. Second arg indicates verbosity level.JCabal=Over-ride this hook to get different behavior during haddock.KCabalIHook to run after haddock command. Second arg indicates verbosity level.LCabal Hook to run before test command.MCabal:Over-ride this hook to get different behavior during test.NCabalHook to run after test command.OCabal!Hook to run before bench command.PCabal;Over-ride this hook to get different behavior during bench.QCabal Hook to run after bench command.SCabalEmpty & which do nothing..&',()*+-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRS.&',()*+-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSThomas Tuegel 2010BSD3cabal-devel@haskell.orgportableNone>SX)TCabal Perform the " ./setup test " action.TCabal!positional command-line argumentsCabal information from the .cabal fileCabal#information from the configure stepCabalflags sent to testTTJohan Tibell 2011BSD3cabal-devel@haskell.orgportableNone>SX-fUCabal Perform the " ./setup bench " action.UCabal!positional command-line argumentsCabal information from the .cabal fileCabal#information from the configure stepCabalflags sent to benchmarkUUIsaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone"#2>SX:+CCabal}An external dependency from the package database, OR an internal dependency which we are getting from the package database.DCabalAn 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.)VCabal/The errors that can be thrown when reading the  setup-config file.WCabalNo header found.XCabalIncorrect header.YCabalCannot parse file contents.ZCabalNo file![CabalMismatched version.ECabal Format a V as a user-facing error message.\Cabal Read the c. Throw an exception if the file is missing, if the file cannot be read, or if the file was created by an older version of Cabal.]Cabal Read the c5, returning either an error or the local build info.^CabalTry to read the c._Cabal Read the c. Throw an exception if the file is missing, if the file cannot be read, or if the file was created by an older version of Cabal.`CabalTry to read the c.aCabal$After running configure, output the p to the c.FCabal(Identifier of the current Cabal package.GCabal+Identifier of the current compiler package.HCabal Parse the  setup-configL file header, returning the package identifiers for Cabal and the compiler.ICabal Generate the  setup-config file header.bCabalMCheck that localBuildInfoFile is up-to-date with respect to the .cabal file.cCabalGet the path of dist/setup-config.dCabalReturn 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.eCabalReturn the "dist/" prefix, or the default prefix. The prefix is taken from (in order of highest to lowest preference) the override prefix, the "CABAL_BUILDDIR" environment variable, or + is used. Call this function to resolve a  *DistPref0 flag whenever it is not known to be set. (The  *DistPref; flags are always set to a definite value before invoking  UserHooks.)fCabal Perform the "./setup configure" action. Returns the  .setup-config file.JCabal,Check if the user used any deprecated flags.KCabalSanity check: if '--exact-configuration'X was given, ensure that the complete flag assignment was specified on the command line.gCabalCreate 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.LCabalReturns 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.MCabal;Finalize a generic package description. The workhorse is e7 but there's a bit of other nattering about necessary.(TODO: what exactly is the business with  flaggedTests and flaggedBenchmarks?NCabal>Check for use of Cabal features which require compiler supportOCabal$Select dependencies for the package.PCabal?Select and apply coverage settings for the build based on the  and .hCabal4Compute 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.QCabal@Select and apply profiling settings for the build based on the  and .RCabalGTest for a package dependency and record the version we have installed.iCabalList all installed packages in the given package databases. Non-existent package databases do not cause errors, they just get skipped with a warning and treated as empty ones, since technically they do not contain any package.jCabalLike i, but for a single package DB.,NB: Why isn't this always a fall through to i? That is because i performs some sanity checks on the package database stack in question. However, when sandboxes are involved these sanity checks are not desirable.kCabalA set of files (or directories) that can be monitored to detect when there might have been a change in the installed packages.lCabalKThe 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.SCabalConfigure 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.mCabalMakes 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))TCabal=Output package check warnings and errors. Exit if any errors.UCabal0Preform checks if a relocatable build is allowed\CabalThe file path of the  setup-config file.]CabalThe file path of the  setup-config file.^CabalThe dist directory path._CabalThe dist directory path.`CabalThe dist directory path.aCabalThe dist directory path.CabalThe p to write.HCabalThe file contents.ICabalThe processed package.cCabalThe dist directory path.dCabaldefault "dist" prefixCabaloverride "dist" prefixeCabaloverride "dist" prefixLCabaluse external internal deps?Cabalexact configuration?Cabal allow depending on private libs?Cabal installed setCabal internal setCabalrequired dependenciesMCabalPtests if a dependency is satisfiable. Might say it's satisfiable even when not.OCabalinternal packagesCabalinstalled packagesCabal required depsRCabalPackage id of current packageCabalInstalled packagesCabal;Packages for which we have been given specific deps to useCabal'Are we configuring a single component?iCabalThe stack of package databases.TCabal Path to the .cabal file's directoryfg VWXYZ[\]^_`abcdefghijklmnopfa\_b^`degfgcikjonhmplVWXYZ[] Simon Marlow 2004BSD3cabal-devel@haskell.orgportableNone>SX{VCabal#Callback type for use by sdistWith.sCabalCreate a source distribution.tCabalList 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.WCabalKList those source files that may be executable (e.g. the configure script).XCabalHList those source files that should be copied with ordinary permissions.uCabal)Prepare a directory tree of source files.YCabal)Find the setup script file, if it exists.ZCabalKCreate a default setup script in the target directory, if it doesn't exist.[CabalFind the main executable file.\CabalFind a module definition file#TODO: I don't know if this is right]CabalCGiven 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.^Cabal(Remove the auto-generated modules (like  'Paths_*') from 'exposed-modules' and 'other-modules'.vCabalPrepare 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 w or x.wCabal Modifies a  A by appending a snapshot number corresponding to the given date.xCabal Modifies a A by appending a snapshot number corresponding to the given date.yCabalWGiven a date produce a corresponding integer representation. For example given a date 18032008 produce the number 20080318.zCabalECreate an archive from a tree of source files, and clean up the tree._Cabal8Given a buildinfo, return the names of all source files.{CabalGNote: must be called with the CWD set to the directory containing the '.cabal' file.`Cabal)The name of the tarball without extensionVCabal verbosityCabalinfo from cabal fileCabalinfo from configureCabalsource tree to archiveCabalname of archive to createsCabalinformation from the tarballCabalInformation from configureCabalverbosity & snapshotCabalbuild prefix (temp dir)Cabal'extra preprocessors (includes suffixes)tCabal verbosityCabalinfo from the cabal fileCabal'extra preprocessors (include suffixes)uCabal verbosityCabalinfo from the cabal fileCabalsource tree to populateCabal'extra preprocessors (includes suffixes)vCabal verbosityCabalinfo from the cabal fileCabalsource tree to populateCabal(extra preprocessors (includes suffixes)aCabal verbosityCabalinfo from the cabal fileCabal source tree_CabalExtra preprocessorsCabalExposed modules stuvwxyz{ s{uzvwxythIsaac Jones 2003-2005, Ross Paterson 2006, Duncan Coutts 2007-2008, 2012BSD3cabal-devel@haskell.orgportableNone>SX;|Cabal4Build the libraries and executables in this package.Cabal7Start an interpreter without loading any package files.bCabalEAdd extra C sources generated by preprocessing to build information.cCabalGAdd extra C++ sources generated by preprocessing to build information.dCabalGAdd extra C-- sources generated by preprocessing to build information.eCabalGAdd extra ASM sources generated by preprocessing to build information.fCabalTranslate a exe-style  !# component into an exe for buildinggCabalTranslate a exe-style  # component into an exe for buildinghCabalTranslate a lib-style  !( component into a lib + exe for buildingCabalRInitialize a new package db file for libraries defined internally to the package.iCabalBuild a foreign libraryeNOTE: We assume that we already checked that we can actually build the foreign library in configure.CabalRuns  on every configured component.CabalFCreates the autogenerated files for a particular configured component.Cabal!Generate and write out the Paths_ pkg.hs and cabal_macros.h files|Cabal'Mostly information from the .cabal fileCabalConfiguration informationCabal#Flags that the user passed to buildCabal%preprocessors to run before compiling}Cabal'Mostly information from the .cabal fileCabalConfiguration informationCabal#Flags that the user passed to build~Cabal'Mostly information from the .cabal fileCabalConfiguration informationCabal#Flags that the user passed to buildCabal%preprocessors to run before compilingCabal "dist" prefixCabal'mostly information from the .cabal fileCabalConfiguration informationCabalThe verbosity to useCabal "dist" prefixCabal'mostly information from the .cabal fileCabalConfiguration informationCabalThe verbosity to use|}~|}~Isaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone7>SXSjCabal3The FilePath of a directory, it's a monoid under '( /)'.kCabalTA record that represents the arguments to the haddock executable, a product monoid.lCabal?Path to the interface file, relative to argOutputDir, required.mCabalPackage name, required.nCabal!(Hide modules ?, modules to hide)oCabalIgnore export lists in modules?pCabalA(Template for modules, template for symbols, template for lines).qCabalGenerate hyperlinked sourcesrCabalGenerate quickjump indexsCabalOptional custom CSS file.tCabalOptional URL to contents page.uCabal%HTML or Hoogle doc or both? Required.vCabal G(Interface file, URL to the HTML docs and hyperlinked-source for links).wCabal$Where to generate the documentation.xCabalPage title, required.yCabalPrologue text, required.zCabal Additional flags to pass to GHC.{Cabal"To find the correct GHC, required.|CabalRe-exported modules}CabalModules to process.~Cabal*Call haddock with the specified arguments.CabalGiven a list of  <ps, return a list of interfaces and HTML paths, and an optional warning for packages with missing documentation.Cabaltemplate for HTML locationCabaltemplate for HTML locationCabaltemplate for HTML locationCabaltemplate for HTML locationCabaltemplate for HTML locationCabalCalled when the  exe is not found.Moritz Angermann 2017BSD3cabal-devel@haskell.orgportableNone7>SX-CabalAA record that represents the arguments to the doctest executable.CabalModules to processIsaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone>SX_ CabalA simple implementation of main for a Cabal setup script. It reads the package description file using IO, and performs the action specified on the command line.Cabal A version of [ that is passed the command line arguments, rather than getting them from the environment.CabalA customizable version of .CabalA customizable version of - that also takes the command line arguments.CabalLike P, but accepts the package description as input rather than using IO to read it.CabalA customizable version of .CabalA customizable version of - that also takes the command line arguments.CabalVCombine the preprocessors in the given hooks with the preprocessors built into cabal.CabalTry to read the cCabal Read the c or throw an exception.CabalLHooks that correspond to a plain instantiation of the "simple" build systemCabalBasic autoconf &:- runs  ./configure , if present.the pre-hooks ., 4, 7, :, = and @+ read additional build information from package .buildinfo , if present.Thus  configure/ can use local system information to generate package .buildinfo and possibly other files.     lmn            . /  ' & $ # + - * ! " % ( ) , . / 0 1                           ! " # $ % & ' ( ) * + , - . / 0 1 2 T V U W X Y Z [ \ ] ^ _ ` a b c d l n e f g h i j k m o p q r s t u v w&',()*+-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRS T V U W X Y Z [ \ ] ^ _ ` a b c d l n e f g h i j k m o p q r s t u v w&',()*+-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRS%&'()*%+,%+-%./%01%02%&3%&4%&5%67%68%9:%;<%;=%;>%;?(@A(@B%6C%&D%&E%&F%&G%&H%IJ%KL%9M%9N%9O%9P%&%&Q%&R%&S%&T%&U%&V%;W%;X(@Y%Z[%9\%9]%&^%_%&%6`(@a%bc%9d%Ze%9f%gh%i%Kj%&k%  %  %%&l%&m(no(np(nq(nr(ns%tu%tv%tw%txyz{%|}(n~%9(n%%%%%%(n%|%|(n%%(n(n(n%%%%%%%% % % %%%%%.%.%.%.%.%.%.%.%.%.%.%.%%%%%%%%%%% % % % % % % % % % % % % % % % % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%b%b%b%b%%Z%Z%Z%Z%Z%Z%Z%Z%Z%Z%Z%Z%Z%Z%Z%Z%Z%Z%Z%Z%Z %Z %Z %Z %Z %Z%Z%Z%Z%Z%Z%Z%%%%%%%%%%9%9 %9!%9"%9#%9$%9%%9&%9'%9(%9)%9*%9+%9,%9-%9.%9/%90%91%;2%;3%;4%;5%;6%;7%89%g:%g;%g<%g=%g>%g?%g@%gA%+B%+C%+D%+E%+F%+G%+H%+I%+J%+K%+L%+M%+N%+O%+P%+Q%+R%+S%+T%+U%+V%+W%+X%YZ%Y[%Y\%Y]%Y^%Y_%Y`%Ya%0b%0c%6d%6e%6f%6g%6h%&i%&j%&k%&l%&m%&n%&o%&p%&q%&r%&s%&t%&u%&v%&w%&x%&y%&z%&{%&|%&}%&~%&%&%&%&%%%(@(@(@(@(@(@(@(@(@(@                   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~VV""       !"#$%&'()*+,--./0123456789::;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcde f f g h i j k!l"m"n"n"o"p"q"r"s"s"t"u"v"w"x"x"y"y"z"{"|"}"~"""""""""""""######################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%&''''''''((((((((((((((((((((((( ( ( ( ( ((((((((((())))))))) )!)")#)$)%)&)')()))*)+),)-).)/)0)1)2)3)4)5)6)7)8)9):);)<)=)>)?)@)A)B*CDE+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,h,i,j,j,k,l,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,{,|,},~,,,,,,,,,,,,,,,,,,,----------............../////////////////////////////////////00000000000000000000111111111111111111111111111111111111111 1 1 1 1 1111111111111111112 2!2"2#2$2%2&2'3(3)3*3+3,3+3-3-3.3/303132333435363738393:3;3<3=3>3?3@3A3B3C3D4E4F4G4H4I4J4K4L4M4N4O4P4Q4R4S4S4T4U4V4W4X4Y4Z4[4\4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5T5U5V5W5X5Y5Z6~6~666666666666777777777777777777777777888888888888888999999999999:::::::::::::::;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<===============>>>>>>>>>>>>>>>>> > > ? ? ? ????????????@@@@@@@ @!@"@#@$@%@&@'@(@)@*@+A,A-A.A/A0A1A2A3A4A5A6A7B8B9B B:B;B<B=B>B?B@BABBBCBDBEBFBGBHBIBJBKBLBMBNBOBPBQBBBRBSBTBUBVBWBXBYBZB[B\B]B^B_BBB`BBaBbBcCdCeCfCgChCiCjCkClCmCnCoCpCqCrDsDtDuDvDwDxDyDzD{D|D}D~DDDDDDEEEEEEEEEEEEEEEFFFFFFFFFFFGGGGGGGGGGGGGGGGHHHHHHHHHHHHHIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ J J J J JKKKKKKKKKKKKKKKKLL L!L"L#L$L%L&L'L(L)L*L+L,L-L.L/L0L1L2L3L4L5L6L7L8L9L:L;L<L=L>L?L@LALBLCLDLELFLGLHLILJLKLLLMLNLOLPLQLRLSLTLULVLWLXLYLZL[L\L]L^L_L`LaLbLcLdLeLfLgLhLiLjLkLlLmLnLoLpLqLrLsLtLuLvLwLxLyLzL{L|L}L~LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L !L "L #L $L %L &L 'L (L )L *L +L ,L -L .L /L 0L 1L 2L 3L 4L 5L 6L 7L 8L 9L :L ;L <L =L >L ?L @L AL BL CL DL EL FL GL HL IL JL KL LL ML NL OL PL QL RL SL TL UL VL WL XL YL ZL [L \L ]L ^L _L `L aL bL cL dL eL fL gL hL iL jL kL lL mL nL oL pL qL rL sL tL uL vL wL xL yL zL {L |L }L ~L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L 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 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 O O O O O O O O O O O O O O P P P P P P P P Q Q Q Q QQ Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q !Q "Q #Q $Q %Q &R 'R 'R (R )R *R +R ,R -R .R /R 0R 1R 2R 3R 4R 5R 6R 7SSS 8S 9S :S ;S <S =S >S ?S @S AS BS CS DS ES FT GT GT HT IT JT KT LT MT NT OT PT QT RT ST TU UU UU VU WU XU YU ZU [U \U ]U ^U _U `U aU bV cV dV eV fV gV hV iV jV kV lV mV nV oV pV qV rV sV tV uV vV w x y z { | } ~  H{                               W W W W W W W W W W W W W W W W W W W W W W W W W W W W W XX X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X Y Y Y Y Y Y Y Y Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z [ [ [ [ [ [ [ [ [ [ [ [ [ [ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ ] ] ] ] ] ] ] ] ] ] ] ] ] ] !] "] #] $] %] &] '] (] )] *] +] ,] -] .] /] 0] 1] 2] 3^ 4^ 4^ 5^ 6^ 7^ 8^ 9^ :^ ;^ <^ =^ >^ ?_ @_ A_ 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` g` h` i` j` k` l` m` n` o` p` q` ra sa ta ua va wa xa ya zb {b |b |b }b ~b b c c c d d e e e e e e e e e e e e e e e e f f f f f f f f f f f f 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 h h h i i i i i i i i i i i i i i j j k k k k k k k k l l l l l l l l l l l l l l 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 o o o o o o o o o o p p p p p p p p q q q q q q q q q q q q q r r r r r r r rrr 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 0s 1s 2s 3s 4s 5s 6s 7s 8s 9s :s ;s <s =s >s ?s @s As Bs Cs Ds Es Fs Gs Hs Is Js Ks Ls Ms Ns Os Ps Qs Rs Ss Ts Us Vs Ws Xs Ys Zs [s \s ]t &t t (t *t 't +t ,t -t .t /t 0t 1t 2t 3t 4t 5t 6t 7t 8t 9t :t ;t <t =t >t ?t @t At Bt Ct Dt Et Ft Gt Ht It Jt Kt Lt Mt Nt )u ^u _u `u au bu cu du eu fu gu hu iu ju ku lu mu nu ou pu qu ru su tu uu vu wu xu yu zu {u |u }u ~u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u uu u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u u v v v v v v v v v v v v v v v v v v v v v v !v "v #v $v %v &v 'v (v )v *v +v ,v -v .v /v 0v 1v 2v 3v 4v 5v 6v 7v 8v 9v :v ;v <v =v >v ?v @v Av Bv Cv Dv Ev Fv Gv Hv Iv Jv Kv Lv Mv Nv Ov Pv Qv Rv Sv Tv Uv Vv Wv Xv Yv Zw [www w \w ]w ^w _w `w aw bw cx dx dx ex fx gx hx ix jx Gx Hx Ix kx Kx lx mx nx ox px qx rx sx tx ux vx wx xx yx zx {x |x }x ~x x x Cx Dx x xx x x x x x x x x x x x x x x x x x x x x x x x x y y z z z z z ez fz gz hz iz jz Gz Hz Iz kz Kz lz mz nz oz pz qz rz sz tz uz vz wz xz yz zz {z |z }z ~z z z Cz Dz z zz z z z z z z { { { { { { { { { { { { { { { { { { { { | | | } } } } 9} } } } )} } } } } } } } } } } } } } } ~ ~ 9~ ~ ~ ~ )~                                                   !"#$%&'()*+,--./0123456789:;;<=>? - . / 0@ 1 2AB 3 4 5CDEFGHIJKL ?MNOPQ ,RSTUVWXYZ[\]^_`abcdefghijklmnopqrstuuvwxyz{|}~vwxyz{|};<=>=>? - . / 0@ 1 2AB 3 4 5C<DEFGHIJKL ?MNOW                          ! " # $ % & ' ( ) * + , - . / 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 STUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./01234456789:;<=>?@ABCDEFGHIJKLMNOPQRSSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !""#$%&&'()*+,-./01234566789:;<==>?@ABCDEEFGHIJJKLMNOPQRSTUVWXYZ[\]^_`abccdefghhijklmnopqqrstuvwxyz{{|}~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghiijklmnopqrstuvwxyz{|}~     : !"#$%&'()*+,-./0123456789:;< =>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^^_`abcdefghijklmnopqrstuvwxyz{|}~ =dJ      !"#$%&'())*+,-./0123456789:;<=>?@ABCDE?FGHIJKKLMNOPQRSTUVWXYZ[\]^"_`abc#$&'defghijklmnoopq"rs#tuv$wxyz%{|}~&' N"rs#tuv$wxyz%{|}~&' N% 6d'&     "#sv !"#$%&'()*x+,-./0123456789:;<=>?gh@ABCDEFGHI%JKL%MNOPQRSGT%U%V%WXYXZX[X\X]X^_`abcdcefghi%.j%.kl%mn%mDopqrstuvwxyz%{|%{}~x%%%xz!!!!!%%%%%%%%%%"%%%%%.%3BQRXXXXXu}t               *      !"#$%&'()*+,-./0178923456789:;<=>?@ABCDEFGHIJKLMNOPQRSTcrb~UV}WXYZ[\]^_`abcdefghijklmn`abopqrsctdefghijklmnuvwxyz{|}~%   !!!!!!!!!!$$$$$$$$$$$$$$$$$$$$$$$$$$$$y     $Cabal-3.2.1.0-64u7C0qYIFUDCJD6V8fmPr$Distribution.Compat.Prelude.InternalDistribution.Compat.SemigroupDistribution.Compat.TypeableDistribution.Compat.StackDistribution.Compat.ParsingDistribution.Compat.ExceptionDistribution.Utils.GenericDistribution.Compat.GraphDistribution.Compat.DirectoryDistribution.Compat.FilePathDistribution.Compat.BinaryDistribution.Simple.UtilsDistribution.Compat.NewtypeDistribution.Compat.Process%Distribution.PackageDescription.UtilsDistribution.Utils.MD5Distribution.Utils.ShortTextDistribution.Utils.StructuredDistribution.Utils.ProgressDistribution.Utils.MapAccumDistribution.Utils.IODataDistribution.Types.ConditionDistribution.TestSuite$Distribution.Simple.Program.Internal$Distribution.Simple.PreProcess.Unlit(Distribution.Simple.InstallDirs.InternalDistribution.Simple.FlagDistribution.Simple.CCompilerDistribution.Parsec.PositionDistribution.Parsec.Warning#Distribution.Parsec.FieldLineStreamDistribution.Parsec.Error&Distribution.PackageDescription.QuirksDistribution.Fields.LexerMonadDistribution.Fields.LexerDistribution.Fields.FieldDistribution.Fields.Parser Distribution.Compat.ResponseFileDistribution.Compat.DListDistribution.Compat.LensDistribution.Types.CondTreeDistribution.Compat.CreatePipeDistribution.Compat.CharParsingDistribution.CabalSpecVersion$Distribution.SPDX.LicenseListVersionDistribution.PrettyDistribution.ParsecDistribution.Types.Version(Distribution.Types.VersionRange.InternalDistribution.Types.VersionRange"Distribution.Types.VersionIntervalDistribution.Types.SourceRepo"Distribution.Types.SourceRepo.Lens#Distribution.Types.PkgconfigVersion(Distribution.Types.PkgconfigVersionRange Distribution.Types.PkgconfigName&Distribution.Types.PkgconfigDependencyDistribution.Types.PackageName&Distribution.Types.UnqualComponentName+Distribution.Types.PackageVersionConstraint$Distribution.Types.LibraryVisibilityDistribution.Types.LibraryName$Distribution.Types.MungedPackageName!Distribution.Types.ForeignLibType#Distribution.Types.ForeignLibOptionDistribution.Types.Flag"Distribution.Types.ExecutableScope Distribution.Types.ComponentNameDistribution.Types.ComponentId!Distribution.Types.GivenComponentDistribution.Types.BuildTypeDistribution.Types.AbiHashDistribution.TextDistribution.System"Distribution.SPDX.LicenseReferenceDistribution.SPDX.LicenseId$Distribution.SPDX.LicenseExceptionId#Distribution.SPDX.LicenseExpressionDistribution.SPDX.LicenseDistribution.ReadEDistribution.ModuleName!Distribution.Types.ModuleRenaming"Distribution.Types.IncludeRenamingDistribution.Types.Mixin!Distribution.Types.ModuleReexportDistribution.FieldGrammar.ClassDistribution.Verbosity.InternalDistribution.VerbosityDistribution.VersionDistribution.Types.TestType%Distribution.Types.TestSuiteInterfaceDistribution.Types.PackageIdDistribution.Types.UnitIdDistribution.Types.ModuleDistribution.Backpack Distribution.Types.ExposedModuleDistribution.Backpack.ModSubst Distribution.Backpack.FullUnitId$Distribution.Types.PackageName.Magic!Distribution.Types.PackageId.Lens"Distribution.Types.MungedPackageId&Distribution.Types.LegacyExeDependency Distribution.Types.ExeDependencyDistribution.Types.Dependency!Distribution.Types.SetupBuildInfo&Distribution.Types.SetupBuildInfo.Lens Distribution.Types.DependencyMap Distribution.Types.BenchmarkType%Distribution.Types.BenchmarkInterfaceDistribution.PackageDistribution.Types.AnnotatedId#Distribution.Types.ComponentInclude Distribution.Types.AbiDependencyDistribution.License'Distribution.Types.InstalledPackageInfo,Distribution.Types.InstalledPackageInfo.LensLanguage.Haskell.ExtensionDistribution.CompilerDistribution.Types.ConfVarDistribution.Types.BuildInfo"Distribution.Types.HookedBuildInfo!Distribution.Types.BuildInfo.LensDistribution.Types.TestSuite!Distribution.Types.TestSuite.LensDistribution.Types.LibraryDistribution.Types.Library.LensDistribution.Types.ForeignLib"Distribution.Types.ForeignLib.LensDistribution.Types.Executable"Distribution.Types.Executable.LensDistribution.Types.BenchmarkDistribution.Types.Component)Distribution.Types.ComponentRequestedSpec%Distribution.Types.PackageDescription,Distribution.Types.GenericPackageDescription1Distribution.Types.GenericPackageDescription.Lens!Distribution.Types.Benchmark.Lens*Distribution.Types.PackageDescription.Lens$Distribution.Simple.BuildToolDependsDistribution.Simple.InstallDirsDistribution.Parsec.NewtypesDistribution.Utils.NubListDistribution.Utils.LogProgress(Distribution.Simple.Program.ResponseFile Distribution.Simple.Program.Find!Distribution.Simple.Program.TypesDistribution.Simple.Program.Run"Distribution.Simple.Program.ScriptDistribution.Simple.Program.HpcDistribution.Simple.GlobDistribution.Simple.CompilerDistribution.Simple.GHCJSDistribution.Simple.Program.GHC#Distribution.Simple.Program.BuiltinDistribution.Simple.Program.DbDistribution.Simple.Program!Distribution.Simple.Program.StripDistribution.Simple.CommandDistribution.Simple.Setup-Distribution.PackageDescription.ConfigurationDistribution.MakeDistribution.Fields.PrettyDistribution.Fields.ParseResultDistribution.Fields.ConfVar Distribution.FieldGrammar.Pretty Distribution.FieldGrammar.ParsecDistribution.FieldGrammar,Distribution.PackageDescription.FieldGrammar+Distribution.PackageDescription.PrettyPrint&Distribution.PackageDescription.Parsec%Distribution.FieldGrammar.FieldDescrs4Distribution.Types.InstalledPackageInfo.FieldGrammar!Distribution.InstalledPackageInfo*Distribution.Types.ComponentLocalBuildInfoDistribution.Types.TargetInfo!Distribution.Simple.Program.HcPkg Distribution.Simple.PackageIndex!Distribution.Types.LocalBuildInfo"Distribution.Simple.LocalBuildInfoDistribution.Simple.Test.LogDistribution.Simple.Program.LdDistribution.Simple.Program.ArDistribution.Simple.HpcDistribution.Simple.BuildTargetDistribution.Simple.BuildPathsDistribution.Simple.UHC%Distribution.PackageDescription.Check%Distribution.Simple.Build.PathsModuleDistribution.Simple.Test.LibV09Distribution.Simple.Test.ExeV10 Distribution.Simple.Build.MacrosDistribution.Simple.Configure)Distribution.Backpack.ConfiguredComponent%Distribution.Backpack.ComponentsGraph Distribution.Simple.HaskellSuiteDistribution.Simple.GHC!Distribution.Simple.ShowBuildInfoDistribution.Simple.Install!Distribution.Backpack.ModuleShape$Distribution.Backpack.PreModuleShape%Distribution.Backpack.LinkedComponentDistribution.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.SimpleDistribution.Compat.Async%Distribution.Compat.Internal.TempFileDistribution.Compat.MonadFailSystem.Process createProcess rawSystemrunInteractiveProcess Verbosity annotateIODistribution.Simple.Utils.JsonDistribution.Utils.Base62Distribution.Utils.StringDistribution.Compat.PreludeText.PrettyPrint<> Data.ListnubnubBySystem.FilePath isAbsolute isRelativeDistribution.GetOptSystem.EnvironmentgetArgsDistribution.Compat.SnocList$Distribution.Compat.GetShortPathNameDistribution.Compat.EnvironmentControl.Exception IOExceptionDistribution.LexDistribution.Compat.CopyFileDistribution.SPDX simpleParseIncludeRenamingData.MapelemstoList Data.GraphGraphDistribution.Utils.UnionFind!Distribution.Backpack.ModuleScope Data.TypeableTypeable Data.GenericsData GHC.GenericsGenericGeneric1 Data.FunctorFunctorData.Traversable Traversable Data.FoldableFoldableLanguage.Haskell.TH.SyntaxLift PackageDescription.ConfigurationaddBuildableConditionDistribution.Types.LensDistribution.PackageDescriptionCheck Paths_Cabal Distribution.Simple.GHC.ImplInfo D.C.SetupfilterConfigureFlagsDistribution.FieldsbuildfindPackageDescDistribution.Backpack.Id Distribution.Simple.GHC.Internal)Distribution.Simple.GHC.EnvironmentParsermainDistribution.Backpack.UnifyMDistribution.Backpack.MixLink*Distribution.Backpack.PreExistingComponentTestType$Distribution.Backpack.ReadyComponentbaseGHC.Base++ghc-primGHC.PrimseqGHC.Listfilterzip System.IOprint Data.Tuplefstsnd otherwisemap$GHC.Num fromInteger-GHC.Real fromRationalGHC.EnumenumFrom enumFromThen enumFromToenumFromThenTo GHC.Classes==>=negatefail>>=>>fmapreturn Control.Arrowfirst Data.String fromString fromIntegral realToFrac toInteger toRationalmemptymappendmconcat<*>pure*>BoundedEnumEq GHC.FloatFloating FractionalIntegralMonad Data.DataNumOrdGHC.ReadReadReal RealFloatRealFracGHC.ShowShowData.Typeable.InternalIsString Applicative SemigroupMonoid GHC.TypesBoolCharDoubleFloatIntGHC.IntInt8Int16Int32Int64 integer-gmpGHC.Integer.TypeInteger GHC.MaybeMaybeOrderingRationalWordGHC.WordWord8Word16Word32Word64 Data.EitherEitherGHC.Stack.Types CallStackFalseNothingJustTrueLeftRightLTEQGTData.List.NonEmptyinitlasttailhead Control.MonadunlessfoldMfilterMfor sequenceAtraverseControl.ApplicativeoptionalData.Functor.Identity runIdentityIdentityreadIOreadLn appendFile writeFilereadFileinteract getContentsgetLinegetCharputStrLnputStrputChar GHC.StackwithFrozenCallStack callStackGHC.IO.ExceptionioErrorGHC.IOFilePath userErrorIOError GHC.ExceptionprettyCallStackGHC.Exception.TypedisplayExceptiontypeRepTypeRepfindnotElemallanyorand concatMapconcat sequence_for_ traverse_productsumminimummaximumelemlengthnullfoldl'foldlfoldrfoldMapData.Semigroup.InternalgetAllAllgetAnyAny Data.OldListunwordswordsunlineslinesunfoldrsortBysort intercalate intersperse isInfixOf isSuffixOf isPrefixOf Text.Read readMaybereadseitherData.Ord comparing Data.ProxyProxylex readParenreadList readsPrecText.ParserCombinators.ReadPReadSatanhacoshasinhtanhcoshsinhatanacosasintancossinlogBase**sqrtlogexppiatan2isIEEEisNegativeZeroisDenormalized isInfiniteisNaN scaleFloat significandexponent encodeFloat decodeFloat floatRange floatDigits floatRadix GHC.UnicodetoUppertoLowerisUpper isAlphaNumisAlphaisDigitisSpacevoid<$>lcmgcd^^^oddevendivModquotRemmoddivremquotrecip/floorceilingroundtruncateproperFractionmaxBoundminBoundfromEnumtoEnumpredsuccGHC.Charchr showParen showStringshowCharshowsShowSshowListshow showsPrecunzip3unzipzipWith3zipWithzip3!!lookupreversebreakspansplitAtdroptake dropWhile takeWhilecycle replicaterepeatiteratescanr1scanrscanl1scanl Data.MaybemapMaybe catMaybes listToMaybe maybeToList fromMaybe isNothingisJustmaybeuncurrycurrysubtractsignumabs*+asTypeOfuntil$!flip.constidordapliftM2liftMwhen=<<<$<*manysome<|>empty Alternativemplusmzero MonadPlus:|NonEmptyStringGHC.Err undefinederrorWithoutStackTraceerror/=<=compare&&||not<>maxminbinary-0.8.6.0Data.Binary.ClassputListgetputBinarycontainers-0.6.0.1Data.Map.InternalMap CyclicSCC AcyclicSCCSCCData.Set.InternalSetdeepseq-1.4.4.0Control.DeepSeqrnfNFDatadirectory-1.3.3.0System.Directory doesPathExist listDirectory makeAbsolutefilepath-1.4.2.1System.FilePath.PosixstripExtension isExtensionOfdecodeFileOrFail'decodeOrFailIOtryIOcatchIO catchExitcreateTempDirectoryNewtypepackunpackalaalafpack'unpack'$fNewtype->Endo$fNewtypeaProduct $fNewtypeaSum$fNewtypeaIdentityenableProcessJobs WithCallStackparentSrcLocPrefixwithLexicalCallStackannotateCallStackIOuserBugcabalBugMD5showMD5md5 binaryPutMD5 binaryGetMD5decodeStringUtf8encodeStringUtf8 GStructured Structured structure SopStructure StructureNominal TypeVersionConstructorNameTypeName hashStructure typeVersiontypeNamestructureBuilder structureHashstructuredEncodestructuredEncodeFilestructuredDecodestructuredDecodeOrFailIOstructuredDecodeFileOrFailnominalStructurecontainerStructuregenericStructure$fStructuredLocalTime$fStructuredTimeOfDay$fStructuredTimeZone$fStructuredDay$fStructuredNominalDiffTime$fStructuredUniversalTime$fStructuredDiffTime$fStructuredUTCTime$fStructuredSeq$fStructuredIntSet$fStructuredIntMap$fStructuredSet$fStructuredMap$fStructuredText$fStructuredText0$fStructuredByteString$fStructuredByteString0$fStructured(,,,,,,)$fStructured(,,,,,)$fStructured(,,,,)$fStructured(,,,)$fStructured(,,)$fStructured(,)$fStructuredNonEmpty$fStructured[]$fStructuredRatio$fStructuredEither$fStructuredMaybe$fStructuredDouble$fStructuredFloat$fStructuredWord64$fStructuredWord32$fStructuredWord16$fStructuredWord8$fStructuredInt64$fStructuredInt32$fStructuredInt16$fStructuredInt8$fStructuredWord$fStructuredInteger$fStructuredInt$fStructuredChar$fStructuredOrdering$fStructuredBool$fStructured() $fBinaryTag$fGStructuredSumV1$fGStructuredSum:+:$fGStructuredM1$fGStructuredProd:*:$fGStructuredProdU1$fGStructuredProdK1$fGStructuredProdM1$fGStructuredSumM1 $fEqStructure$fOrdStructure$fShowStructure$fGenericStructureOption' getOption'Last'getLast'First' getFirst'gmappendgmempty$fSemigroupFirst'$fFunctorLast'$fSemigroupLast'$fStructuredLast'$fMonoidOption'$fSemigroupOption'$fStructuredOption'$fGSemigroup:*:$fGSemigroupM1$fGSemigroupK1 $fGMonoid:*: $fGMonoidM1 $fGMonoidK1 $fEqFirst' $fOrdFirst' $fShowFirst' $fEqLast' $fOrdLast' $fReadLast' $fShowLast'$fGenericLast' $fBinaryLast' $fEqOption' $fOrdOption' $fReadOption' $fShowOption'$fBinaryOption'$fGenericOption'$fFunctorOption' NoCallStackIOIO<<>> genericRnffoldr1foldl1 ShortText toShortText fromShortTextunsafeFromUTF8BS$fIsStringShortText$fMonoidShortText$fSemigroupShortText$fReadShortText$fShowShortText$fNFDataShortText$fStructuredShortText$fBinaryShortText $fEqShortText$fOrdShortText$fGenericShortText$fDataShortTextProgress stepProgress failProgress foldProgress$fAlternativeProgress$fApplicativeProgress$fMonadProgress$fFunctorProgress mapAccumM$fApplicativeStateM$fFunctorStateM IODataModeIODataModeTextIODataModeBinaryKnownIODataModehGetIODataContentstoIOData iodataModeIOData IODataText IODataBinary withIOData hPutContents$fNFDataIOData$fKnownIODataModeByteString$fKnownIODataMode[]wrapTextwrapLinewithFileContentswriteFileAtomic fromUTF8BS fromUTF8LBStoUTF8BS toUTF8LBS validateUTF8 ignoreBOM readUTF8FilewithUTF8FileContents writeUTF8FilenormaliseLineEndingsdropWhileEndLEtakeWhileEndLEordNubordNubBy listUnion ordNubRightlistUnionRightsafeHeadsafeTailsafeLastsafeInitequating lowercaseisAscii isAsciiAlphaisAsciiAlphaNum unintersperse breakMaybe spanMaybeunfoldrMunsnocunsnocNEisAbsoluteOnAnyPlatformisRelativeOnAnyPlatform ConditionVarLitCNotCOrCAndcNotcAndcOrsimplifyCondition$fNFDataCondition$fStructuredCondition$fBinaryCondition$fMonadPlusCondition$fAlternativeCondition$fSemigroupCondition$fMonoidCondition$fMonadCondition$fApplicativeCondition$fTraversableCondition$fFoldableCondition$fFunctorCondition$fShowCondition $fEqCondition$fDataCondition$fGenericConditionResultPassFailErrorFinishedOptionsGroup 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 $fShowResultstripExtractVersionplainunlitPathTemplateVariable PrefixVar BindirVar LibdirVar LibsubdirVar DynlibdirVar DatadirVar DatasubdirVar DocdirVar HtmldirVar PkgNameVar PkgVerVarPkgIdVar LibNameVar CompilerVarOSVarArchVarAbiVar AbiTagVarExecutableNameVarTestSuiteNameVarTestSuiteResultVarBenchmarkNameVar PathComponentOrdinaryVariable$fReadPathTemplateVariable$fShowPathTemplateVariable $fStructuredPathTemplateVariable$fBinaryPathTemplateVariable$fReadPathComponent$fShowPathComponent$fStructuredPathComponent$fBinaryPathComponent$fEqPathTemplateVariable$fOrdPathTemplateVariable$fGenericPathTemplateVariable$fEqPathComponent$fOrdPathComponent$fGenericPathComponent BooleanFlagasBoolFlagNoFlagtoFlagfromFlagfromFlagOrDefault flagToMaybe flagToListallFlags maybeToFlag $fEnumFlag $fBoundedFlag$fSemigroupFlag $fMonoidFlag$fApplicativeFlag $fFunctorFlag$fStructuredFlag $fBinaryFlag$fBooleanFlagBool$fEqFlag $fGenericFlag $fShowFlag $fReadFlagCDialectC ObjectiveC CPlusPlusObjectiveCPlusPluscSourceExtensionscDialectFilenameExtensionfilenameCDialect$fSemigroupCDialect$fMonoidCDialect $fEqCDialect$fShowCDialectPositionincPosretPosshowPoszeroPos positionCol positionRow$fNFDataPosition$fBinaryPosition $fEqPosition $fOrdPosition$fShowPosition$fGenericPositionPWarning PWarnTypePWTOtherPWTUTF PWTBoolCase PWTVersionTag PWTNewSyntax PWTOldSyntaxPWTDeprecatedFieldPWTInvalidSubsectionPWTUnknownFieldPWTUnknownSectionPWTTrailingFieldsPWTExtraMainIsPWTExtraTestModulePWTExtraBenchmarkModule PWTLexNBSP PWTLexBOM PWTLexTabPWTQuirkyCabalFile PWTDoubleDashPWTMultipleSingularFieldPWTBuildTypeDefault showPWarning$fNFDataPWarnType$fBinaryPWarnType$fNFDataPWarning$fBinaryPWarning $fEqPWarnType$fOrdPWarnType$fShowPWarnType$fEnumPWarnType$fBoundedPWarnType$fGenericPWarnType$fShowPWarning$fGenericPWarningFieldLineStreamFLSLastFLSConsfieldLineStreamEndfieldLineStreamFromStringfieldLineStreamFromBS$fStreamFieldLineStreammChar$fShowFieldLineStreamPError showPError$fNFDataPError$fBinaryPError $fShowPError$fGenericPError patchQuirks InputStreamLexStatecurPoscurInputcurCodewarnings LexWarningLexWarningTypeLexWarningNBSP LexWarningBOM LexWarningTab LexResultLexunLex toPWarnings execLexersetPosgetPos adjustPosgetInputsetInput getStartCode setStartCode addWarning $fMonadLex$fApplicativeLex $fFunctorLex$fEqLexWarningType$fOrdLexWarningType$fShowLexWarningType$fShowLexWarningLTokenLTokenTokSymTokStrTokOtherIndent TokFieldLineColon OpenBrace CloseBraceEOF LexicalErrorlexTokenltest mkLexState bol_sectionin_field_bracesin_field_layout in_section $fShowToken $fShowLTokenName FieldName SectionArg SecArgName SecArgStr SecArgOther FieldLineFieldSection fieldNamefieldAnn fieldUniverse fieldLineAnn fieldLineBS sectionArgAnnmkNamegetNamenameAnn $fEqFieldLine$fShowFieldLine$fFunctorFieldLine$fFoldableFieldLine$fTraversableFieldLine$fEqSectionArg$fShowSectionArg$fFunctorSectionArg$fFoldableSectionArg$fTraversableSectionArg$fEqName $fShowName $fFunctorName$fFoldableName$fTraversableName $fEqField $fShowField$fFunctorField$fFoldableField$fTraversableField readFields readFields'$fStreamLexState'IdentityLTokenexpandResponseParsingtryskipManyskipSome unexpectedeof notFollowedBychoiceoption skipOptionalbetweensepBy sepByNonEmptysepEndByNonEmptysepEndBy endByNonEmptyendBycountchainrchainlchainl1chainr1manyTill$fParsingParsecT$fParsingIdentityT $fParsingRWST$fParsingRWST0$fParsingWriterT$fParsingWriterT0$fParsingReaderT$fParsingStateT$fParsingStateT0DListrunDList singletonfromListsnoc$fSemigroupDList $fMonoidDListPretext runPretextALens'ALensASetterAGetterGetting Traversal'Lens' TraversalLens LensLike'LensLikeviewusegettingsetover toDListOftoListOftoSetOfaview_1_2&^..~?~%~.=?=%=^##~#%~ cloneLens$fFunctorPretext CondBranchcondBranchConditioncondBranchIfTruecondBranchIfFalseCondTreeCondNode condTreeDatacondTreeConstraintscondTreeComponents condIfThencondIfThenElse mapCondTreemapTreeConstrs mapTreeConds mapTreeDatatraverseCondTreeVtraverseCondBranchVtraverseCondTreeCtraverseCondBranchCextractConditionsimplifyCondTreeignoreConditions$fNFDataCondBranch$fStructuredCondBranch$fBinaryCondBranch$fFoldableCondBranch$fNFDataCondTree$fStructuredCondTree$fBinaryCondTree$fShowCondBranch$fEqCondBranch$fDataCondBranch$fGenericCondBranch$fFunctorCondBranch$fTraversableCondBranch$fShowCondTree $fEqCondTree$fDataCondTree$fGenericCondTree$fFunctorCondTree$fFoldableCondTree$fTraversableCondTree createPipesetFileOrdinarysetFileExecutable CharParsingsatisfycharnotCharanyCharstringtextoneOfnoneOfspacesspacenewlinetabupperloweralphaNumletterdigithexDigitoctDigit satisfyRangeintegralmunch1munch skipSpaces1$fCharParsingParsecT$fCharParsingIdentityT$fCharParsingRWST$fCharParsingRWST0$fCharParsingWriterT$fCharParsingWriterT0$fCharParsingReaderT$fCharParsingStateT$fCharParsingStateT0 HasGlobstar NoGlobstarHasCommonStanzasNoCommonStanzasHasElifNoElifCabalSpecVersion CabalSpecV1_0 CabalSpecV1_2 CabalSpecV1_4 CabalSpecV1_6 CabalSpecV1_8CabalSpecV1_10CabalSpecV1_12CabalSpecV1_18CabalSpecV1_20CabalSpecV1_22CabalSpecV1_24 CabalSpecV2_0 CabalSpecV2_2 CabalSpecV2_4 CabalSpecV3_0showCabalSpecVersioncabalSpecLatestcabalSpecFromVersionDigitscabalSpecFromVersionDigitsMaybecabalSpecToVersionDigitscabalSpecMinimumLibraryVersionspecHasCommonStanzas specHasElif$fEqCabalSpecVersion$fOrdCabalSpecVersion$fShowCabalSpecVersion$fReadCabalSpecVersion$fEnumCabalSpecVersion$fBoundedCabalSpecVersion$fDataCabalSpecVersion$fGenericCabalSpecVersion $fEqHasElif $fShowHasElif$fEqHasCommonStanzas$fShowHasCommonStanzasLicenseListVersionLicenseListVersion_3_0LicenseListVersion_3_2LicenseListVersion_3_6!cabalSpecVersionToSPDXListVersion$fEqLicenseListVersion$fOrdLicenseListVersion$fShowLicenseListVersion$fEnumLicenseListVersion$fBoundedLicenseListVersion SeparatorPrettyprettyprettyVersioned prettyShow defaultStyle flatStyle showFilePath showToken showFreeTextshowFreeTextV3$fPrettyIdentity $fPrettyInt $fPrettyBool ParsecParserPPunPP CabalParsing parsecWarningparsecHaskellStringaskCabalSpecVersionParsecparsec lexemeParsec simpleParsec eitherParsecexplicitEitherParsecrunParsecParserrunParsecParser' parsecToken parsecToken'parsecFilePathparsecStandardparsecCommaListparsecLeadingCommaListparsecOptCommaListparsecLeadingOptCommaList parsecQuotedparsecMaybeQuotedparsecUnqualComponentName $fParsecBool$fParsecIdentity$fCabalParsingParsecParser$fCharParsingParsecParser$fParsingParsecParser$fMonadFailParsecParser$fMonadPlusParsecParser$fMonadParsecParser$fAlternativeParsecParser$fApplicativeParsecParser$fFunctorParsecParserVersionversionDigitParser mkVersionversion0 mkVersion'versionNumbers nullVersion alterVersion validVersion$fParsecVersion$fPrettyVersion$fNFDataVersion$fStructuredVersion$fBinaryVersion $fReadVersion $fShowVersion $fOrdVersion $fDataVersion $fEqVersion$fGenericVersion VersionRangeF AnyVersionF ThisVersionF LaterVersionFOrLaterVersionFEarlierVersionFOrEarlierVersionFWildcardVersionFMajorBoundVersionFUnionVersionRangesFIntersectVersionRangesFVersionRangeParensF VersionRange AnyVersion ThisVersion LaterVersionOrLaterVersionEarlierVersionOrEarlierVersionWildcardVersionMajorBoundVersionUnionVersionRangesIntersectVersionRangesVersionRangeParens anyVersion noVersion thisVersionnotThisVersion laterVersionorLaterVersionearlierVersionorEarlierVersionunionVersionRangesintersectVersionRanges withinVersionmajorBoundVersionprojectVersionRangecataVersionRangeembedVersionRangeanaVersionRangehyloVersionRangeversionRangeParsermajorUpperBound$fParsecVersionRange$fNFDataVersionRange$fStructuredVersionRange$fBinaryVersionRange$fPrettyVersionRange$fDataVersionRange$fEqVersionRange$fGenericVersionRange$fReadVersionRange$fShowVersionRange$fDataVersionRangeF$fEqVersionRangeF$fGenericVersionRangeF$fReadVersionRangeF$fShowVersionRangeF$fFunctorVersionRangeF$fFoldableVersionRangeF$fTraversableVersionRangeFfoldVersionRangenormaliseVersionRangestripParensVersionRange withinRangewildcardUpperBoundisWildcardRange hasUpperBound hasLowerBoundBoundExclusiveBoundInclusiveBound UpperBound NoUpperBound LowerBoundVersionIntervalVersionIntervalsasVersionIntervalsversionIntervalsmkVersionIntervalswithinIntervalstoVersionIntervalsfromVersionIntervalsunionVersionIntervalsintersectVersionIntervalsinvertVersionIntervalsrelaxLastIntervalrelaxHeadInterval$fOrdUpperBound$fOrdLowerBound $fEqBound $fShowBound$fEqUpperBound$fShowUpperBound$fEqLowerBound$fShowLowerBound$fEqVersionIntervals$fShowVersionIntervalsRepoTypeDarcsGitSVNCVS MercurialGnuArchBazaarMonotone OtherRepoTypeRepoKindRepoHeadRepoThisRepoKindUnknown SourceReporepoKindrepoType repoLocation repoModule repoBranchrepoTag repoSubdiremptySourceRepoknownRepoTypesclassifyRepoKindclassifyRepoType$fParsecRepoKind$fPrettyRepoKind$fNFDataRepoKind$fStructuredRepoKind$fBinaryRepoKind$fParsecRepoType$fPrettyRepoType$fNFDataRepoType$fStructuredRepoType$fBinaryRepoType$fNFDataSourceRepo$fStructuredSourceRepo$fBinarySourceRepo $fEqRepoKind$fGenericRepoKind $fOrdRepoKind$fReadRepoKind$fShowRepoKind$fDataRepoKind $fEqRepoType$fGenericRepoType $fOrdRepoType$fReadRepoType$fShowRepoType$fDataRepoType$fEqSourceRepo$fOrdSourceRepo$fGenericSourceRepo$fReadSourceRepo$fShowSourceRepo$fDataSourceRepoPkgconfigVersion rpmvercmp$fParsecPkgconfigVersion$fPrettyPkgconfigVersion$fNFDataPkgconfigVersion$fStructuredPkgconfigVersion$fBinaryPkgconfigVersion$fOrdPkgconfigVersion$fEqPkgconfigVersion$fGenericPkgconfigVersion$fReadPkgconfigVersion$fShowPkgconfigVersion$fDataPkgconfigVersionPkgconfigVersionRange PcAnyVersion PcThisVersionPcLaterVersionPcEarlierVersionPcOrLaterVersionPcOrEarlierVersionPcUnionVersionRangesPcIntersectVersionRangesanyPkgconfigVersionisAnyPkgconfigVersionwithinPkgconfigVersionRangeversionToPkgconfigVersion#versionRangeToPkgconfigVersionRange$fParsecPkgconfigVersionRange$fPrettyPkgconfigVersionRange$fNFDataPkgconfigVersionRange!$fStructuredPkgconfigVersionRange$fBinaryPkgconfigVersionRange$fGenericPkgconfigVersionRange$fReadPkgconfigVersionRange$fShowPkgconfigVersionRange$fEqPkgconfigVersionRange$fDataPkgconfigVersionRange PkgconfigNameunPkgconfigNamemkPkgconfigName$fNFDataPkgconfigName$fParsecPkgconfigName$fPrettyPkgconfigName$fStructuredPkgconfigName$fBinaryPkgconfigName$fIsStringPkgconfigName$fGenericPkgconfigName$fReadPkgconfigName$fShowPkgconfigName$fEqPkgconfigName$fOrdPkgconfigName$fDataPkgconfigNamePkgconfigDependency$fParsecPkgconfigDependency$fPrettyPkgconfigDependency$fNFDataPkgconfigDependency$fStructuredPkgconfigDependency$fBinaryPkgconfigDependency$fGenericPkgconfigDependency$fReadPkgconfigDependency$fShowPkgconfigDependency$fEqPkgconfigDependency$fDataPkgconfigDependency PackageName unPackageName mkPackageName$fNFDataPackageName$fParsecPackageName$fPrettyPackageName$fStructuredPackageName$fBinaryPackageName$fIsStringPackageName$fGenericPackageName$fReadPackageName$fShowPackageName$fEqPackageName$fOrdPackageName$fDataPackageNameUnqualComponentNameunUnqualComponentNamemkUnqualComponentName packageNameToUnqualComponentName unqualComponentNameToPackageName$fNFDataUnqualComponentName$fParsecUnqualComponentName$fPrettyUnqualComponentName$fStructuredUnqualComponentName$fBinaryUnqualComponentName$fIsStringUnqualComponentName$fGenericUnqualComponentName$fReadUnqualComponentName$fShowUnqualComponentName$fEqUnqualComponentName$fOrdUnqualComponentName$fDataUnqualComponentName$fSemigroupUnqualComponentName$fMonoidUnqualComponentNamePackageVersionConstraint $fParsecPackageVersionConstraint $fPrettyPackageVersionConstraint $fNFDataPackageVersionConstraint$$fStructuredPackageVersionConstraint $fBinaryPackageVersionConstraint!$fGenericPackageVersionConstraint$fReadPackageVersionConstraint$fShowPackageVersionConstraint$fEqPackageVersionConstraint$fDataPackageVersionConstraintLibraryVisibilityLibraryVisibilityPublicLibraryVisibilityPrivate$fMonoidLibraryVisibility$fSemigroupLibraryVisibility$fNFDataLibraryVisibility$fStructuredLibraryVisibility$fBinaryLibraryVisibility$fParsecLibraryVisibility$fPrettyLibraryVisibility$fGenericLibraryVisibility$fShowLibraryVisibility$fReadLibraryVisibility$fEqLibraryVisibility$fDataLibraryVisibility LibraryName LMainLibName LSubLibNameprettyLibraryNameComponentparsecLibraryNameComponentdefaultLibNameshowLibraryNamelibraryNameStanzalibraryNameStringmaybeToLibraryName$fNFDataLibraryName$fStructuredLibraryName$fBinaryLibraryName$fEqLibraryName$fGenericLibraryName$fOrdLibraryName$fReadLibraryName$fShowLibraryName$fDataLibraryNameMungedPackageNamedecodeCompatPackageNameencodeCompatPackageName$fParsecMungedPackageName$fPrettyMungedPackageName$fNFDataMungedPackageName$fStructuredMungedPackageName$fBinaryMungedPackageName$fGenericMungedPackageName$fReadMungedPackageName$fShowMungedPackageName$fEqMungedPackageName$fOrdMungedPackageName$fDataMungedPackageNameForeignLibTypeForeignLibNativeSharedForeignLibNativeStaticForeignLibTypeUnknownknownForeignLibTypesforeignLibTypeIsShared$fMonoidForeignLibType$fSemigroupForeignLibType$fNFDataForeignLibType$fStructuredForeignLibType$fBinaryForeignLibType$fParsecForeignLibType$fPrettyForeignLibType$fGenericForeignLibType$fShowForeignLibType$fReadForeignLibType$fEqForeignLibType$fDataForeignLibTypeForeignLibOptionForeignLibStandalone$fNFDataForeignLibOption$fStructuredForeignLibOption$fBinaryForeignLibOption$fParsecForeignLibOption$fPrettyForeignLibOption$fGenericForeignLibOption$fShowForeignLibOption$fReadForeignLibOption$fEqForeignLibOption$fDataForeignLibOptionFlagAssignmentFlagNameMkFlagflagNameflagDescription flagDefault flagManual emptyFlag mkFlagName unFlagNamemkFlagAssignmentunFlagAssignmentnullFlagAssignmentlookupFlagAssignmentinsertFlagAssignmentdiffFlagAssignmentfindDuplicateFlagAssignments showFlagValuedispFlagAssignmentparsecFlagAssignment$fParsecFlagName$fPrettyFlagName$fStructuredFlagName$fBinaryFlagName$fIsStringFlagName $fNFDataFlag$fShowFlagAssignment$fReadFlagAssignment$fMonoidFlagAssignment$fSemigroupFlagAssignment$fOrdFlagAssignment$fEqFlagAssignment$fStructuredFlagAssignment $fEqFlagName$fGenericFlagName $fOrdFlagName$fShowFlagName$fReadFlagName$fDataFlagName$fNFDataFlagName $fDataFlag$fBinaryFlagAssignment$fGenericFlagAssignment$fNFDataFlagAssignmentExecutableScopeExecutablePublicExecutablePrivate$fMonoidExecutableScope$fSemigroupExecutableScope$fNFDataExecutableScope$fStructuredExecutableScope$fBinaryExecutableScope$fParsecExecutableScope$fPrettyExecutableScope$fGenericExecutableScope$fShowExecutableScope$fReadExecutableScope$fEqExecutableScope$fDataExecutableScope ComponentNameCLibName CFLibNameCExeName CTestName CBenchNameshowComponentNamecomponentNameStanzacomponentNameString$fParsecComponentName$fPrettyComponentName$fStructuredComponentName$fBinaryComponentName$fEqComponentName$fGenericComponentName$fOrdComponentName$fReadComponentName$fShowComponentName ComponentId mkComponentId unComponentId$fNFDataComponentId$fParsecComponentId$fPrettyComponentId$fStructuredComponentId$fBinaryComponentId$fIsStringComponentId$fGenericComponentId$fReadComponentId$fShowComponentId$fEqComponentId$fOrdComponentId$fDataComponentIdGivenComponentgivenComponentPackagegivenComponentNamegivenComponentId$fStructuredGivenComponent$fBinaryGivenComponent$fGenericGivenComponent$fReadGivenComponent$fShowGivenComponent$fEqGivenComponent BuildTypeSimple ConfigureMakeCustomknownBuildTypes$fParsecBuildType$fPrettyBuildType$fNFDataBuildType$fStructuredBuildType$fBinaryBuildType$fGenericBuildType$fShowBuildType$fReadBuildType $fEqBuildType$fDataBuildTypeAbiHash unAbiHash mkAbiHash$fParsecAbiHash$fPrettyAbiHash$fNFDataAbiHash$fStructuredAbiHash$fBinaryAbiHash$fIsStringAbiHash $fEqAbiHash $fShowAbiHash $fReadAbiHash$fGenericAbiHashdisplayPlatformArchI386X86_64PPCPPC64SparcArmAArch64MipsSHIA64S390AlphaHppaRs6000M68kVax JavaScript OtherArchOSLinuxWindowsOSXFreeBSDOpenBSDNetBSD DragonFlySolarisAIXHPUXIRIXHaLVMHurdIOSAndroidGhcjsOtherOSClassificationStrictness PermissiveCompatStrictknownOSs classifyOSbuildOS knownArches classifyArch buildArch buildPlatformplatformFromTriple $fParsecOS $fPrettyOS $fNFDataOS$fStructuredOS $fBinaryOS $fParsecArch $fPrettyArch $fNFDataArch$fStructuredArch $fBinaryArch$fParsecPlatform$fPrettyPlatform$fNFDataPlatform$fStructuredPlatform$fBinaryPlatform$fEqOS $fGenericOS$fOrdOS$fShowOS$fReadOS$fDataOS$fEqArch $fGenericArch $fOrdArch $fShowArch $fReadArch $fDataArch $fEqPlatform$fGenericPlatform $fOrdPlatform$fShowPlatform$fReadPlatform$fDataPlatform LicenseRef licenseReflicenseDocumentRef mkLicenseRef mkLicenseRef'$fParsecLicenseRef$fPrettyLicenseRef$fNFDataLicenseRef$fStructuredLicenseRef$fBinaryLicenseRef$fShowLicenseRef$fReadLicenseRef$fEqLicenseRef$fOrdLicenseRef$fDataLicenseRef$fGenericLicenseRef LicenseIdNullBSDAALAbstyles Adobe_2006 Adobe_GlyphADSLAFL_1_1AFL_1_2AFL_2_0AFL_2_1AFL_3_0AfmparseAGPL_1_0 AGPL_1_0_onlyAGPL_1_0_or_later AGPL_3_0_onlyAGPL_3_0_or_laterAladdinAMDPLPAAMLAMPASANTLR_PD Apache_1_0 Apache_1_1 Apache_2_0APAFMLAPL_1_0APSL_1_0APSL_1_1APSL_1_2APSL_2_0Artistic_1_0_cl8Artistic_1_0_Perl Artistic_1_0 Artistic_2_0BahyphBarrBeerwareBitTorrent_1_0BitTorrent_1_1Blessing BlueOak_1_0_0Borceux BSD_1_ClauseBSD_2_Clause_FreeBSDBSD_2_Clause_NetBSDBSD_2_Clause_Patent BSD_2_ClauseBSD_3_Clause_AttributionBSD_3_Clause_ClearBSD_3_Clause_LBNL$BSD_3_Clause_No_Nuclear_License_2014BSD_3_Clause_No_Nuclear_License BSD_3_Clause_No_Nuclear_WarrantyBSD_3_Clause_Open_MPI BSD_3_ClauseBSD_4_Clause_UC BSD_4_ClauseBSD_ProtectionBSD_Source_CodeBSL_1_0 Bzip2_1_0_5 Bzip2_1_0_6Caldera CATOSL_1_1 CC_BY_1_0 CC_BY_2_0 CC_BY_2_5 CC_BY_3_0 CC_BY_4_0 CC_BY_NC_1_0 CC_BY_NC_2_0 CC_BY_NC_2_5 CC_BY_NC_3_0 CC_BY_NC_4_0CC_BY_NC_ND_1_0CC_BY_NC_ND_2_0CC_BY_NC_ND_2_5CC_BY_NC_ND_3_0CC_BY_NC_ND_4_0CC_BY_NC_SA_1_0CC_BY_NC_SA_2_0CC_BY_NC_SA_2_5CC_BY_NC_SA_3_0CC_BY_NC_SA_4_0 CC_BY_ND_1_0 CC_BY_ND_2_0 CC_BY_ND_2_5 CC_BY_ND_3_0 CC_BY_ND_4_0 CC_BY_SA_1_0 CC_BY_SA_2_0 CC_BY_SA_2_5 CC_BY_SA_3_0 CC_BY_SA_4_0CC_PDDCCC0_1_0CDDL_1_0CDDL_1_1CDLA_Permissive_1_0CDLA_Sharing_1_0 CECILL_1_0 CECILL_1_1 CECILL_2_0 CECILL_2_1CECILL_BCECILL_C CERN_OHL_1_1 CERN_OHL_1_2 ClArtistic CNRI_JythonCNRI_Python_GPL_Compatible CNRI_Python Condor_1_1Copyleft_next_0_3_0Copyleft_next_0_3_1CPAL_1_0CPL_1_0 CPOL_1_02 CrosswordCrystalStacker CUA_OPL_1_0CubeCurl D_FSL_1_0DiffmarkDOCDotseqnDSDPDvipdfmECL_1_0ECL_2_0EFL_1_0EFL_2_0EGenixEntessaEPL_1_0EPL_2_0 ErlPL_1_1 EUDatagridEUPL_1_0EUPL_1_1EUPL_1_2EurosymFair Frameworx_1_0 FreeImageFSFAPFSFULLRFSFULFTL GFDL_1_1_onlyGFDL_1_1_or_later GFDL_1_2_onlyGFDL_1_2_or_later GFDL_1_3_onlyGFDL_1_3_or_laterGiftwareGL2PSGlideGlulxeGnuplot GPL_1_0_onlyGPL_1_0_or_later GPL_2_0_onlyGPL_2_0_or_later GPL_3_0_onlyGPL_3_0_or_later GSOAP_1_3b HaskellReportHPND_sell_variantHPNDIBM_pibsICUIJG ImageMagickIMatixImlib2Info_ZIP Intel_ACPIIntel Interbase_1_0IPAIPL_1_0ISC JasPer_2_0JPNICJSONLAL_1_2LAL_1_3Latex2e Leptonica LGPL_2_0_onlyLGPL_2_0_or_later LGPL_2_1_onlyLGPL_2_1_or_later LGPL_3_0_onlyLGPL_3_0_or_laterLGPLLR Libpng_2_0LibpngLibtiff LiLiQ_P_1_1 LiLiQ_R_1_1LiLiQ_Rplus_1_1 Linux_OpenIBLPL_1_02LPL_1_0LPPL_1_0LPPL_1_1LPPL_1_2 LPPL_1_3a LPPL_1_3c MakeIndexMirOSMIT_0MIT_advertisingMIT_CMUMIT_ennaMIT_fehMITNFAMITMotosotoMpich2MPL_1_0MPL_1_1MPL_2_0_no_copyleft_exceptionMPL_2_0MS_PLMS_RLMTLLMulticsMupNASA_1_3NaumenNBPL_1_0NCSANet_SNMPNetCDFNewsletrNGPLNLOD_1_0NLPLNokiaNOSLNowebNPL_1_0NPL_1_1 NPOSL_3_0NRLNTPOCCT_PLOCLC_2_0ODbL_1_0 ODC_By_1_0OFL_1_0OFL_1_1 OGL_UK_1_0 OGL_UK_2_0 OGL_UK_3_0OGTSL OLDAP_1_1 OLDAP_1_2 OLDAP_1_3 OLDAP_1_4 OLDAP_2_0_1 OLDAP_2_0 OLDAP_2_1 OLDAP_2_2_1 OLDAP_2_2_2 OLDAP_2_2 OLDAP_2_3 OLDAP_2_4 OLDAP_2_5 OLDAP_2_6 OLDAP_2_7 OLDAP_2_8OMLOpenSSLOPL_1_0 OSET_PL_2_1OSL_1_0OSL_1_1OSL_2_0OSL_2_1OSL_3_0 Parity_6_0_0PDDL_1_0PHP_3_01PHP_3_0Plexus PostgreSQLPsfragPsutils Python_2_0QhullQPL_1_0Rdisc RHeCos_1_1RPL_1_1RPL_1_5RPSL_1_0RSA_MDRSCPLRubySAX_PDSaxpathSCEA Sendmail_8_23Sendmail SGI_B_1_0 SGI_B_1_1 SGI_B_2_0SHL_0_51SHL_0_5 SimPL_2_0 SISSL_1_2SISSL SleepycatSMLNJSMPPLSNIA Spencer_86 Spencer_94 Spencer_99SPL_1_0SSPL_1_0SugarCRM_1_1_3SWL TAPR_OHL_1_0TCL TCP_wrappersTMate TORQUE_1_1TOSL TU_Berlin_1_0 TU_Berlin_2_0Unicode_DFS_2015Unicode_DFS_2016 Unicode_TOU UnlicenseUPL_1_0VimVOSTROMVSL_1_0 W3C_19980720 W3C_20150513W3C Watcom_1_0WsuipaWTFPLX11Xerox XFree86_1_1XinetdXnetXppXSkatYPL_1_0YPL_1_1ZedZend_2_0 Zimbra_1_3 Zimbra_1_4Zlib_acknowledgementZlibZPL_1_1ZPL_2_0ZPL_2_1licenseIdMigrationMessage licenseId licenseNamelicenseIsOsiApproved licenseIdList mkLicenseId$fNFDataLicenseId$fParsecLicenseId$fPrettyLicenseId$fStructuredLicenseId$fBinaryLicenseId $fEqLicenseId$fOrdLicenseId$fEnumLicenseId$fBoundedLicenseId$fShowLicenseId$fReadLicenseId$fDataLicenseId$fGenericLicenseIdLicenseExceptionIdDS389_exceptionAutoconf_exception_2_0Autoconf_exception_3_0Bison_exception_2_2Bootloader_exceptionClasspath_exception_2_0CLISP_exception_2_0DigiRule_FOSS_exceptionECos_exception_2_0Fawkes_Runtime_exceptionFLTK_exceptionFont_exception_2_0Freertos_exception_2_0GCC_exception_2_0GCC_exception_3_1Gnu_javamail_exception GPL_CC_1_0I2p_gpl_java_exceptionLibtool_exceptionLinux_syscall_noteLLVM_exceptionLZMA_exception Mif_exceptionNokia_Qt_exception_1_1OCaml_LGPL_linking_exceptionOCCT_exception_1_0OpenJDK_assembly_exception_1_0Openvpn_openssl_exception!PS_or_PDF_font_exception_20170817Qt_GPL_exception_1_0Qt_LGPL_exception_1_1Qwt_exception_1_0Swift_exceptionU_boot_exception_2_0Universal_FOSS_exception_1_0WxWindows_exception_3_1licenseExceptionIdlicenseExceptionNamelicenseExceptionIdListmkLicenseExceptionId$fNFDataLicenseExceptionId$fParsecLicenseExceptionId$fPrettyLicenseExceptionId$fStructuredLicenseExceptionId$fBinaryLicenseExceptionId$fEqLicenseExceptionId$fOrdLicenseExceptionId$fEnumLicenseExceptionId$fBoundedLicenseExceptionId$fShowLicenseExceptionId$fReadLicenseExceptionId$fDataLicenseExceptionId$fGenericLicenseExceptionIdSimpleLicenseExpression ELicenseIdELicenseIdPlus ELicenseRefLicenseExpressionELicenseEAndEOrsimpleLicenseExpression$fNFDataSimpleLicenseExpression$fParsecSimpleLicenseExpression$fPrettySimpleLicenseExpression#$fStructuredSimpleLicenseExpression$fBinarySimpleLicenseExpression$fNFDataLicenseExpression$fParsecLicenseExpression$fPrettyLicenseExpression$fStructuredLicenseExpression$fBinaryLicenseExpression$fShowSimpleLicenseExpression$fReadSimpleLicenseExpression$fEqSimpleLicenseExpression$fOrdSimpleLicenseExpression$fDataSimpleLicenseExpression $fGenericSimpleLicenseExpression$fShowLicenseExpression$fReadLicenseExpression$fEqLicenseExpression$fOrdLicenseExpression$fDataLicenseExpression$fGenericLicenseExpressionLicenseNONE$fParsecLicense$fPrettyLicense$fNFDataLicense$fStructuredLicense$fBinaryLicense $fShowLicense $fReadLicense $fEqLicense $fOrdLicense $fDataLicense$fGenericLicenseReadErunReadE succeedReadE failReadE readEOrFail parsecToReadE$fFunctorReadE ModuleNamevalidModuleComponentfromComponents components toFilePath$fStructuredShortTextLst$fBinaryShortTextLst$fReadShortTextLst$fShowShortTextLst$fNFDataShortTextLst$fIsStringModuleName$fParsecModuleName$fPrettyModuleName$fNFDataModuleName$fStructuredModuleName$fBinaryModuleName$fEqShortTextLst$fGenericShortTextLst$fOrdShortTextLst$fDataShortTextLst$fEqModuleName$fGenericModuleName$fOrdModuleName$fReadModuleName$fShowModuleName$fDataModuleNameModuleRenamingDefaultRenamingHidingRenaminginterpModuleRenamingdefaultRenamingisDefaultRenaming$fParsecModuleRenaming$fPrettyModuleRenaming$fNFDataModuleRenaming$fStructuredModuleRenaming$fBinaryModuleRenaming$fShowModuleRenaming$fReadModuleRenaming$fEqModuleRenaming$fOrdModuleRenaming$fDataModuleRenaming$fGenericModuleRenamingincludeProvidesRnincludeRequiresRndefaultIncludeRenamingisDefaultIncludeRenaming$fParsecIncludeRenaming$fPrettyIncludeRenaming$fNFDataIncludeRenaming$fStructuredIncludeRenaming$fBinaryIncludeRenaming$fShowIncludeRenaming$fReadIncludeRenaming$fEqIncludeRenaming$fOrdIncludeRenaming$fDataIncludeRenaming$fGenericIncludeRenamingMixinmixinPackageNamemixinIncludeRenaming $fParsecMixin $fPrettyMixin $fNFDataMixin$fStructuredMixin $fBinaryMixin $fShowMixin $fReadMixin $fEqMixin $fOrdMixin $fDataMixin$fGenericMixinModuleReexportmoduleReexportOriginalPackagemoduleReexportOriginalNamemoduleReexportName$fParsecModuleReexport$fPrettyModuleReexport$fNFDataModuleReexport$fStructuredModuleReexport$fBinaryModuleReexport$fEqModuleReexport$fGenericModuleReexport$fReadModuleReexport$fShowModuleReexport$fDataModuleReexport FieldGrammarblurFieldGrammaruniqueFieldAlabooleanFieldDefoptionalFieldAlaoptionalFieldDefAla freeTextFieldfreeTextFieldDeffreeTextFieldDefSTmonoidalFieldAlaprefixedFields knownField hiddenFielddeprecatedSince removedInavailableSince uniqueField optionalFieldoptionalFieldDef monoidalFielddefaultFreeTextFieldDefSTNodeNIsNodeKeynodeKey nodeNeighbors nodeValuesizememberinsert deleteKey deleteLookup unionRight unionLeftstronglyConnCompcyclesbroken neighbors revNeighborsclosure revClosuretopSort revTopSortfromDistinctListkeyskeysSettoMaptoGraph$fIsNodeEither $fNFDataGraph$fFoldableGraph $fEqGraph$fStructuredGraph $fBinaryGraph $fReadGraph $fShowGraph $fIsNodeNode $fFunctorNode $fShowNode$fEqNode VerbosityFlag VCallStack VCallSiteVNoWrap VMarkOutput VTimestampVerbosityLevelSilentNormalVerbose Deafening$fStructuredVerbosityLevel$fBinaryVerbosityLevel$fStructuredVerbosityFlag$fBinaryVerbosityFlag$fGenericVerbosityLevel$fShowVerbosityLevel$fReadVerbosityLevel$fEqVerbosityLevel$fOrdVerbosityLevel$fEnumVerbosityLevel$fBoundedVerbosityLevel$fGenericVerbosityFlag$fShowVerbosityFlag$fReadVerbosityFlag$fEqVerbosityFlag$fOrdVerbosityFlag$fEnumVerbosityFlag$fBoundedVerbosityFlagsilentnormalverbose deafening moreVerbose lessVerbosemodifyVerbosityintToVerbosityflagToVerbosity showForCabal showForGHCverboseCallSiteverboseCallStackverboseMarkOutputverboseUnmarkOutput verboseNoWrapverboseTimestampverboseNoTimestampverboseNoFlagsverboseHasFlagsisVerboseCallSiteisVerboseCallStackisVerboseMarkOutputisVerboseNoWrapisVerboseQuietisVerboseTimestamp$fStructuredVerbosity$fBinaryVerbosity$fBoundedVerbosity$fEnumVerbosity$fOrdVerbosity $fEqVerbosity$fGenericVerbosity$fShowVerbosity$fReadVerbosity isAnyVersion isNoVersionisSpecificVersionsimplifyVersionRangedifferenceVersionRangesinvertVersionRangeremoveUpperBoundremoveLowerBoundTestType TestTypeExe TestTypeLibTestTypeUnknownknownTestTypes$fParsecTestType$fPrettyTestType$fNFDataTestType$fStructuredTestType$fBinaryTestType$fGenericTestType$fShowTestType$fReadTestType $fEqTestType$fDataTestTypeTestSuiteInterfaceTestSuiteExeV10TestSuiteLibV09TestSuiteUnsupported$fSemigroupTestSuiteInterface$fMonoidTestSuiteInterface$fNFDataTestSuiteInterface$fStructuredTestSuiteInterface$fBinaryTestSuiteInterface$fEqTestSuiteInterface$fGenericTestSuiteInterface$fReadTestSuiteInterface$fShowTestSuiteInterface$fDataTestSuiteInterfacePackageIdentifierpkgName pkgVersion PackageId$fNFDataPackageIdentifier$fParsecPackageIdentifier$fPrettyPackageIdentifier$fStructuredPackageIdentifier$fBinaryPackageIdentifier$fGenericPackageIdentifier$fReadPackageIdentifier$fShowPackageIdentifier$fEqPackageIdentifier$fOrdPackageIdentifier$fDataPackageIdentifier DefUnitId unDefUnitIdUnitIdunUnitIdmkUnitIdnewSimpleUnitIdmkLegacyUnitIdgetHSLibraryNameunsafeMkDefUnitId$fIsStringUnitId$fParsecUnitId$fPrettyUnitId$fStructuredUnitId$fBinaryUnitId$fParsecDefUnitId$fStructuredDefUnitId$fGenericUnitId $fReadUnitId $fShowUnitId $fEqUnitId $fOrdUnitId $fDataUnitId$fNFDataUnitId$fGenericDefUnitId$fReadDefUnitId$fShowDefUnitId $fEqDefUnitId$fOrdDefUnitId$fDataDefUnitId$fBinaryDefUnitId$fNFDataDefUnitId$fPrettyDefUnitIdModule$fNFDataModule$fParsecModule$fPrettyModule$fStructuredModule$fBinaryModule$fGenericModule $fReadModule $fShowModule $fEqModule $fOrdModule $fDataModuleOpenModuleSubst OpenModule OpenModuleVar OpenUnitIdIndefFullUnitIdDefiniteUnitIdopenUnitIdFreeHoles mkOpenUnitId mkDefUnitIdopenModuleFreeHolesdispOpenModuleSubstdispOpenModuleSubstEntryparsecOpenModuleSubstparsecOpenModuleSubstEntryopenModuleSubstFreeHolesabstractUnitIdhashModuleSubst$fParsecOpenModule$fPrettyOpenModule$fNFDataOpenModule$fStructuredOpenModule$fBinaryOpenModule$fParsecOpenUnitId$fPrettyOpenUnitId$fNFDataOpenUnitId$fStructuredOpenUnitId$fBinaryOpenUnitId$fGenericOpenModule$fReadOpenModule$fShowOpenModule$fEqOpenModule$fOrdOpenModule$fDataOpenModule$fGenericOpenUnitId$fReadOpenUnitId$fShowOpenUnitId$fEqOpenUnitId$fOrdOpenUnitId$fDataOpenUnitId ExposedModule exposedNameexposedReexport$fNFDataExposedModule$fStructuredExposedModule$fBinaryExposedModule$fParsecExposedModule$fPrettyExposedModule$fEqExposedModule$fGenericExposedModule$fReadExposedModule$fShowExposedModuleModSubstmodSubst $fModSubst(,) $fModSubst[] $fModSubstMap $fModSubstSet$fModSubstOpenUnitId$fModSubstOpenModuleFullDb FullUnitIdexpandOpenUnitId expandUnitId$fShowFullUnitId$fGenericFullUnitId nonExistentPackageThisIsCabalBugfakePackageName fakePackageIdMungedPackageId mungedName mungedVersioncomputeCompatPackageId$fNFDataMungedPackageId$fParsecMungedPackageId$fPrettyMungedPackageId$fStructuredMungedPackageId$fBinaryMungedPackageId$fGenericMungedPackageId$fReadMungedPackageId$fShowMungedPackageId$fEqMungedPackageId$fOrdMungedPackageId$fDataMungedPackageIdLegacyExeDependency$fParsecLegacyExeDependency$fPrettyLegacyExeDependency$fNFDataLegacyExeDependency$fStructuredLegacyExeDependency$fBinaryLegacyExeDependency$fGenericLegacyExeDependency$fReadLegacyExeDependency$fShowLegacyExeDependency$fEqLegacyExeDependency$fDataLegacyExeDependency ExeDependencyqualifiedExeName$fParsecExeDependency$fPrettyExeDependency$fNFDataExeDependency$fStructuredExeDependency$fBinaryExeDependency$fGenericExeDependency$fReadExeDependency$fShowExeDependency$fEqExeDependency$fDataExeDependency Dependency depPkgName depVerRange depLibrariesthisPackageVersionnotThisPackageVersionsimplifyDependency$fParsecDependency$fPrettyDependency$fNFDataDependency$fStructuredDependency$fBinaryDependency$fGenericDependency$fReadDependency$fShowDependency$fEqDependency$fDataDependencySetupBuildInfo setupDependsdefaultSetupDepends$fSemigroupSetupBuildInfo$fMonoidSetupBuildInfo$fNFDataSetupBuildInfo$fStructuredSetupBuildInfo$fBinarySetupBuildInfo$fGenericSetupBuildInfo$fShowSetupBuildInfo$fEqSetupBuildInfo$fReadSetupBuildInfo$fDataSetupBuildInfo DependencyMaptoDepMap fromDepMap constrainBy$fSemigroupDependencyMap$fMonoidDependencyMap$fShowDependencyMap$fReadDependencyMap BenchmarkTypeBenchmarkTypeExeBenchmarkTypeUnknownknownBenchmarkTypes$fParsecBenchmarkType$fPrettyBenchmarkType$fNFDataBenchmarkType$fStructuredBenchmarkType$fBinaryBenchmarkType$fGenericBenchmarkType$fShowBenchmarkType$fReadBenchmarkType$fEqBenchmarkType$fDataBenchmarkTypeBenchmarkInterfaceBenchmarkExeV10BenchmarkUnsupported$fSemigroupBenchmarkInterface$fMonoidBenchmarkInterface$fNFDataBenchmarkInterface$fStructuredBenchmarkInterface$fBinaryBenchmarkInterface$fEqBenchmarkInterface$fGenericBenchmarkInterface$fReadBenchmarkInterface$fShowBenchmarkInterface$fDataBenchmarkInterfacePackageInstalledinstalledDepends HasUnitIdinstalledUnitIdHasMungedPackageIdmungedIdPackage packageId mungedName'mungedVersion' packageNamepackageVersion$fPackagePackageIdentifier#$fHasMungedPackageIdMungedPackageId AnnotatedIdann_pid ann_cnameann_id$fFunctorAnnotatedId$fPackageAnnotatedId$fOrdAnnotatedId$fEqAnnotatedId$fShowAnnotatedIdComponentInclude ci_ann_id ci_renaming ci_implicitci_idci_pkgidci_cname AbiDependency depUnitId depAbiHash$fNFDataAbiDependency$fStructuredAbiDependency$fBinaryAbiDependency$fParsecAbiDependency$fPrettyAbiDependency$fEqAbiDependency$fGenericAbiDependency$fReadAbiDependency$fShowAbiDependencyGPLAGPLLGPLBSD2BSD3BSD4MPLApache PublicDomainAllRightsReservedUnspecifiedLicense OtherLicenseUnknownLicense knownLicenses licenseToSPDXlicenseFromSPDXInstalledPackageInfosourcePackageId sourceLibNameinstalledComponentId_ libVisibilityinstantiatedWithcompatPackageKeylicense copyright maintainerauthor stabilityhomepagepkgUrlsynopsis descriptioncategoryabiHash indefiniteexposedexposedModules hiddenModulestrusted importDirs libraryDirslibraryDynDirsdataDir hsLibrariesextraLibrariesextraGHCiLibraries includeDirsincludesdepends abiDepends ccOptions cxxOptions ldOptions frameworkDirs frameworkshaddockInterfaces haddockHTMLspkgRootmungedPackageIdmungedPackageNameemptyInstalledPackageInfo$fIsNodeInstalledPackageInfo&$fPackageInstalledInstalledPackageInfo$fHasUnitIdInstalledPackageInfo$fPackageInstalledPackageInfo($fHasMungedPackageIdInstalledPackageInfo$fNFDataInstalledPackageInfo $fStructuredInstalledPackageInfo$fBinaryInstalledPackageInfo$fEqInstalledPackageInfo$fGenericInstalledPackageInfo$fReadInstalledPackageInfo$fShowInstalledPackageInfoKnownExtensionOverlappingInstancesUndecidableInstancesIncoherentInstancesDoRec RecursiveDoParallelListCompMultiParamTypeClassesMonomorphismRestrictionFunctionalDependencies Rank2Types RankNTypesPolymorphicComponentsExistentialQuantificationScopedTypeVariablesPatternSignaturesImplicitParamsFlexibleContextsFlexibleInstancesEmptyDataDeclsCPPKindSignatures BangPatternsTypeSynonymInstancesTemplateHaskellForeignFunctionInterfaceArrowsGenericsImplicitPreludeNamedFieldPuns PatternGuardsGeneralizedNewtypeDerivingGeneralisedNewtypeDerivingExtensibleRecordsRestrictedTypeSynonyms 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 TypeInTypeUndecidableSuperClassesMonadFailDesugaringTemplateHaskellQuotesOverloadedLabelsTypeFamilyDependenciesDerivingStrategies DerivingVia UnboxedSumsHexFloatLiteralsBlockArgumentsNumericUnderscoresQuantifiedConstraints StarIsTypeEmptyDataDerivingCUSKsImportQualifiedPostStandaloneKindSignaturesUnliftedNewtypes ExtensionEnableExtensionDisableExtensionUnknownExtensionLanguage Haskell98 Haskell2010UnknownLanguageknownLanguagesclassifyLanguagedeprecatedExtensionsclassifyExtension$fParsecLanguage$fPrettyLanguage$fNFDataLanguage$fStructuredLanguage$fBinaryLanguage$fPrettyKnownExtension$fNFDataKnownExtension$fStructuredKnownExtension$fBinaryKnownExtension$fParsecExtension$fPrettyExtension$fNFDataExtension$fStructuredExtension$fBinaryExtension$fGenericLanguage$fShowLanguage$fReadLanguage $fEqLanguage$fDataLanguage$fGenericKnownExtension$fShowKnownExtension$fReadKnownExtension$fEqKnownExtension$fOrdKnownExtension$fEnumKnownExtension$fBoundedKnownExtension$fDataKnownExtension$fGenericExtension$fShowExtension$fReadExtension $fEqExtension$fOrdExtension$fDataExtensionAbiTagNoAbiTag CompilerInfocompilerInfoIdcompilerInfoAbiTagcompilerInfoCompatcompilerInfoLanguagescompilerInfoExtensions CompilerIdPerCompilerFlavorCompilerFlavorGHCGHCJSNHCYHCHugsHBCHeliumJHCLHCUHCEta HaskellSuite OtherCompilerknownCompilerFlavorsclassifyCompilerFlavorbuildCompilerFlavorbuildCompilerIddefaultCompilerFlavorperCompilerFlavorToList abiTagStringunknownCompilerInfo$fParsecCompilerFlavor$fPrettyCompilerFlavor$fNFDataCompilerFlavor$fStructuredCompilerFlavor$fBinaryCompilerFlavor$fMonoidPerCompilerFlavor$fSemigroupPerCompilerFlavor$fNFDataPerCompilerFlavor$fStructuredPerCompilerFlavor$fBinaryPerCompilerFlavor$fParsecCompilerId$fPrettyCompilerId$fNFDataCompilerId$fStructuredCompilerId$fBinaryCompilerId$fParsecAbiTag$fPrettyAbiTag$fStructuredAbiTag$fBinaryAbiTag$fBinaryCompilerInfo$fGenericCompilerFlavor$fShowCompilerFlavor$fReadCompilerFlavor$fEqCompilerFlavor$fOrdCompilerFlavor$fDataCompilerFlavor$fGenericPerCompilerFlavor$fShowPerCompilerFlavor$fReadPerCompilerFlavor$fEqPerCompilerFlavor$fDataPerCompilerFlavor$fEqCompilerId$fGenericCompilerId$fOrdCompilerId$fReadCompilerId$fShowCompilerId $fEqAbiTag$fGenericAbiTag $fShowAbiTag $fReadAbiTag$fGenericCompilerInfo$fShowCompilerInfo$fReadCompilerInfoConfVarImpl$fNFDataConfVar$fStructuredConfVar$fBinaryConfVar $fEqConfVar $fShowConfVar $fDataConfVar$fGenericConfVar BuildInfo buildable buildToolsbuildToolDepends cppOptions asmOptions cmmOptionspkgconfigDependsextraFrameworkDirs asmSources cmmSourcescSources cxxSources jsSources hsSourceDirs otherModulesvirtualModulesautogenModulesdefaultLanguageotherLanguagesdefaultExtensionsotherExtensions oldExtensions extraLibs extraGHCiLibsextraBundledLibsextraLibFlavoursextraDynLibFlavours extraLibDirsautogenIncludesinstallIncludes profOptions sharedOptions staticOptionscustomFieldsBItargetBuildDependsmixinsemptyBuildInfo allLanguages allExtensionsusedExtensionsusesTemplateHaskellOrQQ hcOptions hcProfOptionshcSharedOptionshcStaticOptions$fSemigroupBuildInfo$fMonoidBuildInfo$fNFDataBuildInfo$fStructuredBuildInfo$fBinaryBuildInfo$fGenericBuildInfo$fShowBuildInfo$fReadBuildInfo $fEqBuildInfo$fDataBuildInfoHookedBuildInfoemptyHookedBuildInfo HasBuildInfostraverseBuildInfos HasBuildInfo buildInfo$fHasBuildInfoBuildInfo TestSuitetestName testInterface testBuildInfoemptyTestSuitetestType testModulestestModulesAutogen$fSemigroupTestSuite$fMonoidTestSuite$fNFDataTestSuite$fStructuredTestSuite$fBinaryTestSuite$fHasBuildInfoTestSuite$fGenericTestSuite$fShowTestSuite$fReadTestSuite $fEqTestSuite$fDataTestSuiteLibrarylibNamereexportedModules signatures libExposed libBuildInfo emptyLibraryexplicitLibModuleslibModulesAutogen$fSemigroupLibrary$fMonoidLibrary$fNFDataLibrary$fStructuredLibrary$fBinaryLibrary$fHasBuildInfoLibrary$fGenericLibrary $fShowLibrary $fEqLibrary $fReadLibrary $fDataLibraryLibVersionInfo ForeignLibforeignLibNameforeignLibTypeforeignLibOptionsforeignLibBuildInfoforeignLibVersionInfoforeignLibVersionLinuxforeignLibModDefFilemkLibVersionInfolibVersionInfoCRAlibVersionNumberlibVersionNumberShowlibVersionMajoremptyForeignLibforeignLibModulesforeignLibIsSharedforeignLibVersion$fParsecLibVersionInfo$fPrettyLibVersionInfo$fNFDataLibVersionInfo$fStructuredLibVersionInfo$fBinaryLibVersionInfo$fReadLibVersionInfo$fShowLibVersionInfo$fOrdLibVersionInfo$fMonoidForeignLib$fSemigroupForeignLib$fNFDataForeignLib$fStructuredForeignLib$fBinaryForeignLib$fHasBuildInfoForeignLib$fDataLibVersionInfo$fEqLibVersionInfo$fGenericLibVersionInfo$fGenericForeignLib$fShowForeignLib$fReadForeignLib$fEqForeignLib$fDataForeignLib ExecutableexeName modulePathexeScopeemptyExecutable exeModulesexeModulesAutogen$fSemigroupExecutable$fMonoidExecutable$fNFDataExecutable$fStructuredExecutable$fBinaryExecutable$fHasBuildInfoExecutable$fGenericExecutable$fShowExecutable$fReadExecutable$fEqExecutable$fDataExecutable exeBuildInfo Benchmark benchmarkNamebenchmarkInterfacebenchmarkBuildInfoemptyBenchmark benchmarkTypebenchmarkModulesbenchmarkModulesAutogen$fSemigroupBenchmark$fMonoidBenchmark$fHasBuildInfoBenchmark$fNFDataBenchmark$fStructuredBenchmark$fBinaryBenchmark$fGenericBenchmark$fShowBenchmark$fReadBenchmark $fEqBenchmark$fDataBenchmark ComponentCLibCFLibCExeCTestCBench foldComponentcomponentBuildInfocomponentBuildable componentNamepartitionComponents$fHasBuildInfoComponent$fSemigroupComponent$fShowComponent $fEqComponent$fReadComponentComponentDisabledReasonDisabledComponentDisabledAllTestsDisabledAllBenchmarksDisabledAllButOneComponentRequestedSpecOneComponentRequestedSpectestsRequestedbenchmarksRequesteddefaultComponentRequestedSpeccomponentEnabledcomponentNameRequestedcomponentDisabledReason"$fStructuredComponentRequestedSpec$fBinaryComponentRequestedSpec$fGenericComponentRequestedSpec$fReadComponentRequestedSpec$fShowComponentRequestedSpec$fEqComponentRequestedSpecPackageDescriptionspecVersionRawpackage licenseRaw licenseFiles testedWith bugReports sourceReposcustomFieldsPD buildTypeRawsetupBuildInfolibrary subLibraries executables foreignLibs testSuites benchmarks dataFiles extraSrcFiles extraTmpFiles extraDocFiles specVersion specVersion'license' buildTypeemptyPackageDescription hasPublicLibhasLibs allLibrarieswithLibhasExeswithExehasTestswithTest hasBenchmarks withBenchmarkhasForeignLibswithForeignLib allBuildInfoenabledBuildInfosallBuildDependsenabledBuildDependsupdatePackageDescription pkgComponentspkgBuildableComponentsenabledComponentslookupComponent getComponent!$fHasBuildInfosPackageDescription$fPackagePackageDescription$fNFDataPackageDescription$fStructuredPackageDescription$fBinaryPackageDescription$fGenericPackageDescription$fShowPackageDescription$fReadPackageDescription$fEqPackageDescription$fDataPackageDescriptionGenericPackageDescriptionpackageDescriptiongenPackageFlags condLibrarycondSubLibrariescondForeignLibscondExecutablescondTestSuitescondBenchmarksemptyGenericPackageDescription($fHasBuildInfosGenericPackageDescription!$fNFDataGenericPackageDescription%$fStructuredGenericPackageDescription!$fBinaryGenericPackageDescription"$fPackageGenericPackageDescription$fShowGenericPackageDescription$fEqGenericPackageDescription$fDataGenericPackageDescription"$fGenericGenericPackageDescription allCondTrees_OS_Arch_Flag_ImplcomponentModulesdesugarBuildToolgetAllToolDependencies isInternalgetAllInternalToolDependenciesPathTemplateEnv PathTemplateCopyDest NoCopyDestCopyToCopyToDbInstallDirTemplates InstallDirsprefixbindirlibdir libsubdir dynlibdirflibdir libexecdir libexecsubdir includedirdatadir datasubdirdocdirmandirhtmldir haddockdir sysconfdircombineInstallDirsdefaultInstallDirsdefaultInstallDirs'substituteInstallDirTemplatesabsoluteInstallDirsprefixRelativeInstallDirstoPathTemplatefromPathTemplatecombinePathTemplatesubstPathTemplateinitialPathTemplateEnvpackageTemplateEnvcompilerTemplateEnvplatformTemplateEnvabiTemplateEnvinstallDirsTemplateEnv$fSemigroupInstallDirs$fMonoidInstallDirs$fStructuredInstallDirs$fBinaryInstallDirs$fBinaryCopyDest$fReadPathTemplate$fShowPathTemplate$fStructuredPathTemplate$fBinaryPathTemplate$fEqInstallDirs$fReadInstallDirs$fShowInstallDirs$fFunctorInstallDirs$fGenericInstallDirs $fEqCopyDest$fShowCopyDest$fGenericCopyDest$fEqPathTemplate$fOrdPathTemplate$fGenericPathTemplate FilePathNT getFilePathNT TestedWith getTestedWith SpecLicensegetSpecLicense SpecVersiongetSpecVersionMQuoted getMQuotedToken' getToken'getTokenSet'ListSep prettySepparseSep NoCommaFSepFSepVCat CommaFSep CommaVCatalaListalaList'alaSetalaSet'$fSepNoCommaFSep $fSepFSep $fSepVCat$fSepCommaFSep$fSepCommaVCat $fPrettyList $fParsecList$fNewtype[]List $fPrettySet' $fParsecSet'$fNewtypeSetSet' $fPrettyToken $fParsecToken$fNewtype[]Token$fPrettyToken'$fParsecToken'$fNewtype[]Token'$fPrettyMQuoted$fParsecMQuoted$fNewtypeaMQuoted$fPrettySpecVersion$fParsecSpecVersion$fNewtypeEitherSpecVersion$fPrettySpecLicense$fParsecSpecLicense$fNewtypeEitherSpecLicense$fPrettyTestedWith$fParsecTestedWith$fNewtype(,)TestedWith$fPrettyFilePathNT$fParsecFilePathNT$fNewtype[]FilePathNTTempFileOptionsoptKeepTempFiles cabalVersiondieNoVerbositydieWithLocation'die' dieNoWraptopHandlerWith topHandlerwarnnotice noticeNoWrap noticeDoc setupMessageinfo infoNoWrapdebug debugNoWrap chattyTryhandleDoesNotExistwithOutputMarker maybeExitprintRawCommandAndArgsprintRawCommandAndArgsAndEnv rawSystemExitrawSystemExitCoderawSystemExitWithEnvrawSystemIOWithEnvcreateProcessWithEnvrawSystemStdoutrawSystemStdInOutfindProgramVersionxargsfindFile findFileExfindFileWithExtensionfindAllFilesWithExtensionfindFileWithExtension' findFirstFilefindModuleFilesfindModuleFilesExfindModuleFilefindModuleFileExgetDirectoryContentsRecursiveisInSearchPathaddLibraryPathmoreRecentFileexistsAndIsMoreRecentThancreateDirectoryIfMissingVerbosecopyFileVerboseinstallOrdinaryFileinstallExecutableFileinstallMaybeExecutableFile copyFileTo copyFilesinstallOrdinaryFilesinstallExecutableFilesinstallMaybeExecutableFilesinstallDirectoryContentscopyDirectoryRecursivedoesExecutableExistdefaultTempFileOptions withTempFilewithTempFileExwithTempDirectorywithTempDirectoryEx rewriteFileEx currentDirshortRelativePathdropExeExtension exeExtensionsdefaultPackageDesctryFindPackageDescfindHookedPackageDesc $fEqTraceWhenNubListR fromNubListRNubList fromNubList toNubList overNubList toNubListR overNubListR$fStructuredNubList$fBinaryNubList $fReadNubList $fShowNubList$fSemigroupNubList$fMonoidNubList$fReadNubListR$fShowNubListR$fSemigroupNubListR$fMonoidNubListR $fEqNubList$fGenericNubList $fEqNubListR LogProgressrunLogProgress warnProgress infoProgress dieProgressaddProgressCtx$fMonadLogProgress$fApplicativeLogProgress$fFunctorLogProgresswithResponseFileProgramSearchPathEntryProgramSearchPathDirProgramSearchPathDefaultProgramSearchPathdefaultProgramSearchPathfindProgramOnSearchPathprogramSearchPathAsPATHVargetSystemSearchPath"$fStructuredProgramSearchPathEntry$fBinaryProgramSearchPathEntry$fEqProgramSearchPathEntry$fGenericProgramSearchPathEntryProgramLocation UserSpecified FoundOnSystem locationPathConfiguredProgram programIdprogramVersionprogramDefaultArgsprogramOverrideArgsprogramOverrideEnvprogramPropertiesprogramLocationprogramMonitorFilesProgArgProgram programNameprogramFindLocationprogramFindVersionprogramPostConfprogramNormaliseArgs programPathsuppressOverrideArgs simpleProgramsimpleConfiguredProgram$fStructuredProgramLocation$fBinaryProgramLocation$fStructuredConfiguredProgram$fBinaryConfiguredProgram $fShowProgram$fEqProgramLocation$fGenericProgramLocation$fReadProgramLocation$fShowProgramLocation$fEqConfiguredProgram$fGenericConfiguredProgram$fReadConfiguredProgram$fShowConfiguredProgram IOEncodingIOEncodingTextIOEncodingUTF8ProgramInvocationprogInvokePathprogInvokeArgs progInvokeEnvprogInvokePathEnv progInvokeCwdprogInvokeInputprogInvokeInputEncodingprogInvokeOutputEncodingemptyProgramInvocationsimpleProgramInvocationprogramInvocationrunProgramInvocationgetProgramInvocationOutputgetProgramInvocationLBS#getProgramInvocationOutputAndErrorsgetEffectiveEnvironmentmultiStageProgramInvocationinvocationAsSystemScriptinvocationAsShellScriptinvocationAsBatchFilemarkupunionGlobGlobSyntaxErrorStarInDirectoryStarInFileNameStarInExtensionNoExtensionOnStar EmptyGlobLiteralFileNameGlobStarVersionDoesNotSupportGlobStarVersionDoesNotSupportGlob GlobResult GlobMatchGlobWarnMultiDotGlobMissingDirectoryexplainGlobSyntaxErrorfileGlobMatches parseFileGlobmatchDirFileGlobrunDirFileGlob$fShowGlobResult$fEqGlobResult$fOrdGlobResult$fFunctorGlobResult$fEqGlobSyntaxError$fShowGlobSyntaxErrorProfDetailLevelProfDetailNoneProfDetailDefaultProfDetailExportedFunctionsProfDetailToplevelFunctionsProfDetailAllFunctionsProfDetailOtherDebugInfoLevel NoDebugInfoMinimalDebugInfoNormalDebugInfoMaximalDebugInfoOptimisationLevelNoOptimisationNormalOptimisationMaximumOptimisationPackageDBStack PackageDBGlobalPackageDB UserPackageDBSpecificPackageDBCompiler compilerIdcompilerAbiTagcompilerCompatcompilerLanguagescompilerExtensionscompilerPropertiesshowCompilerIdshowCompilerIdWithAbicompilerFlavorcompilerVersioncompilerCompatFlavorcompilerCompatVersion compilerInforegistrationPackageDBabsolutePackageDBPathsabsolutePackageDBPathflagToOptimisationLevelflagToDebugInfoLevelunsupportedLanguageslanguageToFlagsunsupportedExtensionsextensionsToFlagsparmakeSupportedreexportedModulesSupportedrenamingPackageFlagsSupportedunifiedIPIDRequiredpackageKeySupportedunitIdSupportedbackpackSupportedlibraryDynDirSupportedarResponseFilesSupportedcoverageSupportedprofilingSupportedflagToProfDetailLevelknownProfDetailLevelsshowProfDetailLevel$fStructuredPackageDB$fBinaryPackageDB$fStructuredOptimisationLevel$fBinaryOptimisationLevel$fStructuredDebugInfoLevel$fBinaryDebugInfoLevel$fStructuredCompiler$fBinaryCompiler$fStructuredProfDetailLevel$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$fShowProfDetailLevel GhcImplInfosupportsHaskell2010 reportsNoExtalwaysNondecIndentflagGhciScript flagProfAutoflagPackageConf flagDebugInfosupportsDebugLevelssupportsPkgEnvFilesflagWarnMissingHomeModules getImplInfo GhcProfAutoGhcProfAutoAllGhcProfAutoToplevelGhcProfAutoExportedGhcDynLinkMode GhcStaticOnlyGhcDynamicOnlyGhcStaticAndDynamicGhcOptimisationGhcNoOptimisationGhcNormalOptimisationGhcMaximumOptimisationGhcSpecialOptimisationGhcModeGhcModeCompile GhcModeLink GhcModeMakeGhcModeInteractiveGhcModeAbiHash GhcOptions ghcOptMode ghcOptExtraghcOptExtraDefaultghcOptInputFilesghcOptInputModulesghcOptOutputFileghcOptOutputDynFileghcOptSourcePathClearghcOptSourcePathghcOptThisUnitIdghcOptThisComponentIdghcOptInstantiatedWith ghcOptNoCodeghcOptPackageDBsghcOptPackagesghcOptHideAllPackagesghcOptWarnMissingHomeModulesghcOptNoAutoLinkPackagesghcOptLinkLibsghcOptLinkLibPathghcOptLinkOptionsghcOptLinkFrameworksghcOptLinkFrameworkDirs ghcOptNoLinkghcOptLinkNoHsMainghcOptLinkModDefFilesghcOptCcOptionsghcOptCxxOptionsghcOptAsmOptionsghcOptCppOptionsghcOptCppIncludePathghcOptCppIncludesghcOptFfiIncludesghcOptLanguageghcOptExtensionsghcOptExtensionMapghcOptOptimisationghcOptDebugInfoghcOptProfilingModeghcOptProfilingAutoghcOptSplitSectionsghcOptSplitObjs ghcOptNumJobs ghcOptHPCDirghcOptGHCiScriptsghcOptHiSuffixghcOptObjSuffixghcOptDynHiSuffixghcOptDynObjSuffix ghcOptHiDir ghcOptObjDirghcOptOutputDir ghcOptStubDirghcOptDynLinkModeghcOptStaticLib ghcOptShared ghcOptFPicghcOptDylibName ghcOptRPathsghcOptVerbosityghcOptExtraPath ghcOptCabalnormaliseGhcArgsrunGHC ghcInvocationrenderGhcOptionspackageDbArgsDb$fSemigroupGhcOptions$fMonoidGhcOptions $fShowGhcMode $fEqGhcMode$fShowGhcOptimisation$fEqGhcOptimisation$fShowGhcDynLinkMode$fEqGhcDynLinkMode$fShowGhcProfAuto$fEqGhcProfAuto$fShowGhcOptions$fGenericGhcOptionsbuiltinPrograms ghcProgram runghcProgram ghcPkgProgram ghcjsProgramghcjsPkgProgram hmakeProgram jhcProgram uhcProgram hpcProgramhaskellSuiteProgramhaskellSuitePkgProgram happyProgram alexProgram gccProgram arProgram stripProgram hsc2hsProgram c2hsProgram cpphsProgramhscolourProgramdoctestProgramhaddockProgramgreencardProgram ldProgram tarProgram cppProgrampkgConfigProgram ProgramDbemptyProgramDbdefaultProgramDbrestoreProgramDbaddKnownProgramaddKnownProgramslookupKnownProgram knownProgramsgetProgramSearchPathsetProgramSearchPathmodifyProgramSearchPathuserSpecifyPathuserMaybeSpecifyPathuserSpecifyArgsuserSpecifyPathsuserSpecifyArgssuserSpecifiedArgs lookupProgram updateProgramconfiguredProgramsconfigureProgramunconfigureProgramconfigureAllKnownProgramsreconfigureProgramsrequireProgram needProgramlookupProgramVersionrequireProgramVersion$fStructuredProgramDb$fBinaryProgramDb$fReadProgramDb$fShowProgramDb runProgramgetProgramOutput runDbProgramgetDbProgramOutputstripExestripLib CommandSpecCommand CommandType NormalCommand HiddenCommand CommandParse CommandHelp CommandList CommandErrorsCommandReadyToGo MkOptDescrArgPlaceHolderOptFlagsLFlagsSFlagsOptDescrReqArgOptArg ChoiceOptBoolOpt OptionField optionDescr DescriptionShowOrParseArgsShowArgs ParseArgs CommandUI commandNamecommandSynopsis commandUsagecommandDescription commandNotescommandDefaultFlagscommandOptions multiOptionreqArgoptArgreqArg'optArg'noArgboolOptboolOpt' choiceOptchoiceOptFromEnum liftOptioncommandShowOptions usageDefaultusageAlternatives mkCommandUIcommandParseArgs hiddenCommandcommandAddAction commandsRun noExtraFlagsgetNormalCommandDescriptions helpCommandUIcommandFromSpec$fFunctorCommandParseShowBuildInfoFlagsbuildInfoBuildFlagsbuildInfoOutputFileBenchmarkFlagsbenchmarkDistPrefbenchmarkVerbositybenchmarkOptions TestFlags testDistPref testVerbosity testHumanLogtestMachineLogtestShowDetails testKeepTix testWrappertestFailWhenNoTestSuites testOptionsTestShowDetailsNeverFailuresAlways StreamingDirect ReplFlagsreplProgramPathsreplProgramArgs replDistPref replVerbosity replReloadreplReplOptions BuildFlagsbuildProgramPathsbuildProgramArgs buildDistPrefbuildVerbosity buildNumJobs buildArgsbuildCabalFilePath CleanFlags cleanSaveConf cleanDistPrefcleanVerbositycleanCabalFilePath HaddockFlagshaddockProgramPathshaddockProgramArgs haddockHoogle haddockHtmlhaddockHtmlLocationhaddockForHackagehaddockExecutableshaddockTestSuiteshaddockBenchmarkshaddockForeignLibshaddockInternal haddockCsshaddockLinkedSourcehaddockQuickJumphaddockHscolourCsshaddockContentshaddockDistPrefhaddockKeepTempFileshaddockVerbosityhaddockCabalFilePath haddockArgs HaddockTarget ForHackageForDevelopment DoctestFlagsdoctestProgramPathsdoctestProgramArgsdoctestDistPrefdoctestVerbosity HscolourFlags hscolourCSShscolourExecutableshscolourTestSuiteshscolourBenchmarkshscolourForeignLibshscolourDistPrefhscolourVerbosityhscolourCabalFilePath RegisterFlags regPackageDB regGenScript regGenPkgConf regInPlace regDistPref regPrintId regVerbosityregArgsregCabalFilePath SDistFlags sDistSnapshotsDistDirectory sDistDistPrefsDistListSourcessDistVerbosity InstallFlagsinstallPackageDB installDestinstallDistPrefinstallUseWrapperinstallInPlaceinstallVerbosityinstallCabalFilePath CopyFlagscopyDest copyDistPref copyVerbositycopyArgscopyCabalFilePath ConfigFlags configArgsconfigPrograms_configProgramPathsconfigProgramArgsconfigProgramPathExtraconfigHcFlavor configHcPath configHcPkgconfigVanillaLib configProfLibconfigSharedLibconfigStaticLib configDynExeconfigFullyStaticExe configProfExe configProfconfigProfDetailconfigProfLibDetailconfigConfigureArgsconfigOptimizationconfigProgPrefixconfigProgSuffixconfigInstallDirsconfigScratchDirconfigExtraLibDirsconfigExtraFrameworkDirsconfigExtraIncludeDirs configIPID configCIDconfigDeterministicconfigDistPrefconfigCabalFilePathconfigVerbosityconfigUserInstallconfigPackageDBs configGHCiLibconfigSplitSectionsconfigSplitObjsconfigStripExesconfigStripLibsconfigConstraintsconfigDependenciesconfigInstantiateWithconfigConfigurationsFlags configTestsconfigBenchmarksconfigCoverageconfigLibCoverageconfigExactConfigurationconfigFlagErrorconfigRelocatableconfigDebugInfoconfigUseResponseFiles!configAllowDependingOnPrivateLibs GlobalFlags globalVersionglobalNumericVersiondefaultDistPrefdefaultGlobalFlags globalCommandemptyGlobalFlagsconfigProgramsconfigAbsolutePathsdefaultConfigFlagsconfigureCommandconfigureOptionsreadPackageDbListshowPackageDbListinstallDirsOptionsemptyConfigFlagsdefaultCopyFlags copyCommandemptyCopyFlagsdefaultInstallFlagsinstallCommandemptyInstallFlagsdefaultSDistFlags sdistCommandemptySDistFlagsdefaultRegisterFlagsregisterCommandunregisterCommandemptyRegisterFlagsemptyHscolourFlagsdefaultHscolourFlagshscolourCommanddefaultDoctestFlagsdoctestCommandemptyDoctestFlagsdefaultHaddockFlagshaddockCommandhaddockOptionsemptyHaddockFlagsdefaultCleanFlags cleanCommandemptyCleanFlagsdefaultBuildFlags buildCommand buildOptionsemptyBuildFlagsdefaultReplFlags replCommand replOptionsdefaultTestFlags testCommand testOptions'emptyTestFlagsdefaultBenchmarkFlagsbenchmarkCommandbenchmarkOptions'emptyBenchmarkFlagsprogramFlagsDescriptionprogramDbPaths'programDbOptionstrueArgfalseArgoptionDistPrefoptionVerbosity optionNumJobsdefaultShowBuildFlagsshowBuildInfoCommand configureArgsconfigureCCompilerconfigureLinker splitArgs$fSemigroupGlobalFlags$fMonoidGlobalFlags$fSemigroupConfigFlags$fMonoidConfigFlags$fEqConfigFlags$fStructuredConfigFlags$fBinaryConfigFlags$fSemigroupCopyFlags$fMonoidCopyFlags$fSemigroupInstallFlags$fMonoidInstallFlags$fSemigroupSDistFlags$fMonoidSDistFlags$fSemigroupRegisterFlags$fMonoidRegisterFlags$fSemigroupHscolourFlags$fMonoidHscolourFlags$fSemigroupDoctestFlags$fMonoidDoctestFlags$fParsecHaddockTarget$fPrettyHaddockTarget$fStructuredHaddockTarget$fBinaryHaddockTarget$fSemigroupHaddockFlags$fMonoidHaddockFlags$fSemigroupCleanFlags$fMonoidCleanFlags$fSemigroupBuildFlags$fMonoidBuildFlags$fSemigroupReplFlags$fMonoidReplFlags$fSemigroupTestShowDetails$fMonoidTestShowDetails$fParsecTestShowDetails$fPrettyTestShowDetails$fStructuredTestShowDetails$fBinaryTestShowDetails$fSemigroupTestFlags$fMonoidTestFlags$fSemigroupBenchmarkFlags$fMonoidBenchmarkFlags$fGenericGlobalFlags$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$fGenericTestShowDetails$fShowTestShowDetails$fGenericTestFlags$fGenericBenchmarkFlags$fShowShowBuildInfoFlagsparseConditionextractConditionsfreeVars finalizePDflattenPackageDescriptiontransformAllBuildInfostransformAllBuildDepends$fSemigroupDepTestRslt$fMonoidDepTestRslt$fSemigroupPDTagged$fMonoidPDTagged$fShowPDTagged defaultMaindefaultMainArgs PrettyField PrettySection showFields showFields'genericFromParsecFieldsprettyFieldLinesprettySectionArgsfromParsecFields$fSemigroupMargin$fFunctorPrettyField$fFoldablePrettyField$fTraversablePrettyField $fEqMargin ParseResultrunParseResult recoverWithsetCabalSpecVersiongetCabalSpecVersion parseWarning parseWarnings parseFailureparseFatalFailureparseFatalFailure'readAndParseFile parseString$fMonadParseResult$fApplicativeParseResult$fFunctorParseResultparseConditionConfVarPrettyFieldGrammarprettyFieldGrammar $fFieldGrammarPrettyFieldGrammar$fApplicativePrettyFieldGrammar$fFunctorPrettyFieldGrammarParsecFieldGrammar MkSection NamelessFieldMkNamelessFieldFieldsnamelessFieldAnnparseFieldGrammarfieldGrammarKnownFieldListrunFieldParser'runFieldParserfieldLinesToStream $fFieldGrammarParsecFieldGrammar$fApplicativeParsecFieldGrammar$fEqNamelessField$fShowNamelessField$fFunctorNamelessField $fEqSection $fShowSection$fFunctorSection$fFunctorParsecFieldGrammarPrettyFieldGrammar'ParsecFieldGrammar'^^^partitionFields takeFieldsBenchmarkStanza_benchmarkStanzaBenchmarkType_benchmarkStanzaMainIs_benchmarkStanzaBenchmarkModule_benchmarkStanzaBuildInfoTestSuiteStanza_testStanzaTestType_testStanzaMainIs_testStanzaTestModule_testStanzaBuildInfopackageDescriptionFieldGrammarlibraryFieldGrammarforeignLibFieldGrammarexecutableFieldGrammartestStanzaTestTypetestStanzaMainIstestStanzaTestModuletestStanzaBuildInfotestSuiteFieldGrammarvalidateTestSuiteunvalidateTestSuitebenchmarkStanzaBenchmarkTypebenchmarkStanzaMainIsbenchmarkStanzaBenchmarkModulebenchmarkStanzaBuildInfobenchmarkFieldGrammarvalidateBenchmarkunvalidateBenchmarkbuildInfoFieldGrammarflagFieldGrammarsourceRepoFieldGrammarsetupBInfoFieldGrammar$fHasBuildInfoTestSuiteStanza$fHasBuildInfoBenchmarkStanzawriteGenericPackageDescriptionshowGenericPackageDescriptionppGenericPackageDescriptionwritePackageDescriptionshowPackageDescriptionwriteHookedBuildInfoshowHookedBuildInforeadGenericPackageDescriptionparseGenericPackageDescription#parseGenericPackageDescriptionMaybereadHookedBuildInfoparseHookedBuildInfoscanSpecVersion$fFromBuildInfoBenchmarkStanza$fFromBuildInfoTestSuiteStanza$fFromBuildInfoExecutable$fFromBuildInfoForeignLib$fFromBuildInfoBuildInfo $fEqSyntax $fShowSyntax FieldDescrsfieldDescrPrettyfieldDescrParsefieldDescrsToList$fFieldGrammarFieldDescrs$fApplicativeFieldDescrs$fFunctorFieldDescrsipiFieldGrammar$fPrettyExposedModules$fParsecExposedModules$fNewtype[]ExposedModules$fParsecCompatPackageKey$fPrettyCompatPackageKey$fNewtype[]CompatPackageKey$fParsecInstWith$fPrettyInstWith$fNewtype[]InstWith$fPrettySpecLicenseLenient$fParsecSpecLicenseLenient!$fNewtypeEitherSpecLicenseLenientinstalledComponentIdinstalledOpenUnitIdrequiredSignaturessourceComponentNameparseInstalledPackageInfoshowInstalledPackageInfoshowFullInstalledPackageInfoshowInstalledPackageInfoField#showSimpleInstalledPackageInfoFieldComponentLocalBuildInfoLibComponentLocalBuildInfoFLibComponentLocalBuildInfoExeComponentLocalBuildInfoTestComponentLocalBuildInfoBenchComponentLocalBuildInfocomponentLocalNamecomponentComponentIdcomponentUnitIdcomponentIsIndefinite_componentInstantiatedWithcomponentPackageDepscomponentIncludescomponentExeDepscomponentInternalDepscomponentCompatPackageKeycomponentCompatPackageNamecomponentExposedModulescomponentIsPubliccomponentIsIndefinitemaybeComponentInstantiatedWith$fIsNodeComponentLocalBuildInfo#$fStructuredComponentLocalBuildInfo$fBinaryComponentLocalBuildInfo $fGenericComponentLocalBuildInfo$fReadComponentLocalBuildInfo$fShowComponentLocalBuildInfo TargetInfo targetCLBItargetComponent$fIsNodeTargetInfoRegisterOptionsregisterAllowOverwriteregisterMultiInstanceregisterSuppressFilesCheck HcPkgInfo hcPkgProgram noPkgDbStack noVerboseFlagsupportsDirDbsrequiresDirDbsnativeMultiInstancerecacheMultiInstancesuppressFilesCheckinvokedefaultRegisterOptionsregister unregisterrecacheexposedescribehidedumplistinitInvocationregisterInvocationunregisterInvocationrecacheInvocationexposeInvocationdescribeInvocationhideInvocationdumpInvocationlistInvocation SearchResultNone Unambiguous AmbiguousInstalledPackageIndex PackageIndexmerge deleteUnitIddeleteSourcePackageIddeletePackageName allPackagesallPackagesByNameallPackagesBySourcePackageId&allPackagesBySourcePackageIdAndLibName lookupUnitIdlookupComponentIdlookupSourcePackageIdlookupPackageIdlookupPackageNamelookupDependencylookupInternalDependency searchByNamesearchByNameSubstringdependencyCyclesbrokenPackagesdependencyClosurereverseDependencyClosuretopologicalOrderreverseTopologicalOrderdependencyGraphdependencyInconsistenciesmoduleNameIndex$fSemigroupPackageIndex$fMonoidPackageIndex$fStructuredPackageIndex$fBinaryPackageIndex$fEqPackageIndex$fGenericPackageIndex$fShowPackageIndex$fReadPackageIndexLocalBuildInfo configFlagsflagAssignmentcomponentEnabledSpecextraConfigArgsinstallDirTemplatescompiler hostPlatformbuildDir cabalFilePathcomponentGraphcomponentNameMap installedPkgs pkgDescrFile localPkgDescr withPrograms withPackageDBwithVanillaLib withProfLib withSharedLib withStaticLib withDynExewithFullyStaticExe withProfExewithProfLibDetailwithProfExeDetailwithOptimization withDebugInfo withGHCiLib splitSections splitObjs stripExes stripLibs exeCoverage libCoverage progPrefix progSuffix relocatablelocalComponentId localPackage localUnitIdlocalCompatPackageKeycomponentNameTargets' unitIdTarget'componentNameCLBIsallTargetsInBuildOrder'withAllTargetsInBuildOrder'neededTargetsInBuildOrder'withNeededTargetsInBuildOrder' testCoveragecomponentNameTargets unitIdTargetallTargetsInBuildOrderwithAllTargetsInBuildOrderneededTargetsInBuildOrderwithNeededTargetsInBuildOrder$fStructuredLocalBuildInfo$fBinaryLocalBuildInfo$fGenericLocalBuildInfo$fReadLocalBuildInfo$fShowLocalBuildInfocomponentBuildDir withLibLBI withExeLBI withBenchLBI withTestLBIenabledTestLBIsenabledBenchLBIswithAllComponentsInBuildOrderallComponentsInBuildOrderdepLibraryPaths allLibModulesabsoluteComponentInstallDirsabsoluteInstallCommandDirs"prefixRelativeComponentInstallDirsTestLogsTestLog GroupLogstestOptionsReturned testResult TestSuiteLog testSuiteNametestLogslogFile PackageLogplatformlocalPackageLogcountTestResults suitePassed suiteFailed suiteErrortestSuiteLogPathsummarizePackage summarizeTestsummarizeSuiteFinishsummarizeSuiteStart$fReadTestLogs$fShowTestLogs $fEqTestLogs$fReadTestSuiteLog$fShowTestSuiteLog$fEqTestSuiteLog$fReadPackageLog$fShowPackageLog$fEqPackageLogcombineObjectFilescreateArLibArchiveWayVanillaProfDynmixDirtixDir tixFilePathhtmlDirguessWay markupTest markupPackage $fBoundedWay $fEnumWay$fEqWay $fReadWay $fShowWay 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 haddockPrefautogenPackageModulesDirautogenComponentModulesDir cppHeaderNameautogenPathsModuleName haddockNamegetLibSourceFilesgetExeSourceFilesgetFLibSourceFilesgetSourceFiles exeBuildDir flibBuildDirmkGenericStaticLibName mkLibName mkProfLibNamemkGenericSharedLibNamemkSharedLibNamemkStaticLibNamemkGenericSharedBundledLibName exeExtension objExtension dllExtensionstaticLibExtension configuregetInstalledPackagesbuildLibbuildExe installLibregisterPackageinplacePackageDbPathCheckPackageContentOps doesFileExistdoesDirectoryExistgetDirectoryContentsgetFileContents PackageCheckPackageBuildImpossiblePackageBuildWarningPackageDistSuspiciousPackageDistSuspiciousWarnPackageDistInexcusable explanation checkPackagecheckConfiguredPackagecheckPackageFilescheckPackageContentcheckPackageFileNames$fShowPackageCheck$fEqPackageCheck$fOrdPackageCheckgeneratePathsModule pkgPathEnvVarrunTeststubName stubFilePathwriteSimpleTestStubsimpleTestStubstubMain stubWriteLoggenerateCabalMacrosHeadergeneratePackageVersionMacroscomputeComponentIdcomputeCompatPackageKeyConfiguredComponentMapConfiguredComponent cc_ann_id cc_component cc_public cc_exe_deps cc_includescc_cidcc_pkgidcc_namedispConfiguredComponenttoConfiguredComponentextendConfiguredComponentMaptoConfiguredComponentsnewPackageDepsBehaviourComponentsWithDepsComponentsGraphdispComponentsWithDepsmkComponentsGraphcomponentsGraphToListcomponentCycleMsg hstoolVersionnumericVersiongetCompilerVersion getExtensions getLanguages initPackageDB packageDbOptGhcEnvironmentFileEntryGhcEnvFileCommentGhcEnvFilePackageIdGhcEnvFilePackageDbGhcEnvFileClearPackageDbStackghcPlatformAndVersionStringsimpleGhcEnvironmentFilewriteGhcEnvironmentFilerenderGhcEnvironmentFile ParseErrorExcparseGhcEnvironmentFilereadGhcEnvironmentFile getGhcInfogetPackageDBContents getLibDirgetGlobalPackageDB getInstalledPackagesMonitorFilesreplLibstartInterpreter buildFLibreplFLibreplExe libAbiHashcomponentGhcOptionscomponentCcGhcOptions installExe installFLib isDynamic hcPkgInforunCmd mkBuildInfoinstall ModuleShapemodShapeProvidesmodShapeRequiresemptyModuleShapeshapeInstalledPackage$fModSubstModuleShape$fStructuredModuleShape$fBinaryModuleShape$fEqModuleShape$fShowModuleShape$fGenericModuleShapePreModuleShapepreModShapeProvidespreModShapeRequirestoPreModuleShaperenamePreModuleShapemixLinkPreModuleShape$fEqPreModuleShape$fShowPreModuleShape$fGenericPreModuleShapeLinkedComponentMapLinkedComponent lc_ann_id lc_component lc_exe_deps lc_public lc_includeslc_sig_includeslc_shapelc_cidlc_pkgidlc_uidlc_instsdispLinkedComponenttoLinkedComponenttoLinkedComponentsextendLinkedComponentMap$fPackageLinkedComponentModTime getModTimeposixSecondsToModTime getFileAge getCurTimecalibrateMtimeChangeDelay $fReadModTime $fShowModTime$fStructuredModTime$fBinaryModTime$fGenericModTime$fBoundedModTime $fEqModTime $fOrdModTime!configureComponentLocalBuildInfos setupMessage'generateRegistrationInfocreatePackageDBdoesPackageDBExistdeletePackageDB invokeHcPkggeneralInstalledPackageInfoinplaceInstalledPackageInfoabsoluteInstalledPackageInfointernalPackageDBPathPPSuffixHandler PreProcessorplatformIndependentrunPreProcessormkSimplePreProcessorrunSimplePreProcessorpreprocessComponent ppGreenCardppUnlitppCppppCpp'ppHsc2hsppC2hsplatformDefinesppHappyppAlex ppSuffixesknownSuffixHandlerspreprocessExtras UserHooksreadDeschookedPreProcessorshookedProgramspreConfconfHookpostConfpreBuild buildHook postBuildpreReplreplHookpostReplpreClean cleanHook postCleanpreCopycopyHookpostCopypreInstinstHookpostInstpreRegregHookpostRegpreUnreg unregHook postUnreg preHscolour hscolourHook postHscolour preDoctest doctestHook postDoctest preHaddock haddockHook postHaddockpreTesttestHookpostTestpreBench benchHook postBenchArgsemptyUserHookstestbenchConfigStateFileErrorConfigStateFileNoHeaderConfigStateFileBadHeaderConfigStateFileNoParseConfigStateFileMissingConfigStateFileBadVersiongetConfigStateFiletryGetConfigStateFiletryGetPersistBuildConfiggetPersistBuildConfigmaybeGetPersistBuildConfigwritePersistBuildConfigcheckPersistBuildConfigOutdatedlocalBuildInfoFile findDistPreffindDistPrefOrDefaultgetInternalPackagescomputeEffectiveProfilinginterpretPackageDbFlagsccLdOptionsBuildInfoconfigCompilerAuxExconfigCompilerExcheckForeignDeps$fExceptionConfigStateFileError$fShowConfigStateFileErrorsdistlistPackageSources prepareTreeprepareSnapshotTreesnapshotPackagesnapshotVersiondateToSnapshotNumber createArchiveprintPackageProblems showBuildInforeplcreateInternalPackageDBinitialBuildStepscomponentInitialBuildStepswriteAutogenFileshaddockhaddockPackagePathshscolour$fSemigroupDirectory$fMonoidDirectory$fSemigroupHaddockArgs$fMonoidHaddockArgs$fReadDirectory$fShowDirectory $fEqDirectory$fOrdDirectory$fGenericHaddockArgsdoctest$fSemigroupDoctestArgs$fMonoidDoctestArgs$fShowDoctestArgs$fGenericDoctestArgsdefaultMainWithHooksdefaultMainWithHooksArgsdefaultMainNoReaddefaultMainWithHooksNoReaddefaultMainWithHooksNoReadArgssimpleUserHooksautoconfUserHooksAsyncCancelledcancelAsyncMGHC.MVarMVar asyncThreadId GHC.Conc.SyncThreadIdAsync withAsyncuninterruptibleCancelwait waitCatch withAsyncNF byteSwap64 byteSwap32 byteSwap16 Data.BinarydecodeFileOrFail decodeFile encodeFile decodeOrFaildecodeencode GBinaryPutgput GBinaryGetggetData.Binary.PutputWord8PutData.Binary.GetgetWord8Data.Binary.Get.InternalGetopenBinaryTempFile openTempFileopenNewBinaryFileControl.Monad.Fail MonadFailJson JsonArrayJsonBoolJsonNull JsonNumber JsonObject JsonString renderJson hashToBase62bytestring-0.10.8.2Data.ByteString.Lazy.Internal ByteStringData.SemigroupLastFirstGNFDataData.ByteString.Short.InternalShortByteStringGHC.IO.Handle.Text hGetContentshPutStr GHC.IO.HandlehCloseData.ByteString.Internalpatches _makePatchKeybsRemove bsReplacebsRemoveStarting usageInfogetOptSystem.Console.GetOptArgOrdergetOpt' RequireOrderPermute ReturnInOrderOptionArgDescrNoArg StartCode LexState'parsec-3.1.13.0Text.Parsec.PrimStreamgetLexerWarnings setLexerModeSnocList runSnocListgetShortPathNamesetEnvunsetEnv lookupEnvgetEnvironmenttokenizeQuotedWordscopyFilecopyFileChanged filesEqualcopyOrdinaryFilecopyExecutableFilesetDirOrdinarylines_ Data.VersiondoesNotIntersectcombineFlagValues ShortTextLstmoduleRenamingParsecfromMapLinkPoint writePoint readPointfreshrepr equivalentparsecVerbosity verboseQuiet verboseFlag verboseNoFlag isVerboseFlag WithSource ModuleSourceModuleRequiresModuleProvides ModuleScopeemptyModuleScopeModuleWithSource FromMixinsFromBuildDependsFromExposedModulesFromOtherModulesFromSignaturesmodScopeProvidesmodScopeRequiresdispModuleSource unWithSource getSourceclassifyKnownExtensioncombineLibraryNamecomponentNameNotRequestedReasonpretty-1.1.3.6Text.PrettyPrint.HughesPJfsepvcatversion getBinDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameMarkWhen NormalMark TraceWhen AlwaysTraceioeSetVerbatimioeGetVerbatimverbatimUserErrordisplaySomeExceptionDocwrapTextVerbosity withTimestamp withMetadatawithTrailingNewlinewithCallStackPrefix traceWhen copyFilesWith readNubList formatMsgfindExecutablemarkupInvocationunionInvocation FinalMatchFinalLitGlobStem globMatchessplitConstantPrefixcheckExtextensionToFlagextensionToFlag' ghcSupportedghcjsVersionImplInfoghcVersionImplInfopackageDbArgsConfuserSpecifiedPathconfigurePrograms CommonFlag commandHelpparsecModSubstEntrydispModSubstEntryprogramDbPathsprogramDbOption TargetSet DepMapUnion DepTestRsltsimplifyWithSysParamsresolveWithFlagsaddBuildableConditionPDTaggedPDTaggedPDNulloverallDependenciesflattenTaggedTargetsBlockPSSyntaxsectionizeFields FromBuildInfoSectionS parseFields warnImportcheckForUndefinedFlagscheckForUndefinedCustomSetup parseCondTreeparseCondTreeWithCommonStanzasprocessImportsBasicSpecLicenseLenientsetMaybePackageName<+> DepUniqueKey mkTargetInfo wipeMetadatahpcDirMatchmatchInexactly findMatchUserBuildTargetSingleUserBuildTargetDoubleUserBuildTargetTriplereadUserBuildTargetshowBuildTarget' matchPlusmatchPlusShadowing exactMatchesinexactMatchescheckBuildTargetsuhcLanguageExtensionsaddBuiltinVersionsinstalledPkgConfigisPkgDirmkInstalledPackageInfo checkSanitycheckAllGhcOptionscheckGhcOptionscheckCabalVersioncheckPackageVersionscheckPathsModuleExtensions"checkDevelopmentOnlyFlagsBuildInfo checkDevelopmentOnlyFlagsOptions checkTarPath checkPackageFilesPreDistributioncheckGlobFilesisGoodRelativeFilePathisGoodRelativeGlobisGoodRelativeDirectoryPath stubRunTestsgenerateToolVersionMacrosgenerateMacrosgenerateComponentIdMacrogenerateCurrentPackageVersionmkConfiguredComponenttoConfiguredComponent'fixFakePkgNameconfigureToolchainfilterGhciFlags ghcArchString ghcOsStringghcEnvironmentFileNamerenderGhcEnvironmentFileEntrytargetPlatformcomponentCxxGhcOptionscomponentAsmGhcOptionscomponentCmmGhcOptions mkGHCiLibNamemkGHCiProfLibNameghcLookupPropertygetHaskellObjectsmkGhcOptPackages substTopDircheckPackageDbEnvVarprofDetailLevelFlag BuildSources GBuildModegbuildgetUserPackageDBflibTargetName flibBuildNameexeMainModuleNamedecodeMainIsArg gbuildSourcesifNeedsRPathWorkaroundextractRtsInfocheckNeedsRecompilationgetObjectFileName getRPathspopThreadedFlagguessToolFromGhcPathguessGhcPkgFromGhcPathguessHsc2hsFromGhcPathguessHaddockFromGhcPathtoPackageIndexgetInstalledPackages'getCompilerArgs copyPackage copyComponentinstallDataFilesinstallIncludeFilesModuleProvidesU ModuleScopeU ModuleSubstU UnitIdUniqueUnitIdU'UnitIdUModuleUModuleU'UnifRefUnifEnv unify_uniq unify_reqsunify_self_cidunify_verbosity unify_ctxunify_db unify_errsUnifyM runUnifyMliftSTGHC.STST readUnifRef writeUnifRef getUnifEnv addErrContextaddErrContextMconvertModuleSubstconvertModuleSubstUemptyModuleScopeUconvertIncludeconvertModuleScopeUconvertModuleProvidesconvertModuleProvidesUModuleWithSourceU UnitIdThunkU ModuleVarUaddErrfailWith failIfErrstryM convertUnitId convertModuleconvertUnitIdUconvertModuleUmixLink linkProvision unifyModulePreExistingComponent pc_pkgname pc_compnameipiToPreExistingComponent pc_munged_idpc_uidpc_cid pc_open_uidpc_shapegetModificationTimeposixTimeToModTime 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_iddispReadyComponentWrappedPreProcessorExtrasPreProcessorExtraspreprocessFileknownExtrasHandlersExternalDependencyInternalDependencydispConfigStateFileErrorcurrentCabalIdcurrentCompilerId parseHeader showHeadercheckDeprecatedFlagscheckExactConfigurationdependencySatisfiableconfigureFinalizedPackagecheckCompilerProblemsconfigureDependenciesconfigureCoverageconfigureProfilingselectDependencyconfigureRequiredProgramcheckPackageProblemscheckRelocatableCreateArchiveFun!listPackageSourcesMaybeExecutablelistPackageSourcesOrdinary findSetupFilemaybeCreateDefaultSetupScriptfindMainExeFilefindModDefFilefindIncludeFilefilterAutogenModulesallSourcesBuildInfo tarBallNameoverwriteSnapshotPackageDescaddExtraCSourcesaddExtraCxxSourcesaddExtraCmmSourcesaddExtraAsmSourcestestSuiteExeV10AsExebenchmarkExeV10asExetestSuiteLibV09AsLibAndExe Directory HaddockArgsargInterfaceFileargPackageNameargHideModulesargIgnoreExports argLinkSourceargLinkedSource argQuickJump argCssFile argContents argOutput argInterfaces argOutputDirargTitle argPrologue argGhcOptions argGhcLibDir argReexports argTargets runHaddock mkHaddockArgs fromLibraryfromExecutablefromForeignLib getInterfaces hscolour' DoctestArgsallSuffixHandlerstryGetBuildConfiggetBuildConfig