h"oՍ+      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                          !"""""""""""""""""""""""""""""""""""######################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%&''''''''(((((((((((((((((((((((((((((((((((((()))))))))))))))))))))))))))))))))))))))))))*  ++++++++++++++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,----------..............//// / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / 0 0 0 0 0 0 0 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 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 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 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 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 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 9 9 9 9 9 9 9 9 9 9 9 9 : : : : : : : : : : : : : : : ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; < < < < < < < < < < < < = = = = = = = = = = = = = = = > > > > > > > > > > > > > > > > > > > ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ A A A A A A A A A A A A B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B C C C C C C C C C C C C C C C D D D D D D D D D D D D D D D D D D E E E E E E E E E E E E E E E F F F F F F F F F F F G G G G G G G G G G G G G G G G H H H H H H H H H H H H H I I J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J K K K K K K K KKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^^^________________________________________`````````````aaaaaaaabbbbbbbcccddeeeeeeeeeeeeeeeeffffffffffffggggggggggggghhhhhhhhhhhhhhhhhhiiiiiiiiiiiiiijjkkkkkkkkllllllllllllllmmmmmmmmmmmmmnnnnnnnnnnnnnnooooooooooppppppppqqqqqqqqqqqqqrrrrrrrrrrrrrrrrrrrrrrrrrrrrrsssssssssssssssssssssssssssssssssssssssssssssssssssssssssssttttttttttttttttttttttttttttttttttttttttttuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvwwwwwwwwwwwwxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxyyzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz{{{{{{{{{{{{{{{{{{{{|||}}}}}}}}}}}}}}}}}}}}}}}~~~~~~~                                                                                                                                                                                                              !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""################################################################################################################################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))********************************************************************************************************************************+++++++++++++++++++++++++++++None3{+CabalThe exception thrown by + to terminate a thread.+CabalAsync, but based on +, as we don't depend on stm.+Cabal Returns the +" of the thread running the given +.+CabalSpawn an asynchronous action in a separate thread, and pass its Async handle to the supplied function. When the function returns or throws an exception, + is called on the Async. withAsync action inner = mask $ \restore -> do a <- async (restore action) restore (inner a) `finally` uninterruptibleCancel aThis is a useful variant of async that ensures an Async( is never left running unintentionally.Note: a reference to the child thread is kept alive until the call to + returns, so nesting many + calls requires linear memory.+CabalWait for an asynchronous action to complete, and return its value. If the asynchronous action threw an exception, then the exception is re-thrown by +. wait = atomically . waitSTM+CabalWait for an asynchronous action to complete, and return either Left e# if the action raised an exception e, or Right a if it returned a value a. %waitCatch = atomically . waitCatchSTM+Cabal.Cancel an asynchronous action by throwing the AsyncCancelled' exception to it, and waiting for the +' thread to quit. Has no effect if the + has already completed. cancel a = throwTo (asyncThreadId a) AsyncCancelled <* waitCatch a Note that +) will not terminate until the thread the +, refers to has terminated. This means that + will block for as long said thread blocks when receiving an asynchronous exception.For example, it could block if:It's executing a foreign call, and thus cannot receive the asynchronous exception;It's executing some cleanup handler after having received the exception, and the handler is blocking.+CabalCancel an asynchronous actionThis is a variant of +, but it is not interruptible. ++++++++++  Safe-Inferred|%Cabal8Lazily reconstruct a value previously written to a file. LMNOP+++++++++++++++++++++  Safe-Inferred| Safe-Inferred|}}  Safe-Inferred| Safe-Inferred}#+++ Safe-Inferred}T7 None9>CabalThe 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 have to repeat inner type. 8newtype New = New Old deriving anyclass (Newtype Old) !Another approach would be to use  TypeFamilies) (and possibly compute inner type using  GHC.Generics), but we think FunctionalDependencies( version gives cleaner type signatures.Cabal#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]10Cabal,alaf Sum foldMap length ["cabal", "install"]12Note: as with 0, the user supplied function for the newtype is ignored.Cabal Variant of , which takes a phantom type.Cabal Variant of , which takes a phantom type. Safe-InferredCabalEnable process jobs to ensure accurate determination of process completion in the presence of exec(3) on Windows.9Unfortunately the process job support is badly broken in process releases prior to 1.6.8, so we disable it in these versions, despite the fact that this means we may see sporatic build failures without jobs.Cabal2 with process jobs enabled when appropriate. See .Cabal2 with process jobs enabled when appropriate. See .Cabal2 with process jobs enabled when appropriate. See .Cabal Filename of the executable (see  RawCommand for details)Cabal#Arguments to pass to the executableCabal&Optional path to the working directoryCabal(Optional environment (otherwise inherit) Safe-InferredDCabalGive the *parent* of the person who invoked this; so it's most suitable for being called from a utility function. You probably want to call this using v; otherwise it's not very useful. We didn't implement this for base-4.8.1 because we cannot rely on freezing to have taken place.CabalThis function is for when you *really* want to add a call stack to raised IO, but you don't have a X so you can't use  . If you have a  Verbosity$, please use that function instead.Rvw|Rvw| Safe-Inferred6~6~cabal-devel@haskell.orgportable Safe-Inferred Safe-Inferred++++++++ Safe-Inferred+CabalHash a string using GHC's fingerprinting algorithm (a 128-bit MD5 hash) and then encode the resulting hash in base 62.+NoneCabalShow  in human readable formshowMD5 (Fingerprint 123 456)""000000000000007b00000000000001c8" showMD5 $ md5 $ BS.pack [0..127]""37eff01866ba3f538421b30b7cbefcac"@since 3.2.0.0Cabal@since 3.2.0.0Cabal@since 3.2.0.0Cabal@since 3.2.0.0 Safe-InferredCabalDecode  from UTF8-encoded octets.;Invalid data in the UTF8 stream (this includes code-points U+D800 through U+DFFF0) will be decoded as the replacement character (U+FFFD). See also CabalEncode ! to a list of UTF8-encoded octetsCode-points in the U+D800-U+DFFF; range will be encoded as the replacement character (i.e. U+FFFD). See also  decodeUtf8(c) 2019 Oleg GrenrusNone./89?xCabalUsed to implement .CabalClass 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 CabalStructure of a datatype.It can be infinite, as far as s involved are finite. (e.g. polymorphic recursion might cause troubles).Cabal5nominal, yet can be parametrised by other structures.Cabala newtype wrapperCabalsum-of-products structureCabal,A sematic version of a data type. Usually 0.CabalA MD5 hash digest of .CabalA van-Laarhoven lens into  of   :: Lens'   CabalA van-Laarhoven lens into  of   :: Lens'   CabalFlatten ) into something we can calculate hash of.As  can be potentially infinite. For mutually recursive types, we keep track of s, and put just ' name when it's occurred another time.Cabal Semantically  . .Cabal Structured +:. Encode a value to using binary serialisation to a lazy +5. Encoding starts with 16 byte large structure hash.Cabal"Lazily serialise a value to a fileCabal Structured +. Decode a value from a lazy +, reconstructing the original structure. Throws pure exception on invalid inputs.Cabal8Lazily reconstruct a value previously written to a file.CabalUse 6 to infer nameCabalDerive  genrically.None38?CabalA wrapper around I, providing the = and > instances implemented for I since  base-4.11.Cabal A copy of +.Cabal A copy of +.CabalGenerically generate a = (') operation for any type implementing <. This operation will append two values by point-wise appending their component fields. It is only defined for product types.  a ( b c) =  ( a b) c CabalGenerically generate a >  ) for any product-like type implementing <.%It is only defined for product types.   a = a =  a  => !"=> !"None?+CabalHidden internal type-classCabal New name for Cabal 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. &' ()* +,-./  0123456789%$#:;ed<=>" !?SV@ABCDEFGHITUJ[YZKLMNOPQWX\]^_`abcihgjklmnopqrstuxyz{~None38Cabal 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 APICabal Construct  from CabalConvert  to Cabal"Convert from UTF-8 encoded strict  ByteString.Cabal Text whether  is empty.CabalO(n). Length in characters. Slow as converts to string.None5CabalA type to represent the unfolding of an expensive long running calculation that may fail (or maybe not expensive, but complicated!) We may get intermediate steps before the final result which may be used to indicate progress and/or logging messages.TODO: Apply Codensity to avoid left-associativity problem. See  4http://comonad.com/reader/2011/free-monads-for-less/ and http://blog.ezyang.com/2012/01/problem-set-the-codensity-transformation/CabalEmit a step and then continue.CabalFail the computation.Cabal Consume a  calculation. Much like  for lists but with two base cases, one for a final result and one for failure.Eg to convert into a simple Q result use: $foldProgress (flip const) Left RightNone0CabalMonadic variant of  mapAccumL.None'(CabalCabalCabal Wrapper for +Note$: This operation uses lazy I/O. Use  to force all data to be read and consequently the internal file handle to be closed.CabalRepresents either textual or binary data passed via I/O functions which support binary/text modeCabal2How Text gets encoded is usually locale-dependent.Cabal2Raw binary which gets read/written in binary mode.Cabal Test whether  is emptyCabal Wrapper for + and +This is the dual operation ot ., and consequently the handle is closed with hClose.Note: this performs lazy-IO.  #Isaac Jones, Simon Marlow 2003-2004=BSD3 portions Copyright (c) 2007, Galois Inc.cabal-devel@haskell.orgportableNone8?$CabalWraps text to the default line width. Existing newlines are preserved.CabalWraps a list of words to a list of lines of words of a particular width.Cabal?Gets the contents of a file, but guarantee that it gets closed.The file is read lazily but if it is not fully consumed by the action then the remaining input is truncated and the file is closed.CabalWrites a file atomically.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.CabalDecode  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 Variant of  for lazy +sCabalEncode  to to UTF8-encoded +Code-points in the U+D800-U+DFFF; range will be encoded as the replacement character (i.e. U+FFFD).Cabal Variant of  for lazy +sCabalCheck that strict  ByteString2 is valid UTF8. Returns 'Just offset' if it's not.CabalIgnore a Unicode byte order mark (BOM) at the beginning of the inputCabal2Reads a UTF8 encoded text file as a Unicode StringReads lazily using ordinary n.Cabal2Reads a UTF8 encoded text file as a Unicode StringSame behaviour as .Cabal4Writes a Unicode String as a UTF8 encoded text file.Uses ", so provides the same guarantees.Cabal3Fix different systems silly line ending conventionsCabaldropWhileEndLE 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...CabaltakeWhileEndLE p is equivalent to reverse . takeWhile p . reverse;, but is usually faster (as well as being easier to read).CabalLike  , but has  O(n log n) complexity instead of O(n^2) . Code for  and  taken from Niklas Hambchen's  $http://github.com/nh2/haskell-ordnubordnub package.CabalLike  and . Selects a key for each element and takes the nub based on that key.Cabal Like "Data.List.union", but has  O(n log n) complexity instead of O(n^2).CabalA right-biased version of .Example:ordNub [1,2,1] :: [Int][1,2]ordNubRight [1,2,1] :: [Int][2,1]CabalA right-biased version of .Example:listUnion [1,2,3,4,3] [2,1,1] [1,2,3,4,3]"listUnionRight [1,2,3,4,3] [2,1,1] [4,3,2,1,1]CabalA total variant of _.CabalA total variant of ^.CabalA total variant of ].CabalA total variant of \.CabalLower case stringlowercase "Foobar""foobar"CabalAscii charactersCabalAscii letters.CabalAscii letters and digits.isAsciiAlphaNum 'a'TrueisAsciiAlphaNum ''FalseCabalLike  , but with I predicatebreakMaybe (readMaybe :: String -> Maybe Int) ["foo", "bar", "1", "2", "quu"]$(["foo","bar"],Just (1,["2","quu"])) Maybe Int) ["foo", "bar"](["foo","bar"],Nothing)CabalLike  but with I 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 with monadic action. Just (r + b, b + 1)) (1 :: Int) 2 [3,4,5,6,7]CabalThe opposite of snoc, which is the reverse of consExample:unsnoc [1, 2, 3]Just ([1,2],3) unsnoc []NothingCabalLike  , but for  so without the IExample:unsnocNE (1 :| [2, 3]) ([1,2],3)unsnocNE (1 :| [])([],1)Cabal 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  isRelativeOnAnyPlatform = not . ))None382Cabal?A boolean expression parameterized over the variable type used.CabalBoolean negation of a  value.CabalBoolean AND of two Condtion values.CabalBoolean OR of two  values.Cabal5Simplify the condition and return its free variables.Cabal(partial) variable assignment  Thomas Tuegel 2010BSD3cabal-devel@haskell.orgportableNone?CabalIf true, then children of this group may be run in parallel. Note that this setting is not inherited by children. In particular, consider a group F with "concurrently = False" that has some children, including a group T with "concurrently = True". The children of group T may be run concurrently with each other, as long as none are run at the same time as any of the direct children of group F.CabalA human-readable description of the option to guide the user setting it.CabalPerform the test.Cabal1A name for the test, unique within a test suite.Cabal0Users can select groups of tests by their tags.Cabal5Descriptions of the options recognized by this test.CabalTry to set the named option to the given value. Returns an error message if the option is not supported or the value could not be correctly parsed; otherwise, a 5 with the option set to the given value is returned.CabalCreate a named group of tests, which are assumed to be safe to run in parallel.++cabal-devel@haskell.orgportableNone CabalExtract the version number from the output of 'strip --version'.Invoking "strip --version" gives very inconsistent results. We ignore everything in parentheses (see #2497), look for the first word that starts with a number, and try parsing out the first two components of it. Non-GNU strip' doesn't appear to have a version flag....cabal-devel@haskell.orgportableNoneCabalNo unliteration.Cabal takes a filename (for error reports), and transforms the given string, to eliminate the literate comments from the program text.None38CabalThe $prefix path variableCabalThe $bindir path variableCabalThe $libdir path variableCabalThe  $libsubdir path variableCabalThe  $dynlibdir path variableCabalThe $datadir path variableCabalThe  $datasubdir path variableCabalThe $docdir path variableCabalThe $htmldir path variableCabalThe $pkg package name path variableCabalThe $version package version path variableCabalThe $pkgid package Id path variable, eg foo-1.0CabalThe $libname path variableCabal"The compiler name and version, eg  ghc-6.6.1CabalThe operating system name, eg windows or linuxCabalThe CPU architecture name, eg i386 or x86_64CabalThe compiler's ABI identifier,Cabal%The optional ABI tag for the compilerCabal+The executable name; used in shell wrappersCabal$The name of the test suite being runCabal,The result of the test suite being run, eg pass, fail, or error.Cabal#The name of the benchmark being run8Isaac Jones 2003-2004 Duncan Coutts 2007BSD3cabal-devel@haskell.orgportableNone38?˵Cabal#Types that represent boolean flags.Cabal1All flags are monoids, they come in two flavours:  list flags eg !--ghc-option=foo --ghc-option=bar&gives us all the values ["foo", "bar"] singular value flags, eg: --enable-foo --disable-foogives us Just False So this Flag type is for the latter singular kind of flag. Its monoid instance gives us the behaviour where it starts out as ' and later flags override earlier ones.Cabal  2011, Dan Knappcabal-devel@haskell.orgportableNoneCabalRepresents a dialect of C. The Monoid instance expresses backward compatibility, in the sense that 'mappend a b' is the least inclusive dialect which both a and b! can be correctly interpreted as.CabalA list of all file extensions which are recognized as possibly containing some dialect of C code. Note that this list is only for source files, not for header files.CabalTakes a dialect of C and whether code is intended to be passed through the preprocessor, and returns a filename extension for containing that code.CabalInfers from a filename's extension the dialect of C which it contains, and whether it is intended to be passed through the preprocessor.None8Cabal-1-indexed row and column positions in a file.Cabal)Shift position by n columns to the right.Cabal(Shift position to beginning of next row.CabalCabalNone8CabalParser warning.Cabal0Type of parser warning. We do classify warnings.Different application may decide not to show some, or have fatal behaviour on othersCabalUnclassified warningCabalInvalid UTF encodingCabaltrue or false, not True or FalseCabalthere are version with tagsCabalNew syntax used, but no cabal-version: >= 1.2 specifiedCabalOld syntax used, and cabal-version >= 1.2 specifiedCabalextra main-is fieldCabalextra test-module fieldCabalextra benchmark-module fieldCabal+legacy cabal file that we know how to patchCabalDouble dash token, most likely it's a mistake - it's not a commentCabal3e.g. name or version should be specified only once.Cabal>Workaround for derive-package having build-type: Default. See  ,https://github.com/haskell/cabal/issues/5020.None >.CabalThis is essentially a lazy bytestring, but chunks are glued with newline '\n'.CabalConvert  to .Note: inefficient! None8~Cabal Parser error.!None =Cabal 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+ contains first 256 bytes, pre- and post-fingerprints and a patch function.+Cabal#Helper to create entries in patches+Cabalneedle+CabalneedleCabal replacement+Cabalneedle(c) Sven Panne 2002-2005/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgportableNoneڱ+CabalReturn a string describing the usage of a command, derived from the header (first argument) and the options described by the second argument.+CabalProcess the command-line, and return the list of values that matched (and those that didn't). The arguments are:The order requirements (see +)The option descriptions (see +)9The actual command line arguments (presumably got from ).+ returns a triple consisting of the option arguments, a list of non-options, and a list of error messages.+CabalThis is almost the same as +, but returns a quadruple consisting of the option arguments, a list of non-options, a list of unrecognized options, and a list of error messages. +++++++++++++"BSD3cabal-devel@haskell.orgportableNone܇Cabal"position at current input locationCabalthe current inputCabal lexer codeCabalEncountered non breaking spaceCabal"BOM at the start of the cabal fileCabal Leading tagsCabal5Execute the given lexer on the supplied input stream.Cabal#Add warning at the current position+CabalAn alex lexer start code#BSD3cabal-devel@haskell.orgportableNoneFCabalTokens of outer cabal file structure. Field values are treated opaquely.Cabal+Haskell-like identifier, number or operatorCabalString in quotesCabalOperators and parensCabalIndentation tokenCabal Lines after :$None567 Cabal A field name. Invariant: + is lower-case ASCII.Cabal+Section arguments, e.g. name of the libraryCabalidentifier, or something which looks like number. Also many dot numbers, i.e. "7.6.3"Cabal quoted stringCabaleverything else, mm. operators (e.g. in if-section conditionals)CabalA line of text representing the value of a field from a Cabal file. A field may contain multiple lines. Invariant: + has no newlines.Cabal2A Cabal-like file consists of a series of fields (foo: bar) and sections ( library ...).CabalSection of field nameCabalAll transitive descendants of , including itself.Note:# the resulting list is never empty.CabalCabalCabalExtract annotation from .%BSD3cabal-devel@haskell.orgportableNone +CabalThe ++ (with a prime) is an instance of parsec's + wrapped around lexer's  (without a prime)+Cabal%Get lexer warnings accumulated so far+Cabal0Set Alex code i.e. the mode "state" lexer is in.CabalParse cabal style + into list of s, i.e. the cabal AST.CabalLike  but also return lexer warnings  BSD3cabal-dev@haskell.org experimentalportableNone+++&None?None &' ()* +,-./  0123456789%$#:;ed<=>" !?SV@ABCDEFGHITUJ[YZKLMNOPQWX\]^_`abcihgjklmnopqrstuxyz{~ &' ()* +,./  01234579%$#>" !?SV@ABCHITUJ[YZKQWXjklmnopqrstuxyz{=6~-<8ihg_^]\:;edc`abLMNOPDEFG(c) Edward Kmett 2011-2012BSD3ekmett@gmail.com experimental non-portableNone'(CabalAdditional functionality needed to describe parsers independent of input type.CabalTake a parser that may consume input, and on failure, go back to where we started and fail as if we didn't consume input.CabalGive a parser a nameCabalA version of many that discards its input. Specialized because it can often be implemented more cheaply.Cabal skipSome p applies the parser p one? or more times, skipping its result. (aka skipMany1 in parsec)Cabal,Used to emit an error on an unexpected tokenCabalThis parser only succeeds at the end of the input. This is not a primitive parser but it is defined using . 0 eof = notFollowedBy anyChar "end of input"CabalnotFollowedBy p only succeeds when parser p fails. This parser does not consume any input. This parser can be used to implement the 'longest match' rule. For example, when recognizing keywords (for example let), we want to make sure that a keyword is not followed by a legal identifier character, in which case the keyword is actually an identifier (for example lets-). We can program this behaviour as follows: ; keywordLet = try $ string "let" <* notFollowedBy alphaNumCabal choice ps( tries to apply the parsers in the list ps in order, until one of them succeeds. Returns the value of the succeeding parser.Cabal option x p tries to apply parser p. If p6 fails without consuming input, it returns the value x#, otherwise the value returned by p. + priority = option 0 (digitToInt <$> digit)CabalskipOptional p tries to apply parser p. It will parse p or nothing. It only fails if p9 fails after consuming input. It discards the result of p. (Plays the role of parsec's optional, which conflicts with Applicative's optional)Cabalbetween open close p parses open, followed by p and close!. Returns the value returned by p. , braces = between (symbol "{") (symbol "}")Cabal sepBy p sep parses zero or more occurrences of p, separated by sep'. Returns a list of values returned by p. % commaSep p = p `sepBy` (symbol ",")CabalsepByNonEmpty p sep parses one or more occurrences of p, separated by sep1. Returns a non-empty list of values returned by p.CabalsepEndByNonEmpty p sep parses one or more occurrences of p%, separated and optionally ended by sep2. Returns a non-empty list of values returned by p.CabalsepEndBy p sep parses zero or more occurrences of p%, separated and optionally ended by sep, ie. haskell style statements. Returns a list of values returned by p. 6 haskellStatements = haskellStatement `sepEndBy` semiCabalendByNonEmpty p sep parses one or more occurrences of p, separated and ended by sep1. Returns a non-empty list of values returned by p.Cabal endBy p sep parses zero or more occurrences of p, separated and ended by sep'. Returns a list of values returned by p. ( cStatements = cStatement `endBy` semiCabal count n p parses n occurrences of p. If n4 is smaller or equal to zero, the parser equals to  return []. Returns a list of n values returned by p.Cabal chainr p op x parses zero or more occurrences of p, separated by op Returns a value obtained by a right7 associative application of all functions returned by op to the values returned by p!. If there are no occurrences of p , the value x is returned.Cabal chainl p op x parses zero or more occurrences of p, separated by op . Returns a value obtained by a left7 associative application of all functions returned by op to the values returned by p#. If there are zero occurrences of p , the value x is returned.Cabalchainl1 p op x parses one or more occurrences of p, separated by op Returns a value obtained by a left7 associative application of all functions returned by op to the values returned by 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 "-"Cabalchainr1 p op x parses one or more occurrences of p, separated by op Returns a value obtained by a right7 associative application of all functions returned by op to the values returned by p.CabalmanyTill p end applies parser p zero or more times until parser end2 succeeds. Returns the list of values returned by p,. This parser can be used to scan comments:  simpleComment = do{ string "")) }Note the overlapping parsers anyChar and  string "-->"#, and therefore the use of the  combinator.ff0cabal-devel@haskell.org Windows-onlyNone+None?+CabalsetEnv name value, sets the specified environment variable to value.Throws  if either name or value1 is the empty string or contains an equals sign.++++'(c) Ben Gamari 2015-2019BSD3cabal-dev@haskell.org experimentalportableNone\CabalDifference list.CabalMake  with containing single element.Ben Gamari 2015-2019cabal-devel@haskell.orgportableNone+(NoneCaballens, variant is also parametrised by profunctor.Cabal)(3 :: Int) ^. getting (+2) . getting show"5"Cabal" is a reverse application operator%% 18444444844)None35678 9 CabalA ( represents a conditional branch, e.g.,  if flag(foo) on some syntax a). It also has an optional false branch.CabalA  is used to represent the conditional structure of a Cabal file, reflecting a syntax element subject to constraints, and then any number of sub-elements which may be enabled subject to some condition. Both a and c are usually >s.:To be more concrete, consider the following fragment of a Cabal file: 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@ Traversal@ for the variablesCabal@ Traversal@ for the variablesCabal@ Traversal @ for the aggregated constraintsCabal@ Traversal @ for the aggregated constraintsCabalExtract the condition matched by the given predicate from a cond tree.We use this mainly for extracting buildable conditions (see the Note above), but the function is in fact more general.CabalFlattens a CondTree using a partial flag assignment. When a condition cannot be evaluated, both branches are ignored.CabalFlatten a CondTree. This will resolve the CondTree by taking all possible paths into account. Note that since branches represent exclusive choices this may not result in a "sane" result.*None? None +Cabal:Copies a file to a new destination. Often you should use + instead.+CabalLike +, but does not touch the target if source and destination are already byte-identical. This is recommended as it is useful for time-stamp based recompilation avoidance.+CabalChecks if two files are byte-identical. Returns False if either of the files do not exist or if files are of different size.+++++++(c) Edward Kmett 2011BSD3ekmett@gmail.com experimental non-portableNone'(?]Cabal;Additional functionality needed to parse character streams.Cabal:Parse a single character of the input, with UTF-8 decodingCabalchar c parses a single character c&. Returns the parsed character (i.e. c).e.g.  semiColon =  ';'Cabal notChar c( parses any single character other than c . Returns the parsed character.CabalThis parser succeeds for any character. Returns the parsed character.Cabalstring s* parses a sequence of characters given by s#. Returns the parsed string (i.e. s). ; divOrMod = string "div" <|> string "mod"Cabaltext t8 parses a sequence of characters determined by the text t) Returns the parsed text fragment (i.e. t).Using OverloadedStrings: 7 divOrMod = text "div" <|> text "mod"CabaloneOf cs succeeds if the current character is in the supplied list of characters cs*. Returns the parsed character. See also .  vowel = oneOf "aeiou"CabalAs the dual of ,  noneOf cs' succeeds if the current character is not$ in the supplied list of characters cs . Returns the parsed character.  consonant = noneOf "aeiou"CabalSkips zero* or more white space characters. See also .Cabal>Parses a white space character (any character which satisfies  ) Returns the parsed character.Cabal?Parses a newline character ('\n'). Returns a newline character.Cabal7Parses a tab character ('\t'). Returns a tab character.Cabal:Parses an upper case letter. Returns the parsed character.Cabal 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#An integral without leading zeroes. Cabal Construct  ( from list of version number components.For instance, mkVersion [3,2,1] constructs a   representing the version 3.2.1.-All version components must be non-negative.  mkVersion []# currently represents the special null version; see also  . CabalVersion 0. A lower bound of  . Cabal Variant of   which converts a  Data.Version + into Cabal's   type. CabalUnpack  ( into list of version number components.This is the inverse to  , so the following holds: %(versionNumbers . mkVersion) vs == vs Cabal"Constant representing the special null  The   compares (via 0) as less than every proper   value. Cabal3Apply function to list of version number components 0alterVersion f == mkVersion . f . versionNumbers 1None35678?19 Cabal F-Algebra of  . See  . CabalThe version range -any4. That is, a version range containing all versions. withinRange v anyVersion = True CabalThe empty version range, that is a version range containing no versions.This can be constructed using any unsatisfiable version range expression, for example  > 1 && < 1. withinRange v noVersion = False CabalThe version range == v (withinRange v' (thisVersion v) = v' == v CabalThe version range  v|| v +withinRange v' (notThisVersion v) = v' /= v CabalThe version range > v (withinRange v' (laterVersion v) = v' > v CabalThe version range >= v +withinRange v' (orLaterVersion v) = v' >= v CabalThe version range < v *withinRange v' (earlierVersion v) = v' < v CabalThe version range <= v -withinRange v' (orEarlierVersion v) = v' <= v CabalThe version range  vr1 || vr2  withinRange v' (unionVersionRanges vr1 vr2) = withinRange v' vr1 || withinRange v' vr2 CabalThe version range  vr1 && vr2  withinRange v' (intersectVersionRanges vr1 vr2) = withinRange v' vr1 && withinRange v' vr2 CabalThe version range == v.*.For example, for version 1.2, the version range == 1.2.* is the same as >= 1.2 && < 1.3 withinRange v' (laterVersion v) = v' >= v && v' < upper v where upper (Version lower t) = Version (init lower ++ [last lower + 1]) t CabalThe 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 CabalFold  . Cabal CabalUnfold  . CabalRefold  Cabal , parser parametrised by version digit parser  is used for all  . is used for backward-compat pkgconfig-depends versions, PkgConfigVersionRange. Cabal= 0.4.1 && < 0.5+ + 2None5 Cabal-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 asVersionIntervals. Cabal Normalise  .In particular collapse  (== v || > v) into >= v , and so on. CabalRemove   constructors. Cabal.Does this version fall within the given range?(This is the evaluation function for the   type. Cabal Cabal+Does the version range have an upper bound? Cabal4Does 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"-any" versionCabal "== v"Cabal "> v"Cabal "< v"Cabal"_ || _" unionCabal"_ && _" intersection( ( 3None3? Cabal$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. CabalView a   as a union of intervals.5This provides a canonical view of the semantics of a   as opposed to the syntax of the expression used to define it. For the syntactic view use  .Each interval is non-empty. The sequence is in increasing order and no intervals overlap or touch. Therefore only the first and last can be unbounded. The sequence can be empty if the range is empty (e.g. a range expression like  1&& 2).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&Inspect the list of version intervals. CabalDirectly construct a   from a list of intervals.In  Cabal-2.2 the I! is dropped from the result type.+Cabal6Check an upper bound does not intersect a lower bound:--| or ---) or ---] or ---) but not ---] |--- (--- (--- [--- [--- Cabal5Test if a version falls within the version intervals.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 Convert a  $ to a sequence of version intervals. Cabal Convert a   value back into a  0 expression representing the version intervals.  4None38K CabalAn 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/What this repo info is for, what it represents. CabalThe repository for the "head" or development version of the project. This repo is where we should track the latest development activity or the usual repo people should get to contribute patches. CabalThe repository containing the sources for this exact package version or release. For this kind of repo a tag should be given to give enough information to re-create the exact sources. CabalInformation about the source revision control system for a package.When specifying a repo it is useful to know the meaning or intention of the information as doing so enables automation. There are two obvious common purposes: one is to find the repo for the latest development version, the other is to find the repo for this specific release. The ReopKind6 specifies which one we mean (or another custom one).A package can specify one or the other kind or both. Most will specify just a head repo but some may want to specify a repo to reconstruct the sources for this package release. The required information is the   which tells us if it's using  ,   for example. The  ? and other details are interpreted according to the repo type. Cabal)The kind of repo. This field is required. Cabal;The type of the source repository system for this repo, eg   or  . This field is required. Cabal)The location of the repository. For most  )s this is a URL. This field is required. Cabal  can put multiple "modules" on one server and requires a module name in addition to the location to identify a particular repo. Logically this is part of the location but unfortunately has to be specified separately. This field is required for the    $ and should not be given otherwise. CabalThe name or identifier of the branch, if any. Many source control systems have the notion of multiple branches in a repo that exist in the same location. For example   and   use this while systems like   use different locations for different branches. This field is optional but should be used if necessary to identify the sources, especially for the   repo kind. CabalThe tag identify a particular state of the repository. This should be given for the   repo kind and not for   kind. CabalSome 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.  5NoneLX  6None38Mi Cabal pkg-config versions.In fact, this can be arbitrary +, but   instance is a little pickier. CabalCompare two version strings as  pkg-config would compare them.  7None38M Cabal Cabal2018-12-21: These "legacy" situations are not legacy. We can  build-depends; on the internal library. However Now dependency contains Set LibraryName, and we should use that. Cabal8Converts an unqualified component name to a package name  is the inverse of  .Useful in legacy situations where a package name may refer to an internal component, if one is defined with that name. Cabal   <None38W Cabal2A version constraint on a package. Different from  ExeDependency and  Dependency since it does not specify the need for a component, not even the main library. There are a few places in the codebase where  Dependency is used where   should be used instead (#5570).  =None38X< CabalMulti-lib visibility Cabal&Can be depenendent from other packages CabalInternal library, default  >None38Y` Cabal Pretty print   in build-target-ish syntax.Note: there are no  or  / instances, as there's other way to represent  , namely as bare  . Cabal Convert the   of a library into a  . ?None38eE CabalA combination of a package and component name used in various legacy interfaces, chiefly bundled with a version as MungedPackageId". It's generally better to use a UnitId to opaquely refer to some compilation/packing unit, but that doesn't always work, e.g. where a "name" is needed, in which case this can be used as a fallback.Use mkMungedPackageName and unMungedPackageName to convert from/to a .In 3.0.0.0 representation was changed from opaque (string) to semantic representation. CabalIntended for internal use only,decodeCompatPackageName "z-servant-z-lackey"MungedPackageName (PackageName "servant") (LSubLibName (UnqualComponentName "lackey")) CabalIntended 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. Cabal1simpleParsec "servant" :: Maybe MungedPackageName=Just (MungedPackageName (PackageName "servant") LMainLibName) (  .   ) fa == fa Cabal Test whether   is empty. CabalLookup the value for a flagReturns T$ if the flag isn't contained in the  . Cabal-Insert or update the boolean value of a flag.&If the flag is already present in the  FlagAssigment, the value will be updated and the fact that multiple values have been provided for that flag will be recorded so that a warning can be generated later on. Cabal+Remove all flag-assignments from the first  # that are contained in the second  NB/TODO: This currently only removes flag assignments which also match the value assignment! We should review the code which uses this operation to figure out if this it's not enough to only compare the flagnames without the values. Cabal Find the  's that have been listed more than once. Cabal+String representation of a flag-value pair. Cabal Pretty-prints a flag assignment. CabalParses a flag assignment. Cabal Cabal Cabal  CNone38q Cabal  =  CabalAny like semigroup, where   is 'Any True'  DNone38r CabalThis 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. ENone38uI CabalA   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 .This type is opaque since  Cabal-2.0 Cabal Construct a   from a   is the inverse to  Note: No validations are performed to ensure that the resulting   is valid CabalConvert   to  Cabal   FNone38v: CabalA   represents a library depended on and explicitly specified by the user/client with  --dependencyIt enables Cabal to know which   to associate with a library  GNone38x Cabal.The type of build system used by this package. Cabalcalls Distribution.Simple.defaultMain Cabalcalls 9Distribution.Simple.defaultMainWithHooks defaultUserHooks, which invokes  configure to generate additional build information used by later phases. Cabalcalls Distribution.Make.defaultMain Cabaluses user-supplied Setup.hs or  Setup.lhs (default)  HNone38y Cabal ABI HashesUse   and   to convert from/to a .This type is opaque since  Cabal-2.0 Cabal Construct a   from a   is the inverse to  Note: No validations are performed to ensure that the resulting   is valid CabalConvert   to  Cabal   INoney  JDuncan Coutts 2007-2008cabal-devel@haskell.orgportableNone38? CabalThese are the known Arches: I386, X86_64, PPC, PPC64, Sparc, Arm, AArch64, Mips, SH, IA64, S39, Alpha, Hppa, Rs6000, M68k, Vax, and JavaScript.The following aliases can also be used: * PPC alias: powerpc * PPC64 alias : powerpc64, powerpc64le * Sparc aliases: sparc64, sun4 * Mips aliases: mipsel, mipseb * Arm aliases: armeb, armel * AArch64 aliases: arm64 CabalThese are the known OS names: Linux, Windows, OSX ,FreeBSD, OpenBSD, NetBSD, DragonFly ,Solaris, AIX, HPUX, IRIX ,HaLVM ,Hurd ,IOS, Android,GhcjsThe following aliases can also be used:, * Windows aliases: mingw32, win32, cygwin32 * OSX alias: darwin * Hurd alias: gnu * FreeBSD alias: kfreebsdgnu * Solaris alias: solaris2 Cabal3How 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 or arch by the same name. Variety is not a virtue in this case. We don't mind about case though.For the System.Info.os/arch different Haskell implementations use different names for the same or/arch. Also they tend to distinguish versions of an OS/arch which we just don't care about.The   classification allows us to recognise aliases that are already in common use but it allows us to distinguish them from the canonical name which enables us to warn about such deprecated aliases. Cabal4The platform Cabal was compiled on. In most cases, LocalBuildInfo.hostPlatform8 should be used instead (the platform we're targeting).3 3 KNone38R Cabal,AuserdefinedlicensereferencedenotedbyLicenseRef-[idstring].(foralicensenotontheSPDX LicenseList) CabalLicense reference. CabalDocument reference. CabalCreate  % from optional document ref and name. CabalLike  % but convert invalid characters into -.  LNone38CabalSPDX License identifierCabal0BSD, BSD Zero Clause LicenseCabalAAL, Attribution Assurance LicenseCabalAbstyles, Abstyles LicenseCabal Adobe-2006:, Adobe Systems Incorporated Source Code License AgreementCabal Adobe-Glyph, Adobe Glyph List LicenseCabalADSL!, Amazon Digital Services LicenseCabalAFL-1.1, Academic Free License v1.1CabalAFL-1.2, Academic Free License v1.2CabalAFL-2.0, Academic Free License v2.0CabalAFL-2.1, Academic Free License v2.1CabalAFL-3.0, Academic Free License v3.0CabalAfmparse, Afmparse LicenseCabalAGPL-1.0;, Affero General Public License v1.0, SPDX License List 3.0Cabal AGPL-1.0-only, Affero General Public License v1.0 only, SPDX License List 3.2, SPDX License List 3.6CabalAGPL-1.0-or-later, Affero General Public License v1.0 or later, SPDX License List 3.2, SPDX License List 3.6Cabal AGPL-3.0-only-, GNU Affero General Public License v3.0 onlyCabalAGPL-3.0-or-later1, GNU Affero General Public License v3.0 or laterCabalAladdin, Aladdin Free Public LicenseCabalAMDPLPA, AMD's plpa_map.c LicenseCabalAML, Apple MIT LicenseCabalAMPAS1, Academy of Motion Picture Arts and Sciences BSDCabalANTLR-PD, ANTLR Software Rights NoticeCabal Apache-1.0, Apache License 1.0Cabal Apache-1.1, Apache License 1.1Cabal Apache-2.0, Apache License 2.0CabalAPAFML, Adobe Postscript AFM LicenseCabalAPL-1.0, Adaptive Public License 1.0CabalAPSL-1.0!, Apple Public Source License 1.0CabalAPSL-1.1!, Apple Public Source License 1.1CabalAPSL-1.2!, Apple Public Source License 1.2CabalAPSL-2.0!, Apple Public Source License 2.0CabalArtistic-1.0-cl8!, Artistic License 1.0 w/clause 8CabalArtistic-1.0-Perl, Artistic License 1.0 (Perl)Cabal Artistic-1.0, Artistic License 1.0Cabal Artistic-2.0, Artistic License 2.0CabalBahyph, Bahyph LicenseCabalBarr, Barr LicenseCabalBeerware, Beerware LicenseCabalBitTorrent-1.0%, BitTorrent Open Source License v1.0CabalBitTorrent-1.1%, BitTorrent Open Source License v1.1Cabalblessing(, SQLite Blessing, SPDX License List 3.6Cabal BlueOak-1.0.05, Blue Oak Model License 1.0.0, SPDX License List 3.6CabalBorceux, Borceux licenseCabal BSD-1-Clause, BSD 1-Clause LicenseCabalBSD-2-Clause-FreeBSD, BSD 2-Clause FreeBSD LicenseCabalBSD-2-Clause-NetBSD, BSD 2-Clause NetBSD LicenseCabalBSD-2-Clause-Patent", BSD-2-Clause Plus Patent LicenseCabal BSD-2-Clause, BSD 2-Clause  Simplified LicenseCabalBSD-3-Clause-Attribution, BSD with attributionCabalBSD-3-Clause-Clear, BSD 3-Clause Clear LicenseCabalBSD-3-Clause-LBNL5, Lawrence Berkeley National Labs BSD variant licenseCabal$BSD-3-Clause-No-Nuclear-License-2014&, BSD 3-Clause No Nuclear License 2014CabalBSD-3-Clause-No-Nuclear-License!, BSD 3-Clause No Nuclear LicenseCabal BSD-3-Clause-No-Nuclear-Warranty", BSD 3-Clause No Nuclear WarrantyCabalBSD-3-Clause-Open-MPI6, BSD 3-Clause Open MPI variant, SPDX License List 3.6Cabal BSD-3-Clause, BSD 3-Clause New or Revised LicenseCabalBSD-4-Clause-UC2, BSD-4-Clause (University of California-Specific)Cabal BSD-4-Clause, BSD 4-Clause Original or Old LicenseCabalBSD-Protection, BSD Protection LicenseCabalBSD-Source-Code, BSD Source Code AttributionCabalBSL-1.0, Boost Software License 1.0Cabal bzip2-1.0.5#, bzip2 and libbzip2 License v1.0.5Cabal bzip2-1.0.6#, bzip2 and libbzip2 License v1.0.6CabalCaldera, Caldera LicenseCabal CATOSL-1.15, Computer Associates Trusted Open Source License 1.1Cabal CC-BY-1.0*, Creative Commons Attribution 1.0 GenericCabal CC-BY-2.0*, Creative Commons Attribution 2.0 GenericCabal CC-BY-2.5*, Creative Commons Attribution 2.5 GenericCabal CC-BY-3.0+, Creative Commons Attribution 3.0 UnportedCabal CC-BY-4.00, Creative Commons Attribution 4.0 InternationalCabal CC-BY-NC-1.09, Creative Commons Attribution Non Commercial 1.0 GenericCabal CC-BY-NC-2.09, Creative Commons Attribution Non Commercial 2.0 GenericCabal CC-BY-NC-2.59, Creative Commons Attribution Non Commercial 2.5 GenericCabal CC-BY-NC-3.0:, Creative Commons Attribution Non Commercial 3.0 UnportedCabal CC-BY-NC-4.0?, Creative Commons Attribution Non Commercial 4.0 InternationalCabalCC-BY-NC-ND-1.0, Creative Commons Attribution Non Commercial No Derivatives 1.0 GenericCabalCC-BY-NC-ND-2.0, Creative Commons Attribution Non Commercial No Derivatives 2.0 GenericCabalCC-BY-NC-ND-2.5, Creative Commons Attribution Non Commercial No Derivatives 2.5 GenericCabalCC-BY-NC-ND-3.0, Creative Commons Attribution Non Commercial No Derivatives 3.0 UnportedCabalCC-BY-NC-ND-4.0, Creative Commons Attribution Non Commercial No Derivatives 4.0 InternationalCabalCC-BY-NC-SA-1.0, Creative Commons Attribution Non Commercial Share Alike 1.0 GenericCabalCC-BY-NC-SA-2.0, Creative Commons Attribution Non Commercial Share Alike 2.0 GenericCabalCC-BY-NC-SA-2.5, Creative Commons Attribution Non Commercial Share Alike 2.5 GenericCabalCC-BY-NC-SA-3.0, Creative Commons Attribution Non Commercial Share Alike 3.0 UnportedCabalCC-BY-NC-SA-4.0, Creative Commons Attribution Non Commercial Share Alike 4.0 InternationalCabal CC-BY-ND-1.09, Creative Commons Attribution No Derivatives 1.0 GenericCabal CC-BY-ND-2.09, Creative Commons Attribution No Derivatives 2.0 GenericCabal CC-BY-ND-2.59, Creative Commons Attribution No Derivatives 2.5 GenericCabal CC-BY-ND-3.0:, Creative Commons Attribution No Derivatives 3.0 UnportedCabal CC-BY-ND-4.0?, Creative Commons Attribution No Derivatives 4.0 InternationalCabal CC-BY-SA-1.06, Creative Commons Attribution Share Alike 1.0 GenericCabal CC-BY-SA-2.06, Creative Commons Attribution Share Alike 2.0 GenericCabal CC-BY-SA-2.56, Creative Commons Attribution Share Alike 2.5 GenericCabal CC-BY-SA-3.07, Creative Commons Attribution Share Alike 3.0 UnportedCabal CC-BY-SA-4.0<, Creative Commons Attribution Share Alike 4.0 InternationalCabalCC-PDDC, Creative Commons Public Domain Dedication and Certification, SPDX License List 3.6CabalCC0-1.0&, Creative Commons Zero v1.0 UniversalCabalCDDL-1.01, Common Development and Distribution License 1.0CabalCDDL-1.11, Common Development and Distribution License 1.1CabalCDLA-Permissive-1.01, Community Data License Agreement Permissive 1.0CabalCDLA-Sharing-1.0., Community Data License Agreement Sharing 1.0Cabal CECILL-1.0-, CeCILL Free Software License Agreement v1.0Cabal CECILL-1.1-, CeCILL Free Software License Agreement v1.1Cabal CECILL-2.0-, CeCILL Free Software License Agreement v2.0Cabal CECILL-2.1-, CeCILL Free Software License Agreement v2.1CabalCECILL-B*, CeCILL-B Free Software License AgreementCabalCECILL-C*, CeCILL-C Free Software License AgreementCabal CERN-OHL-1.18, CERN Open Hardware License v1.1, SPDX License List 3.6Cabal CERN-OHL-1.28, CERN Open Hardware Licence v1.2, SPDX License List 3.6Cabal ClArtistic, Clarified Artistic LicenseCabal CNRI-Jython, CNRI Jython LicenseCabalCNRI-Python-GPL-Compatible:, CNRI Python Open Source GPL Compatible License AgreementCabal CNRI-Python, CNRI Python LicenseCabal Condor-1.1, Condor Public License v1.1Cabalcopyleft-next-0.3.0,, copyleft-next 0.3.0, SPDX License List 3.6Cabalcopyleft-next-0.3.1,, copyleft-next 0.3.1, SPDX License List 3.6CabalCPAL-1.0', Common Public Attribution License 1.0CabalCPL-1.0, Common Public License 1.0Cabal CPOL-1.02 , Code Project Open License 1.02Cabal Crossword, Crossword LicenseCabalCrystalStacker, CrystalStacker LicenseCabal CUA-OPL-1.0 , CUA Office Public License v1.0CabalCube, Cube LicenseCabalcurl, curl LicenseCabal D-FSL-1.0 , Deutsche Freie Software LizenzCabaldiffmark, diffmark licenseCabalDOC , DOC LicenseCabalDotseqn, Dotseqn LicenseCabalDSDP, DSDP LicenseCabaldvipdfm, dvipdfm LicenseCabalECL-1.0$, Educational Community License v1.0CabalECL-2.0$, Educational Community License v2.0CabalEFL-1.0, Eiffel Forum License v1.0CabalEFL-2.0, Eiffel Forum License v2.0CabaleGenix!, eGenix.com Public License 1.1.0CabalEntessa, Entessa Public License v1.0CabalEPL-1.0, Eclipse Public License 1.0CabalEPL-2.0, Eclipse Public License 2.0Cabal ErlPL-1.1, Erlang Public License v1.1Cabal EUDatagrid, EU DataGrid Software LicenseCabalEUPL-1.0#, European Union Public License 1.0CabalEUPL-1.1#, European Union Public License 1.1CabalEUPL-1.2#, European Union Public License 1.2CabalEurosym, Eurosym LicenseCabalFair, Fair LicenseCabal Frameworx-1.0, Frameworx Open License 1.0Cabal FreeImage, FreeImage Public License v1.0CabalFSFAP, FSF All Permissive LicenseCabalFSFULLR0, FSF Unlimited License (with License Retention)CabalFSFUL, FSF Unlimited LicenseCabalFTL, Freetype Project LicenseCabal GFDL-1.1-only*, GNU Free Documentation License v1.1 onlyCabalGFDL-1.1-or-later., GNU Free Documentation License v1.1 or laterCabal GFDL-1.2-only*, GNU Free Documentation License v1.2 onlyCabalGFDL-1.2-or-later., GNU Free Documentation License v1.2 or laterCabal GFDL-1.3-only*, GNU Free Documentation License v1.3 onlyCabalGFDL-1.3-or-later., GNU Free Documentation License v1.3 or laterCabalGiftware, Giftware LicenseCabalGL2PS, GL2PS LicenseCabalGlide, 3dfx Glide LicenseCabalGlulxe, Glulxe LicenseCabalgnuplot, gnuplot LicenseCabal GPL-1.0-only&, GNU General Public License v1.0 onlyCabalGPL-1.0-or-later*, GNU General Public License v1.0 or laterCabal GPL-2.0-only&, GNU General Public License v2.0 onlyCabalGPL-2.0-or-later*, GNU General Public License v2.0 or laterCabal GPL-3.0-only&, GNU General Public License v3.0 onlyCabalGPL-3.0-or-later*, GNU General Public License v3.0 or laterCabal gSOAP-1.3b, gSOAP Public License v1.3bCabal HaskellReport!, Haskell Language Report LicenseCabalHPND-sell-variant, Historical Permission Notice and Disclaimer - sell variant, SPDX License List 3.6CabalHPND-, Historical Permission Notice and DisclaimerCabalIBM-pibs., IBM PowerPC Initialization and Boot SoftwareCabalICU , ICU LicenseCabalIJG , Independent JPEG Group LicenseCabal ImageMagick, ImageMagick LicenseCabaliMatix,, iMatix Standard Function Library AgreementCabalImlib2, Imlib2 LicenseCabalInfo-ZIP, Info-ZIP LicenseCabal Intel-ACPI', Intel ACPI Software License AgreementCabalIntel, Intel Open Source LicenseCabal Interbase-1.0, Interbase Public License v1.0CabalIPA, IPA Font LicenseCabalIPL-1.0, IBM Public License v1.0CabalISC , ISC LicenseCabal JasPer-2.0, JasPer LicenseCabalJPNIC, Japan Network Information Center License, SPDX License List 3.6CabalJSON, JSON LicenseCabalLAL-1.2, Licence Art Libre 1.2CabalLAL-1.3, Licence Art Libre 1.3CabalLatex2e, Latex2e LicenseCabal Leptonica, Leptonica LicenseCabal LGPL-2.0-only,, GNU Library General Public License v2 onlyCabalLGPL-2.0-or-later0, GNU Library General Public License v2 or laterCabal LGPL-2.1-only-, GNU Lesser General Public License v2.1 onlyCabalLGPL-2.1-or-later1, GNU Lesser General Public License v2.1 or laterCabal LGPL-3.0-only-, GNU Lesser General Public License v3.0 onlyCabalLGPL-3.0-or-later1, GNU Lesser General Public License v3.0 or laterCabalLGPLLR8, Lesser General Public License For Linguistic ResourcesCabal libpng-2.08, PNG Reference Library version 2, SPDX License List 3.6CabalLibpng, libpng LicenseCaballibtiff, libtiff LicenseCabal LiLiQ-P-1.12, Licence Libre du Qubec @ Permissive version 1.1Cabal LiLiQ-R-1.13, Licence Libre du Qubec @ Rciprocit version 1.1CabalLiLiQ-Rplus-1.19, Licence Libre du Qubec @ Rciprocit forte version 1.1Cabal Linux-OpenIB, Linux Kernel Variant of OpenIB.org license, SPDX License List 3.2, SPDX License List 3.6CabalLPL-1.02, Lucent Public License v1.02CabalLPL-1.0#, Lucent Public License Version 1.0CabalLPPL-1.0#, LaTeX Project Public License v1.0CabalLPPL-1.1#, LaTeX Project Public License v1.1CabalLPPL-1.2#, LaTeX Project Public License v1.2Cabal LPPL-1.3a$, LaTeX Project Public License v1.3aCabal LPPL-1.3c$, LaTeX Project Public License v1.3cCabal MakeIndex, MakeIndex LicenseCabalMirOS, MirOS LicenseCabalMIT-0, MIT No Attribution, SPDX License List 3.2, SPDX License List 3.6CabalMIT-advertising, Enlightenment License (e16)CabalMIT-CMU , CMU LicenseCabalMIT-enna, enna LicenseCabalMIT-feh , feh LicenseCabalMITNFA, MIT +no-false-attribs licenseCabalMIT , MIT LicenseCabalMotosoto, Motosoto LicenseCabalmpich2, mpich2 LicenseCabalMPL-1.0, Mozilla Public License 1.0CabalMPL-1.1, Mozilla Public License 1.1CabalMPL-2.0-no-copyleft-exception4, Mozilla Public License 2.0 (no copyleft exception)CabalMPL-2.0, Mozilla Public License 2.0CabalMS-PL, Microsoft Public LicenseCabalMS-RL, Microsoft Reciprocal LicenseCabalMTLL!, Matrix Template Library LicenseCabalMultics, Multics LicenseCabalMup , Mup LicenseCabalNASA-1.3 , NASA Open Source Agreement 1.3CabalNaumen, Naumen Public LicenseCabalNBPL-1.0, Net Boolean Public License v1CabalNCSA1, University of Illinois/NCSA Open Source LicenseCabalNet-SNMP, Net-SNMP LicenseCabalNetCDF, NetCDF licenseCabalNewsletr, Newsletr LicenseCabalNGPL , Nethack General Public LicenseCabalNLOD-1.0,, Norwegian Licence for Open Government DataCabalNLPL, No Limit Public LicenseCabalNokia, Nokia Open Source LicenseCabalNOSL, Netizen Open Source LicenseCabalNoweb, Noweb LicenseCabalNPL-1.0, Netscape Public License v1.0CabalNPL-1.1, Netscape Public License v1.1Cabal NPOSL-3.0&, Non-Profit Open Software License 3.0CabalNRL , NRL LicenseCabalNTP , NTP LicenseCabalOCCT-PL(, Open CASCADE Technology Public LicenseCabalOCLC-2.0", OCLC Research Public License 2.0CabalODbL-1.0 , ODC Open Database License v1.0Cabal ODC-By-1.0, Open Data Commons Attribution License v1.0, SPDX License List 3.2, SPDX License List 3.6CabalOFL-1.0, SIL Open Font License 1.0CabalOFL-1.1, SIL Open Font License 1.1Cabal OGL-UK-1.05, Open Government Licence v1.0, SPDX License List 3.6Cabal OGL-UK-2.05, Open Government Licence v2.0, SPDX License List 3.6Cabal OGL-UK-3.05, Open Government Licence v3.0, SPDX License List 3.6CabalOGTSL, Open Group Test Suite LicenseCabal OLDAP-1.1, Open LDAP Public License v1.1Cabal OLDAP-1.2, Open LDAP Public License v1.2Cabal OLDAP-1.3, Open LDAP Public License v1.3Cabal OLDAP-1.4, Open LDAP Public License v1.4Cabal OLDAP-2.0.1!, Open LDAP Public License v2.0.1Cabal OLDAP-2.0;, Open LDAP Public License v2.0 (or possibly 2.0A and 2.0B)Cabal OLDAP-2.1, Open LDAP Public License v2.1Cabal OLDAP-2.2.1!, Open LDAP Public License v2.2.1Cabal OLDAP-2.2.2 , Open LDAP Public License 2.2.2Cabal OLDAP-2.2, Open LDAP Public License v2.2Cabal OLDAP-2.3, Open LDAP Public License v2.3Cabal OLDAP-2.4, Open LDAP Public License v2.4Cabal OLDAP-2.5, Open LDAP Public License v2.5Cabal OLDAP-2.6, Open LDAP Public License v2.6Cabal OLDAP-2.7, Open LDAP Public License v2.7Cabal OLDAP-2.8, Open LDAP Public License v2.8CabalOML, Open Market LicenseCabalOpenSSL, OpenSSL LicenseCabalOPL-1.0, Open Public License v1.0Cabal OSET-PL-2.1!, OSET Public License version 2.1CabalOSL-1.0, Open Software License 1.0CabalOSL-1.1, Open Software License 1.1CabalOSL-2.0, Open Software License 2.0CabalOSL-2.1, Open Software License 2.1CabalOSL-3.0, Open Software License 3.0Cabal Parity-6.0.08, The Parity Public License 6.0.0, SPDX License List 3.6CabalPDDL-1.0,, ODC Public Domain Dedication & License 1.0CabalPHP-3.01, PHP License v3.01CabalPHP-3.0, PHP License v3.0CabalPlexus, Plexus Classworlds LicenseCabal PostgreSQL, PostgreSQL LicenseCabalpsfrag, psfrag LicenseCabalpsutils, psutils LicenseCabal Python-2.0, Python License 2.0CabalQhull, Qhull LicenseCabalQPL-1.0, Q Public License 1.0CabalRdisc, Rdisc LicenseCabal RHeCos-1.1", Red Hat eCos Public License v1.1CabalRPL-1.1, Reciprocal Public License 1.1CabalRPL-1.5, Reciprocal Public License 1.5CabalRPSL-1.0), RealNetworks Public Source License v1.0CabalRSA-MD, RSA Message-Digest License CabalRSCPL", Ricoh Source Code Public LicenseCabalRuby, Ruby LicenseCabalSAX-PD, Sax Public Domain NoticeCabalSaxpath, Saxpath LicenseCabalSCEA, SCEA Shared Source LicenseCabal Sendmail-8.23., Sendmail License 8.23, SPDX License List 3.6CabalSendmail, Sendmail LicenseCabal SGI-B-1.0", SGI Free Software License B v1.0Cabal SGI-B-1.1", SGI Free Software License B v1.1Cabal SGI-B-2.0", SGI Free Software License B v2.0CabalSHL-0.51, Solderpad Hardware License, Version 0.51, SPDX License List 3.6CabalSHL-0.58, Solderpad Hardware License v0.5, SPDX License List 3.6Cabal SimPL-2.0, Simple Public License 2.0Cabal SISSL-1.2,, Sun Industry Standards Source License v1.2CabalSISSL,, Sun Industry Standards Source License v1.1Cabal Sleepycat, Sleepycat LicenseCabalSMLNJ#, Standard ML of New Jersey LicenseCabalSMPPL*, Secure Messaging Protocol Public LicenseCabalSNIA, SNIA Public License 1.1Cabal Spencer-86, Spencer License 86Cabal Spencer-94, Spencer License 94Cabal Spencer-99, Spencer License 99CabalSPL-1.0, Sun Public License v1.0CabalSSPL-1.08, Server Side Public License, v 1, SPDX License List 3.6CabalSugarCRM-1.1.3 , SugarCRM Public License v1.1.3CabalSWL8, Scheme Widget Library (SWL) Software License AgreementCabal TAPR-OHL-1.08, TAPR Open Hardware License v1.0, SPDX License List 3.6CabalTCL, TCL/TK LicenseCabal TCP-wrappers, TCP Wrappers LicenseCabalTMate, TMate Open Source LicenseCabal TORQUE-1.1$, TORQUE v2.5+ Software License v1.1CabalTOSL, Trusster Open Source LicenseCabal TU-Berlin-1.0, Technische Universitaet Berlin License 1.0, SPDX License List 3.2, SPDX License List 3.6Cabal TU-Berlin-2.0, Technische Universitaet Berlin License 2.0, SPDX License List 3.2, SPDX License List 3.6CabalUnicode-DFS-2015<, Unicode License Agreement - Data Files and Software (2015)CabalUnicode-DFS-2016<, Unicode License Agreement - Data Files and Software (2016)Cabal Unicode-TOU, Unicode Terms of UseCabal Unlicense, The UnlicenseCabalUPL-1.0#, Universal Permissive License v1.0CabalVim , Vim LicenseCabalVOSTROM(, VOSTROM Public License for Open SourceCabalVSL-1.0, Vovida Software License v1.0Cabal W3C-19980720., W3C Software Notice and License (1998-07-20)Cabal W3C-201505137, W3C Software Notice and Document License (2015-05-13)CabalW3C., W3C Software Notice and License (2002-12-31)Cabal Watcom-1.0', Sybase Open Watcom Public License 1.0CabalWsuipa, Wsuipa LicenseCabalWTFPL-, Do What The F*ck You Want To Public LicenseCabalX11 , X11 LicenseCabalXerox, Xerox LicenseCabal XFree86-1.1, XFree86 License 1.1Cabalxinetd, xinetd LicenseCabalXnet, X.Net LicenseCabalxpp , XPP LicenseCabalXSkat, XSkat LicenseCabalYPL-1.0, Yahoo! Public License v1.0CabalYPL-1.1, Yahoo! Public License v1.1CabalZed , Zed LicenseCabalZend-2.0, Zend License v2.0Cabal Zimbra-1.3, Zimbra Public License v1.3Cabal Zimbra-1.4, Zimbra Public License v1.4Cabalzlib-acknowledgement*, zlib/libpng License with AcknowledgementCabalZlib, zlib LicenseCabalZPL-1.1, Zope Public License 1.1CabalZPL-2.0, Zope Public License 2.0CabalZPL-2.1, Zope Public License 2.1Cabal=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]CabalLicense SPDX identifier, e.g. "BSD-3-Clause".CabalLicense name, e.g. &"GNU General Public License v2.0 only"CabalWhether the license is approved by Open Source Initiative (OSI).See  ,https://opensource.org/licenses/alphabetical.Cabal Create a  from a .Cabal6eitherParsec "BSD-3-Clause" :: Either String LicenseIdRight BSD_3_Clause.eitherParsec "BSD3" :: Either String LicenseIdLeft "...Unknown SPDX license identifier: 'BSD3' Do you mean BSD-3-Clause?"MNone38.(CabalSPDX License identifierCabal 389-exception , 389 Directory Server ExceptionCabalAutoconf-exception-2.0, Autoconf exception 2.0CabalAutoconf-exception-3.0, Autoconf exception 3.0CabalBison-exception-2.2, Bison exception 2.2CabalBootloader-exception#, Bootloader Distribution ExceptionCabalClasspath-exception-2.0, Classpath exception 2.0CabalCLISP-exception-2.0, CLISP exception 2.0CabalDigiRule-FOSS-exception!, DigiRule FOSS License ExceptionCabaleCos-exception-2.0, eCos exception 2.0CabalFawkes-Runtime-exception, Fawkes Runtime ExceptionCabalFLTK-exception, FLTK exceptionCabalFont-exception-2.0, Font exception 2.0Cabalfreertos-exception-2.0, FreeRTOS Exception 2.0CabalGCC-exception-2.0#, GCC Runtime Library exception 2.0CabalGCC-exception-3.1#, GCC Runtime Library exception 3.1Cabalgnu-javamail-exception, GNU JavaMail exceptionCabal GPL-CC-1.07, GPL Cooperation Commitment 1.0, SPDX License List 3.6Cabali2p-gpl-java-exception, i2p GPL+Java ExceptionCabalLibtool-exception, Libtool ExceptionCabalLinux-syscall-note, Linux Syscall NoteCabalLLVM-exception>, LLVM Exception, SPDX License List 3.2, SPDX License List 3.6CabalLZMA-exception, LZMA exceptionCabal mif-exception', Macros and Inline Functions ExceptionCabalNokia-Qt-exception-1.1, Nokia Qt LGPL exception 1.1, SPDX License List 3.0, SPDX License List 3.2CabalOCaml-LGPL-linking-exception5, OCaml LGPL Linking Exception, SPDX License List 3.6CabalOCCT-exception-1.0, Open CASCADE Exception 1.0CabalOpenJDK-assembly-exception-1.0, OpenJDK Assembly exception 1.0, SPDX License List 3.2, SPDX License List 3.6Cabalopenvpn-openssl-exception, OpenVPN OpenSSL ExceptionCabal!PS-or-PDF-font-exception-20170817, PS/PDF font exception (2017-08-17), SPDX License List 3.2, SPDX License List 3.6CabalQt-GPL-exception-1.0, Qt GPL exception 1.0, SPDX License List 3.2, SPDX License List 3.6CabalQt-LGPL-exception-1.1, Qt LGPL exception 1.1, SPDX License List 3.2, SPDX License List 3.6CabalQwt-exception-1.0, Qwt exception 1.0CabalSwift-exception(, Swift Exception, SPDX License List 3.6Cabalu-boot-exception-2.0, U-Boot exception 2.0CabalUniversal-FOSS-exception-1.0>, Universal FOSS Exception, Version 1.0, SPDX License List 3.6CabalWxWindows-exception-3.1!, WxWindows Library Exception 3.1CabalLicense SPDX identifier, e.g. "BSD-3-Clause".CabalLicense name, e.g. &"GNU General Public License v2.0 only"Cabal Create a  from a .))NNone38CabalSimple License Expressions.Cabal9An SPDX License List Short Form Identifier. For example:  GPL-2.0-onlyCabalAn SPDX License List Short Form Identifier with a unary"+" operator suffix to represent the current version of the license or any later version. For example: GPL-2.0+Cabal4A SPDX user defined license reference: For example:  LicenseRef-23, LicenseRef-MIT-Style-1, or 0DocumentRef-spdx-tool-1.2:LicenseRef-MIT-Style-2CabalSPDX License Expression. idstring = 1*(ALPHA / DIGIT / "-" / "." ) license id = 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)  ONone38;CabalDeclared license. See