h&?      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                      !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""###################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%&&&&& & & & & & & & & & & & & & & & ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) * * * * * * * * * + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + , , , , , , , - - - - - - - - - - - - - - . . . . . . . . . . . . . . . . . . . . . . . . . / / / / / / / / / / / / / / / 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 7 7 7 7 7 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 : : : : : : : : : : : : : : : : : : : : : : : : : : : ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; < < < < < < < < < < < < < < < < < = = = = = = = = = = = = = > > ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ???@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIJJJJJJJJKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQRRRRRRRRRRRRRRSSTTTTTTTTTTTTTTTTUUUUUUUUUUUUUVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXYYZZZZZZZZZ[[[[[[[[[[[[[[[[\\\\\\\\\\\\\\]]]]]]]]]]]]]]^^^^^^^^^^^^^______________________________`````````````````````````````````````````````````````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddeeeeeeeeeeeeffgggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggghhiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjjjjjjjjjjjjjjjjjjjkkkllllllllllllllllllllllllmmmmmmmnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnooooooopppppppppppppppppppppqqqqrrrrrrrrrrrrrrrrrrrrrssssssssssssssssttttttttttttttttttttuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuvvvvvvvvvvvvvvvvvvvvvwwwwwwwwwwwwwwwwwwxxxyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyzzzzzzzzzzzzzzzz{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{||||||||||||||||||||||}}}}}~~~~~~~~~~~~~~~~~~~~~  Safe-InferredNN Cabal-syntax8Lazily reconstruct a value previously written to a file. PQRST Safe-InferredO+ Cabal-syntaxTry  IOException. Cabal-syntaxCatch  IOException. Cabal-syntaxCatch  Safe-InferredOb99  Safe-Inferred<S Cabal-syntaxThe FunctionalDependencies version of  type-class.Since 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 has 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. Cabal-syntax#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]10 Cabal-syntax,alaf Sum foldMap length ["cabal", "install"]12Note: as with 0, the user supplied function for the newtype is ignored. Cabal-syntax Variant of , which takes a phantom type. Cabal-syntax Variant of , which takes a phantom type. Safe-InferredT 88 cabal-devel@haskell.orgportable Safe-InferredT]  Safe-InferredU Cabal-syntaxHash a string using GHC's fingerprinting algorithm (a 128-bit MD5 hash) and then encode the resulting hash in base 62.  Safe-InferredW Cabal-syntaxShow  in human readable formshowMD5 (Fingerprint 123 456)""000000000000007b00000000000001c8" showMD5 $ md5 $ BS.pack [0..127]""37eff01866ba3f538421b30b7cbefcac"@since 3.2.0.0 Cabal-syntax@since 3.2.0.0 Cabal-syntax@since 3.2.0.0 Cabal-syntax@since 3.2.0.0 Cabal-syntax;showMD5 $ md5FromInteger 0x37eff01866ba3f538421b30b7cbefcac""37eff01866ba3f538421b30b7cbefcac"Note: the input is truncated:showMD5 $ md5FromInteger 0x1230000037eff01866ba3f538421b30b7cbefcac""37eff01866ba3f538421b30b7cbefcac"*Yet, negative numbers are not a problem...showMD5 $ md5FromInteger (-1)""ffffffffffffffffffffffffffffffff" Safe-InferredZ Cabal-syntaxDecode B 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  Cabal-syntaxEncode B! 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 Grenrus Safe-Inferred 0;<a0 Cabal-syntaxUsed to implement . Cabal-syntaxClass of types with a known .For regular data types  can be derived generically. data Record = Record { a :: Int, b :: Bool, c :: [Char] } deriving (> ) instance  Record  Cabal-syntaxStructure of a datatype.It can be infinite, as far as s involved are finite. (e.g. polymorphic recursion might cause troubles). Cabal-syntax5nominal, yet can be parametrised by other structures. Cabal-syntaxa newtype wrapper Cabal-syntaxsum-of-products structure Cabal-syntax-A semantic version of a data type. Usually 0. Cabal-syntaxA MD5 hash digest of . Cabal-syntaxA van-Laarhoven lens into  of   :: Lens'    Cabal-syntaxA van-Laarhoven lens into  of   :: Lens'    Cabal-syntaxFlatten ) into something we can calculate hash of.As  can be potentially infinite. For mutually recursive types, we keep track of s, and put just ' name when it's occurred another time. Cabal-syntax Semantically  . . Cabal-syntax Structured :. Encode a value to using binary serialisation to a lazy 5. Encoding starts with 16 byte large structure hash. Cabal-syntax"Lazily serialise a value to a file Cabal-syntax Structured . Decode a value from a lazy , reconstructing the original structure. Throws pure exception on invalid inputs. Cabal-syntax8Lazily reconstruct a value previously written to a file. Cabal-syntaxUse 8 to infer name Cabal-syntaxDerive  generically. Safe-Inferred6;d Cabal-syntaxA wrapper around L, providing the ? and @ instances implemented for L since  base-4.11. Cabal-syntax A copy of . Cabal-syntax A copy of . Cabal-syntaxGenerically 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  Cabal-syntaxGenerically generate a @ !) for any product-like type implementing >.%It is only defined for product types.   a = a =  a  ? @!"#? @!"# Safe-Inferred6eU Cabal-syntax Cabal-syntaxNote: there aren't Monoid instance.   Trustworthyg Cabal-syntaxHidden internal type-class Cabal-syntax New name for  Cabal-syntax GHC.Generics-based  implementation#This is needed in order to support  deepseq < 1.4 which didn't have a >-based default  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  implementation. $() *+, -./01 23456789:;'%&<=op>? @#!"AWZBCDEFGHIJKLXYM`^_NOPQRSTU]\V[abcdefghijklmnqutsvwxyz{|}~ () *+, -.01 2345679;'%&@#!"AWZBCDEFKLXYM`^_NOU]\vwxyz{|}~? 8/>:utsaV[ehdfg<=opqlmn$cbPQRSTGHIJijk Safe-Inferred6;o9 Cabal-syntax Compact representation of short Strings-The data is stored internally as UTF8 in an  when compiled against bytestring >= 0.10.4, and otherwise the fallback is to use plain old non-compat '[Char]'.3Note: This type is for internal uses (such as e.g.  PackageName*) and shall not be exposed in Cabal's API Cabal-syntax Construct  from B Cabal-syntaxConvert  to B Cabal-syntax"Convert from UTF-8 encoded strict  ByteString. Cabal-syntax Text whether  is empty. Cabal-syntaxO(n). Length in characters. Slow as converts to string.#Isaac Jones, Simon Marlow 2003-2004=BSD3 portions Copyright (c) 2007, Galois Inc.cabal-devel@haskell.orgportable Safe-Inferred;' Cabal-syntaxWraps text to the default line width. Existing newlines are preserved. Cabal-syntaxWraps a list of words to a list of lines of words of a particular width. Cabal-syntax?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. Cabal-syntaxWrites a file atomically.The 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. Cabal-syntaxDecode B 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). Cabal-syntax Variant of  for lazy s Cabal-syntaxEncode B to UTF8-encoded Code-points in the U+D800-U+DFFF; range will be encoded as the replacement character (i.e. U+FFFD). Cabal-syntax Variant of  for lazy s Cabal-syntaxCheck that strict  ByteString2 is valid UTF8. Returns 'Just offset' if it's not. Cabal-syntaxIgnore a Unicode byte order mark (BOM) at the beginning of the input Cabal-syntax2Reads a UTF8 encoded text file as a Unicode StringReads lazily using ordinary y. Cabal-syntax2Reads a UTF8 encoded text file as a Unicode StringSame behaviour as . Cabal-syntax4Writes a Unicode String as a UTF8 encoded text file.Uses ", so provides the same guarantees. Cabal-syntax3Fix different systems silly line ending conventions Cabal-syntaxdropWhileEndLE p is equivalent to reverse . dropWhile p . reverse, but quite a bit faster. The difference between "Data.List.dropWhileEnd" and this version is that the one in  Data.List 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:safeTail $ 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... Cabal-syntaxtakeWhileEndLE p is equivalent to reverse . takeWhile p . reverse;, but is usually faster (as well as being easier to read). Cabal-syntaxLike  , 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. Cabal-syntaxLike  and . Selects a key for each element and takes the nub based on that key. Cabal-syntax Like "Data.List.union", but has  O(n log n) complexity instead of O(n^2). Cabal-syntaxA right-biased version of .Example:ordNub [1,2,1] :: [Int][1,2]ordNubRight [1,2,1] :: [Int][2,1] Cabal-syntaxA 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] Cabal-syntaxA total variant of h. Cabal-syntaxA total variant of d. Cabal-syntaxA total variant of f. Cabal-syntaxA total variant of g. Cabal-syntaxLower case stringlowercase "Foobar""foobar" Cabal-syntaxAscii characters Cabal-syntaxAscii letters. Cabal-syntaxAscii letters and digits.isAsciiAlphaNum 'a'TrueisAsciiAlphaNum ''False Cabal-syntaxLike  , but with L predicatebreakMaybe (readMaybe :: String -> Maybe Int) ["foo", "bar", "1", "2", "quu"]$(["foo","bar"],Just (1,["2","quu"])) Maybe Int) ["foo", "bar"](["foo","bar"],Nothing) Cabal-syntaxLike  but with L 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"]) Cabal-syntax with monadic action. Just (r + b, b + 1)) (1 :: Int) 2 [3,4,5,6,7] Cabal-syntaxThe opposite of snoc, which is the reverse of consExample:unsnoc [1, 2, 3]Just ([1,2],3) unsnoc []Nothing Cabal-syntaxLike  , but for V so without the LExample:unsnocNE (1 :| [2, 3]) ([1,2],3)unsnocNE (1 :| [])([],1) Cabal-syntax Cabal-syntax Cabal-syntax Cabal-syntax and  are like  and  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. Cabal-syntax  isRelativeOnAnyPlatform = not . ,, Safe-Inferred6;  Cabal-syntax?A boolean expression parameterized over the variable type used. Cabal-syntaxBoolean negation of a  value. Cabal-syntaxBoolean AND of two  values. Cabal-syntaxBoolean OR of two  values. Cabal-syntax5Simplify the condition and return its free variables. Cabal-syntax(partial) variable assignment   Safe-Inferred;A Cabal-syntax-1-indexed row and column positions in a file. Cabal-syntax)Shift position by n columns to the right. Cabal-syntax(Shift position to beginning of next row. Cabal-syntax Cabal-syntax Safe-Inferred; Cabal-syntaxParser warning. Cabal-syntax0Type of parser warning. We do classify warnings.Different application may decide not to show some, or have fatal behaviour on others Cabal-syntaxUnclassified warning Cabal-syntaxInvalid UTF encoding Cabal-syntaxtrue or false, not True or False Cabal-syntaxthere are version with tags Cabal-syntaxNew syntax used, but no cabal-version: >= 1.2 specified Cabal-syntaxOld syntax used, and cabal-version >= 1.2 specified Cabal-syntaxextra main-is field Cabal-syntaxextra test-module field Cabal-syntaxextra benchmark-module field Cabal-syntax+legacy cabal file that we know how to patch Cabal-syntaxDouble dash token, most likely it's a mistake - it's not a comment Cabal-syntax3e.g. name or version should be specified only once. Cabal-syntax>Workaround for derive-package having build-type: Default. See  ,https://github.com/haskell/cabal/issues/5020. Cabal-syntax3Version operators used (without cabal-version: 1.8) Cabal-syntax2Version wildcard used (without cabal-version: 1.6) Cabal-syntax$Warnings about cabal-version format. Cabal-syntax!Empty filepath, i.e. literally "" Cabal-syntaxExperimental feature Safe-Inferred" Cabal-syntaxThis is essentially a lazy bytestring, but chunks are glued with newline '\n'. Cabal-syntaxConvert B to .Note: inefficient! Safe-Inferred;v Cabal-syntax Parser error. Safe-Inferred"p Cabal-syntax 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. Cabal-syntax contains first 256 bytes, pre- and post-fingerprints and a patch function. Cabal-syntax#Helper to create entries in patches Cabal-syntaxneedle Cabal-syntaxneedle Cabal-syntax replacement Cabal-syntaxneedleBSD3cabal-devel@haskell.orgportable Safe-Inferred  Cabal-syntax"position at current input location Cabal-syntaxthe current input Cabal-syntax lexer code Cabal-syntaxEncountered non breaking space Cabal-syntax"BOM at the start of the cabal file Cabal-syntax Leading tags Cabal-syntax5Execute the given lexer on the supplied input stream. Cabal-syntax#Add warning at the current position Cabal-syntax Add warning at specific position Cabal-syntaxAn alex lexer start codeBSD3cabal-devel@haskell.orgportable Safe-Inferred Cabal-syntaxTokens of outer cabal file structure. Field values are treated opaquely. Cabal-syntax+Haskell-like identifier, number or operator Cabal-syntaxString in quotes Cabal-syntaxOperators and parens Cabal-syntaxIndentation token Cabal-syntax Lines after :(c) Edward Kmett 2011-2012BSD3ekmett@gmail.com experimental non-portable Safe-Inferred)*m Cabal-syntaxAdditional functionality needed to describe parsers independent of input type. Cabal-syntaxTake a parser that may consume input, and on failure, go back to where we started and fail as if we didn't consume input. Cabal-syntaxGive a parser a name Cabal-syntaxA version of many that discards its input. Specialized because it can often be implemented more cheaply. Cabal-syntax skipSome p applies the parser p one? or more times, skipping its result. (aka skipMany1 in parsec) Cabal-syntax,Used to emit an error on an unexpected token Cabal-syntaxThis 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" Cabal-syntaxnotFollowedBy 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 alphaNum Cabal-syntax choice ps( tries to apply the parsers in the list ps in order, until one of them succeeds. Returns the value of the succeeding parser. Cabal-syntax 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) Cabal-syntaxskipOptional 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 p. (Plays the role of parsec's optional, which conflicts with Applicative's optional) Cabal-syntaxbetween open close p parses open, followed by p and close!. Returns the value returned by p. , braces = between (symbol "{") (symbol "}") Cabal-syntax 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 ",") Cabal-syntaxsepByNonEmpty p sep parses one or more occurrences of p, separated by sep1. Returns a non-empty list of values returned by p. Cabal-syntaxsepEndByNonEmpty 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. Cabal-syntaxsepEndBy p sep parses zero or more occurrences of p%, separated and optionally ended by sep, ie. haskell style statements. Returns a list of values returned by p. 6 haskellStatements = haskellStatement `sepEndBy` semi Cabal-syntaxendByNonEmpty 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-syntax 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` semi Cabal-syntax 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-syntax 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-syntax 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. Cabal-syntaxchainl1 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 p. . 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 "-" Cabal-syntaxchainr1 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. Cabal-syntaxmanyTill 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:  simpleComment = do{ string "")) }Note the overlapping parsers anyChar and  string "-->"#, and therefore the use of the  combinator.rr0(c) Ben Gamari 2015-2019BSD3cabal-dev@haskell.org experimentalportable Safe-Inferred Cabal-syntaxDifference list. Cabal-syntaxMake  containing single element. Cabal-syntax Safe-Inferred Cabal-syntaxlens, variant is also parametrised by profunctor. Cabal-syntax)(3 :: Int) ^. getting (+2) . getting show"5" Cabal-syntax" is a reverse application operator%% 18444444844 Safe-Inferred689:;  Cabal-syntaxA ( represents a conditional branch, e.g.,  if flag(foo) on some syntax a). It also has an optional false branch. Cabal-syntaxA  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: build-depends: base >= 4.0 if flag(extra) build-depends: base >= 4.2 %One way to represent this is to have  ConfVar [ Dependency]  BuildInfo . Here,  represents the actual fields which are not behind any conditional, while  recursively records any further fields which are behind a conditional. ) records the constraints (in this case,  base >= 4.0) 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-syntax@ Traversal@ for the variables Cabal-syntax@ Traversal@ for the variables Cabal-syntax@ Traversal @ for the aggregated constraints Cabal-syntax@ Traversal @ for the aggregated constraints Cabal-syntaxExtract the condition matched by the given predicate from a cond tree.We use this mainly for extracting buildable conditions (see the Note in Distribution.PackageDescription.Configuration), but the function is in fact more general. Cabal-syntaxFlattens a CondTree using a partial flag assignment. When a condition cannot be evaluated, both branches are ignored. Cabal-syntaxFlatten 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. Cabal-syntaxFlatten a CondTree. This will traverse the CondTree by taking all possible paths into account, but merging inclusive when two paths may co-exist, and exclusively when the paths are an if/else(c) Edward Kmett 2011BSD3ekmett@gmail.com experimental non-portable Safe-Inferred)* Cabal-syntax;Additional functionality needed to parse character streams. Cabal-syntax:Parse a single character of the input, with UTF-8 decoding Cabal-syntaxchar c parses a single character c&. Returns the parsed character (i.e. c).e.g.  semiColon =  ';' Cabal-syntax notChar c( parses any single character other than c . Returns the parsed character. Cabal-syntaxThis parser succeeds for any character. Returns the parsed character. Cabal-syntaxstring s* parses a sequence of characters given by s#. Returns the parsed string (i.e. s). ; divOrMod = string "div" <|> string "mod" Cabal-syntaxtext 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" Cabal-syntaxoneOf cs succeeds if the current character is in the supplied list of characters cs*. Returns the parsed character. See also .  vowel = oneOf "aeiou" Cabal-syntaxAs 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" Cabal-syntaxSkips zero* or more white space characters. See also . Cabal-syntax>Parses a white space character (any character which satisfies  ) Returns the parsed character. Cabal-syntax?Parses a newline character ('\n'). Returns a newline character. Cabal-syntax7Parses a tab character ('\t'). Returns a tab character. Cabal-syntax:Parses an upper case letter. Returns the parsed character. Cabal-syntax 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 8 instance using a different (and more compact) encoding. Cabal-syntax#An integral without leading zeroes. Cabal-syntax 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  . Cabal-syntaxVersion 0. A lower bound of . Cabal-syntax Variant of  which converts a  Data.Version  into Cabal's  type.  Cabal-syntaxUnpack ( into list of version number components.This is the inverse to , so the following holds: %(versionNumbers . mkVersion) vs == vs  Cabal-syntax"Constant representing the special null The   compares (via 2) as less than every proper  value.  Cabal-syntax3Apply function to list of version number components 0alterVersion f == mkVersion . f . versionNumbers    ' Safe-Inferred "689:;  Cabal-syntax F-Algebra of  . See  .  Cabal-syntax == version.  Cabal-syntax > version . NB: not >=  Cabal-syntax >= version.  Cabal-syntax < version.  Cabal-syntax <= version.  Cabal-syntax ^>= version , same as >= version && < MAJ(version)+1.  Cabal-syntax||.  Cabal-syntax&&.  Cabal-syntaxThe version range -any4. That is, a version range containing all versions. withinRange v anyVersion = True  Cabal-syntaxThe empty version range -none1, that is a version range containing no versions.This can be constructed using any unsatisfiable version range expression, for example < 0. withinRange v noVersion = False  Cabal-syntaxThe version range == v. (withinRange v' (thisVersion v) = v' == v  Cabal-syntaxThe version range /= v. +withinRange v' (notThisVersion v) = v' /= v  Cabal-syntaxThe version range > v. (withinRange v' (laterVersion v) = v' > v  Cabal-syntaxThe version range >= v. +withinRange v' (orLaterVersion v) = v' >= v  Cabal-syntaxThe version range < v. *withinRange v' (earlierVersion v) = v' < v  Cabal-syntaxThe version range <= v. -withinRange v' (orEarlierVersion v) = v' <= v  Cabal-syntaxThe version range  vr1 || vr2.  withinRange v' (unionVersionRanges vr1 vr2) = withinRange v' vr1 || withinRange v' vr2  Cabal-syntaxThe version range  vr1 && vr2.  withinRange v' (intersectVersionRanges vr1 vr2) = withinRange v' vr1 && withinRange v' vr2  Cabal-syntaxThe version range == v.*.For example, for version 1.2, the version range == 1.2.* is the same as >= 1.2 && < 1.3. withinRange v' (withinVersion v) = v' >= v && v' < upper v where upper (Version lower t) = Version (init lower ++ [last lower + 1]) t  Cabal-syntaxThe 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.  Cabal-syntaxGeneric destructor for  .  Cabal-syntaxFold  .  Cabal-syntaxGeneric constructor for  .  Cabal-syntaxUnfold  .  Cabal-syntaxRefold  . Cabal-syntax+Don't use && and || operators. If possible.  Cabal-syntax - parser parametrised by version digit parser. is used for all  . is used for backward-compat pkgconfig-depends versions, PkgConfigVersionRange.  Cabal-syntax=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  Cabal-syntax"Increment the last version number. Example: For 1.2 this returns 1.37 so that it can be used as upper bound when resolving == 1.2.*. For 0.4.1 it returns 0.4.2.  Cabal-syntax,simpleParsec "^>= 3.4" :: Maybe VersionRange*Just (MajorBoundVersion (mkVersion [3,4]))Small history:-any and -none removed in 3.4 Use >=0 and <0 instead.map (`simpleParsec'` "-none") [CabalSpecV3_0, CabalSpecV3_4] :: [Maybe VersionRange]/[Just (EarlierVersion (mkVersion [0])),Nothing]$Set operations are introduced in 3.0map (`simpleParsec'` "^>= { 1.2 , 1.3 }") [CabalSpecV2_4, CabalSpecV3_0] :: [Maybe VersionRange][Nothing,Just (UnionVersionRanges (MajorBoundVersion (mkVersion [1,2])) (MajorBoundVersion (mkVersion [1,3])))]^>= is introduced in 2.0map (`simpleParsec'` "^>=1.2") [CabalSpecV1_24, CabalSpecV2_0] :: [Maybe VersionRange]4[Nothing,Just (MajorBoundVersion (mkVersion [1,2]))]-none is introduced in 1.22map (`simpleParsec'` "-none") [CabalSpecV1_20, CabalSpecV1_22] :: [Maybe VersionRange]/[Nothing,Just (EarlierVersion (mkVersion [0]))]7Operators are introduced in 1.8. Issues only a warning.map (`simpleParsecW'` "== 1 || ==2") [CabalSpecV1_6, CabalSpecV1_8] :: [Maybe VersionRange][Nothing,Just (UnionVersionRanges (ThisVersion (mkVersion [1])) (ThisVersion (mkVersion [2])))]Wild-version ranges are introduced in 1.6. Issues only a warning.map (`simpleParsecW'` "== 1.2.*") [CabalSpecV1_4, CabalSpecV1_6] :: [Maybe VersionRange][Nothing,Just (IntersectVersionRanges (OrLaterVersion (mkVersion [1,2])) (EarlierVersion (mkVersion [1,3])))]  Cabal-syntaxfmap pretty (simpleParsec' CabalSpecV1_6 "== 3.2.*" :: Maybe VersionRange)Just >=3.2 && <3.3fmap (prettyVersioned CabalSpecV1_6) (simpleParsec' CabalSpecV1_6 "== 3.2.*" :: Maybe VersionRange) Just ==3.2.*fmap pretty (simpleParsec' CabalSpecV1_6 "-any" :: Maybe VersionRange)Just >=0fmap (prettyVersioned CabalSpecV1_6) (simpleParsec' CabalSpecV1_6 "-any" :: Maybe VersionRange)Just >=0& & ( Safe-Inferred6  Cabal-syntax(v,.. if used as lower bound, ..,v) if used as upper bound.  Cabal-syntax[v,.. if used as lower bound, ..,v] if used as upper bound.  Cabal-syntax ..,D)  Cabal-syntaxEither exclusive ..,v) or inclusive ..,v].  Cabal-syntaxEither exclusive (v,.. or inclusive [v,...  Cabal-syntaxVersion intervals with exclusive or inclusive bounds, in all combinations:  (lb,ub)  meaning  lb < \_ < ub . (lb,ub]  meaning  lb < \_ D ub . [lb,ub)  meaning  lb D \_ < ub . [lb,ub]  meaning  lb D \_ < ub ..The upper bound can also be missing, meaning " ..,D) ".  Cabal-syntax$A complementary representation of a  , using an increasing sequence of separated (i.e., non-overlapping, non-touching) non-empty intervals. The represented range is the union of these intervals, meaning that the empty sequence denotes the empty range.As ranges form a Boolean algebra, we can compute union, intersection, and complement. These operations are all linear in the size of the input, thanks to the ordered representation.The interval-sequence representation gives a canonical representation for the semantics of  s. 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 (just ) 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.  Cabal-syntaxView a  & as a sequence of separated 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 foldVersionRange. Canonical; means that two semantically equal ranges translate to the same [ ] , thus its *4 instance can decide semantical equality of ranges.In the returned sequence, each interval is non-empty. The sequence is in increasing order and the intervals are separated, i.e., they neither overlap nor touch. Therefore only the first and last interval can be unbounded. The sequence can be empty if the range is empty (e.g. a range expression like  > 2 && < 1).Other checks are trivial to implement using this view. For example: isNoVersion vr | [] <- asVersionIntervals vr = True | otherwise = False isSpecificVersion vr | [(LowerBound v InclusiveBound ,UpperBound v' InclusiveBound)] <- asVersionIntervals vr , v == v' = Just v | otherwise = Nothing  Cabal-syntax&Inspect the list of version intervals. Cabal-syntax[0,... Cabal-syntaxCheck that the sequence is ordered, adjacent intervals are separated (do not overlap), an no interval is empty (which would be a redundant entry). Cabal-syntax9The partial identity function, erroring out on illformed  .  Cabal-syntaxDirectly construct a   from a list of intervals. Cabal-syntaxAdd an interval to the sequence, fusing with existing intervals if necessary. Cabal-syntaxA valid interval is non-empty. Cabal-syntax$Check that an interval is non-empty. Cabal-syntaxCheck an upper bound does not intersect, or even touch a lower bound:  ---| or ---) but not ---] or ---) or ---] |--- (--- (--- [--- [---  Cabal-syntax6Check an upper bound does not intersect a lower bound:  ---| or ---) or ---] or ---) but not ---] |--- (--- (--- [--- [---  Cabal-syntax5Test if a version falls within the version intervals.It 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-syntax Convert a  $ to a sequence of version intervals.  Cabal-syntax Convert a   value back into a  0 expression representing the version intervals.  Cabal-syntaxUnion two interval sequences, fusing intervals where necessary. Computed  O(n+m) ' time, resulting in sequence of length  D n+m . Cabal-syntaxGiven two version intervals i1 and i2, return one of the following:  Left Nothingwhen i1 < i2! and the intervals are separated. Right Nothingwhen i2 < i1! and the intervals are separated.Left (i1 / i2)when ub(i1) <= ub(i2)% and the intervals are not separated.Right (i1 / i2)when ub(i2) < ub(i1)% and the intervals are not separated.Herein, i < i'& means that the whole of the interval i" is strictly left of the whole of i', and ub(i)( returns the right boundary of interval i' which could be inclusive or exclusive.  Cabal-syntaxThe intersection  is \cap is'  of two interval sequences  is  and  is'  of lengths  n  and  m &, resp., satisfies the specification / is D is' = \{ i D i' \mid i D is, i' D is' \} . Thanks to the ordered representation of intervals it can be computed in  O(n+m)  (rather than the naive  O(nm) .The length of  is \cap is'  is  D \min(n,m) . Cabal-syntaxGiven two version intervals i1 and i2, return one of the following:  Left Nothingwhen i1 < i2. Right Nothingwhen i2 < i1.Left (i1 / i2)when ub(i1) <= ub(i2).Right (i1 / i2)when ub(i2) < ub(i1).Herein, i < i'& means that the whole of the interval i" is strictly left of the whole of i', and ub(i)( returns the right boundary of interval i' which could be inclusive or exclusive.  Cabal-syntaxCompute the complement.  O(n) .  Cabal-syntaxRemove the last upper bound, enlarging the range. But empty ranges stay empty.  O(n) .  Cabal-syntax+Remove the first lower bound (i.e, make it  [0 . Empty ranges stay empty.  O(1) .  Cabal-syntax ub1 <= ub2 holds iff interval 0..ub1 is contained in interval 0..ub2.  Cabal-syntax lb1 <= lb2 holds iff interval lb1.. is contained in interval lb2...  ) Safe-Inferred6"  Cabal-syntax$A complementary representation of a  . Instead of a boolean version predicate it uses an increasing sequence of non-overlapping, non-empty intervals.The key point is that this representation gives a canonical representation for the semantics of  s. 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.  Cabal-syntax&Inspect the list of version intervals. Cabal-syntax Check that interval is non-empty Cabal-syntaxPost-processing takes a list of ordered version intervals, but possibly overlapping, and creates  .  Cabal-syntaxView 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 foldVersionRange.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).Other checks are trivial to implement using this view. For example: isNoVersion vr | [] <- asVersionIntervals vr = True | otherwise = False isSpecificVersion vr | [(LowerBound v InclusiveBound ,UpperBound v' InclusiveBound)] <- asVersionIntervals vr , v == v' = Just v | otherwise = Nothing Cabal-syntaxCheck an upper bound does not intersect, or even touch a lower bound:  ---| or ---) but not ---] or ---) or ---] |--- (--- (--- [--- [---  Cabal-syntax  invariant:all intervals are valid (lower bound is less then upper bound, i.e. non-empty)-intervals doesn't touch each other (distinct)  Cabal-syntax Convert a  $ to a sequence of version intervals.  Cabal-syntax Convert a   value back into a  0 expression representing the version intervals.  Cabal-syntaxSince  Cabal-3.6 this function.. TODO  * Safe-Inferred)/  Cabal-syntax-Fold over the basic syntactic structure of a  .This 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  .  Cabal-syntax Normalise  .In particular collapse  (== v || > v) into >= v , and so on.  Cabal-syntaxRemove VersionRangeParens constructors.#Since version 3.4 this function is , there aren't VersionRangeParens constructor in   anymore.  Cabal-syntax.Does this version fall within the given range?(This is the evaluation function for the   type.  Cabal-syntax 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). isAnyVersion (EarlierVersion v `UnionVersionRanges` orLaterVersion v)  Cabal-syntax+Does the version range have an upper bound?  Cabal-syntax4Does the version range have an explicit lower bound?Note: this function only considers the user-specified lower bounds, but not the implicit >=0 lower bound.  Cabal-syntax"-any" version Cabal-syntax "== v" Cabal-syntax "> v" Cabal-syntax "< v" Cabal-syntax"_ || _" union Cabal-syntax"_ && _" intersection' ' + Safe-Inferred6;6  Cabal-syntaxAn enumeration of common source control systems. The fields used in the   depend on the type of repo. The tools and methods used to obtain and track the repo depend on the repo type.  Cabal-syntax  Cabal-syntax/What this repo info is for, what it represents.  Cabal-syntaxThe 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.  Cabal-syntaxThe 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.  Cabal-syntaxInformation 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-syntax)The kind of repo. This field is required.  Cabal-syntax;The type of the source repository system for this repo, eg   or  . This field is required.  Cabal-syntax)The location of the repository. For most  )s this is a URL. This field is required.  Cabal-syntax  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.  Cabal-syntaxThe 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.  Cabal-syntaxThe tag identify a particular state of the repository. This should be given for the   repo kind and not for   kind.  Cabal-syntaxSome repositories contain multiple projects in different subdirectories This field specifies the subdirectory where this packages sources can be found, eg the subdirectory containing the .cabal file. It is interpreted relative to the root of the repository. This field is optional. If not given the default is "." ie no subdirectory.  , Safe-Inferred6  - Safe-Inferred6;8w  Cabal-syntax pkg-config versions.In fact, this can be arbitrary , but  instance is a little pickier.  Cabal-syntaxCompare two version strings as  pkg-config would compare them.  Cabal-syntax/simpleParsec "1.0.2n" :: Maybe PkgconfigVersion Just (PkgconfigVersion "1.0.2n")1simpleParsec "0.3.5+ds" :: Maybe PkgconfigVersionNothing  . Safe-Inferred6;9  Cabal-syntax  Cabal-syntax2018-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.  Cabal-syntax8Converts an unqualified component name to a package name  is the inverse of  .Useful in legacy situations where a package name may refer to an internal component, if one is defined with that name.  Cabal-syntax   3 Safe-Inferred"6;C  Cabal-syntaxMulti-lib visibility  Cabal-syntax.Can be used as a dependency for other packages  Cabal-syntaxInternal library, default  4 Safe-Inferred6;D  Cabal-syntax Pretty print   in build-target-ish syntax.Note: there are no  or / instances, as there's other way to represent  , namely as bare  .  Cabal-syntax Convert the   of a library into a  . 5 Safe-Inferred6;P  Cabal-syntaxA 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 B.In 3.0.0.0 representation was changed from opaque (string) to semantic representation.  Cabal-syntaxIntended for internal use only,decodeCompatPackageName "z-servant-z-lackey"MungedPackageName (PackageName "servant") (LSubLibName (UnqualComponentName "lackey"))  Cabal-syntaxIntended for internal use onlyencodeCompatPackageName $ MungedPackageName "servant" (LSubLibName "lackey") PackageName "z-servant-z-lackey"This is used in  cabal-install in the Solver. May become obsolete as solver moves to per-component solving.  Cabal-syntax1simpleParsec "servant" :: Maybe MungedPackageName=Just (MungedPackageName (PackageName "servant") LMainLibName) (  .   ) fa == fa  Cabal-syntax Test whether   is empty.  Cabal-syntaxLookup the value for a flagReturns X$ if the flag isn't contained in the  .  Cabal-syntax-Insert or update the boolean value of a flag.&If the flag is already present in the  , 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-syntax+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-syntax Find the  's that have been listed more than once.  Cabal-syntax+String representation of a flag-value pair.  Cabal-syntax Pretty-prints a flag assignment.  Cabal-syntaxParses a flag assignment.  Cabal-syntax!Parse a non-empty flag assignment6The flags have to explicitly start with minus or plus.  Cabal-syntaxShow flag assignment.  Cabal-syntaxWe need this as far as we support custom setups older than 2.2.0.0  Cabal-syntax Cabal-syntax  Cabal-syntaxWe need this as far as we support custom setups older than 2.2.0.0  Cabal-syntax  Cabal-syntax'simpleParsec "" :: Maybe FlagAssignmentJust (fromList [])0simpleParsec "+foo -bar" :: Maybe FlagAssignmentJust (fromList [(FlagName "bar",(1,False)),(FlagName "foo",(1,True))])1simpleParsec "-none -any" :: Maybe FlagAssignmentJust (fromList [(FlagName "any",(1,False)),(FlagName "none",(1,False))]):simpleParsec "+foo -foo +foo +foo" :: Maybe FlagAssignment+Just (fromList [(FlagName "foo",(4,True))])4simpleParsec "+foo -bar baz" :: Maybe FlagAssignmentNothing"Issue #7279 was fixed in Cabal-3.8explicitEitherParsec (parsecCommaList parsec) "+foo , -bar" :: Either String [FlagAssignment]Right [fromList [(FlagName "foo",(1,True))],fromList [(FlagName "bar",(1,False))]]explicitEitherParsec (parsecCommaList parsecFlagAssignmentNonEmpty) "+foo , -bar" :: Either String [FlagAssignment]Right [fromList [(FlagName "foo",(1,True))],fromList [(FlagName "bar",(1,False))]]/simpleParsec "+foo+foo" :: Maybe FlagAssignmentNothing  Cabal-syntax  Cabal-syntax  Cabal-syntax  9 Safe-Inferred"6;d  Cabal-syntax! =   Cabal-syntaxAny like semigroup, where   is 'Any True'  : Safe-Inferred6;e  Cabal-syntaxThis gets the underlying unqualified component name. In fact, it is guaranteed to uniquely identify a component, returning Nothing if the   was for the public library.  ; Safe-Inferred6;g  Cabal-syntaxA   uniquely identifies the transitive source code closure of a component (i.e. libraries, executables).For non-Backpack components, this corresponds one to one with the UnitId, which serves as the basis for install paths, linker symbols, etc.Use   and   to convert from/to a B.This type is opaque since  Cabal-2.0  Cabal-syntax Construct a   from a B  is the inverse to  Note: No validations are performed to ensure that the resulting   is valid  Cabal-syntaxConvert   to B  Cabal-syntax   < Safe-Inferred"6;i  Cabal-syntax.The type of build system used by this package.  Cabal-syntaxcalls Distribution.Simple.defaultMain  Cabal-syntaxcalls 9Distribution.Simple.defaultMainWithHooks defaultUserHooks, which invokes  configure to generate additional build information used by later phases.  Cabal-syntaxcalls Distribution.Make.defaultMain  Cabal-syntaxuses user-supplied Setup.hs or  Setup.lhs (default)  = Safe-Inferred6;k  Cabal-syntax ABI HashesUse   and   to convert from/to a B.This type is opaque since  Cabal-2.0  Cabal-syntaxConvert   to B  Cabal-syntax Construct a   from a B  is the inverse to  Note: No validations are performed to ensure that the resulting   is valid  Cabal-syntax   > Safe-Inferredk  ?Duncan Coutts 2007-2008cabal-devel@haskell.orgportable Safe-Inferred6;si  Cabal-syntaxThese are the known Arches: I386, X86_64, PPC, PPC64, Sparc, Arm, AArch64, Mips, SH, IA64, S390, S390X, Alpha, Hppa, Rs6000, M68k, Vax, JavaScript and Wasm32.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: arm64  Cabal-syntaxThese are the known OS names: Linux, Windows, OSX ,FreeBSD, OpenBSD, NetBSD, DragonFly ,Solaris, AIX, HPUX, IRIX ,HaLVM ,Hurd ,IOS, Android, Ghcjs, WasiThe following aliases can also be used:, * Windows aliases: mingw32, win32, cygwin32 * OSX alias: darwin * Hurd alias: gnu * FreeBSD alias: kfreebsdgnu * Solaris alias: solaris2  Cabal-syntax3How strict to be when classifying strings into the   and   enums.The 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 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.  Cabal-syntax4The platform Cabal was compiled on. In most cases, LocalBuildInfo.hostPlatform8 should be used instead (the platform we're targeting).6 6 @ Safe-Inferred6;u Cabal-syntax,AuserdefinedlicensereferencedenotedbyLicenseRef-[idstring].(foralicensenotontheSPDX LicenseList) Cabal-syntaxLicense reference. Cabal-syntaxDocument reference. Cabal-syntaxCreate % from optional document ref and name. Cabal-syntaxLike % but convert invalid characters into -.A Safe-Inferred6 Cabal-syntax#SPDX License identifiers list v3.16 Cabal-syntax0BSD, BSD Zero Clause License Cabal-syntaxAAL, Attribution Assurance License Cabal-syntaxAbstyles, Abstyles License Cabal-syntax Adobe-2006:, Adobe Systems Incorporated Source Code License Agreement Cabal-syntax Adobe-Glyph, Adobe Glyph List License Cabal-syntaxADSL!, Amazon Digital Services License Cabal-syntaxAFL-1.1, Academic Free License v1.1 Cabal-syntaxAFL-1.2, Academic Free License v1.2 Cabal-syntaxAFL-2.0, Academic Free License v2.0 Cabal-syntaxAFL-2.1, Academic Free License v2.1 Cabal-syntaxAFL-3.0, Academic Free License v3.0 Cabal-syntaxAfmparse, Afmparse License Cabal-syntaxAGPL-1.0;, Affero General Public License v1.0, SPDX License List 3.0 Cabal-syntax AGPL-1.0-only, Affero General Public License v1.0 only, SPDX License List 3.2, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxAGPL-1.0-or-later, Affero General Public License v1.0 or later, SPDX License List 3.2, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntax AGPL-3.0-only-, GNU Affero General Public License v3.0 only Cabal-syntaxAGPL-3.0-or-later1, GNU Affero General Public License v3.0 or later Cabal-syntaxAladdin, Aladdin Free Public License Cabal-syntaxAMDPLPA, AMD's plpa_map.c License Cabal-syntaxAML, Apple MIT License Cabal-syntaxAMPAS1, Academy of Motion Picture Arts and Sciences BSD Cabal-syntaxANTLR-PD-fallback, ANTLR Software Rights Notice with license fallback, SPDX License List 3.16 Cabal-syntaxANTLR-PD, ANTLR Software Rights Notice Cabal-syntax Apache-1.0, Apache License 1.0 Cabal-syntax Apache-1.1, Apache License 1.1 Cabal-syntax Apache-2.0, Apache License 2.0 Cabal-syntaxAPAFML, Adobe Postscript AFM License Cabal-syntaxAPL-1.0, Adaptive Public License 1.0 Cabal-syntaxApp-s2p*, App::s2p License, SPDX License List 3.16 Cabal-syntaxAPSL-1.0!, Apple Public Source License 1.0 Cabal-syntaxAPSL-1.1!, Apple Public Source License 1.1 Cabal-syntaxAPSL-1.2!, Apple Public Source License 1.2 Cabal-syntaxAPSL-2.0!, Apple Public Source License 2.0 Cabal-syntaxArtistic-1.0-cl8!, Artistic License 1.0 w/clause 8 Cabal-syntaxArtistic-1.0-Perl, Artistic License 1.0 (Perl) Cabal-syntax Artistic-1.0, Artistic License 1.0 Cabal-syntax Artistic-2.0, Artistic License 2.0 Cabal-syntaxBahyph, Bahyph License Cabal-syntaxBarr, Barr License Cabal-syntaxBeerware, Beerware License Cabal-syntaxBitTorrent-1.0%, BitTorrent Open Source License v1.0 Cabal-syntaxBitTorrent-1.1%, BitTorrent Open Source License v1.1 Cabal-syntaxblessing, SQLite Blessing, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntax BlueOak-1.0.0, Blue Oak Model License 1.0.0, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxBorceux, Borceux license Cabal-syntax BSD-1-Clause, BSD 1-Clause License Cabal-syntaxBSD-2-Clause-FreeBSD, BSD 2-Clause FreeBSD License, SPDX License List 3.0, SPDX License List 3.2, SPDX License List 3.6, SPDX License List 3.9 Cabal-syntaxBSD-2-Clause-NetBSD, BSD 2-Clause NetBSD License, SPDX License List 3.0, SPDX License List 3.2, SPDX License List 3.6 Cabal-syntaxBSD-2-Clause-Patent", BSD-2-Clause Plus Patent License Cabal-syntaxBSD-2-Clause-Views, BSD 2-Clause with views sentence, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntax BSD-2-Clause, BSD 2-Clause  Simplified License Cabal-syntaxBSD-3-Clause-Attribution, BSD with attribution Cabal-syntaxBSD-3-Clause-Clear, BSD 3-Clause Clear License Cabal-syntaxBSD-3-Clause-LBNL5, Lawrence Berkeley National Labs BSD variant license Cabal-syntaxBSD-3-Clause-Modification3, BSD 3-Clause Modification, SPDX License List 3.16 Cabal-syntax BSD-3-Clause-No-Military-License:, BSD 3-Clause No Military License, SPDX License List 3.16 Cabal-syntax$BSD-3-Clause-No-Nuclear-License-2014&, BSD 3-Clause No Nuclear License 2014 Cabal-syntaxBSD-3-Clause-No-Nuclear-License!, BSD 3-Clause No Nuclear License Cabal-syntax BSD-3-Clause-No-Nuclear-Warranty", BSD 3-Clause No Nuclear Warranty Cabal-syntaxBSD-3-Clause-Open-MPI, BSD 3-Clause Open MPI variant, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntax BSD-3-Clause, BSD 3-Clause New or Revised License Cabal-syntaxBSD-4-Clause-Shortened0, BSD 4 Clause Shortened, SPDX License List 3.16 Cabal-syntaxBSD-4-Clause-UC2, BSD-4-Clause (University of California-Specific) Cabal-syntax BSD-4-Clause, BSD 4-Clause Original or Old License Cabal-syntaxBSD-Protection, BSD Protection License Cabal-syntaxBSD-Source-Code, BSD Source Code Attribution Cabal-syntaxBSL-1.0, Boost Software License 1.0 Cabal-syntax bzip2-1.0.5, bzip2 and libbzip2 License v1.0.5, SPDX License List 3.0, SPDX License List 3.2, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10 Cabal-syntaxBUSL-1.15, Business Source License 1.1, SPDX License List 3.16 Cabal-syntax bzip2-1.0.6#, bzip2 and libbzip2 License v1.0.6 Cabal-syntax C-UDA-1.0, Computational Use of Data Agreement v1.0, SPDX License List 3.16 Cabal-syntaxCAL-1.0-Combined-Work-Exception, Cryptographic Autonomy License 1.0 (Combined Work Exception), SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxCAL-1.0, Cryptographic Autonomy License 1.0, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxCaldera, Caldera License Cabal-syntax CATOSL-1.15, Computer Associates Trusted Open Source License 1.1 Cabal-syntax CC-BY-1.0*, Creative Commons Attribution 1.0 Generic Cabal-syntax CC-BY-2.0*, Creative Commons Attribution 2.0 Generic Cabal-syntax CC-BY-2.5-AU, Creative Commons Attribution 2.5 Australia, SPDX License List 3.16 Cabal-syntax CC-BY-2.5*, Creative Commons Attribution 2.5 Generic Cabal-syntax CC-BY-3.0-AT, Creative Commons Attribution 3.0 Austria, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntax CC-BY-3.0-DE, Creative Commons Attribution 3.0 Germany, SPDX License List 3.16 Cabal-syntax CC-BY-3.0-NL, Creative Commons Attribution 3.0 Netherlands, SPDX License List 3.16 Cabal-syntax CC-BY-3.0-US, Creative Commons Attribution 3.0 United States, SPDX License List 3.16 Cabal-syntax CC-BY-3.0+, Creative Commons Attribution 3.0 Unported Cabal-syntax CC-BY-4.00, Creative Commons Attribution 4.0 International Cabal-syntax CC-BY-NC-1.09, Creative Commons Attribution Non Commercial 1.0 Generic Cabal-syntax CC-BY-NC-2.09, Creative Commons Attribution Non Commercial 2.0 Generic Cabal-syntax CC-BY-NC-2.59, Creative Commons Attribution Non Commercial 2.5 Generic Cabal-syntaxCC-BY-NC-3.0-DE, Creative Commons Attribution Non Commercial 3.0 Germany, SPDX License List 3.16 Cabal-syntax CC-BY-NC-3.0:, Creative Commons Attribution Non Commercial 3.0 Unported Cabal-syntax CC-BY-NC-4.0?, Creative Commons Attribution Non Commercial 4.0 International Cabal-syntaxCC-BY-NC-ND-1.0, Creative Commons Attribution Non Commercial No Derivatives 1.0 Generic Cabal-syntaxCC-BY-NC-ND-2.0, Creative Commons Attribution Non Commercial No Derivatives 2.0 Generic Cabal-syntaxCC-BY-NC-ND-2.5, Creative Commons Attribution Non Commercial No Derivatives 2.5 Generic Cabal-syntaxCC-BY-NC-ND-3.0-DE, Creative Commons Attribution Non Commercial No Derivatives 3.0 Germany, SPDX License List 3.16 Cabal-syntaxCC-BY-NC-ND-3.0-IGO, Creative Commons Attribution Non Commercial No Derivatives 3.0 IGO, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxCC-BY-NC-ND-3.0, Creative Commons Attribution Non Commercial No Derivatives 3.0 Unported Cabal-syntaxCC-BY-NC-ND-4.0, Creative Commons Attribution Non Commercial No Derivatives 4.0 International Cabal-syntaxCC-BY-NC-SA-1.0, Creative Commons Attribution Non Commercial Share Alike 1.0 Generic Cabal-syntaxCC-BY-NC-SA-2.0-FR, Creative Commons Attribution-NonCommercial-ShareAlike 2.0 France, SPDX License List 3.16 Cabal-syntaxCC-BY-NC-SA-2.0-UK, Creative Commons Attribution Non Commercial Share Alike 2.0 England and Wales, SPDX License List 3.16 Cabal-syntaxCC-BY-NC-SA-2.0, Creative Commons Attribution Non Commercial Share Alike 2.0 Generic Cabal-syntaxCC-BY-NC-SA-2.5, Creative Commons Attribution Non Commercial Share Alike 2.5 Generic Cabal-syntaxCC-BY-NC-SA-3.0-DE, Creative Commons Attribution Non Commercial Share Alike 3.0 Germany, SPDX License List 3.16 Cabal-syntaxCC-BY-NC-SA-3.0-IGO, Creative Commons Attribution Non Commercial Share Alike 3.0 IGO, SPDX License List 3.16 Cabal-syntaxCC-BY-NC-SA-3.0, Creative Commons Attribution Non Commercial Share Alike 3.0 Unported Cabal-syntaxCC-BY-NC-SA-4.0, Creative Commons Attribution Non Commercial Share Alike 4.0 International Cabal-syntax CC-BY-ND-1.09, Creative Commons Attribution No Derivatives 1.0 Generic Cabal-syntax CC-BY-ND-2.09, Creative Commons Attribution No Derivatives 2.0 Generic Cabal-syntax CC-BY-ND-2.59, Creative Commons Attribution No Derivatives 2.5 Generic Cabal-syntaxCC-BY-ND-3.0-DE, Creative Commons Attribution No Derivatives 3.0 Germany, SPDX License List 3.16 Cabal-syntax CC-BY-ND-3.0:, Creative Commons Attribution No Derivatives 3.0 Unported Cabal-syntax CC-BY-ND-4.0?, Creative Commons Attribution No Derivatives 4.0 International Cabal-syntax CC-BY-SA-1.06, Creative Commons Attribution Share Alike 1.0 Generic Cabal-syntaxCC-BY-SA-2.0-UK, Creative Commons Attribution Share Alike 2.0 England and Wales, SPDX License List 3.16 Cabal-syntax CC-BY-SA-2.06, Creative Commons Attribution Share Alike 2.0 Generic Cabal-syntaxCC-BY-SA-2.1-JP, Creative Commons Attribution Share Alike 2.1 Japan, SPDX License List 3.16 Cabal-syntax CC-BY-SA-2.56, Creative Commons Attribution Share Alike 2.5 Generic Cabal-syntaxCC-BY-SA-3.0-AT, Creative Commons Attribution Share Alike 3.0 Austria, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxCC-BY-SA-3.0-DE, Creative Commons Attribution Share Alike 3.0 Germany, SPDX License List 3.16 Cabal-syntax CC-BY-SA-3.07, Creative Commons Attribution Share Alike 3.0 Unported Cabal-syntax CC-BY-SA-4.0<, Creative Commons Attribution Share Alike 4.0 International Cabal-syntaxCC-PDDC, Creative Commons Public Domain Dedication and Certification, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxCC0-1.0&, Creative Commons Zero v1.0 Universal Cabal-syntaxCDDL-1.01, Common Development and Distribution License 1.0 Cabal-syntaxCDDL-1.11, Common Development and Distribution License 1.1 Cabal-syntaxCDL-1.0:, Common Documentation License 1.0, SPDX License List 3.16 Cabal-syntaxCDLA-Permissive-1.01, Community Data License Agreement Permissive 1.0 Cabal-syntaxCDLA-Permissive-2.0, Community Data License Agreement Permissive 2.0, SPDX License List 3.16 Cabal-syntaxCDLA-Sharing-1.0., Community Data License Agreement Sharing 1.0 Cabal-syntax CECILL-1.0-, CeCILL Free Software License Agreement v1.0 Cabal-syntax CECILL-1.1-, CeCILL Free Software License Agreement v1.1 Cabal-syntax CECILL-2.0-, CeCILL Free Software License Agreement v2.0 Cabal-syntax CECILL-2.1-, CeCILL Free Software License Agreement v2.1 Cabal-syntaxCECILL-B*, CeCILL-B Free Software License Agreement Cabal-syntaxCECILL-C*, CeCILL-C Free Software License Agreement Cabal-syntax CERN-OHL-1.1, CERN Open Hardware Licence v1.1, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntax CERN-OHL-1.2, CERN Open Hardware Licence v1.2, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxCERN-OHL-P-2.0, CERN Open Hardware Licence Version 2 - Permissive, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxCERN-OHL-S-2.0, CERN Open Hardware Licence Version 2 - Strongly Reciprocal, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxCERN-OHL-W-2.0, CERN Open Hardware Licence Version 2 - Weakly Reciprocal, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntax ClArtistic, Clarified Artistic License Cabal-syntax CNRI-Jython, CNRI Jython License Cabal-syntaxCNRI-Python-GPL-Compatible:, CNRI Python Open Source GPL Compatible License Agreement Cabal-syntax CNRI-Python, CNRI Python License Cabal-syntaxCOIL-1.0:, Copyfree Open Innovation License, SPDX License List 3.16 Cabal-syntaxCommunity-Spec-1.0=, Community Specification License 1.0, SPDX License List 3.16 Cabal-syntax Condor-1.1, Condor Public License v1.1 Cabal-syntaxcopyleft-next-0.3.0, copyleft-next 0.3.0, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxcopyleft-next-0.3.1, copyleft-next 0.3.1, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxCPAL-1.0', Common Public Attribution License 1.0 Cabal-syntaxCPL-1.0, Common Public License 1.0 Cabal-syntax CPOL-1.02 , Code Project Open License 1.02 Cabal-syntax Crossword, Crossword License Cabal-syntaxCrystalStacker, CrystalStacker License Cabal-syntax CUA-OPL-1.0 , CUA Office Public License v1.0 Cabal-syntaxCube, Cube License Cabal-syntaxcurl, curl License Cabal-syntax D-FSL-1.0 , Deutsche Freie Software Lizenz Cabal-syntaxdiffmark, diffmark license Cabal-syntax DL-DE-BY-2.0, Data licence Germany @ attribution @ version 2.0, SPDX License List 3.16 Cabal-syntaxDOC , DOC License Cabal-syntaxDotseqn, Dotseqn License Cabal-syntaxDRL-1.04, Detection Rule License 1.0, SPDX License List 3.16 Cabal-syntaxDSDP, DSDP License Cabal-syntaxdvipdfm, dvipdfm License Cabal-syntaxECL-1.0$, Educational Community License v1.0 Cabal-syntaxECL-2.0$, Educational Community License v2.0 Cabal-syntaxEFL-1.0, Eiffel Forum License v1.0 Cabal-syntaxEFL-2.0, Eiffel Forum License v2.0 Cabal-syntaxeGenix!, eGenix.com Public License 1.1.0 Cabal-syntax Elastic-2.0-, Elastic License 2.0, SPDX License List 3.16 Cabal-syntaxEntessa, Entessa Public License v1.0 Cabal-syntaxEPICS, EPICS Open License, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxEPL-1.0, Eclipse Public License 1.0 Cabal-syntaxEPL-2.0, Eclipse Public License 2.0 Cabal-syntax ErlPL-1.1, Erlang Public License v1.1 Cabal-syntax etalab-2.0, Etalab Open License 2.0, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntax EUDatagrid, EU DataGrid Software License Cabal-syntaxEUPL-1.0#, European Union Public License 1.0 Cabal-syntaxEUPL-1.1#, European Union Public License 1.1 Cabal-syntaxEUPL-1.2#, European Union Public License 1.2 Cabal-syntaxEurosym, Eurosym License Cabal-syntaxFair, Fair License Cabal-syntaxFDK-AAC:, Fraunhofer FDK AAC Codec Library, SPDX License List 3.16 Cabal-syntax Frameworx-1.0, Frameworx Open License 1.0 Cabal-syntax FreeBSD-DOC7, FreeBSD Documentation License, SPDX License List 3.16 Cabal-syntax FreeImage, FreeImage Public License v1.0 Cabal-syntaxFSFAP, FSF All Permissive License Cabal-syntaxFSFULLR0, FSF Unlimited License (with License Retention) Cabal-syntaxFSFUL, FSF Unlimited License Cabal-syntaxFTL, Freetype Project License Cabal-syntaxGD$, GD License, SPDX License List 3.16 Cabal-syntaxGFDL-1.1-invariants-only, GNU Free Documentation License v1.1 only - invariants, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxGFDL-1.1-invariants-or-later, GNU Free Documentation License v1.1 or later - invariants, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxGFDL-1.1-no-invariants-only, GNU Free Documentation License v1.1 only - no invariants, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxGFDL-1.1-no-invariants-or-later, GNU Free Documentation License v1.1 or later - no invariants, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntax GFDL-1.1-only*, GNU Free Documentation License v1.1 only Cabal-syntaxGFDL-1.1-or-later., GNU Free Documentation License v1.1 or later Cabal-syntaxGFDL-1.2-invariants-only, GNU Free Documentation License v1.2 only - invariants, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxGFDL-1.2-invariants-or-later, GNU Free Documentation License v1.2 or later - invariants, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxGFDL-1.2-no-invariants-only, GNU Free Documentation License v1.2 only - no invariants, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxGFDL-1.2-no-invariants-or-later, GNU Free Documentation License v1.2 or later - no invariants, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntax GFDL-1.2-only*, GNU Free Documentation License v1.2 only Cabal-syntaxGFDL-1.2-or-later., GNU Free Documentation License v1.2 or later Cabal-syntaxGFDL-1.3-invariants-only, GNU Free Documentation License v1.3 only - invariants, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxGFDL-1.3-invariants-or-later, GNU Free Documentation License v1.3 or later - invariants, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxGFDL-1.3-no-invariants-only, GNU Free Documentation License v1.3 only - no invariants, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxGFDL-1.3-no-invariants-or-later, GNU Free Documentation License v1.3 or later - no invariants, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntax GFDL-1.3-only*, GNU Free Documentation License v1.3 only Cabal-syntaxGFDL-1.3-or-later., GNU Free Documentation License v1.3 or later Cabal-syntaxGiftware, Giftware License Cabal-syntaxGL2PS, GL2PS License Cabal-syntaxGlide, 3dfx Glide License Cabal-syntaxGlulxe, Glulxe License Cabal-syntaxGLWTPL, Good Luck With That Public License, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxgnuplot, gnuplot License Cabal-syntax GPL-1.0-only&, GNU General Public License v1.0 only Cabal-syntaxGPL-1.0-or-later*, GNU General Public License v1.0 or later Cabal-syntax GPL-2.0-only&, GNU General Public License v2.0 only Cabal-syntaxGPL-2.0-or-later*, GNU General Public License v2.0 or later Cabal-syntax GPL-3.0-only&, GNU General Public License v3.0 only Cabal-syntaxGPL-3.0-or-later*, GNU General Public License v3.0 or later Cabal-syntax gSOAP-1.3b, gSOAP Public License v1.3b Cabal-syntax HaskellReport!, Haskell Language Report License Cabal-syntaxHippocratic-2.1, Hippocratic License 2.1, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxHPND-sell-variant, Historical Permission Notice and Disclaimer - sell variant, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxHPND-, Historical Permission Notice and Disclaimer Cabal-syntaxHTMLTIDY+, HTML Tidy License, SPDX License List 3.16 Cabal-syntaxIBM-pibs., IBM PowerPC Initialization and Boot Software Cabal-syntaxICU , ICU License Cabal-syntaxIJG , Independent JPEG Group License Cabal-syntax ImageMagick, ImageMagick License Cabal-syntaxiMatix,, iMatix Standard Function Library Agreement Cabal-syntaxImlib2, Imlib2 License Cabal-syntaxInfo-ZIP, Info-ZIP License Cabal-syntax Intel-ACPI', Intel ACPI Software License Agreement Cabal-syntaxIntel, Intel Open Source License Cabal-syntax Interbase-1.0, Interbase Public License v1.0 Cabal-syntaxIPA, IPA Font License Cabal-syntaxIPL-1.0, IBM Public License v1.0 Cabal-syntaxISC , ISC License Cabal-syntaxJam%, Jam License, SPDX License List 3.16 Cabal-syntax JasPer-2.0, JasPer License Cabal-syntaxJPNIC, Japan Network Information Center License, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxJSON, JSON License Cabal-syntaxLAL-1.2, Licence Art Libre 1.2 Cabal-syntaxLAL-1.3, Licence Art Libre 1.3 Cabal-syntaxLatex2e, Latex2e License Cabal-syntax Leptonica, Leptonica License Cabal-syntax LGPL-2.0-only,, GNU Library General Public License v2 only Cabal-syntaxLGPL-2.0-or-later0, GNU Library General Public License v2 or later Cabal-syntax LGPL-2.1-only-, GNU Lesser General Public License v2.1 only Cabal-syntaxLGPL-2.1-or-later1, GNU Lesser General Public License v2.1 or later Cabal-syntax LGPL-3.0-only-, GNU Lesser General Public License v3.0 only Cabal-syntaxLGPL-3.0-or-later1, GNU Lesser General Public License v3.0 or later Cabal-syntaxLGPLLR8, Lesser General Public License For Linguistic Resources Cabal-syntax libpng-2.0, PNG Reference Library version 2, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxLibpng, libpng License Cabal-syntaxlibselinux-1.0, libselinux public domain notice, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxlibtiff, libtiff License Cabal-syntax LiLiQ-P-1.12, Licence Libre du Qubec @ Permissive version 1.1 Cabal-syntax LiLiQ-R-1.13, Licence Libre du Qubec @ Rciprocit version 1.1 Cabal-syntaxLiLiQ-Rplus-1.19, Licence Libre du Qubec @ Rciprocit forte version 1.1 Cabal-syntaxLinux-man-pages-copyleft2, Linux man-pages Copyleft, SPDX License List 3.16 Cabal-syntax Linux-OpenIB, Linux Kernel Variant of OpenIB.org license, SPDX License List 3.2, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxLPL-1.02, Lucent Public License v1.02 Cabal-syntaxLPL-1.0#, Lucent Public License Version 1.0 Cabal-syntaxLPPL-1.0#, LaTeX Project Public License v1.0 Cabal-syntaxLPPL-1.1#, LaTeX Project Public License v1.1 Cabal-syntaxLPPL-1.2#, LaTeX Project Public License v1.2 Cabal-syntax LPPL-1.3a$, LaTeX Project Public License v1.3a Cabal-syntax LPPL-1.3c$, LaTeX Project Public License v1.3c Cabal-syntax MakeIndex, MakeIndex License Cabal-syntaxMirOS, The MirOS Licence Cabal-syntaxMIT-0, MIT No Attribution, SPDX License List 3.2, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxMIT-advertising, Enlightenment License (e16) Cabal-syntaxMIT-CMU , CMU License Cabal-syntaxMIT-enna, enna License Cabal-syntaxMIT-feh , feh License Cabal-syntaxMIT-Modern-Variant4, MIT License Modern Variant, SPDX License List 3.16 Cabal-syntaxMIT-open-group0, MIT Open Group variant, SPDX License List 3.16 Cabal-syntaxMITNFA, MIT +no-false-attribs license Cabal-syntaxMIT , MIT License Cabal-syntaxMotosoto, Motosoto License Cabal-syntaxmpich2, mpich2 License Cabal-syntaxMPL-1.0, Mozilla Public License 1.0 Cabal-syntaxMPL-1.1, Mozilla Public License 1.1 Cabal-syntaxMPL-2.0-no-copyleft-exception4, Mozilla Public License 2.0 (no copyleft exception) Cabal-syntaxMPL-2.0, Mozilla Public License 2.0 Cabal-syntaxMS-PL, Microsoft Public License Cabal-syntaxMS-RL, Microsoft Reciprocal License Cabal-syntaxMTLL!, Matrix Template Library License Cabal-syntax MulanPSL-1.0, Mulan Permissive Software License, Version 1, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntax MulanPSL-2.0, Mulan Permissive Software License, Version 2, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxMultics, Multics License Cabal-syntaxMup , Mup License Cabal-syntax NAIST-2003, Nara Institute of Science and Technology License (2003), SPDX License List 3.16 Cabal-syntaxNASA-1.3 , NASA Open Source Agreement 1.3 Cabal-syntaxNaumen, Naumen Public License Cabal-syntaxNBPL-1.0, Net Boolean Public License v1 Cabal-syntax NCGL-UK-2.0, Non-Commercial Government Licence, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxNCSA1, University of Illinois/NCSA Open Source License Cabal-syntaxNet-SNMP, Net-SNMP License Cabal-syntaxNetCDF, NetCDF license Cabal-syntaxNewsletr, Newsletr License Cabal-syntaxNGPL , Nethack General Public License Cabal-syntaxNIST-PD-fallback, NIST Public Domain Notice with license fallback, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxNIST-PD, NIST Public Domain Notice, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxNLOD-1.07, Norwegian Licence for Open Government Data (NLOD) 1.0 Cabal-syntaxNLOD-2.0, Norwegian Licence for Open Government Data (NLOD) 2.0, SPDX License List 3.16 Cabal-syntaxNLPL, No Limit Public License Cabal-syntaxNokia, Nokia Open Source License Cabal-syntaxNOSL, Netizen Open Source License Cabal-syntaxNoweb, Noweb License Cabal-syntaxNPL-1.0, Netscape Public License v1.0 Cabal-syntaxNPL-1.1, Netscape Public License v1.1 Cabal-syntax NPOSL-3.0&, Non-Profit Open Software License 3.0 Cabal-syntaxNRL , NRL License Cabal-syntaxNTP-0, NTP No Attribution, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxNTP , NTP License Cabal-syntax O-UDA-1.0, Open Use of Data Agreement v1.0, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxOCCT-PL(, Open CASCADE Technology Public License Cabal-syntaxOCLC-2.0", OCLC Research Public License 2.0 Cabal-syntaxODbL-1.0., Open Data Commons Open Database License v1.0 Cabal-syntax ODC-By-1.0, Open Data Commons Attribution License v1.0, SPDX License List 3.2, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxOFL-1.0-no-RFN, SIL Open Font License 1.0 with no Reserved Font Name, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntax OFL-1.0-RFN, SIL Open Font License 1.0 with Reserved Font Name, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxOFL-1.0, SIL Open Font License 1.0 Cabal-syntaxOFL-1.1-no-RFN, SIL Open Font License 1.1 with no Reserved Font Name, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntax OFL-1.1-RFN, SIL Open Font License 1.1 with Reserved Font Name, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxOFL-1.1, SIL Open Font License 1.1 Cabal-syntaxOGC-1.0, OGC Software License, Version 1.0, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxOGDL-Taiwan-1.0, Taiwan Open Government Data License, version 1.0, SPDX License List 3.16 Cabal-syntaxOGL-Canada-2.0, Open Government Licence - Canada, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntax OGL-UK-1.0, Open Government Licence v1.0, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntax OGL-UK-2.0, Open Government Licence v2.0, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntax OGL-UK-3.0, Open Government Licence v3.0, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxOGTSL, Open Group Test Suite License Cabal-syntax OLDAP-1.1, Open LDAP Public License v1.1 Cabal-syntax OLDAP-1.2, Open LDAP Public License v1.2 Cabal-syntax OLDAP-1.3, Open LDAP Public License v1.3 Cabal-syntax OLDAP-1.4, Open LDAP Public License v1.4 Cabal-syntax OLDAP-2.0.1!, Open LDAP Public License v2.0.1 Cabal-syntax OLDAP-2.0;, Open LDAP Public License v2.0 (or possibly 2.0A and 2.0B) Cabal-syntax OLDAP-2.1, Open LDAP Public License v2.1 Cabal-syntax OLDAP-2.2.1!, Open LDAP Public License v2.2.1 Cabal-syntax OLDAP-2.2.2 , Open LDAP Public License 2.2.2 Cabal-syntax OLDAP-2.2, Open LDAP Public License v2.2 Cabal-syntax OLDAP-2.3, Open LDAP Public License v2.3 Cabal-syntax OLDAP-2.4, Open LDAP Public License v2.4 Cabal-syntax OLDAP-2.5, Open LDAP Public License v2.5 Cabal-syntax OLDAP-2.6, Open LDAP Public License v2.6 Cabal-syntax OLDAP-2.7, Open LDAP Public License v2.7 Cabal-syntax OLDAP-2.8, Open LDAP Public License v2.8 Cabal-syntaxOML, Open Market License Cabal-syntaxOpenSSL, OpenSSL License Cabal-syntaxOPL-1.0, Open Public License v1.0 Cabal-syntax OPUBL-1.07, Open Publication License v1.0, SPDX License List 3.16 Cabal-syntax OSET-PL-2.1!, OSET Public License version 2.1 Cabal-syntaxOSL-1.0, Open Software License 1.0 Cabal-syntaxOSL-1.1, Open Software License 1.1 Cabal-syntaxOSL-2.0, Open Software License 2.0 Cabal-syntaxOSL-2.1, Open Software License 2.1 Cabal-syntaxOSL-3.0, Open Software License 3.0 Cabal-syntax Parity-6.0.0, The Parity Public License 6.0.0, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntax Parity-7.0.0, The Parity Public License 7.0.0, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxPDDL-1.0:, Open Data Commons Public Domain Dedication & License 1.0 Cabal-syntaxPHP-3.01, PHP License v3.01 Cabal-syntaxPHP-3.0, PHP License v3.0 Cabal-syntaxPlexus, Plexus Classworlds License Cabal-syntaxPolyForm-Noncommercial-1.0.0, PolyForm Noncommercial License 1.0.0, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxPolyForm-Small-Business-1.0.0, PolyForm Small Business License 1.0.0, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntax PostgreSQL, PostgreSQL License Cabal-syntaxPSF-2.0, Python Software Foundation License 2.0, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxpsfrag, psfrag License Cabal-syntaxpsutils, psutils License Cabal-syntax Python-2.0, Python License 2.0 Cabal-syntaxQhull, Qhull License Cabal-syntaxQPL-1.0, Q Public License 1.0 Cabal-syntaxRdisc, Rdisc License Cabal-syntax RHeCos-1.1", Red Hat eCos Public License v1.1 Cabal-syntaxRPL-1.1, Reciprocal Public License 1.1 Cabal-syntaxRPL-1.5, Reciprocal Public License 1.5 Cabal-syntaxRPSL-1.0), RealNetworks Public Source License v1.0 Cabal-syntaxRSA-MD, RSA Message-Digest License Cabal-syntaxRSCPL", Ricoh Source Code Public License Cabal-syntaxRuby, Ruby License Cabal-syntaxSAX-PD, Sax Public Domain Notice Cabal-syntaxSaxpath, Saxpath License Cabal-syntaxSCEA, SCEA Shared Source License Cabal-syntax SchemeReport8, Scheme Language Report License, SPDX License List 3.16 Cabal-syntax Sendmail-8.23, Sendmail License 8.23, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxSendmail, Sendmail License Cabal-syntax SGI-B-1.0", SGI Free Software License B v1.0 Cabal-syntax SGI-B-1.1", SGI Free Software License B v1.1 Cabal-syntax SGI-B-2.0", SGI Free Software License B v2.0 Cabal-syntaxSHL-0.51, Solderpad Hardware License, Version 0.51, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxSHL-0.5, Solderpad Hardware License v0.5, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntax SimPL-2.0, Simple Public License 2.0 Cabal-syntax SISSL-1.2,, Sun Industry Standards Source License v1.2 Cabal-syntaxSISSL,, Sun Industry Standards Source License v1.1 Cabal-syntax Sleepycat, Sleepycat License Cabal-syntaxSMLNJ#, Standard ML of New Jersey License Cabal-syntaxSMPPL*, Secure Messaging Protocol Public License Cabal-syntaxSNIA, SNIA Public License 1.1 Cabal-syntax Spencer-86, Spencer License 86 Cabal-syntax Spencer-94, Spencer License 94 Cabal-syntax Spencer-99, Spencer License 99 Cabal-syntaxSPL-1.0, Sun Public License v1.0 Cabal-syntax SSH-OpenSSH, SSH OpenSSH license, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntax SSH-short, SSH short notice, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxSSPL-1.0, Server Side Public License, v 1, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxSugarCRM-1.1.3 , SugarCRM Public License v1.1.3 Cabal-syntaxSWL8, Scheme Widget Library (SWL) Software License Agreement Cabal-syntax TAPR-OHL-1.0, TAPR Open Hardware License v1.0, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxTCL, TCL/TK License Cabal-syntax TCP-wrappers, TCP Wrappers License Cabal-syntaxTMate, TMate Open Source License Cabal-syntax TORQUE-1.1$, TORQUE v2.5+ Software License v1.1 Cabal-syntaxTOSL, Trusster Open Source License Cabal-syntax TU-Berlin-1.0, Technische Universitaet Berlin License 1.0, SPDX License List 3.2, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntax TU-Berlin-2.0, Technische Universitaet Berlin License 2.0, SPDX License List 3.2, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxUCL-1.0, Upstream Compatibility License v1.0, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxUnicode-DFS-2015<, Unicode License Agreement - Data Files and Software (2015) Cabal-syntaxUnicode-DFS-2016<, Unicode License Agreement - Data Files and Software (2016) Cabal-syntax Unicode-TOU, Unicode Terms of Use Cabal-syntax Unlicense, The Unlicense Cabal-syntaxUPL-1.0#, Universal Permissive License v1.0 Cabal-syntaxVim , Vim License Cabal-syntaxVOSTROM(, VOSTROM Public License for Open Source Cabal-syntaxVSL-1.0, Vovida Software License v1.0 Cabal-syntax W3C-19980720., W3C Software Notice and License (1998-07-20) Cabal-syntax W3C-201505137, W3C Software Notice and Document License (2015-05-13) Cabal-syntaxW3C., W3C Software Notice and License (2002-12-31) Cabal-syntax Watcom-1.0', Sybase Open Watcom Public License 1.0 Cabal-syntaxWsuipa, Wsuipa License Cabal-syntaxWTFPL-, Do What The F*ck You Want To Public License Cabal-syntax$X11-distribute-modifications-variant, X11 License Distribution Modification Variant, SPDX License List 3.16 Cabal-syntaxX11 , X11 License Cabal-syntaxXerox, Xerox License Cabal-syntax XFree86-1.1, XFree86 License 1.1 Cabal-syntaxxinetd, xinetd License Cabal-syntaxXnet, X.Net License Cabal-syntaxxpp , XPP License Cabal-syntaxXSkat, XSkat License Cabal-syntaxYPL-1.0, Yahoo! Public License v1.0 Cabal-syntaxYPL-1.1, Yahoo! Public License v1.1 Cabal-syntaxZed , Zed License Cabal-syntaxZend-2.0, Zend License v2.0 Cabal-syntax Zimbra-1.3, Zimbra Public License v1.3 Cabal-syntax Zimbra-1.4, Zimbra Public License v1.4 Cabal-syntaxzlib-acknowledgement*, zlib/libpng License with Acknowledgement Cabal-syntaxZlib, zlib License Cabal-syntaxZPL-1.1, Zope Public License 1.1 Cabal-syntaxZPL-2.0, Zope Public License 2.0 Cabal-syntaxZPL-2.1, Zope Public License 2.1 Cabal-syntax=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 identifierstraverse_ (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."SPDX 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."For 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]Right [GPL_2_0_only,GPL_3_0_only,LGPL_2_1_only,MIT,ISC,MPL_2_0,Apache_2_0] Cabal-syntaxLicense SPDX identifier, e.g. "BSD-3-Clause". Cabal-syntaxLicense name, e.g. &"GNU General Public License v2.0 only" Cabal-syntaxWhether the license is approved by Open Source Initiative (OSI).See  ,https://opensource.org/licenses/alphabetical. Cabal-syntaxWhether the license is considered libre by Free Software Foundation (FSF).See 1https://www.gnu.org/licenses/license-list.en.html Cabal-syntax Create a  from a B. Cabal-syntax6eitherParsec "BSD-3-Clause" :: Either String LicenseIdRight BSD_3_Clause.eitherParsec "BSD3" :: Either String LicenseIdLeft "...Unknown SPDX license identifier: 'BSD3' Do you mean BSD-3-Clause?"B Safe-Inferred6;/R- Cabal-syntax.SPDX License Exceptions identifiers list v3.16 Cabal-syntax 389-exception , 389 Directory Server Exception Cabal-syntaxAutoconf-exception-2.0, Autoconf exception 2.0 Cabal-syntaxAutoconf-exception-3.0, Autoconf exception 3.0 Cabal-syntaxBison-exception-2.2, Bison exception 2.2 Cabal-syntaxBootloader-exception#, Bootloader Distribution Exception Cabal-syntaxClasspath-exception-2.0, Classpath exception 2.0 Cabal-syntaxCLISP-exception-2.0, CLISP exception 2.0 Cabal-syntaxDigiRule-FOSS-exception!, DigiRule FOSS License Exception Cabal-syntaxeCos-exception-2.0, eCos exception 2.0 Cabal-syntaxFawkes-Runtime-exception, Fawkes Runtime Exception Cabal-syntaxFLTK-exception, FLTK exception Cabal-syntaxFont-exception-2.0, Font exception 2.0 Cabal-syntaxfreertos-exception-2.0, FreeRTOS Exception 2.0 Cabal-syntaxGCC-exception-2.0#, GCC Runtime Library exception 2.0 Cabal-syntaxGCC-exception-3.1#, GCC Runtime Library exception 3.1 Cabal-syntaxgnu-javamail-exception, GNU JavaMail exception Cabal-syntaxGPL-3.0-linking-exception, GPL-3.0 Linking Exception, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntax GPL-3.0-linking-source-exception, GPL-3.0 Linking Exception (with Corresponding Source), SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntax GPL-CC-1.0, GPL Cooperation Commitment 1.0, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxi2p-gpl-java-exception, i2p GPL+Java Exception Cabal-syntaxLGPL-3.0-linking-exception, LGPL-3.0 Linking Exception, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxLibtool-exception, Libtool Exception Cabal-syntaxLinux-syscall-note, Linux Syscall Note Cabal-syntaxLLVM-exception, LLVM Exception, SPDX License List 3.2, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxLZMA-exception, LZMA exception Cabal-syntax mif-exception', Macros and Inline Functions Exception Cabal-syntaxNokia-Qt-exception-1.1, Nokia Qt LGPL exception 1.1, SPDX License List 3.0, SPDX License List 3.2 Cabal-syntaxOCaml-LGPL-linking-exception, OCaml LGPL Linking Exception, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxOCCT-exception-1.0, Open CASCADE Exception 1.0 Cabal-syntaxOpenJDK-assembly-exception-1.0, OpenJDK Assembly exception 1.0, SPDX License List 3.2, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxopenvpn-openssl-exception, OpenVPN OpenSSL Exception Cabal-syntax!PS-or-PDF-font-exception-20170817, PS/PDF font exception (2017-08-17), SPDX License List 3.2, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxQt-GPL-exception-1.0, Qt GPL exception 1.0, SPDX License List 3.2, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxQt-LGPL-exception-1.1, Qt LGPL exception 1.1, SPDX License List 3.2, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxQwt-exception-1.0, Qwt exception 1.0 Cabal-syntaxSHL-2.0, Solderpad Hardware License v2.0, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxSHL-2.1, Solderpad Hardware License v2.1, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxSwift-exception, Swift Exception, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxu-boot-exception-2.0, U-Boot exception 2.0 Cabal-syntaxUniversal-FOSS-exception-1.0, Universal FOSS Exception, Version 1.0, SPDX License List 3.6, SPDX License List 3.9, SPDX License List 3.10, SPDX License List 3.16 Cabal-syntaxWxWindows-exception-3.1!, WxWindows Library Exception 3.1 Cabal-syntaxLicense SPDX identifier, e.g. "BSD-3-Clause". Cabal-syntaxLicense name, e.g. &"GNU General Public License v2.0 only" Cabal-syntax Create a  from a B...C Safe-Inferred6;5K Cabal-syntaxSimple License Expressions. Cabal-syntax9An SPDX License List Short Form Identifier. For example:  GPL-2.0-only Cabal-syntaxAn 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+ Cabal-syntax4A SPDX user defined license reference: For example:  LicenseRef-23, LicenseRef-MIT-Style-1, or 0DocumentRef-spdx-tool-1.2:LicenseRef-MIT-Style-2 Cabal-syntaxSPDX License Expression. idstring = 1*(ALPHA / DIGIT / "-" / "." ) license id = license exception id = 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)  D Safe-Inferred6;: Cabal-syntaxDeclared license. See  instead.F Safe-Inferred6;L Cabal-syntaxRenaming 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-syntax"A module renaming/thinning; e.g., (A as B, C as C) brings B and C into scope. Cabal-syntaxThe default renaming, bringing all exported modules into scope. Cabal-syntaxHiding renaming, e.g.,  hiding (A, B), bringing all exported modules into scope except the hidden ones. Cabal-syntax Interpret a  as a partial map from  to 7. For efficiency, you should partially apply it with  and then reuse it. Cabal-syntax3The default renaming, if something is specified in  build-depends only. Cabal-syntaxTests if its the default renaming; we can use a more compact syntax in G in this case. Cabal-syntaxbetween parens Cabal-syntaxmodule name parserG Safe-Inferred6;M* Cabal-syntaxA renaming on an include: (provides renaming, requires renaming) Cabal-syntaxThe  applied when you only  build-depends on a package. Cabal-syntaxIs an  the default one?H Safe-Inferred6;S Cabal-syntax Invariant: if  is  , it's not the same as ). In other words, the same invariant as  Dependency has. Cabal-syntaxSmart constructor of , enforces invariant. Cabal-syntaxRestore invariant Cabal-syntax#simpleParsec "mylib" :: Maybe MixinJust (Mixin {mixinPackageName = PackageName "mylib", mixinLibraryName = LMainLibName, mixinIncludeRenaming = IncludeRenaming {includeProvidesRn = DefaultRenaming, includeRequiresRn = DefaultRenaming}}),simpleParsec "thatlib:sublib" :: Maybe MixinJust (Mixin {mixinPackageName = PackageName "thatlib", mixinLibraryName = LSubLibName (UnqualComponentName "sublib"), mixinIncludeRenaming = IncludeRenaming {includeProvidesRn = DefaultRenaming, includeRequiresRn = DefaultRenaming}})-simpleParsec "thatlib:thatlib" :: Maybe MixinJust (Mixin {mixinPackageName = PackageName "thatlib", mixinLibraryName = LMainLibName, mixinIncludeRenaming = IncludeRenaming {includeProvidesRn = DefaultRenaming, includeRequiresRn = DefaultRenaming}})$Sublibrary syntax is accepted since cabal-version: 3.4.map (`simpleParsec'` "mylib:sub") [CabalSpecV3_0, CabalSpecV3_4] :: [Maybe Mixin][Nothing,Just (Mixin {mixinPackageName = PackageName "mylib", mixinLibraryName = LSubLibName (UnqualComponentName "sub"), mixinIncludeRenaming = IncludeRenaming {includeProvidesRn = DefaultRenaming, includeRequiresRn = DefaultRenaming}})]I Safe-Inferred6;S^(c) Edward Z. Yang 2016BSD3cabal-dev@haskell.org experimentalportable Safe-Inferred 6a Cabal-syntax,A simple, trivial data type which admits an  instance. Cabal-syntaxThe  class is used for datatypes which represent directed graph nodes. A node of type a- is associated with some unique key of type  a); given a node we can determine its key (") and the keys of its neighbors (). Cabal-syntaxA graph of nodes a5. The nodes are expected to have instance of class . Cabal-syntaxGet the value from a . Cabal-syntaxO(1). Is the graph empty? Cabal-syntaxO(1)#. The number of nodes in the graph. Cabal-syntaxO(log V)#. Check if the key is in the graph. Cabal-syntaxO(log V)(. Lookup the node at a key in the graph. Cabal-syntaxO(1). The empty graph. Cabal-syntaxO(log V). Insert a node into a graph. Cabal-syntaxO(log V)*. Delete the node at a key from the graph. Cabal-syntaxO(log V). Lookup and delete. This function returns the deleted value if it existed. Cabal-syntax O(V + V'). Right-biased union, preferring entries from the second map when conflicts occur.  x =  (f x). Cabal-syntax O(V + V'). Left-biased union, preferring entries from the first map when conflicts occur. Cabal-syntax(V + E). Compute the strongly connected components of a graph. Requires amortized construction of graph. Cabal-syntax(V + E). Compute the cycles of a graph. Requires amortized construction of graph. Cabal-syntaxO(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. Cabal-syntaxLookup the immediate neighbors from a key in the graph. Requires amortized construction of graph. Cabal-syntaxLookup the immediate reverse neighbors from a key in the graph. Requires amortized construction of graph. Cabal-syntaxCompute 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. Cabal-syntaxCompute 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. Cabal-syntaxTopologically sort the nodes of a graph. Requires amortized construction of graph. Cabal-syntaxReverse topologically sort the nodes of a graph. Requires amortized construction of graph. Cabal-syntaxO(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) instead. The values of the map are assumed to already be in WHNF. Cabal-syntax O(V log V)<. Convert a list of nodes (with distinct keys) into a graph. Cabal-syntaxO(V)'. Convert a graph into a list of nodes. Cabal-syntaxO(V)&. Convert a graph into a list of keys. Cabal-syntaxO(V)%. Convert a graph into a set of keys. Cabal-syntaxO(1). Convert a graph into a map from keys to nodes. The resulting map m* is guaranteed to have the property that  ((k,n) -> k ==  n) ( m). Cabal-syntaxO(1). Convert a graph into a ,. Requires amortized construction of graph.$$JIsaac Jones, Simon Marlow 2003-2004 Duncan Coutts 2008BSD3cabal-devel@haskell.orgportable Safe-Inferredi Cabal-syntaxThis is the converse of  . 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): isNoVersion (EarlierVersion v `IntersectVersionRanges` LaterVersion v) Cabal-syntax6Is this version range in fact just a specific version?For example the version range ">= 3 && <= 3" contains only the version 3. Cabal-syntax 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-syntaxGiven a version range, remove the highest upper bound. Example: (>= 1 && < 3) || (>= 4 && < 5) is converted to  (>= 1 &&  3)|| (= 4). Cabal-syntaxGiven a version range, remove the lowest lower bound. Example:  (>= 1 &&  3)|| ( = 4 && < 5) is converted to  (>= 0 &&  3)|| ( = 4 && < 5). Cabal-syntaxRewrite  ^>= x.y.z into >= x.y.z && < x.(y+1) Cabal-syntaxRewrite  ^>= x.y.z into >= x.y.z Cabal-syntaxRewrite  ^>= x.y.z into  B, B -> A). Cabal-syntax 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. Cabal-syntaxAn  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 lossily represent it as a 'DefiniteUnitId 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 https://github.com/ezyang/ghc-proposals/blob/backpack/proposals/0000-backpack.rst Cabal-syntaxIdentifies a component which may have some unfilled holes; specifying its   and its . TODO: Invariant that + is non-empty? See also the Text instance. Cabal-syntaxIdentifies 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. Cabal-syntaxGet the set of holes ( ModuleVar) embedded in a . Cabal-syntaxSafe constructor from a UnitId. The only way to do this safely is if the instantiation is provided. Cabal-syntax Create a  from a  % and an instantiation with no holes. Cabal-syntaxGet the set of holes ( ModuleVar) embedded in a . Cabal-syntaxPretty-print the entries of a module substitution, suitable for embedding into a  or passing to GHC via --instantiate-with. Cabal-syntax5Pretty-print a single entry of a module substitution. Cabal-syntax Inverse to  dispModSubst. Cabal-syntax Inverse to dispModSubstEntry. Cabal-syntaxGet the set of holes ( ModuleVar) embedded in a .. This is NOT the domain of the substitution. Cabal-syntaxWhen typechecking, we don't demand that a freshly instantiated  be compiled; instead, we just depend on the installed indefinite unit installed at the  . Cabal-syntaxTake 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. Cabal-syntaxeitherParsec "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")) Cabal-syntax1eitherParsec "foobar" :: Either String OpenUnitIdRight (DefiniteUnitId (DefUnitId {unDefUnitId = UnitId "foobar"}))eitherParsec "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"))]))Q Safe-Inferred6;R Safe-Inferred6; Cabal-syntax2A 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 was used where  is not used instead (#5570). Cabal-syntax Cabal-syntax Cabal-syntax4simpleParsec "foo" :: Maybe PackageVersionConstraintJust (PackageVersionConstraint (PackageName "foo") (OrLaterVersion (mkVersion [0]))):simpleParsec "foo >=2.0" :: Maybe PackageVersionConstraintJust (PackageVersionConstraint (PackageName "foo") (OrLaterVersion (mkVersion [2,0])))8simpleParsec "foo-2.0" :: Maybe PackageVersionConstraintJust (PackageVersionConstraint (PackageName "foo") (ThisVersion (mkVersion [2,0])))S Safe-InferredT Safe-Inferred6; Cabal-syntaxA simple pair of a   and .   is to  as  PackageName is to . See   for more info. Cabal-syntaxThe combined package and component name. see documentation for  . Cabal-syntax/The version of this package / component, eg 1.2 Cabal-syntax1simpleParsec "foo-bar-0" :: Maybe MungedPackageIdJust (MungedPackageId {mungedName = MungedPackageName (PackageName "foo-bar") LMainLibName, mungedVersion = mkVersion [0]})/simpleParsec "foo-bar" :: Maybe MungedPackageIdJust (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-syntaxprettyShow $ MungedPackageId (MungedPackageName "servant" LMainLibName) (mkVersion [1,2,3])"servant-1.2.3"prettyShow $ MungedPackageId (MungedPackageName "servant" (LSubLibName "lackey")) (mkVersion [0,1,2])"z-servant-z-lackey-0.1.2"U Safe-Inferred6;  Cabal-syntaxDescribes 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.V Safe-Inferred6; Cabal-syntax6Describes a dependency on an executable from a package Cabal-syntaxExamples1simpleParsec "happy:happy" :: Maybe ExeDependencyJust (ExeDependency (PackageName "happy") (UnqualComponentName "happy") (OrLaterVersion (mkVersion [0])))= 1.19.12" :: Maybe ExeDependencyJust (ExeDependency (PackageName "happy") (UnqualComponentName "happy") (OrLaterVersion (mkVersion [1,19,12]))):simpleParsec "happy:happy>=1.19.12" :: Maybe ExeDependencyJust (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 ExeDependencyNothingW Safe-Inferred6;C Cabal-syntax0Describes a dependency on a source package (API) Invariant:! package name does not appear as   in set of library names.Note:  is not an instance of 2, and so it cannot be used in  or as the key to a (. For these and similar use cases see  DependencyMap. Cabal-syntaxThe set of libraries required from the package. Only the selected libraries will be built. It does not affect the cabal-install solver yet. Cabal-syntaxSmart constructor of .If   is appears as  = in a set of sublibraries, it is automatically converted to  . Cabal-syntaxLibrary set with main library. Cabal-syntax Simplify the   expression in a . See . Cabal-syntax,simpleParsec "mylib:sub" :: Maybe DependencyJust (Dependency (PackageName "mylib") (OrLaterVersion (mkVersion [0])) (fromNonEmpty (LSubLibName (UnqualComponentName "sub") :| [])))4simpleParsec "mylib:{sub1,sub2}" :: Maybe DependencyJust (Dependency (PackageName "mylib") (OrLaterVersion (mkVersion [0])) (fromNonEmpty (LSubLibName (UnqualComponentName "sub1") :| [LSubLibName (UnqualComponentName "sub2")])))8simpleParsec "mylib:{ sub1 , sub2 }" :: Maybe DependencyJust (Dependency (PackageName "mylib") (OrLaterVersion (mkVersion [0])) (fromNonEmpty (LSubLibName (UnqualComponentName "sub1") :| [LSubLibName (UnqualComponentName "sub2")])))?simpleParsec "mylib:{ sub1 , sub2 } ^>= 42" :: Maybe DependencyJust (Dependency (PackageName "mylib") (MajorBoundVersion (mkVersion [42])) (fromNonEmpty (LSubLibName (UnqualComponentName "sub1") :| [LSubLibName (UnqualComponentName "sub2")])))3simpleParsec "mylib:{ } ^>= 42" :: Maybe DependencyNothingtraverse_ print (map simpleParsec ["mylib:mylib", "mylib:{mylib}", "mylib:{mylib,sublib}" ] :: [Maybe Dependency])Just (Dependency (PackageName "mylib") (OrLaterVersion (mkVersion [0])) (fromNonEmpty (LMainLibName :| [])))Just (Dependency (PackageName "mylib") (OrLaterVersion (mkVersion [0])) (fromNonEmpty (LMainLibName :| [])))Just (Dependency (PackageName "mylib") (OrLaterVersion (mkVersion [0])) (fromNonEmpty (LMainLibName :| [LSubLibName (UnqualComponentName "sublib")])))$Spaces around colon are not allowed:map simpleParsec ["mylib: sub", "mylib :sub", "mylib: {sub1,sub2}", "mylib :{sub1,sub2}"] :: [Maybe Dependency]![Nothing,Nothing,Nothing,Nothing]$Sublibrary syntax is accepted since cabal-version: 3.0map (`simpleParsec'` "mylib:sub") [CabalSpecV2_4, CabalSpecV3_0] :: [Maybe Dependency][Nothing,Just (Dependency (PackageName "mylib") (OrLaterVersion (mkVersion [0])) (fromNonEmpty (LSubLibName (UnqualComponentName "sub") :| [])))] Cabal-syntax3prettyShow $ Dependency "pkg" anyVersion mainLibSet"pkg"prettyShow $ Dependency "pkg" anyVersion $ NES.insert (LSubLibName "sublib") mainLibSet"pkg:{pkg, sublib}"prettyShow $ Dependency "pkg" anyVersion $ NES.singleton (LSubLibName "sublib") "pkg:sublib"prettyShow $ Dependency "pkg" anyVersion $ NES.insert (LSubLibName "sublib-b") $ NES.singleton (LSubLibName "sublib-a")"pkg:{sublib-a, sublib-b}"X Safe-Inferred6;p Cabal-syntaxIs 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.Y Safe-InferredZ Safe-Inferredj Cabal-syntaxA map of dependencies. Newtyped since the default monoid instance is not appropriate. The monoid instance uses  .[ Safe-Inferred"6;X Cabal-syntax3The "benchmark-type" field in the benchmark stanza. Cabal-syntax"type: exitcode-stdio-x.y" Cabal-syntax,Some unknown benchmark type e.g. "type: foo"\ Safe-Inferred6; Cabal-syntax4The benchmark interfaces that are currently defined.More interfaces may be defined in future, either new revisions or totally new interfaces. Cabal-syntaxBenchmark 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. Test tooling may pass command line arguments and/or connect the stdin channel to the test. Cabal-syntaxA benchmark that does not conform to one of the above interfaces for the given reason (e.g. unknown benchmark type).]Isaac Jones 2003-2004BSD3cabal-devel@haskell.orgportable Safe-Inferred6; Cabal-syntaxClass 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-syntax'Packages that have an installed unit ID Cabal-syntaxClass 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 . In particular, installed packages cannot, there may be many installed instances of the same source package.2  ^ Safe-Inferred6;M Cabal-syntaxAn ABI dependency is a dependency on a library which also records the ABI hash (abiHash ) of the library it depends on.The 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._The License data type.8Isaac Jones 2003-2005 Duncan Coutts 2008BSD3cabal-devel@haskell.orgportable Safe-Inferred6; Cabal-syntaxIndicates 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. Cabal-syntaxGNU 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-syntax &https://www.gnu.org/licenses/agpl.html,GNU Affero General Public License, version 3. Cabal-syntax$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-syntax .http://www.opensource.org/licenses/bsd-license2-clause BSD license. Cabal-syntax /http://www.opensource.org/licenses/bsd-3-clause3-clause BSD license. Cabal-syntax 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-syntax &http://www.opensource.org/licenses/MIT MIT license. Cabal-syntax http://www.isc.org/downloads/software-support-policy/isc-license/ ISC license Cabal-syntax https://www.mozilla.org/MPL/#Mozilla Public License, version 2.0. Cabal-syntax https://www.apache.org/licenses/Apache License, version 2.0. Cabal-syntaxThe 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. Cabal-syntaxExplicitly 'All Rights Reserved', eg for proprietary software. The package may not be legally modified or redistributed by anyone but the rightsholder. Cabal-syntaxNo license specified which legally defaults to 'All Rights Reserved'. The package may not be legally modified or redistributed by anyone but the rightsholder. Cabal-syntaxAny other software license. Cabal-syntax$Indicates an erroneous license name. Cabal-syntax.The list of all currently recognised licenses. Cabal-syntax Convert old  to SPDX &. Non-SPDX licenses are converted to . Cabal-syntaxConvert  to ,*This is lossy conversion. We try our best.&licenseFromSPDX . licenseToSPDX $ BSD3BSD3 simpleParsec "BSD-3-Clause OR GPL-3.0-only"-Just (UnknownLicense "BSD3ClauseORGPL30only")` Safe-Inferred"6;; Cabal-syntax overrides  Cabal-syntax5Returns the munged package name, which we write into name- for compatibility with old versions of GHC.99a Safe-InferredE--b Safe-InferredU  Cabal-syntax:A monad with failure and accumulating errors and warnings. Cabal-syntaxForget  s warnings. Cabal-syntax Destruct a  into the emitted warnings and either a successful value or list of errors and possibly recovered a spec-version declaration. Cabal-syntaxRecover/ the parse result, so we can proceed parsing.  will still result in X, if there are recorded errors. Cabal-syntaxSet cabal spec version. Cabal-syntaxGet cabal spec version. Cabal-syntax5Add a warning. This doesn't fail the parsing process. Cabal-syntaxAdd multiple warnings at once. Cabal-syntax*Add an error, but not fail the parser yet.For fatal failure use  Cabal-syntaxAdd an fatal error. Cabal-syntaxA .   Safe-InferredȨcIsaac Jones 2003-2004BSD3libraries@haskell.orgportable Safe-Inferred"6;L Cabal-syntaxKnown Haskell language extensions, including deprecated and undocumented ones.Check  https://downloads.haskell.org/~ghc/9.2.3/docs/html/users_guide/exts/table.html9@Overview of all language extensions@ in GHC User@s Guide for more information. Cabal-syntaxAllow overlapping class instances, provided there is a unique most specific instance for each use. Cabal-syntaxIgnore 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. Cabal-syntaxImplies . 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. Cabal-syntax (deprecated) Deprecated in favour of .-Old description: Allow recursive bindings in do blocks, using the rec keyword. See also . Cabal-syntaxAllow recursive bindings in do blocks, using the rec keyword, or mdo, a variant of do. Cabal-syntaxProvide syntax for writing list comprehensions which iterate over several lists together, like the  family of functions. Cabal-syntax*Allow multiple parameters in a type class. Cabal-syntax,Enable the dreaded monomorphism restriction. Cabal-syntaxEnable deep subsumption, relaxing the simple subsumption rules, implicitly inserting eta-expansions when matching up function types with different quantification structures. Cabal-syntaxAllow 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. Cabal-syntax (deprecated) A synonym for .Old description: Like  but does not allow a higher-rank type to itself appear on the left of a function arrow. Cabal-syntaxAllow a universally-quantified type to occur on the left of a function arrow. Cabal-syntax (deprecated) A synonym for .Old description: Allow data constructors to have polymorphic arguments. Unlike ., does not allow this for ordinary functions. Cabal-syntax1Allow existentially-quantified data constructors. Cabal-syntax=Cause a type variable in a signature, which has an explicit forall quantifier, to scope over the definition of the accompanying value declaration. Cabal-syntaxDeprecated, use  instead. Cabal-syntax7Enable implicit function parameters with dynamic scope. Cabal-syntaxRelax some restrictions on the form of the context of a type signature. Cabal-syntaxRelax some restrictions on the form of the context of an instance declaration. Cabal-syntax2Allow data type declarations with no constructors. Cabal-syntax.Run the C preprocessor on Haskell source code. Cabal-syntaxAllow an explicit kind signature giving the kind of types over which a type variable ranges. Cabal-syntaxEnable a form of pattern which forces evaluation before an attempted match, and a form of strict let/where binding. Cabal-syntax&Allow type synonyms in instance heads. Cabal-syntaxEnable Template Haskell, a system for compile-time metaprogramming. Cabal-syntaxEnable the Foreign Function Interface. In GHC, implements the standard Haskell 98 Foreign Function Interface Addendum, plus some GHC-specific extensions. Cabal-syntaxEnable arrow notation. Cabal-syntax (deprecated) Enable generic type classes, with default instances defined in terms of the algebraic structure of a type. Cabal-syntax,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. Cabal-syntaxEnable syntax for implicitly binding local names corresponding to the field names of a record. Puns bind specific names, unlike . Cabal-syntaxEnable a form of guard which matches a pattern and binds variables. Cabal-syntaxAllow a type declared with newtype to use deriving9 for any class with an instance for the underlying type. Cabal-syntax,Enable the "Trex" extensible records system. Cabal-syntaxEnable type synonyms which are transparent in some definitions and opaque elsewhere, as a way of implementing abstract datatypes. Cabal-syntaxEnable an alternate syntax for string literals, with string templating. Cabal-syntaxAllow the character # as a postfix modifier on identifiers. Also enables literal syntax for unboxed values. Cabal-syntaxAllow data types and type synonyms which are indexed by types, i.e. ad-hoc polymorphism for types. Cabal-syntax=Allow a standalone declaration which invokes the type class deriving mechanism. Cabal-syntaxAllow certain Unicode characters to stand for certain ASCII character sequences, e.g. keywords and punctuation. Cabal-syntax:Allow the use of unboxed types as foreign types, e.g. in foreign import and foreign export. Cabal-syntaxEnable interruptible FFI. Cabal-syntax*Allow use of CAPI FFI calling convention (foreign import capi). Cabal-syntaxDefer validity checking of types until after expanding type synonyms, relaxing the constraints on how synonyms may be used. Cabal-syntaxAllow the name of a type constructor, type class, or type variable to be an infix operator. Cabal-syntaxEnable syntax for implicitly binding local names corresponding to the field names of a record. A wildcard binds all unmentioned names, unlike . Cabal-syntaxDeprecated, use  instead. Cabal-syntaxAllow a record field name to be disambiguated by the type of the record it's in. Cabal-syntax=Enable traditional record syntax (as supported by Haskell 98) Cabal-syntaxEnable overloading of string literals using a type class, much like integer literals. Cabal-syntaxEnable generalized algebraic data types, in which type variables may be instantiated on a per-constructor basis. Implies . Cabal-syntax>Enable GADT syntax for declaring ordinary algebraic datatypes. Cabal-syntax (deprecated) Has no effect.3Old description: Make pattern bindings monomorphic. Cabal-syntaxRelax the requirements on mutually-recursive polymorphic functions. Cabal-syntaxAllow default instantiation of polymorphic types in more situations. Cabal-syntaxEnable unboxed tuples. Cabal-syntaxEnable deriving for classes  and . Cabal-syntaxEnable deriving for  and . Cabal-syntax&Enable support for default signatures. Cabal-syntax?Allow type signatures to be specified in instance declarations. Cabal-syntaxAllow a class method's type to place additional constraints on a class type variable. Cabal-syntaxAllow imports to be qualified by the package name the module is intended to be imported from, e.g. import "network" Network.Socket Cabal-syntax (deprecated) Allow a type variable to be instantiated at a polymorphic type. Cabal-syntax (deprecated)1 Change the syntax for qualified infix operators. Cabal-syntaxRelax the interpretation of left operator sections to allow unary postfix operators. Cabal-syntaxEnable quasi-quotation, a mechanism for defining new concrete syntax for expressions and patterns. Cabal-syntaxEnable generalized list comprehensions, supporting operations such as sorting and grouping. Cabal-syntaxEnable monad comprehensions, which generalise the list comprehension syntax to work for any monad. Cabal-syntaxEnable view patterns, which match a value by applying a function and matching on the result. Cabal-syntaxAllow 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. Cabal-syntaxAllow 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-syntax'Enable the use of tuple sections, e.g. (, True) desugars into x -> (x, True). Cabal-syntaxAllow GHC primops, written in C--, to be imported into a Haskell file. Cabal-syntax!Support for patterns of the form n + k, where k is an integer literal. Cabal-syntaxImprove the layout rule when if expressions are used in a do block. Cabal-syntaxEnable support for multi-way if -expressions. Cabal-syntaxEnable support lambda-case expressions. Cabal-syntaxMakes much of the Haskell sugar be desugared into calls to the function with a particular name that is in scope. Cabal-syntaxMake forall a keyword in types, which can be used to give the generalisation explicitly. Cabal-syntax0Allow contexts to be put on datatypes, e.g. the Eq a in /data Eq a => Set a = NilSet | ConsSet a (Set a). Cabal-syntaxLocal (let and where) bindings are monomorphic. Cabal-syntaxEnable deriving for the  class. Cabal-syntaxEnable deriving for the  class. Cabal-syntaxEnable deriving for the  class. Cabal-syntax&Enable non-decreasing indentation for do blocks. Cabal-syntaxAllow imports to be qualified with a safe keyword that requires the imported module be trusted as according to the Safe Haskell definition of trust. import safe Network.Socket Cabal-syntaxCompile a module in the Safe, Safe Haskell mode -- a restricted form of the Haskell language to ensure type safety. Cabal-syntaxCompile 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. Cabal-syntaxCompile a module in the Unsafe, Safe Haskell mode so that modules compiled using Safe, Safe Haskell mode can't import it. Cabal-syntaxAllow type classimplicit parameterequality constraints to be used as types with the special kind constraint. Also generalise the  (ctxt => ty) syntax so that any type of kind constraint can occur before the arrow. Cabal-syntaxEnable kind polymorphism. Cabal-syntaxEnable datatype promotion. Cabal-syntaxEnable  type data7 declarations, defining constructors at the type level. Cabal-syntaxEnable parallel arrays syntax ([:, :]) for Data Parallel Haskell. Cabal-syntax+Enable explicit role annotations, like in (/type role Foo representational representational). Cabal-syntaxEnable overloading of list literals, arithmetic sequences and list patterns using the IsList type class. Cabal-syntaxEnable case expressions that have no alternatives. Also applies to lambda-case expressions if they are enabled. Cabal-syntax (deprecated) Deprecated in favour of .4Old description: Triggers the generation of derived 8: instances for every datatype and type class declaration. Cabal-syntax;Desugars negative literals directly (without using negate). Cabal-syntax5Allow the use of binary integer literal syntax (e.g.  0b11001001 to denote 201). Cabal-syntax>Allow the use of floating literal syntax for all instances of 1 , including F and K. Cabal-syntax7Enable support for type classes with no type parameter. Cabal-syntax9Enable explicit namespaces in module import/export lists. Cabal-syntaxAllow the user to write ambiguous types, and the type inference engine to infer them. Cabal-syntaxEnable foreign import javascript. Cabal-syntax4Allow giving names to and abstracting over patterns. Cabal-syntaxAllow anonymous placeholders (underscore) inside type signatures. The type inference engine will generate a message describing the type inferred at the hole's location. Cabal-syntaxAllow named placeholders written with a leading underscore inside type signatures. Wildcards with the same name unify to the same type. Cabal-syntaxEnable deriving for any class. Cabal-syntaxEnable deriving for the  class. Cabal-syntax.Enable support for 'static pointers' (and the static keyword) to refer to globally stable names, even across different programs. Cabal-syntaxSwitches data type declarations to be strict by default (as if they had a bang using  BangPatterns*), and allow opt-in field laziness using ~. Cabal-syntaxSwitches all pattern bindings to be strict by default (as if they had a bang using  BangPatterns*), ordinary patterns are recovered using ~ . Implies  StrictData. Cabal-syntaxAllows do-notation for types that are ; as well as .. When enabled, desugaring do notation tries to use ( *) and  and $ as far as possible. Cabal-syntax;Allow records to use duplicated field labels for accessors. Cabal-syntax2Enable explicit type applications with the syntax id @Int. Cabal-syntaxDissolve 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. Cabal-syntaxAllow recursive (and therefore undecidable) super-class relationships. Cabal-syntaxA temporary extension to help library authors check if their code will compile with the new planned desugaring of fail. Cabal-syntax A subset of TemplateHaskell including only quoting. Cabal-syntaxAllows use of the #label syntax. Cabal-syntaxAllow functional dependency annotations on type families to declare them as injective. Cabal-syntaxAllow multiple deriving, clauses, each optionally qualified with a strategy. Cabal-syntaxEnable deriving instances via types of the same runtime representation. Implies . Cabal-syntax%Enable the use of unboxed sum syntax. Cabal-syntaxAllow use of hexadecimal literal notation for floating-point values. Cabal-syntaxAllow do" blocks etc. in argument position. Cabal-syntax-Allow use of underscores in numeric literals. Cabal-syntaxAllow forall in constraints. Cabal-syntaxHave * refer to Type. Cabal-syntax?Liberalises deriving to provide instances for empty data types. Cabal-syntax;Enable detection of complete user-supplied kind signatures. Cabal-syntaxAllows the syntax import M qualified. Cabal-syntax,Allow the use of standalone kind signatures. Cabal-syntaxEnable unlifted newtypes. Cabal-syntaxUse whitespace to determine whether the minus sign stands for negation or subtraction. Cabal-syntax(Enable qualified do-notation desugaring. Cabal-syntaxEnable linear types. Cabal-syntax2Allow the use of visible forall in types of terms. Cabal-syntaxEnable the generation of selector functions corresponding to record fields. Cabal-syntax8Enable the use of record dot-accessor and updater syntax Cabal-syntaxProvides record . syntax in record updates, e.g. x {foo.bar = 1}. Cabal-syntaxEnable data types for which an unlifted or levity-polymorphic result kind is inferred. Cabal-syntax>Undocumented parsing-related extensions introduced in GHC 7.0. Cabal-syntax>Undocumented parsing-related extensions introduced in GHC 7.0. Cabal-syntax>Undocumented parsing-related extensions introduced in GHC 7.2. Cabal-syntax2This represents language extensions beyond a base  definition (such as ) that are supported by some implementations, usually in some special mode.Where applicable, references are given to an implementation's official documentation. Cabal-syntaxEnable a known extension Cabal-syntaxDisable a known extension Cabal-syntax4An unknown extension, identified by the name of its LANGUAGE pragma. Cabal-syntax+This represents a Haskell language dialect. Language ;s are interpreted relative to one of these base languages. Cabal-syntax>The Haskell 98 language as defined by the Haskell 98 report. http://haskell.org/onlinereport/ Cabal-syntaxThe Haskell 2010 language as defined by the Haskell 2010 report. /http://www.haskell.org/onlinereport/haskell2010 Cabal-syntax0The GHC2021 collection of language extensions. https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0380-ghc2021.rst Cabal-syntax,An unknown language, identified by its name. Cabal-syntax+List of known (supported) languages for GHC Cabal-syntaxExtensions that have been deprecated, possibly paired with another extension that replaces it. Cabal-syntax 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 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.dIsaac Jones 2003-2004BSD3cabal-devel@haskell.orgportable Safe-Inferred689:;  Cabal-syntaxCompiler information used for resolving configurations. Some fields can be set to Nothing to indicate that the information is unknown. Cabal-syntaxCompiler flavour and version. Cabal-syntaxTag for distinguishing incompatible ABI's on the same architecture/os. Cabal-syntaxOther implementations that this compiler claims to be compatible with, if known. Cabal-syntax'Supported language standards, if known. Cabal-syntaxSupported extensions, if known. Cabal-syntax$ carries only info per GHC and GHCJSCabal parses only  ghc-options and  ghcjs-options, others are omitted. Cabal-syntaxThe 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 X= and the user will have to specify which compiler they want. Cabal-syntaxMake 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.$$e Safe-Inferred6; Cabal-syntaxA ConfVar# represents the variable type used.f Safe-Inferred"3 Cabal-syntaxParse   from section arguments provided by parsec based outline parser.g Safe-Inferred6;*) Cabal-syntaxcomponent is buildable here Cabal-syntaxTools needed to build this bit.This is a legacy field that  largely supersedes.Unless use are very sure what you are doing, use the functions in $Distribution.Simple.BuildToolDepends, rather than accessing this field directly. Cabal-syntax&Haskell tools needed to build this bitThis field is better than  because it allows one to precisely specify an executable in a package.Unless use are very sure what you are doing, use the functions in $Distribution.Simple.BuildToolDepends, rather than accessing this field directly. Cabal-syntax'options for pre-processing Haskell code Cabal-syntaxoptions for assembler Cabal-syntaxoptions for C-- compiler Cabal-syntaxoptions for C compiler Cabal-syntaxoptions for C++ compiler Cabal-syntaxoptions for linker Cabal-syntaxoptions for hsc2hs Cabal-syntax!pkg-config packages that are used Cabal-syntaxsupport frameworks for Mac OS X Cabal-syntax#extra locations to find frameworks. Cabal-syntaxAssembly files. Cabal-syntax C-- files. Cabal-syntax.where to look for the Haskell module hierarchy Cabal-syntaxnon-exposed or non-main modules Cabal-syntax5exposed modules that do not have a source file (e.g. GHC.Prim from ghc-prim package) Cabal-syntaxnot present on sdist, Paths_* or user-generated with a custom Setup.hs Cabal-syntax+language used when not explicitly specified Cabal-syntax'other languages used within the package Cabal-syntax'language extensions used by all modules Cabal-syntax1other language extensions used within the package Cabal-syntax*the old extensions field, treated same as  Cabal-syntaxwhat libraries to link with when compiling a program that uses your package Cabal-syntaxwhat libraries to link with when compiling a program fully statically that uses your package Cabal-syntaxif present, overrides extraLibs when package is loaded with GHCi. Cabal-syntaxif present, adds libs to hs-libraries, which become part of the package. Example 1: the Cffi library shipping with the rts, alongside the HSrts-1.0.a,.o,... Example 2: a library that is being built by a foreign 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 learn how to call arbitrary library builders. Cabal-syntaxHidden 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 rts package, where there are multiple copies of slightly differently built libs. Cabal-syntax9Hidden Flag. This set of strings will be appended to all dynamic libraries when copying. This is particularly useful with the rts package, where we want different dynamic flavours of the RTS library to be installed. Cabal-syntaxdirectories to find .h files Cabal-syntax'The .h files to be found in includeDirs Cabal-syntax&The .h files to be generated (e.g. by autoconf) Cabal-syntax$.h files to install with the package Cabal-syntaxCustom fields starting with x-, stored in a simple assoc-list. Cabal-syntax7Dependencies specific to a library or executable target Cabal-syntaxThe s used by this component Cabal-syntaxThe +s that are used somewhere by this component Cabal-syntaxThe  Extensions/ that are used by all modules in this component Cabal-syntaxWhether any modules in this component use Template Haskell or Quasi Quotes Cabal-syntax1Select options for a particular Haskell compiler.99h Safe-Inferred6;5 Cabal-syntax2 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.Quite 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.Simple, which is responsible for orchestrating the hooks mechanism. The general strategy: &We run the pre-hook, which produces a  (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.In principle, we are also supposed to update the copy of the PackageDescription stored in LocalBuildInfo at  localPkgDescr. 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  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.i Safe-Inferred5 Cabal-syntaxClassy lenses for .33j Safe-Inferred6;7 Cabal-syntax&A "test-suite" stanza in a cabal file. Cabal-syntax+Get all the module names from a test suite. Cabal-syntaxGet all the auto generated module names from a test suite. This are a subset of .  k Safe-Inferred8l Safe-Inferred6;< Cabal-syntaxWhat sigs need implementations? Cabal-syntaxIs the lib to be exposed by default? (i.e. whether its modules available in GHCi for example) Cabal-syntaxWhether this multilib can be used as a dependency for other packages. Cabal-syntaxGet 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.) Cabal-syntaxGet all the auto generated module names from the library, exposed or not. This are a subset of  libModules. Cabal-syntaxCombine  1. in parsing we prefer value coming from munged name field over the lib-name.Should be irrelevant. Cabal-syntaxThis instance is not good.We need it for . 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.  m Safe-Inferred=Rn Safe-Inferred6;E% Cabal-syntaxA foreign library stanza is like a library stanza, except that the built code is intended for consumption by a non-Haskell client. Cabal-syntaxName of the foreign library Cabal-syntax9What kind of foreign library is this (static or dynamic). Cabal-syntaxWhat options apply to this foreign library (e.g., are we merging in all foreign dependencies.) Cabal-syntax+Build information for this foreign library. Cabal-syntaxLibtool-style version-info data to compute library version. Refer to the libtool documentation on the current:revision:age versioning scheme. Cabal-syntaxLinux library version Cabal-syntax*(Windows-specific) module definition filesThis is a list rather than a maybe field so that we can flatten the condition trees (for instance, when creating an sdist) Cabal-syntax Construct  from (current, revision, age) numbers.For instance, mkLibVersionInfo (3,0,0) constructs a  representing the version-info 3:0:0.,All version components must be non-negative. Cabal-syntax From a given , extract the (current, revision, age) numbers. Cabal-syntax&Given a version-info field, produce a major.minor.build version Cabal-syntax#Given a version-info field, return "major.minor.build" as a B Cabal-syntax Return the major! version of a version-info field. Cabal-syntaxAn empty foreign library. Cabal-syntax%Modules defined by a foreign library. Cabal-syntaxIs the foreign library shared? Cabal-syntaxGet 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.o Safe-InferredEp Safe-Inferred6;F Cabal-syntax$Get all the module names from an exe Cabal-syntaxGet all the auto generated module names from an exe This are a subset of .  q Safe-InferredFr Safe-Inferred6;G Cabal-syntax%A "benchmark" stanza in a cabal file. Cabal-syntax*Get all the module names from a benchmark. Cabal-syntaxGet all the auto generated module names from a benchmark. This are a subset of .  s Safe-Inferred;I Cabal-syntax0Is a component buildable (i.e., not marked with buildable: False)? See also this note in Distribution.Types.ComponentRequestedSpec#buildable_vs_enabled_components.  t Safe-Inferred6;L Cabal-syntax0A reason explaining why a component is disabled. Cabal-syntaxDescribes what components are enabled by user-interaction. See also this note in Distribution.Types.ComponentRequestedSpec#buildable_vs_enabled_components. Cabal-syntaxThe default set of enabled components. Historically tests and benchmarks are NOT enabled by default. Cabal-syntax3Is this component enabled? See also this note in Distribution.Types.ComponentRequestedSpec#buildable_vs_enabled_components. Cabal-syntax8Is this component name enabled? See also this note in Distribution.Types.ComponentRequestedSpec#buildable_vs_enabled_components. Cabal-syntax+Is this component disabled, and if so, why? Cabal-syntax0Is this component name disabled, and if so, why?uIsaac Jones 2003-2005BSD3cabal-devel@haskell.orgportable Safe-Inferred6;] Cabal-syntax: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. Cabal-syntaxThe version of the Cabal spec that this package description uses. Cabal-syntax"A one-line summary of this package Cabal-syntax*A more verbose description of this package Cabal-syntaxCustom fields starting with x-, stored in a simple assoc-list. Cabal-syntax The original  build-type value as parsed from the .cabal# file without defaulting. See also . Cabal-syntax The SPDX LicenseExpression of the package. Cabal-syntaxSee . Cabal-syntaxThe effective  build-type! after applying defaulting rules. The original  build-type value parsed is stored in the  field. However, the  build-type 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. Cabal-syntax2Does this package have a buildable PUBLIC library? Cabal-syntax%Does this package have any libraries? Cabal-syntaxIf 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 Distribution.Types.ComponentRequestedSpec#buildable_vs_enabled_components for more information. Cabal-syntax'does this package have any executables? Cabal-syntax%Perform the action on each buildable 1 in the package description. You probably want  withExeLBI if you have a LocalBuildInfo, see the note in Distribution.Types.ComponentRequestedSpec#buildable_vs_enabled_components for more information. Cabal-syntax'Does this package have any test suites? Cabal-syntax$Perform an action on each buildable " in a package. You probably want  withTestLBI if you have a LocalBuildInfo, see the note in Distribution.Types.ComponentRequestedSpec#buildable_vs_enabled_components for more information. Cabal-syntax&Does this package have any benchmarks? Cabal-syntax$Perform an action on each buildable " in a package. You probably want  withBenchLBI if you have a LocalBuildInfo, see the note in Distribution.Types.ComponentRequestedSpec#buildable_vs_enabled_components for more information. Cabal-syntax-Does this package have any foreign libraries? Cabal-syntax%Perform the action on each buildable  in the package description. Cabal-syntaxAll  in the 6: libraries, executables, test-suites and benchmarks.'Useful for implementing package checks. Cabal-syntaxReturn all of the s of enabled components, i.e., all of the ones that would be built if you run  ./Setup build. Cabal-syntax9Get the combined build-depends entries of all components. Cabal-syntaxGet the combined build-depends entries of all enabled components, per the given request spec. Cabal-syntax"All the components in the package. Cabal-syntaxA list of all components in the package that are buildable, i.e., were not marked with buildable: False. This does NOT indicate if we are actually going to build the component, see  instead. Cabal-syntax9A list of all components in the package that are enabled.::v Safe-Inferred6;_l Cabal-syntaxThis is a version as specified in source. We populate this field in index reading for dummy GPDs, only when GPD reading failed, but scanning haven't.Cabal-the-library never produces GPDs with Just as gpdScannedVersion.Perfectly, PackageIndex should have sum type, so we don't need to have dummy GPDs.  w Safe-Inferred_  x Safe-Inferred`Ty Safe-Inferred"` Cabal-syntax Cabal-syntax Cabal-syntax"" Safe-Inferreda Isaac Jones 2003-2005BSD3cabal-devel@haskell.orgportable Safe-Inferredc zThomas Schilling, 2007BSD3cabal-devel@haskell.orgportable Safe-Inferred}" Cabal-syntax0A set of targets with their package dependencies Cabal-syntaxA map of package constraints that combines version ranges using  . Cabal-syntax)Result of dependency test. Isomorphic to Maybe d but renamed for clarity. Cabal-syntaxSimplify a configuration condition using the OS and arch names. Returns the names of all the flags occurring in the condition. Cabal-syntax.Parse a configuration condition from a string. Cabal-syntaxTry 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.]TODO: The current algorithm is rather naive. A better approach would be to:Rule 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).This would require some sort of SAT solving, though, thus it's not implemented unless we really need it. Cabal-syntax Transforms a  by putting the input under the "then" branch of a conditional that is True when Buildable is True. If  can determine that Buildable is always True, it returns the input unchanged. If Buildable is always False, it returns the empty . Cabal-syntaxThis is a special version of  for the  type.It is not simply a specialisation. It is more complicated than it ought to be because of the way the  monoid instance works. The  mempty =  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. Cabal-syntaxExtract conditions matched by the given predicate from all cond trees in a . Cabal-syntaxCombine the target-specific dependencies in a TargetSet to give the dependencies for the package as a whole. Cabal-syntaxCollect up the targets in a TargetSet of tagged targets, storing the dependencies as we go. Cabal-syntax>Create a package description with all configurations resolved.This function takes a ; and several environment parameters and tries to generate  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: False. While this is arguably the right thing to do, it means we give bad error messages in some situations, see #3858. Cabal-syntaxFlatten 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. Cabal-syntaxWalk a  and apply f to all nested  build-depends fields. Cabal-syntaxWalk a  and apply f to all nested  build-depends fields. Cabal-syntax3Domain for each flag name, will be tested in order. Cabal-syntax3OS where the installed artifacts will run (host OS) Cabal-syntax7Arch where the installed artifacts will run (host Arch) Cabal-syntaxCompiler information Cabal-syntaxAdditional constraints Cabal-syntaxDependency test function. Cabal-syntaxEither the missing dependencies (error case), or a pair of (set of build targets with dependencies, chosen flag assignments) Cabal-syntax%Explicitly specified flag assignments Cabal-syntaxIs a given dependency satisfiable from the set of available packages? If this is unknown then use True. Cabal-syntaxThe  and  Cabal-syntaxCompiler information Cabal-syntaxAdditional constraints Cabal-syntaxEither missing dependencies or the resolved package description along with the flag assignments chosen.{ Safe-Inferred " Cabal-syntaxVersion range or just version Cabal-syntax)SPDX License expression or legacy license Cabal-syntax$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/4899We have this newtype, as writing Parsec and Pretty instances for CabalSpecVersion would cause cycle in modules: Version -> CabalSpecVersion -> Parsec -> ... Cabal-syntaxFilepath are parsed as . Cabal-syntaxEither "quoted" or  un-quoted. Cabal-syntaxHaskell string or [^ ]+ Cabal-syntaxHaskell string or [^ ,]+ Cabal-syntaxLike  , but for V. Cabal-syntaxLike  , but for . Cabal-syntax4List separated with optional commas. Displayed with sep, arguments of type a" are parsed and pretty-printed as b. Cabal-syntax3Paragraph fill list without commas. Displayed with . Cabal-syntax9Paragraph fill list with optional commas. Displayed with . Cabal-syntax3Vertical list with optional commas. Displayed with . Cabal-syntax0Paragraph fill list with commas. Displayed with  Cabal-syntax*Vertical list with commas. Displayed with  Cabal-syntax and  are simply , with additional phantom arguments to constrain the resulting type:t alaList VCat/alaList VCat :: [a] -> List VCat (Identity a) a:t alaList' FSep Token9alaList' FSep Token :: [String] -> List FSep Token String Cabal-syntaxMore general version of . Cabal-syntax and  are simply  constructor, with additional phantom arguments to constrain 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"]) Cabal-syntaxMore general version of . Cabal-syntax and  are simply  constructor, with additional phantom arguments to constrain the resulting type:t alaNonEmpty VCat?alaNonEmpty VCat :: NonEmpty a -> NonEmpty' VCat (Identity a) aunpack' (alaNonEmpty' FSep Token) <$> eitherParsec "foo bar foo"Right ("foo" :| ["bar","foo"]) Cabal-syntaxMore general version of .,,| Safe-Inferred /g Cabal-syntax is parametrised bys 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. Cabal-syntaxUnfocus, zoom out, blur . Cabal-syntax,Field which should be defined, exactly once. Cabal-syntax#Boolean field with a default value. Cabal-syntaxOptional field. Cabal-syntax"Optional field with default value. Cabal-syntax Cabal-syntaxMonoidal field.Values are combined with ".Note:  is a  monoidalField with Last monoid. Cabal-syntax>Parser matching all fields with a name starting with a prefix. Cabal-syntax4Known field, which we don't parse, nor pretty print. Cabal-syntax-Field which is parsed but not pretty printed. Cabal-syntaxDeprecated since Cabal-syntax9Removed in. If we encounter removed field, parsing fails. Cabal-syntax'Annotate field with since spec-version. Cabal-syntaxAnnotate field with since spec-version. This is used to recognise, but warn about the field. It is used to process other-extensions field.&Default implementation is to not warn. Cabal-syntax(Field which can be defined at most once. Cabal-syntax(Field which can be defined at most once. Cabal-syntax"Optional field with default value. Cabal-syntax>Field which can be define multiple times, and the results are mappended. Cabal-syntaxDefault implementation for . Cabal-syntax field name Cabal-syntax pack Cabal-syntaxlens into the field Cabal-syntax field name Cabal-syntaxlens into the field Cabal-syntaxdefault Cabal-syntax field name Cabal-syntaxpack Cabal-syntaxlens into the field Cabal-syntax field name Cabal-syntax pack Cabal-syntax s a: lens into the field Cabal-syntax default value Cabal-syntaxlens into the field Cabal-syntaxlens into the field Cabal-syntaxlens into the field Cabal-syntax field name Cabal-syntaxpack Cabal-syntaxlens into the field Cabal-syntaxfield name prefix Cabal-syntaxlens into the field Cabal-syntaxversion Cabal-syntaxdeprecation message Cabal-syntaxversion Cabal-syntaxremoval message Cabal-syntax spec version Cabal-syntax default value Cabal-syntax spec version Cabal-syntax field name Cabal-syntaxlens into the field Cabal-syntax field name Cabal-syntaxlens into the field Cabal-syntax field name Cabal-syntax s a: lens into the field Cabal-syntax default value Cabal-syntax field name Cabal-syntaxlens into the field Cabal-syntaxlens into the field} Safe-Inferred8d Cabal-syntax We can use  to pp print the s.Note: there is not trailing  ($+$ text "").~ Safe-Inferred"8 Cabal-syntaxThe  constructor of . Cabal-syntax4Single field, without name, but with its annotation.   Safe-Inferred\ Cabal-syntaxPartitioning state Cabal-syntax6Reverse function application which binds tighter than  and %-. Useful for refining grammar specification. <*>  "extensions" (alaList' FSep MQuoted) oldExtensions ^^^  [1,12] "Please use 'default-extensions' or 'other-extensions' fields."  Cabal-syntax;Partition field list into field map and groups of sections. Cabal-syntaxTake all fields from the front.%5 Safe-Inferred"/5 Cabal-syntax?Compat FilePath accepts empty file path, but issues a warning.:There are simply too many (~1200) package definition files license-file: "" and  data-dir: "" across Hackage to outrule them completely. I suspect some of them are generated (e.g. formatted) by machine. Cabal-syntaxAn intermediate type just used for parsing the benchmark stanza. After validation it is converted into the proper  type. Cabal-syntaxAn intermediate type just used for parsing the test-suite stanza. After validation it is converted into the proper  type. Cabal-syntax and 1 are for generating VIM syntax file definitions.00Jrgen Nicklisch-Franken 2010BSD3cabal-devel@haskell.org provisionalportable Safe-Inferred" Cabal-syntax7Writes a .cabal file from a generic package description Cabal-syntax0Writes a generic package description to a string Cabal-syntax)Convert a generic package description to s. Cabal-syntax Cabal-syntax Cabal-syntax Cabal-syntaxIsaac Jones 2003-2005BSD3cabal-devel@haskell.orgportable Safe-Inferred"  Cabal-syntaxSee . Cabal-syntaxCreate a from 9. This class is used to implement common stanza parsing.Law: #view buildInfo . fromBuildInfo = idThis takes name, as s take names too. Cabal-syntaxState of section parser Cabal-syntaxParses 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. Cabal-syntaxL variant of  Cabal-syntax%Parse a non-recursive list of fields. Cabal-syntaxWarn on "import" fields, also map to Maybe, so errorneous fields can be filtered Cabal-syntax Check that we$don't use undefined flags (very bad)(define flags which are unused (just bad) Cabal-syntaxSince cabal-version: 1.24 one can specify  custom-setup. Let us require it. Cabal-syntax Sectionize2 an old-style Cabal file. A sectionized file has:/all global fields at the beginning, followed by"all flag declarations, followed byan 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-syntax#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  Cabal-syntaxfields to be parsed Cabal-syntaxaccept elif Cabal-syntaxgrammar Cabal-syntaxcommon stanzas Cabal-syntaxconstructor from buildInfo Cabal-syntaxcondition extractor Cabal-syntaxgrammar Cabal-syntaxconstruct fromBuildInfo Cabal-syntaxcommon stanzas Cabal-syntaxconstruct fromBuildInfo Cabal-syntaxcommon stanzas Safe-Inferred8 Cabal-syntax2A collection of field parsers and pretty-printers. Cabal-syntax$Lookup a field value pretty-printer. Cabal-syntaxLookup a field value parser. Cabal-syntaxNote: default values are printed. Safe-Inferred"%&/ Cabal-syntaxThis type is used to mangle fields as in serialised textual representation to the actual  fields. Cabal-syntaxSPDX License expression or legacy license. Lenient parser, accepts either. Cabal-syntaxCombine  1. in parsing we prefer value coming from munged name field over the lib-name.Should be irrelevant. Cabal-syntaxSetter for the  package-name9 field. It should be acceptable for this to be a no-op.4"(c) The University of Glasgow 2004libraries@haskell.orgportable Safe-Inferred Cabal-syntaxGet 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). For indefinite libraries, however, you will correctly get an  OpenUnitId with the appropriate . Cabal-syntaxReturns the set of module names which need to be filled for an indefinite package, or the empty set if the package is definite. Cabal-syntax2Return either errors, or IPI with list of warnings Cabal-syntax Pretty print .pkgRoot; isn't printed, as ghc-pkg prints it manually (as GHC-8.4). Cabal-syntaxThe variant of  which outputs pkgroot field too. Cabal-syntax=let ipi = emptyInstalledPackageInfo { maintainer = "Tester" }9fmap ($ ipi) $ showInstalledPackageInfoField "maintainer"Just "maintainer: Tester"                                                          ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! " " " # # # # # # # # # # # # # # # # # # # $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ % % % % % % % % % % % % % % % % % % % % % % % % & & & & & & & & & & & & & & & & & & & & ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) * * * * * * * * * + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + , , , , , , , - - - - - - - - - - - - - - . . . . . . . . . . . . . . . . . . . . . . . . . / / / / / / / / / / / / / / / 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 7 7 7 7 7 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 : : : : : : : : : : : : : : :::::::::::::;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<=============>>???????????????????????????????????????????????????????????????????????????????????????@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIJJJJJJJJKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQRRRRRRRRRRRRRRSSTTTTTTTTTTTTTTTTUUUUUUUUUUUUUVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXYYZZZZZZZZZ[[[[[[[[[[[[[[[[\\\\\\\\\\\\\\]]]]]]]]]]]]]]^^^^^^^^^^^^^______________________________`````````````````````````````````````````````````````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddeeee eeeeeeeeffgggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggghhiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjjjjjjjjjjjjjjjjjjjkkkllllllllllllllllllllllllmmmmmmmnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnooooooopppppppppppppppppppppqqqqrrrrrrrrrrrrrrrrrrrrrssssssssssssssssttttttttttttttttttttuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuvvvvvvvvvvvvvvvvvvvvvwwwwwwwwwww w w w wwwwxxxyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyzzzzzzzzzzzzzzzz{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{||||||||||||||||||||||}}}}}~~ ~~~~~~~~~~~~~~~~~~~ """# '(((((((((()))88Fcltzzzzzzzzz,Cabal-syntax-3.10.2.0-4s9v55YS0UyD8dLofJ8HlNDistribution.Compat.PreludeDistribution.Compat.MonadFailDistribution.Compat.SemigroupDistribution.Compat.TypeableDistribution.Compat.ParsingDistribution.Compat.ExceptionDistribution.Utils.GenericDistribution.Compat.GraphDistribution.Compat.BinaryDistribution.Compat.Newtype%Distribution.PackageDescription.UtilsDistribution.Utils.Base62Distribution.Utils.MD5Distribution.Utils.StringDistribution.Utils.StructuredDistribution.Compat.NonEmptySetDistribution.Utils.ShortTextDistribution.Types.ConditionDistribution.Parsec.PositionDistribution.Parsec.Warning#Distribution.Parsec.FieldLineStreamDistribution.Parsec.Error&Distribution.PackageDescription.QuirksDistribution.Fields.LexerMonadDistribution.Fields.LexerDistribution.Compat.DListDistribution.Compat.LensDistribution.Types.CondTreeDistribution.Compat.CharParsingDistribution.CabalSpecVersion$Distribution.SPDX.LicenseListVersionDistribution.PrettyDistribution.Fields.FieldDistribution.Fields.ParserDistribution.Fields.PrettyDistribution.ParsecDistribution.Utils.PathDistribution.Types.Version(Distribution.Types.VersionRange.Internal)Distribution.Types.VersionInterval.Legacy"Distribution.Types.VersionIntervalDistribution.Types.VersionRangeDistribution.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.LibraryVisibilityDistribution.Types.LibraryName$Distribution.Types.MungedPackageName!Distribution.Types.ForeignLibType#Distribution.Types.ForeignLibOptionDistribution.Types.Flag"Distribution.Types.ExecutableScope Distribution.Types.ComponentNameDistribution.Types.ComponentIdDistribution.Types.BuildTypeDistribution.Types.AbiHashDistribution.TextDistribution.System"Distribution.SPDX.LicenseReferenceDistribution.SPDX.LicenseId$Distribution.SPDX.LicenseExceptionId#Distribution.SPDX.LicenseExpressionDistribution.SPDX.LicenseDistribution.ModuleName!Distribution.Types.ModuleRenaming"Distribution.Types.IncludeRenamingDistribution.Types.Mixin!Distribution.Types.ModuleReexportDistribution.VersionDistribution.Types.TestType%Distribution.Types.TestSuiteInterfaceDistribution.Types.PackageIdDistribution.Types.UnitIdDistribution.Types.ModuleDistribution.Backpack Distribution.Types.ExposedModule+Distribution.Types.PackageVersionConstraint!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.Package Distribution.Types.AbiDependencyDistribution.License'Distribution.Types.InstalledPackageInfo,Distribution.Types.InstalledPackageInfo.LensDistribution.Fields.ParseResultLanguage.Haskell.ExtensionDistribution.CompilerDistribution.Types.ConfVarDistribution.Fields.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.PackageDescription.Configuration"Distribution.FieldGrammar.NewtypesDistribution.FieldGrammar.Class Distribution.FieldGrammar.Pretty Distribution.FieldGrammar.ParsecDistribution.FieldGrammar,Distribution.PackageDescription.FieldGrammar+Distribution.PackageDescription.PrettyPrint&Distribution.PackageDescription.Parsec%Distribution.FieldGrammar.FieldDescrs4Distribution.Types.InstalledPackageInfo.FieldGrammar!Distribution.InstalledPackageInfoText.PrettyPrint<>BS ByteString Data.ListnubnubBySystem.FilePath isAbsolute isRelativeDistribution.SPDX simpleParseIncludeRenamingData.MapelemstoList Data.GraphGraphDistribution.Fields Data.TypeableTypeable Data.GenericsData GHC.GenericsGenericGeneric1 Data.FunctorFunctorData.Traversable Traversable Data.FoldableFoldableLanguage.Haskell.TH.SyntaxLift PackageDescription.ConfigurationaddBuildableConditionDistribution.Types.LensDistribution.PackageDescriptionbaseGHC.Base++ghc-primGHC.PrimseqGHC.Listfilterzip System.IOprint Data.Tuplefstsnd otherwisemap$GHC.Num fromInteger-GHC.Real fromRationalGHC.EnumenumFrom enumFromThen enumFromToenumFromThenTo GHC.Classes==>=negate>>=>>fmapreturnControl.Monad.Failfail Control.Arrowfirst Data.String fromString fromIntegral realToFrac toInteger toRational Control.Monadguardmemptymappendmconcatjoin<*>pure*>BoundedEnumEq GHC.FloatFloating FractionalIntegralMonad Data.DataNumOrdGHC.ReadReadReal RealFloatRealFracGHC.ShowShowData.Typeable.Internal MonadFailIsString Applicative SemigroupMonoid GHC.TypesBoolStringCharDoubleFloatIntGHC.IntInt8Int16Int32Int64 ghc-bignumGHC.Num.IntegerInteger GHC.MaybeMaybeOrderingRationalIOWordGHC.WordWord8Word16Word32Word64 Data.EitherEitherNonEmptyFalseNothingJustTrue:|LeftRightLTEQGT Data.VoidVoidvacuousabsurdData.List.NonEmptytailnonEmptylastinithead System.ExitexitWith exitSuccess exitFailureunlessfoldMfilterMtraverse sequenceAforControl.ApplicativeoptionalData.Functor.Identity runIdentityIdentity writeFilereadLnreadIOreadFileputStrLnputStrputCharinteractgetLine getContentsgetChar appendFileGHC.IO.Exception ExitSuccess ExitFailureExitCodeioErrorGHC.IOFilePaththrowIOevaluatecatch IOExceptionIOError userErrorGHC.Exception.Type SomeException toException fromExceptiondisplayException ExceptionTypeReptypeRepData.Functor.ConstgetConstConstsumproductnullminimummaximumlengthfoldrfoldl'foldlfoldMapelem traverse_ sequence_ornotElemfor_find concatMapconcatanyandall Data.OldListwordsunwordsunlinesunfoldrsortBysort partitionlines isSuffixOf isPrefixOf isInfixOf intersperse intercalate dropWhileEndData.Semigroup.InternalgetAnyAnygetAllAllData.Ord comparing Text.Readreads readMaybepartitionEitherseither Data.ProxyProxy readsPrecreadList readParenlexText.ParserCombinators.ReadPReadS significand scaleFloatisNegativeZeroisNaN isInfiniteisIEEEisDenormalized floatRange floatRadix floatDigitsexponent encodeFloat decodeFloatatan2tanhtansqrtsinhsinpilogBaselogexpcoshcosatanhatanasinhasinacoshacos** GHC.UnicodetoUppertoLowerisUpperisSpaceisDigit isAlphaNumisAlphatruncateroundproperFractionfloorceilingremquotRemquotmoddivModdivrecip/oddlcmgcdeven^^^toEnumsuccpredfromEnumminBoundmaxBoundGHC.CharchrShowS showsPrecshowListshowshows showString showParenshowCharzipWith3zipWithzip3unzip3unzip takeWhiletakesplitAtspanscanr1scanrscanl1scanlreverse replicaterepeatlookupiterate dropWhiledropcyclebreak!! Data.Maybe maybeToListmaybemapMaybe listToMaybe isNothingisJust fromMaybe catMaybes Data.Functiononvoid<$>uncurrycurrysignumabs+*subtractmzeromplus MonadPlus<$<*somemanyempty<|> AlternativewhenuntilordliftM2liftMidflipconstasTypeOfap=<<.$!GHC.Err undefinederrorWithoutStackTraceerror&&not||/=<<=>comparemaxminbinary-0.8.9.0Data.Binary.ClassputListputgetBinarycontainers-0.6.5.1Data.Map.InternalMap CyclicSCC AcyclicSCCSCCData.Set.InternalSetdeepseq-1.4.6.1Control.DeepSeqrnfNFDataforcedeepseqpretty-1.1.3.6Text.PrettyPrint.HughesPJ<+>decodeFileOrFail'decodeOrFailIOtryIOcatchIO catchExitNewtypepackunpackalaalafpack'unpack'$fNewtypeFUNEndo$fNewtypeaProduct $fNewtypeaSum$fNewtypeaIdentityuserBugcabalBug hashToBase62MD5showMD5md5 binaryPutMD5 binaryGetMD5md5FromIntegerdecodeStringUtf8encodeStringUtf8trim GStructuredTag 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 $fEqOption' $fOrdOption' $fReadOption' $fShowOption'$fBinaryOption'$fGenericOption'$fFunctorOption' $fEqLast' $fOrdLast' $fReadLast' $fShowLast'$fGenericLast' $fBinaryLast' $fEqFirst' $fOrdFirst' $fShowFirst' NonEmptySet singletoninsertdelete fromNonEmpty toNonEmptytoSetmember$fFoldableNonEmptySet$fSemigroupNonEmptySet$fNFDataNonEmptySet$fStructuredNonEmptySet$fBinaryNonEmptySet$fShowNonEmptySet$fEqNonEmptySet$fOrdNonEmptySet$fDataNonEmptySet$fReadNonEmptySet<<>> genericRnffoldr1foldl1trace traceShowId traceShow $fGNFData:+: $fGNFData:*: $fGNFDataM1 $fGNFDataK1 $fGNFDataU1 $fGNFDataV1 ShortText toShortText fromShortTextunsafeFromUTF8BS$fIsStringShortText$fMonoidShortText$fSemigroupShortText$fReadShortText$fShowShortText$fNFDataShortText$fStructuredShortText$fBinaryShortText $fEqShortText$fOrdShortText$fGenericShortText$fDataShortTextwrapTextwrapLinewithFileContentswriteFileAtomic fromUTF8BS fromUTF8LBStoUTF8BS toUTF8LBS validateUTF8 ignoreBOM readUTF8FilewithUTF8FileContents writeUTF8FilenormaliseLineEndingsdropWhileEndLEtakeWhileEndLEordNubordNubBy listUnion ordNubRightlistUnionRightsafeHeadsafeTailsafeLastsafeInitequating lowercaseisAscii isAsciiAlphaisAsciiAlphaNum unintersperse breakMaybe spanMaybeunfoldrMunsnocunsnocNEfstOf3sndOf3trdOf3isAbsoluteOnAnyPlatformisRelativeOnAnyPlatform ConditionVarLitCNotCOrCAndcNotcAndcOrsimplifyCondition$fNFDataCondition$fStructuredCondition$fBinaryCondition$fMonadPlusCondition$fAlternativeCondition$fSemigroupCondition$fMonoidCondition$fMonadCondition$fApplicativeCondition$fTraversableCondition$fFoldableCondition$fFunctorCondition$fShowCondition $fEqCondition$fDataCondition$fGenericConditionPositionincPosretPosshowPoszeroPos positionCol positionRow$fNFDataPosition$fBinaryPosition $fEqPosition $fOrdPosition$fShowPosition$fGenericPositionPWarning PWarnTypePWTOtherPWTUTF PWTBoolCase PWTVersionTag PWTNewSyntax PWTOldSyntaxPWTDeprecatedFieldPWTInvalidSubsectionPWTUnknownFieldPWTUnknownSectionPWTTrailingFieldsPWTExtraMainIsPWTExtraTestModulePWTExtraBenchmarkModule PWTLexNBSP PWTLexBOM PWTLexTabPWTQuirkyCabalFile PWTDoubleDashPWTMultipleSingularFieldPWTBuildTypeDefaultPWTVersionOperatorPWTVersionWildcardPWTSpecVersionPWTEmptyFilePathPWTExperimental showPWarning$fNFDataPWarnType$fBinaryPWarnType$fNFDataPWarning$fBinaryPWarning $fEqPWarning $fOrdPWarning$fShowPWarning$fGenericPWarning $fEqPWarnType$fOrdPWarnType$fShowPWarnType$fEnumPWarnType$fBoundedPWarnType$fGenericPWarnTypeFieldLineStreamFLSLastFLSConsfieldLineStreamEndfieldLineStreamFromStringfieldLineStreamFromBS$fStreamFieldLineStreammChar$fShowFieldLineStreamPError showPError$fNFDataPError$fBinaryPError $fShowPError$fGenericPError patchQuirks InputStreamLexStatecurPoscurInputcurCodewarnings LexWarningLexWarningTypeLexWarningNBSP LexWarningBOM LexWarningTab LexResultLexunLex toPWarnings execLexersetPosgetPos adjustPosgetInputsetInput getStartCode setStartCode addWarning addWarningAt $fMonadLex$fApplicativeLex $fFunctorLex$fShowLexWarning$fEqLexWarningType$fOrdLexWarningType$fShowLexWarningTypeLTokenLTokenTokSymTokStrTokOtherIndent TokFieldLineColon OpenBrace CloseBraceEOF LexicalErrorlexTokenltest mkLexState bol_sectionin_field_bracesin_field_layout in_section $fShowLToken $fShowTokenParsingtryskipManyskipSome unexpectedeof notFollowedBychoiceoption skipOptionalbetweensepBy sepByNonEmptysepEndByNonEmptysepEndBy endByNonEmptyendBycountchainrchainlchainl1chainr1manyTill$fParsingParsecT$fParsingIdentityT $fParsingRWST$fParsingRWST0$fParsingWriterT$fParsingWriterT0$fParsingReaderT$fParsingStateT$fParsingStateT0DListrunDListfromListsnoc$fSemigroupDList $fMonoidDListPretext runPretextALens'ALensASetterAGetterGetting Traversal'Lens' TraversalLens LensLike'LensLikeviewusegettingsetover toDListOftoListOftoSetOfaview_1_2&^..~?~%~.=?=%=^##~#%~ cloneLens$fFunctorPretext CondBranchcondBranchConditioncondBranchIfTruecondBranchIfFalseCondTreeCondNode condTreeDatacondTreeConstraintscondTreeComponents condIfThencondIfThenElse mapCondTreemapTreeConstrs mapTreeConds mapTreeDatatraverseCondTreeVtraverseCondBranchVtraverseCondTreeCtraverseCondBranchCextractConditionsimplifyCondTreeignoreConditions foldCondTree$fNFDataCondBranch$fStructuredCondBranch$fBinaryCondBranch$fFoldableCondBranch$fMonoidCondTree$fSemigroupCondTree$fNFDataCondTree$fStructuredCondTree$fBinaryCondTree$fShowCondBranch$fEqCondBranch$fDataCondBranch$fGenericCondBranch$fFunctorCondBranch$fTraversableCondBranch$fShowCondTree $fEqCondTree$fDataCondTree$fGenericCondTree$fFunctorCondTree$fFoldableCondTree$fTraversableCondTree CharParsingsatisfycharnotCharanyCharstringtextoneOfnoneOfspacesspacenewlinetabupperloweralphaNumletterdigithexDigitoctDigit satisfyRangeintegralsignedIntegralmunch1munch 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_0 CabalSpecV3_4 CabalSpecV3_6 CabalSpecV3_8showCabalSpecVersioncabalSpecLatestcabalSpecFromVersionDigitscabalSpecToVersionDigitscabalSpecMinimumLibraryVersionspecHasCommonStanzas specHasElif$fNFDataCabalSpecVersion$fStructuredCabalSpecVersion$fBinaryCabalSpecVersion$fEqHasCommonStanzas$fShowHasCommonStanzas $fEqHasElif $fShowHasElif$fEqCabalSpecVersion$fOrdCabalSpecVersion$fShowCabalSpecVersion$fReadCabalSpecVersion$fEnumCabalSpecVersion$fBoundedCabalSpecVersion$fDataCabalSpecVersion$fGenericCabalSpecVersionLicenseListVersionLicenseListVersion_3_0LicenseListVersion_3_2LicenseListVersion_3_6LicenseListVersion_3_9LicenseListVersion_3_10LicenseListVersion_3_16!cabalSpecVersionToSPDXListVersion$fEqLicenseListVersion$fOrdLicenseListVersion$fShowLicenseListVersion$fEnumLicenseListVersion$fBoundedLicenseListVersion SeparatorPrettyprettyprettyVersioned prettyShow defaultStyle flatStyle showFilePath showToken showTokenStr showFreeTextshowFreeTextV3$fPrettyIdentity $fPrettyInt $fPrettyBool $fPrettyDocName FieldName SectionArg SecArgName SecArgStr SecArgOther FieldLineFieldSection fieldNamefieldAnn fieldUniverse fieldLineAnn fieldLineBS sectionArgAnnmkNamegetNamenameAnnsectionArgsToStringfieldLinesToString $fEqField $fShowField$fFunctorField$fFoldableField$fTraversableField$fEqName $fShowName $fFunctorName$fFoldableName$fTraversableName$fEqSectionArg$fShowSectionArg$fFunctorSectionArg$fFoldableSectionArg$fTraversableSectionArg $fEqFieldLine$fShowFieldLine$fFunctorFieldLine$fFoldableFieldLine$fTraversableFieldLine readFields readFields'$fStreamLexState'IdentityLToken PrettyField PrettySection PrettyEmptyCommentPosition CommentBefore CommentAfter NoComment showFields showFields'genericFromParsecFieldsprettyFieldLinesprettySectionArgsfromParsecFields$fSemigroupMargin $fEqMargin$fFunctorPrettyField$fFoldablePrettyField$fTraversablePrettyField ParsecParserPPunPP CabalParsing parsecWarningparsecHaskellStringaskCabalSpecVersionParsecparsec lexemeParsec simpleParsecsimpleParsecBS simpleParsec'simpleParsecW' eitherParsecexplicitEitherParsecexplicitEitherParsec'runParsecParserrunParsecParser' parsecToken parsecToken'parsecFilePathparsecStandardparsecCommaListparsecCommaNonEmptyparsecLeadingCommaListparsecLeadingCommaNonEmptyparsecOptCommaListparsecLeadingOptCommaList parsecQuotedparsecMaybeQuotedparsecUnqualComponentName $fParsecBool$fParsecIdentity$fCabalParsingParsecParser$fCharParsingParsecParser$fParsingParsecParser$fMonadFailParsecParser$fMonadPlusParsecParser$fMonadParsecParser$fAlternativeParsecParser$fApplicativeParsecParser$fFunctorParsecParser LicenseFile SourceDir PackageDirIsDir SymbolicPathgetSymbolicPath sameDirectoryunsafeMakeSymbolicPath$fPrettySymbolicPath$fParsecSymbolicPath$fNFDataSymbolicPath$fStructuredSymbolicPath$fBinarySymbolicPath$fIsDirPackageDir$fIsDirSourceDir$fGenericSymbolicPath$fShowSymbolicPath$fReadSymbolicPath$fEqSymbolicPath$fOrdSymbolicPath$fDataSymbolicPath$fDataLicenseFile$fDataSourceDir$fDataPackageDirVersionversionDigitParser mkVersionversion0 mkVersion'versionNumbers nullVersion alterVersion validVersion$fParsecVersion$fPrettyVersion$fNFDataVersion$fStructuredVersion$fBinaryVersion $fReadVersion $fShowVersion $fOrdVersion $fDataVersion $fEqVersion$fGenericVersion VersionRangeF ThisVersionF LaterVersionFOrLaterVersionFEarlierVersionFOrEarlierVersionFMajorBoundVersionFUnionVersionRangesFIntersectVersionRangesF VersionRange ThisVersion LaterVersionOrLaterVersionEarlierVersionOrEarlierVersionMajorBoundVersionUnionVersionRangesIntersectVersionRanges anyVersion noVersion thisVersionnotThisVersion laterVersionorLaterVersionearlierVersionorEarlierVersionunionVersionRangesintersectVersionRanges withinVersionmajorBoundVersionprojectVersionRangecataVersionRangeembedVersionRangeanaVersionRangehyloVersionRangeversionRangeParsermajorUpperBoundwildcardUpperBound$fParsecVersionRange$fPrettyVersionRange$fNFDataVersionRange$fStructuredVersionRange$fBinaryVersionRange$fDataVersionRangeF$fEqVersionRangeF$fGenericVersionRangeF$fReadVersionRangeF$fShowVersionRangeF$fFunctorVersionRangeF$fFoldableVersionRangeF$fTraversableVersionRangeF$fDataVersionRange$fEqVersionRange$fOrdVersionRange$fGenericVersionRange$fReadVersionRange$fShowVersionRangeBoundExclusiveBoundInclusiveBound UpperBound NoUpperBound LowerBoundVersionIntervalVersionIntervalsasVersionIntervalsversionIntervalsmkVersionIntervalswithinIntervalstoVersionIntervalsfromVersionIntervalsunionVersionIntervalsintersectVersionIntervalsinvertVersionIntervalsrelaxLastIntervalrelaxHeadInterval$fOrdUpperBound$fOrdLowerBound$fEqVersionIntervals$fShowVersionIntervals$fEqLowerBound$fShowLowerBound$fEqUpperBound$fShowUpperBound $fEqBound $fShowBoundunVersionIntervalsinvariantVersionIntervalsnormaliseVersionRange2$fEqVersionInterval$fShowVersionIntervalfoldVersionRangenormaliseVersionRangestripParensVersionRange withinRange isAnyVersionisAnyVersionLightisWildcardRange hasUpperBound hasLowerBoundRepoType KnownRepoType OtherRepoTypeDarcsGitSVNCVS MercurialGnuArchBazaarMonotonePijulRepoKindRepoHeadRepoThisRepoKindUnknown SourceReporepoKindrepoType repoLocation repoModule repoBranchrepoTag repoSubdiremptySourceRepoknownRepoTypesclassifyRepoKindclassifyRepoType$fParsecRepoKind$fPrettyRepoKind$fNFDataRepoKind$fStructuredRepoKind$fBinaryRepoKind$fPrettyKnownRepoType$fParsecKnownRepoType$fNFDataKnownRepoType$fStructuredKnownRepoType$fBinaryKnownRepoType$fPrettyRepoType$fParsecRepoType$fNFDataRepoType$fStructuredRepoType$fBinaryRepoType$fNFDataSourceRepo$fStructuredSourceRepo$fBinarySourceRepo$fEqSourceRepo$fOrdSourceRepo$fGenericSourceRepo$fReadSourceRepo$fShowSourceRepo$fDataSourceRepo $fEqRepoType$fGenericRepoType $fOrdRepoType$fReadRepoType$fShowRepoType$fDataRepoType$fEqKnownRepoType$fGenericKnownRepoType$fOrdKnownRepoType$fReadKnownRepoType$fShowKnownRepoType$fDataKnownRepoType$fEnumKnownRepoType$fBoundedKnownRepoType $fEqRepoKind$fGenericRepoKind $fOrdRepoKind$fReadRepoKind$fShowRepoKind$fDataRepoKindPkgconfigVersion rpmvercmp$fParsecPkgconfigVersion$fPrettyPkgconfigVersion$fNFDataPkgconfigVersion$fStructuredPkgconfigVersion$fBinaryPkgconfigVersion$fOrdPkgconfigVersion$fEqPkgconfigVersion$fGenericPkgconfigVersion$fReadPkgconfigVersion$fShowPkgconfigVersion$fDataPkgconfigVersionPkgconfigVersionRange PcAnyVersion PcThisVersionPcLaterVersionPcEarlierVersionPcOrLaterVersionPcOrEarlierVersionPcUnionVersionRangesPcIntersectVersionRangesanyPkgconfigVersionisAnyPkgconfigVersionwithinPkgconfigVersionRangeversionToPkgconfigVersion#versionRangeToPkgconfigVersionRange$fParsecPkgconfigVersionRange$fPrettyPkgconfigVersionRange$fNFDataPkgconfigVersionRange!$fStructuredPkgconfigVersionRange$fBinaryPkgconfigVersionRange$fGenericPkgconfigVersionRange$fReadPkgconfigVersionRange$fShowPkgconfigVersionRange$fEqPkgconfigVersionRange$fOrdPkgconfigVersionRange$fDataPkgconfigVersionRange PkgconfigNameunPkgconfigNamemkPkgconfigName$fNFDataPkgconfigName$fParsecPkgconfigName$fPrettyPkgconfigName$fStructuredPkgconfigName$fBinaryPkgconfigName$fIsStringPkgconfigName$fGenericPkgconfigName$fReadPkgconfigName$fShowPkgconfigName$fEqPkgconfigName$fOrdPkgconfigName$fDataPkgconfigNamePkgconfigDependency$fParsecPkgconfigDependency$fPrettyPkgconfigDependency$fNFDataPkgconfigDependency$fStructuredPkgconfigDependency$fBinaryPkgconfigDependency$fGenericPkgconfigDependency$fReadPkgconfigDependency$fShowPkgconfigDependency$fEqPkgconfigDependency$fOrdPkgconfigDependency$fDataPkgconfigDependency PackageName unPackageNameunPackageNameST mkPackageNamemkPackageNameST$fNFDataPackageName$fParsecPackageName$fPrettyPackageName$fStructuredPackageName$fBinaryPackageName$fIsStringPackageName$fGenericPackageName$fReadPackageName$fShowPackageName$fEqPackageName$fOrdPackageName$fDataPackageNameUnqualComponentNameunUnqualComponentNameunUnqualComponentNameSTmkUnqualComponentName packageNameToUnqualComponentName unqualComponentNameToPackageName$fNFDataUnqualComponentName$fParsecUnqualComponentName$fPrettyUnqualComponentName$fStructuredUnqualComponentName$fBinaryUnqualComponentName$fIsStringUnqualComponentName$fGenericUnqualComponentName$fReadUnqualComponentName$fShowUnqualComponentName$fEqUnqualComponentName$fOrdUnqualComponentName$fDataUnqualComponentName$fSemigroupUnqualComponentName$fMonoidUnqualComponentNameLibraryVisibilityLibraryVisibilityPublicLibraryVisibilityPrivate$fMonoidLibraryVisibility$fSemigroupLibraryVisibility$fNFDataLibraryVisibility$fStructuredLibraryVisibility$fBinaryLibraryVisibility$fParsecLibraryVisibility$fPrettyLibraryVisibility$fGenericLibraryVisibility$fShowLibraryVisibility$fReadLibraryVisibility$fEqLibraryVisibility$fOrdLibraryVisibility$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$fOrdForeignLibType$fDataForeignLibTypeForeignLibOptionForeignLibStandalone$fNFDataForeignLibOption$fStructuredForeignLibOption$fBinaryForeignLibOption$fParsecForeignLibOption$fPrettyForeignLibOption$fGenericForeignLibOption$fShowForeignLibOption$fReadForeignLibOption$fEqForeignLibOption$fOrdForeignLibOption$fDataForeignLibOptionFlagAssignmentFlagName PackageFlag MkPackageFlagflagNameflagDescription flagDefault flagManual emptyFlag mkFlagName unFlagNamemkFlagAssignmentunFlagAssignmentnullFlagAssignmentlookupFlagAssignmentinsertFlagAssignmentdiffFlagAssignmentfindDuplicateFlagAssignments showFlagValuedispFlagAssignmentparsecFlagAssignmentparsecFlagAssignmentNonEmptyshowFlagAssignmentlegacyShowFlagAssignmentlegacyShowFlagAssignment'legacyParsecFlagAssignment$fParsecFlagName$fPrettyFlagName$fStructuredFlagName$fBinaryFlagName$fIsStringFlagName$fNFDataPackageFlag$fStructuredPackageFlag$fBinaryPackageFlag$fParsecFlagAssignment$fPrettyFlagAssignment$fShowFlagAssignment$fReadFlagAssignment$fMonoidFlagAssignment$fSemigroupFlagAssignment$fOrdFlagAssignment$fEqFlagAssignment$fStructuredFlagAssignment$fBinaryFlagAssignment$fGenericFlagAssignment$fNFDataFlagAssignment$fShowPackageFlag$fEqPackageFlag$fDataPackageFlag$fGenericPackageFlag $fEqFlagName$fGenericFlagName $fOrdFlagName$fShowFlagName$fReadFlagName$fDataFlagName$fNFDataFlagNameExecutableScopeExecutablePublicExecutablePrivate$fMonoidExecutableScope$fSemigroupExecutableScope$fNFDataExecutableScope$fStructuredExecutableScope$fBinaryExecutableScope$fParsecExecutableScope$fPrettyExecutableScope$fGenericExecutableScope$fShowExecutableScope$fReadExecutableScope$fEqExecutableScope$fOrdExecutableScope$fDataExecutableScope ComponentNameCLibName CNotLibName CBenchName CTestNameCExeName CFLibNameshowComponentNamecomponentNameRawcomponentNameStanzacomponentNameString$fStructuredNotLibComponentName$fBinaryNotLibComponentName$fParsecComponentName$fPrettyComponentName$fStructuredComponentName$fBinaryComponentName$fEqComponentName$fGenericComponentName$fOrdComponentName$fReadComponentName$fShowComponentName$fEqNotLibComponentName$fGenericNotLibComponentName$fOrdNotLibComponentName$fReadNotLibComponentName$fShowNotLibComponentName ComponentId mkComponentId unComponentId$fNFDataComponentId$fParsecComponentId$fPrettyComponentId$fStructuredComponentId$fBinaryComponentId$fIsStringComponentId$fGenericComponentId$fReadComponentId$fShowComponentId$fEqComponentId$fOrdComponentId$fDataComponentId BuildTypeSimple ConfigureMakeCustomknownBuildTypes$fParsecBuildType$fPrettyBuildType$fNFDataBuildType$fStructuredBuildType$fBinaryBuildType$fGenericBuildType$fShowBuildType$fReadBuildType $fEqBuildType$fOrdBuildType$fDataBuildTypeAbiHash unAbiHash mkAbiHash$fParsecAbiHash$fPrettyAbiHash$fNFDataAbiHash$fStructuredAbiHash$fBinaryAbiHash$fIsStringAbiHash $fEqAbiHash $fShowAbiHash $fReadAbiHash$fGenericAbiHashdisplayPlatformArchI386X86_64PPCPPC64SparcArmAArch64MipsSHIA64S390S390XAlphaHppaRs6000M68kVax JavaScriptWasm32 OtherArchOSLinuxWindowsOSXFreeBSDOpenBSDNetBSD DragonFlySolarisAIXHPUXIRIXHaLVMHurdIOSAndroidGhcjsWasiOtherOSClassificationStrictness PermissiveCompatStrictknownOSs classifyOSbuildOS knownArches classifyArch buildArch buildPlatformplatformFromTriple $fParsecOS $fPrettyOS $fNFDataOS$fStructuredOS $fBinaryOS $fParsecArch $fPrettyArch $fNFDataArch$fStructuredArch $fBinaryArch$fParsecPlatform$fPrettyPlatform$fNFDataPlatform$fStructuredPlatform$fBinaryPlatform $fEqPlatform$fGenericPlatform $fOrdPlatform$fShowPlatform$fReadPlatform$fDataPlatform$fEqArch $fGenericArch $fOrdArch $fShowArch $fReadArch $fDataArch$fEqOS $fGenericOS$fOrdOS$fShowOS$fReadOS$fDataOS 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_fallbackANTLR_PD Apache_1_0 Apache_1_1 Apache_2_0APAFMLAPL_1_0App_s2pAPSL_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_PatentBSD_2_Clause_Views BSD_2_ClauseBSD_3_Clause_AttributionBSD_3_Clause_ClearBSD_3_Clause_LBNLBSD_3_Clause_Modification BSD_3_Clause_No_Military_License$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_ShortenedBSD_4_Clause_UC BSD_4_ClauseBSD_ProtectionBSD_Source_CodeBSL_1_0 Bzip2_1_0_5BUSL_1_1 Bzip2_1_0_6 C_UDA_1_0CAL_1_0_Combined_Work_ExceptionCAL_1_0Caldera CATOSL_1_1 CC_BY_1_0 CC_BY_2_0 CC_BY_2_5_AU CC_BY_2_5 CC_BY_3_0_AT CC_BY_3_0_DE CC_BY_3_0_NL CC_BY_3_0_US CC_BY_3_0 CC_BY_4_0 CC_BY_NC_1_0 CC_BY_NC_2_0 CC_BY_NC_2_5CC_BY_NC_3_0_DE 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_0_DECC_BY_NC_ND_3_0_IGOCC_BY_NC_ND_3_0CC_BY_NC_ND_4_0CC_BY_NC_SA_1_0CC_BY_NC_SA_2_0_FRCC_BY_NC_SA_2_0_UKCC_BY_NC_SA_2_0CC_BY_NC_SA_2_5CC_BY_NC_SA_3_0_DECC_BY_NC_SA_3_0_IGOCC_BY_NC_SA_3_0CC_BY_NC_SA_4_0 CC_BY_ND_1_0 CC_BY_ND_2_0 CC_BY_ND_2_5CC_BY_ND_3_0_DE CC_BY_ND_3_0 CC_BY_ND_4_0 CC_BY_SA_1_0CC_BY_SA_2_0_UK CC_BY_SA_2_0CC_BY_SA_2_1_JP CC_BY_SA_2_5CC_BY_SA_3_0_ATCC_BY_SA_3_0_DE CC_BY_SA_3_0 CC_BY_SA_4_0CC_PDDCCC0_1_0CDDL_1_0CDDL_1_1CDL_1_0CDLA_Permissive_1_0CDLA_Permissive_2_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_2CERN_OHL_P_2_0CERN_OHL_S_2_0CERN_OHL_W_2_0 ClArtistic CNRI_JythonCNRI_Python_GPL_Compatible CNRI_PythonCOIL_1_0Community_Spec_1_0 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_0Diffmark DL_DE_BY_2_0DOCDotseqnDRL_1_0DSDPDvipdfmECL_1_0ECL_2_0EFL_1_0EFL_2_0EGenix Elastic_2_0EntessaEPICSEPL_1_0EPL_2_0 ErlPL_1_1 Etalab_2_0 EUDatagridEUPL_1_0EUPL_1_1EUPL_1_2EurosymFairFDK_AAC Frameworx_1_0 FreeBSD_DOC FreeImageFSFAPFSFULLRFSFULFTLGDGFDL_1_1_invariants_onlyGFDL_1_1_invariants_or_laterGFDL_1_1_no_invariants_onlyGFDL_1_1_no_invariants_or_later GFDL_1_1_onlyGFDL_1_1_or_laterGFDL_1_2_invariants_onlyGFDL_1_2_invariants_or_laterGFDL_1_2_no_invariants_onlyGFDL_1_2_no_invariants_or_later GFDL_1_2_onlyGFDL_1_2_or_laterGFDL_1_3_invariants_onlyGFDL_1_3_invariants_or_laterGFDL_1_3_no_invariants_onlyGFDL_1_3_no_invariants_or_later GFDL_1_3_onlyGFDL_1_3_or_laterGiftwareGL2PSGlideGlulxeGLWTPLGnuplot 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 HaskellReportHippocratic_2_1HPND_sell_variantHPNDHTMLTIDYIBM_pibsICUIJG ImageMagickIMatixImlib2Info_ZIP Intel_ACPIIntel Interbase_1_0IPAIPL_1_0ISCJam 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_0LibpngLibselinux_1_0Libtiff LiLiQ_P_1_1 LiLiQ_R_1_1LiLiQ_Rplus_1_1Linux_man_pages_copyleft Linux_OpenIBLPL_1_02LPL_1_0LPPL_1_0LPPL_1_1LPPL_1_2 LPPL_1_3a LPPL_1_3c MakeIndexMirOSMIT_0MIT_advertisingMIT_CMUMIT_ennaMIT_fehMIT_Modern_VariantMIT_open_groupMITNFAMITMotosotoMpich2MPL_1_0MPL_1_1MPL_2_0_no_copyleft_exceptionMPL_2_0MS_PLMS_RLMTLL MulanPSL_1_0 MulanPSL_2_0MulticsMup NAIST_2003NASA_1_3NaumenNBPL_1_0 NCGL_UK_2_0NCSANet_SNMPNetCDFNewsletrNGPLNIST_PD_fallbackNIST_PDNLOD_1_0NLOD_2_0NLPLNokiaNOSLNowebNPL_1_0NPL_1_1 NPOSL_3_0NRLNTP_0NTP O_UDA_1_0OCCT_PLOCLC_2_0ODbL_1_0 ODC_By_1_0OFL_1_0_no_RFN OFL_1_0_RFNOFL_1_0OFL_1_1_no_RFN OFL_1_1_RFNOFL_1_1OGC_1_0OGDL_Taiwan_1_0OGL_Canada_2_0 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 OPUBL_1_0 OSET_PL_2_1OSL_1_0OSL_1_1OSL_2_0OSL_2_1OSL_3_0 Parity_6_0_0 Parity_7_0_0PDDL_1_0PHP_3_01PHP_3_0PlexusPolyForm_Noncommercial_1_0_0PolyForm_Small_Business_1_0_0 PostgreSQLPSF_2_0PsfragPsutils Python_2_0QhullQPL_1_0Rdisc RHeCos_1_1RPL_1_1RPL_1_5RPSL_1_0RSA_MDRSCPLRubySAX_PDSaxpathSCEA SchemeReport 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_0 SSH_OpenSSH SSH_shortSSPL_1_0SugarCRM_1_1_3SWL TAPR_OHL_1_0TCL TCP_wrappersTMate TORQUE_1_1TOSL TU_Berlin_1_0 TU_Berlin_2_0UCL_1_0Unicode_DFS_2015Unicode_DFS_2016 Unicode_TOU UnlicenseUPL_1_0VimVOSTROMVSL_1_0 W3C_19980720 W3C_20150513W3C Watcom_1_0WsuipaWTFPL$X11_distribute_modifications_variantX11Xerox XFree86_1_1XinetdXnetXppXSkatYPL_1_0YPL_1_1ZedZend_2_0 Zimbra_1_3 Zimbra_1_4Zlib_acknowledgementZlibZPL_1_1ZPL_2_0ZPL_2_1licenseIdMigrationMessage licenseId licenseNamelicenseIsOsiApprovedlicenseIsFsfLibre licenseIdList mkLicenseId$fNFDataLicenseId$fParsecLicenseId$fPrettyLicenseId$fStructuredLicenseId$fBinaryLicenseId $fEqLicenseId$fOrdLicenseId$fEnumLicenseId$fBoundedLicenseId$fShowLicenseId$fReadLicenseId$fDataLicenseIdLicenseExceptionIdDS389_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_exceptionGPL_3_0_linking_exception GPL_3_0_linking_source_exception GPL_CC_1_0I2p_gpl_java_exceptionLGPL_3_0_linking_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_0SHL_2_0SHL_2_1Swift_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$fShowLicenseExpression$fReadLicenseExpression$fEqLicenseExpression$fOrdLicenseExpression$fDataLicenseExpression$fGenericLicenseExpression$fShowSimpleLicenseExpression$fReadSimpleLicenseExpression$fEqSimpleLicenseExpression$fOrdSimpleLicenseExpression$fDataSimpleLicenseExpression $fGenericSimpleLicenseExpressionLicenseNONE$fParsecLicense$fPrettyLicense$fNFDataLicense$fStructuredLicense$fBinaryLicense $fShowLicense $fReadLicense $fEqLicense $fOrdLicense $fDataLicense$fGenericLicense ModuleNamevalidModuleComponentfromComponentsmain components toFilePath$fIsStringModuleName$fParsecModuleName$fPrettyModuleName$fNFDataModuleName$fStructuredModuleName$fBinaryModuleName$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$fGenericIncludeRenamingMixinmixinPackageNamemixinLibraryNamemixinIncludeRenamingmkMixinnormaliseMixin $fParsecMixin $fPrettyMixin $fNFDataMixin$fStructuredMixin $fBinaryMixin $fShowMixin $fReadMixin $fEqMixin $fOrdMixin $fDataMixin$fGenericMixinModuleReexportmoduleReexportOriginalPackagemoduleReexportOriginalNamemoduleReexportName$fParsecModuleReexport$fPrettyModuleReexport$fNFDataModuleReexport$fStructuredModuleReexport$fBinaryModuleReexport$fEqModuleReexport$fOrdModuleReexport$fGenericModuleReexport$fReadModuleReexport$fShowModuleReexport$fDataModuleReexportNodeNIsNodeKeynodeKey nodeNeighbors nodeValuesize deleteKey deleteLookup unionRight unionLeftstronglyConnCompcyclesbroken neighbors revNeighborsclosure revClosuretopSort revTopSortfromDistinctListkeyskeysSettoMaptoGraph$fIsNodeEither $fNFDataGraph$fFoldableGraph $fEqGraph$fStructuredGraph $fBinaryGraph $fReadGraph $fShowGraph $fIsNodeNode $fFunctorNode $fShowNode$fEqNode isNoVersionisSpecificVersionsimplifyVersionRangeremoveUpperBoundremoveLowerBoundtransformCarettransformCaretUppertransformCaretLowerTestType TestTypeExe TestTypeLibTestTypeUnknownknownTestTypes testTypeExe testTypeLib$fParsecTestType$fPrettyTestType$fNFDataTestType$fStructuredTestType$fBinaryTestType$fGenericTestType$fShowTestType$fReadTestType $fEqTestType $fOrdTestType$fDataTestTypeTestSuiteInterfaceTestSuiteExeV10TestSuiteLibV09TestSuiteUnsupported$fSemigroupTestSuiteInterface$fMonoidTestSuiteInterface$fNFDataTestSuiteInterface$fStructuredTestSuiteInterface$fBinaryTestSuiteInterface$fEqTestSuiteInterface$fOrdTestSuiteInterface$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$fGenericDefUnitId$fReadDefUnitId$fShowDefUnitId $fEqDefUnitId$fOrdDefUnitId$fDataDefUnitId$fBinaryDefUnitId$fNFDataDefUnitId$fPrettyDefUnitId$fGenericUnitId $fReadUnitId $fShowUnitId $fEqUnitId $fOrdUnitId $fDataUnitId$fNFDataUnitIdModule$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$fShowExposedModulePackageVersionConstraintthisPackageVersionConstraint simplifyPackageVersionConstraint $fParsecPackageVersionConstraint $fPrettyPackageVersionConstraint $fNFDataPackageVersionConstraint$$fStructuredPackageVersionConstraint $fBinaryPackageVersionConstraint!$fGenericPackageVersionConstraint$fReadPackageVersionConstraint$fShowPackageVersionConstraint$fEqPackageVersionConstraint$fDataPackageVersionConstraintMungedPackageId mungedName mungedVersioncomputeCompatPackageId$fNFDataMungedPackageId$fParsecMungedPackageId$fPrettyMungedPackageId$fStructuredMungedPackageId$fBinaryMungedPackageId$fGenericMungedPackageId$fReadMungedPackageId$fShowMungedPackageId$fEqMungedPackageId$fOrdMungedPackageId$fDataMungedPackageIdLegacyExeDependency$fParsecLegacyExeDependency$fPrettyLegacyExeDependency$fNFDataLegacyExeDependency$fStructuredLegacyExeDependency$fBinaryLegacyExeDependency$fGenericLegacyExeDependency$fReadLegacyExeDependency$fShowLegacyExeDependency$fEqLegacyExeDependency$fOrdLegacyExeDependency$fDataLegacyExeDependency ExeDependencyqualifiedExeName$fParsecExeDependency$fPrettyExeDependency$fNFDataExeDependency$fStructuredExeDependency$fBinaryExeDependency$fGenericExeDependency$fReadExeDependency$fShowExeDependency$fEqExeDependency$fOrdExeDependency$fDataExeDependency Dependency depPkgName depVerRange depLibraries mkDependency mainLibSetsimplifyDependency$fParsecDependency$fPrettyDependency$fNFDataDependency$fStructuredDependency$fBinaryDependency$fGenericDependency$fReadDependency$fShowDependency$fEqDependency$fOrdDependency$fDataDependencySetupBuildInfo setupDependsdefaultSetupDepends$fSemigroupSetupBuildInfo$fMonoidSetupBuildInfo$fNFDataSetupBuildInfo$fStructuredSetupBuildInfo$fBinarySetupBuildInfo$fGenericSetupBuildInfo$fShowSetupBuildInfo$fEqSetupBuildInfo$fOrdSetupBuildInfo$fReadSetupBuildInfo$fDataSetupBuildInfo DependencyMaptoDepMap fromDepMap constrainBy$fSemigroupDependencyMap$fMonoidDependencyMap$fShowDependencyMap$fReadDependencyMap$fEqDependencyMap BenchmarkTypeBenchmarkTypeExeBenchmarkTypeUnknownknownBenchmarkTypesbenchmarkTypeExe$fParsecBenchmarkType$fPrettyBenchmarkType$fNFDataBenchmarkType$fStructuredBenchmarkType$fBinaryBenchmarkType$fGenericBenchmarkType$fShowBenchmarkType$fReadBenchmarkType$fEqBenchmarkType$fOrdBenchmarkType$fDataBenchmarkTypeBenchmarkInterfaceBenchmarkExeV10BenchmarkUnsupported$fSemigroupBenchmarkInterface$fMonoidBenchmarkInterface$fNFDataBenchmarkInterface$fStructuredBenchmarkInterface$fBinaryBenchmarkInterface$fEqBenchmarkInterface$fOrdBenchmarkInterface$fGenericBenchmarkInterface$fReadBenchmarkInterface$fShowBenchmarkInterface$fDataBenchmarkInterfacePackageInstalledinstalledDepends HasUnitIdinstalledUnitIdHasMungedPackageIdmungedIdPackage packageId mungedName'mungedVersion' packageNamepackageVersion$fPackagePackageIdentifier#$fHasMungedPackageIdMungedPackageId 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 libraryDirslibraryDirsStaticlibraryDynDirsdataDir hsLibrariesextraLibrariesextraLibrariesStaticextraGHCiLibraries includeDirsincludesdepends abiDepends ccOptions cxxOptions ldOptions frameworkDirs frameworkshaddockInterfaces haddockHTMLspkgRootmungedPackageIdmungedPackageNameemptyInstalledPackageInfo$fIsNodeInstalledPackageInfo&$fPackageInstalledInstalledPackageInfo$fHasUnitIdInstalledPackageInfo$fPackageInstalledPackageInfo($fHasMungedPackageIdInstalledPackageInfo$fNFDataInstalledPackageInfo $fStructuredInstalledPackageInfo$fBinaryInstalledPackageInfo$fEqInstalledPackageInfo$fGenericInstalledPackageInfo$fReadInstalledPackageInfo$fShowInstalledPackageInfo ParseResultwithoutWarningsrunParseResult recoverWithsetCabalSpecVersiongetCabalSpecVersion parseWarning parseWarnings parseFailureparseFatalFailureparseFatalFailure'$fMonadParseResult$fApplicativeParseResult$fFunctorParseResultKnownExtensionOverlappingInstancesUndecidableInstancesIncoherentInstancesDoRec RecursiveDoParallelListCompMultiParamTypeClassesMonomorphismRestrictionDeepSubsumptionFunctionalDependencies 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 DataKindsTypeDataParallelArraysRoleAnnotationsOverloadedLists EmptyCaseAutoDeriveTypeableNegativeLiteralsBinaryLiterals NumDecimalsNullaryTypeClassesExplicitNamespacesAllowAmbiguousTypes JavaScriptFFIPatternSynonymsPartialTypeSignaturesNamedWildCardsDeriveAnyClass DeriveLiftStaticPointers StrictData ApplicativeDoDuplicateRecordFieldsTypeApplications TypeInTypeUndecidableSuperClassesMonadFailDesugaringTemplateHaskellQuotesOverloadedLabelsTypeFamilyDependenciesDerivingStrategies DerivingVia UnboxedSumsHexFloatLiteralsBlockArgumentsNumericUnderscoresQuantifiedConstraints StarIsTypeEmptyDataDerivingCUSKsImportQualifiedPostStandaloneKindSignaturesUnliftedNewtypesLexicalNegation QualifiedDo LinearTypesRequiredTypeArgumentsFieldSelectorsOverloadedRecordDotOverloadedRecordUpdateUnliftedDatatypesAlternativeLayoutRule!AlternativeLayoutRuleTransitional RelaxedLayout ExtensionEnableExtensionDisableExtensionUnknownExtensionLanguage Haskell98 Haskell2010GHC2021UnknownLanguageknownLanguagesclassifyLanguagedeprecatedExtensionsclassifyExtensionknownExtensions$fParsecLanguage$fPrettyLanguage$fNFDataLanguage$fStructuredLanguage$fBinaryLanguage$fPrettyKnownExtension$fNFDataKnownExtension$fStructuredKnownExtension$fBinaryKnownExtension$fParsecExtension$fPrettyExtension$fNFDataExtension$fStructuredExtension$fBinaryExtension$fGenericExtension$fShowExtension$fReadExtension $fEqExtension$fOrdExtension$fDataExtension$fGenericKnownExtension$fShowKnownExtension$fReadKnownExtension$fEqKnownExtension$fOrdKnownExtension$fEnumKnownExtension$fBoundedKnownExtension$fDataKnownExtension$fGenericLanguage$fShowLanguage$fReadLanguage $fEqLanguage $fOrdLanguage$fDataLanguageAbiTagNoAbiTag 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$fGenericCompilerInfo$fShowCompilerInfo$fReadCompilerInfo $fEqAbiTag$fGenericAbiTag $fShowAbiTag $fReadAbiTag$fEqCompilerId$fGenericCompilerId$fOrdCompilerId$fReadCompilerId$fShowCompilerId$fGenericPerCompilerFlavor$fShowPerCompilerFlavor$fReadPerCompilerFlavor$fEqPerCompilerFlavor$fOrdPerCompilerFlavor$fDataPerCompilerFlavor$fFunctorPerCompilerFlavor$fFoldablePerCompilerFlavor$fTraversablePerCompilerFlavor$fGenericCompilerFlavor$fShowCompilerFlavor$fReadCompilerFlavor$fEqCompilerFlavor$fOrdCompilerFlavor$fDataCompilerFlavorConfVarImpl$fNFDataConfVar$fStructuredConfVar$fBinaryConfVar $fEqConfVar $fShowConfVar $fDataConfVar$fGenericConfVarparseConditionConfVarFromClauseparseConditionConfVar BuildInfo buildable buildToolsbuildToolDepends cppOptions asmOptions cmmOptions hsc2hsOptionspkgconfigDependsextraFrameworkDirs asmSources cmmSourcescSources cxxSources jsSources hsSourceDirs otherModulesvirtualModulesautogenModulesdefaultLanguageotherLanguagesdefaultExtensionsotherExtensions oldExtensions extraLibsextraLibsStatic extraGHCiLibsextraBundledLibsextraLibFlavoursextraDynLibFlavours extraLibDirsextraLibDirsStaticautogenIncludesinstallIncludesoptions profOptions sharedOptions staticOptionscustomFieldsBItargetBuildDependsmixinsemptyBuildInfo allLanguages allExtensionsusedExtensionsusesTemplateHaskellOrQQ hcOptions hcProfOptionshcSharedOptionshcStaticOptions$fSemigroupBuildInfo$fMonoidBuildInfo$fNFDataBuildInfo$fStructuredBuildInfo$fBinaryBuildInfo$fGenericBuildInfo$fShowBuildInfo$fReadBuildInfo $fEqBuildInfo$fOrdBuildInfo$fDataBuildInfoHookedBuildInfoemptyHookedBuildInfo HasBuildInfostraverseBuildInfos HasBuildInfo buildInfo$fHasBuildInfoBuildInfo TestSuitetestName testInterface testBuildInfotestCodeGeneratorsemptyTestSuitetestType testModulestestModulesAutogen$fSemigroupTestSuite$fMonoidTestSuite$fNFDataTestSuite$fStructuredTestSuite$fBinaryTestSuite$fHasBuildInfoTestSuite$fGenericTestSuite$fShowTestSuite$fReadTestSuite $fEqTestSuite$fOrdTestSuite$fDataTestSuiteLibrarylibNamereexportedModules signatures libExposed libBuildInfo emptyLibraryexplicitLibModuleslibModulesAutogen$fSemigroupLibrary$fMonoidLibrary$fNFDataLibrary$fStructuredLibrary$fBinaryLibrary$fHasBuildInfoLibrary$fGenericLibrary $fShowLibrary $fEqLibrary $fOrdLibrary $fReadLibrary $fDataLibraryLibVersionInfo ForeignLibforeignLibNameforeignLibTypeforeignLibOptionsforeignLibBuildInfoforeignLibVersionInfoforeignLibVersionLinuxforeignLibModDefFilemkLibVersionInfolibVersionInfoCRAlibVersionNumberlibVersionNumberShowlibVersionMajoremptyForeignLibforeignLibModulesforeignLibIsSharedforeignLibVersion$fParsecLibVersionInfo$fPrettyLibVersionInfo$fNFDataLibVersionInfo$fStructuredLibVersionInfo$fBinaryLibVersionInfo$fReadLibVersionInfo$fShowLibVersionInfo$fOrdLibVersionInfo$fMonoidForeignLib$fSemigroupForeignLib$fNFDataForeignLib$fStructuredForeignLib$fBinaryForeignLib$fHasBuildInfoForeignLib$fGenericForeignLib$fShowForeignLib$fReadForeignLib$fEqForeignLib$fOrdForeignLib$fDataForeignLib$fDataLibVersionInfo$fEqLibVersionInfo$fGenericLibVersionInfo ExecutableexeName modulePathexeScopeemptyExecutable exeModulesexeModulesAutogen$fSemigroupExecutable$fMonoidExecutable$fNFDataExecutable$fStructuredExecutable$fBinaryExecutable$fHasBuildInfoExecutable$fGenericExecutable$fShowExecutable$fReadExecutable$fEqExecutable$fOrdExecutable$fDataExecutable exeBuildInfo Benchmark benchmarkNamebenchmarkInterfacebenchmarkBuildInfoemptyBenchmark benchmarkTypebenchmarkModulesbenchmarkModulesAutogen$fSemigroupBenchmark$fMonoidBenchmark$fHasBuildInfoBenchmark$fNFDataBenchmark$fStructuredBenchmark$fBinaryBenchmark$fGenericBenchmark$fShowBenchmark$fReadBenchmark $fEqBenchmark$fOrdBenchmark$fDataBenchmark ComponentCLibCFLibCExeCTestCBench foldComponentcomponentBuildInfocomponentBuildable componentNamepartitionComponents$fHasBuildInfoComponent$fSemigroupComponent$fShowComponent $fEqComponent$fReadComponentComponentDisabledReasonDisabledComponentDisabledAllTestsDisabledAllBenchmarksDisabledAllButOneComponentRequestedSpecOneComponentRequestedSpectestsRequestedbenchmarksRequesteddefaultComponentRequestedSpeccomponentEnabledcomponentNameRequestedcomponentDisabledReason"$fStructuredComponentRequestedSpec$fBinaryComponentRequestedSpec$fGenericComponentRequestedSpec$fReadComponentRequestedSpec$fShowComponentRequestedSpec$fEqComponentRequestedSpecPackageDescription specVersionpackage licenseRaw licenseFiles testedWith bugReports sourceReposcustomFieldsPD buildTypeRawsetupBuildInfolibrary subLibraries executables foreignLibs testSuites benchmarks dataFiles extraSrcFiles extraTmpFiles extraDocFileslicense' buildTypeemptyPackageDescription hasPublicLibhasLibs allLibrarieswithLibhasExeswithExehasTestswithTest hasBenchmarks withBenchmarkhasForeignLibswithForeignLib allBuildInfoenabledBuildInfosallBuildDependsenabledBuildDependsupdatePackageDescription pkgComponentspkgBuildableComponentsenabledComponentslookupComponent getComponent!$fHasBuildInfosPackageDescription$fPackagePackageDescription$fNFDataPackageDescription$fStructuredPackageDescription$fBinaryPackageDescription$fGenericPackageDescription$fShowPackageDescription$fReadPackageDescription$fEqPackageDescription$fOrdPackageDescription$fDataPackageDescriptionGenericPackageDescriptionpackageDescriptiongpdScannedVersiongenPackageFlags condLibrarycondSubLibrariescondForeignLibscondExecutablescondTestSuitescondBenchmarksemptyGenericPackageDescription($fHasBuildInfosGenericPackageDescription!$fNFDataGenericPackageDescription%$fStructuredGenericPackageDescription!$fBinaryGenericPackageDescription"$fPackageGenericPackageDescription$fShowGenericPackageDescription$fEqGenericPackageDescription$fDataGenericPackageDescription"$fGenericGenericPackageDescription allCondTrees_OS_Arch _PackageFlag_ImplcomponentModulessimplifyWithSysParamsparseConditionextractConditionsfreeVars finalizePDflattenPackageDescriptiontransformAllBuildInfostransformAllBuildDependstransformAllBuildDependsN$fSemigroupDepTestRslt$fMonoidDepTestRslt$fSemigroupDepMapUnion$fSemigroupPDTagged$fMonoidPDTagged$fShowPDTagged TestedWith getTestedWith SpecLicensegetSpecLicense SpecVersiongetSpecVersion FilePathNT getFilePathNTMQuoted getMQuotedToken' getToken'getToken NonEmpty'Set'ListSep prettySepparseSep parseSepNE NoCommaFSepFSepVCat CommaFSep CommaVCatalaListalaList'alaSetalaSet' alaNonEmpty alaNonEmpty'$fSepNoCommaFSep $fSepFSep $fSepVCat$fSepCommaFSep$fSepCommaVCat $fPrettyList $fParsecList$fNewtype[]List $fPrettySet' $fParsecSet'$fNewtypeSetSet'$fPrettyNonEmpty'$fParsecNonEmpty'$fNewtypeNonEmptyNonEmpty' $fPrettyToken $fParsecToken$fNewtype[]Token$fPrettyToken'$fParsecToken'$fNewtype[]Token'$fPrettyMQuoted$fParsecMQuoted$fNewtypeaMQuoted$fPrettyFilePathNT$fParsecFilePathNT$fNewtype[]FilePathNT$fPrettySpecVersion$fParsecSpecVersion$$fNewtypeCabalSpecVersionSpecVersion$fPrettySpecLicense$fParsecSpecLicense$fNewtypeEitherSpecLicense$fPrettyTestedWith$fParsecTestedWith$fNewtype(,)TestedWith$fShowSpecLicense$fEqSpecLicense$fEqSpecVersion$fShowSpecVersion FieldGrammarblurFieldGrammaruniqueFieldAlabooleanFieldDefoptionalFieldAlaoptionalFieldDefAla freeTextFieldfreeTextFieldDeffreeTextFieldDefSTmonoidalFieldAlaprefixedFields knownField hiddenFielddeprecatedSince removedInavailableSinceavailableSinceWarn uniqueField optionalFieldoptionalFieldDef monoidalFielddefaultFreeTextFieldDefSTPrettyFieldGrammarprettyFieldGrammar&$fFieldGrammarPrettyPrettyFieldGrammar$fApplicativePrettyFieldGrammar$fFunctorPrettyFieldGrammarParsecFieldGrammar MkSection NamelessFieldMkNamelessFieldFieldsnamelessFieldAnnparseFieldGrammarfieldGrammarKnownFieldListrunFieldParser'runFieldParserfieldLinesToStream&$fFieldGrammarParsecParsecFieldGrammar$fApplicativeParsecFieldGrammar$fFunctorParsecFieldGrammar $fEqSection $fShowSection$fFunctorSection$fEqNamelessField$fShowNamelessField$fFunctorNamelessFieldPrettyFieldGrammar'ParsecFieldGrammar'^^^partitionFields takeFieldsCompatLicenseFilegetCompatLicenseFileCompatFilePathgetCompatFilePathBenchmarkStanza_benchmarkStanzaBenchmarkType_benchmarkStanzaMainIs_benchmarkStanzaBenchmarkModule_benchmarkStanzaBuildInfoTestSuiteStanza_testStanzaTestType_testStanzaMainIs_testStanzaTestModule_testStanzaBuildInfo_testStanzaCodeGeneratorspackageDescriptionFieldGrammarlibraryFieldGrammarforeignLibFieldGrammarexecutableFieldGrammartestStanzaTestTypetestStanzaMainIstestStanzaTestModuletestStanzaBuildInfotestSuiteFieldGrammarvalidateTestSuiteunvalidateTestSuitebenchmarkStanzaBenchmarkTypebenchmarkStanzaMainIsbenchmarkStanzaBenchmarkModulebenchmarkStanzaBuildInfobenchmarkFieldGrammarvalidateBenchmarkunvalidateBenchmarkbuildInfoFieldGrammarflagFieldGrammarsourceRepoFieldGrammarsetupBInfoFieldGrammarformatDependencyListformatMixinListformatExtraSourceFilesformatExposedModulesformatHsSourceDirsformatOtherExtensionsformatOtherModules$fHasBuildInfoTestSuiteStanza$fHasBuildInfoBenchmarkStanza$fPrettyCompatFilePath$fParsecCompatFilePath$fNewtype[]CompatFilePath$fPrettyCompatLicenseFile$fParsecCompatLicenseFile$fNewtype[]CompatLicenseFilewriteGenericPackageDescriptionshowGenericPackageDescriptionppGenericPackageDescriptionwritePackageDescriptionshowPackageDescriptionwriteHookedBuildInfoshowHookedBuildInfoparseGenericPackageDescription#parseGenericPackageDescriptionMaybeparseHookedBuildInfoscanSpecVersion$fFromBuildInfoBenchmarkStanza$fFromBuildInfoTestSuiteStanza$fFromBuildInfoExecutable$fFromBuildInfoForeignLib$fFromBuildInfoBuildInfo $fEqSyntax $fShowSyntax FieldDescrsfieldDescrPrettyfieldDescrParsefieldDescrsToList$fApplicativeFieldDescrs$fParsecPrettya%$fFieldGrammarParsecPrettyFieldDescrs$fFunctorFieldDescrsipiFieldGrammar$fPrettyExposedModules$fParsecExposedModules$fNewtype[]ExposedModules$fParsecCompatPackageKey$fPrettyCompatPackageKey$fNewtype[]CompatPackageKey$fParsecInstWith$fPrettyInstWith$fNewtype[]InstWith$fPrettySpecLicenseLenient$fParsecSpecLicenseLenient!$fNewtypeEitherSpecLicenseLenientinstalledComponentIdinstalledOpenUnitIdrequiredSignaturessourceComponentNameparseInstalledPackageInfoshowInstalledPackageInfoshowFullInstalledPackageInfoshowInstalledPackageInfoField#showSimpleInstalledPackageInfoField byteSwap64 byteSwap32 byteSwap16 bitReverse8 bitReverse64 bitReverse32 bitReverse16 Data.Binary encodeFileencode decodeOrFaildecodeFileOrFail decodeFiledecode GBinaryPutgput GBinaryGetggetData.Binary.PutPutputWord8Data.Binary.GetgetWord8Data.Binary.Get.InternalGetbytestring-0.11.3.1Data.ByteString.Lazy.InternalData.SemigroupLastFirstGNFDataData.ByteString.Short.InternalShortByteStringData.ByteString.Internalpatches _makePatchKeybsRemove bsReplacebsRemoveStarting StartCodelines_ LexState'parsec-3.1.15.0Text.Parsec.PrimStreamgetLexerWarnings setLexerModeBlock Data.VersionprettyVersionRange16 minLowerBound invariantcheckInvariantinsertInterval validInterval nonEmptyVI doesNotTouchdoesNotIntersect unionIntervalintersectIntervalnonEmptyInterval postprocesscombineFlagValueslegacyShowFlagValuemoduleRenamingParsecfromMapclassifyKnownExtensionreadcombineLibraryNamecomponentNameNotRequestedReason TargetSet DepMapUnion DepTestRsltresolveWithFlagsaddBuildableConditionPDTaggedPDTaggedPDNulloverallDependenciesflattenTaggedTargetsfsepvcatPS_syntaxFieldNames_syntaxExtensionsSyntaxsectionizeFields FromBuildInfoSectionS parseFields warnImportcheckForUndefinedFlagscheckForUndefinedCustomSetup parseCondTreeparseCondTreeWithCommonStanzasprocessImportsBasicSpecLicenseLenientsetMaybePackageName<@>