!  q      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDE F G H I J K L M NOPQRSTUVWX Y Z [ \ ] ^ _ ` a bcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<= >!?!@!A!B!C!D!E!F!G!H!I!J!K!L!M!N!O!P!Q!R!S!T!U!V!W!X"Y"Z#[#\#]#^#_#`#a#b#c#d#e#f#g#h#i#j#k#l#m#n#o#p#q#r#s#t#u#v#w#x#y#z#{#|#}$~$$$$$$$$$$$$$$$$%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& & & & & &&&&&&&&''''''''''' '!'"'#'$'%'&'''(')'*'+','-'.'/'0'1'2'3'4'5'6'7'8'9':';'<'='>'?'@'A'B'C'D'E'F'G'H'I'J'K'L'M'N'O'P'Q'R'S'T'U'V'W'X'Y(Z([(\(](^(_(`(a(b(c(d(e(f(g(h(i(j(k(l(m(n)o)p)q)r)s)t)u)v)w)x)y)z){)|)})~)))))))))))))))*********************************++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++,,,-------------------------- - - . . ................... .!.".#.$.%.&.'.(.).*.+.,.-.../.0.1.2.3.4.5.6.7.8.9.:.;.<.=.>.?.@.A.B.C.D.E.F.G.H.I.J.K.L.M.N.O.P.Q.R.S.T.U.V.W.X.Y.Z.[.\.].^._.`.a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p.q.r.s.t.u.v.w.x.y.z.{.|/}/~0000000000000000000000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 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 01 11 21 31 41 51 61 71 81 91 :1 ;1 <1 =1 >1 ?1 @1 A1 B1 C1 D1 E1 F1 G2 H2 I2 J2 K2 L2 M2 N2 O2 P2 Q2 R2 S2 T2 U2 V2 W2 X2 Y2 Z2 [3 \3 ]3 ^3 _3 `4 a4 b4 c4 d4 e4 f4 g4 h4 i4 j4 k4 l4 m4 n4 o4 p4 q4 r4 s4 t4 u4 v4 w4 x4 y5 z6 {6 |6 }6 ~6 6                                                            7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 9 9 9 9 9 9 9 9 : : : : : : : : : : : : : : : : : : !; "; #; $; %; &; '; (; ); *; +; ,; -; .; /; 0; 1; 2; 3; 4; 5; 6; 7; 8; 9; :; ;; <; =; >; ?; @; A; B; C; D; E; F; G; H; I; J; K; L; M; N; O; P; Q; R; S; T; U; V; W; X; Y; Z; [; \; ]; ^; _; `; a; b; c; d; e; f; g; h; i; j; k; l; m; n; o; p; q; r; s; t; u; v; w; x; y; z; {; |; }; ~; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; !; "; #; $; %; &; '; (; ); *; +; ,; -; .; /; 0; 1; 2; 3; 4; 5; 6; 7; 8; 9; :; ;; <; =; >; ?; @; A; B; C; D; E; F; G; H; I; J; K; L; M; N; O; P; Q; R; S; T; U; V; W; X; Y; Z; [; \; ]; ^; _; `; a; b; c; d; e; f; g; h; i; j; k; l; m; n; o; p; q; r; s; t; u; v; w; x; y; z; {; |; }; ~; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; < < < < < < < < = = = = = = = = = = = = = = = = = = != "= #= $= %= &= '= (= )= *= += ,= -= .= /= 0= 1= 2= 3= 4= 5= 6= 7= 8= 9= := ;= <= == >= ?= @= A= B= C= D= E= F= G= H= I= J= K= L= M= N= O= P= Q= R= S= T= U= V= W= X= Y= Z= [= \= ]= ^= _= `= a= b= c= d= e= f= g= h= i= j= k= l= m= n= o= p= q= r= s= t= u= v= w= x= y= z= {= |= }= ~= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > !> "> #> $> %> &> '> (> )> *> +> ,> -> .> /> 0> 1> 2> 3> 4> 5> 6> 7> 8> 9> :> ;> <> => >> ?> @> A> B> C> D> E? F? G? H? I? J? K? L? M@ N@ O@ P@ Q@ R@ S@ T@ U@ V@ W@ X@ Y@ Z@ [@ \@ ]@ ^@ _@ `@ a@ b@ c@ d@ e@ f@ g@ h@ i@ j@ k@ l@ m@ n@ o@ pA qA rA sA tA uA vA wA xA yA zA {A |A }A ~A A A A A A A A B C D E F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F G G G G G G G G G G G G G G G H H H H H H H I I I I I I J J J J K K K K K K L L L L L L L L L L L L L L L L L M M M M M M M M M N O O O O O O O O O P PPPPPPPPPQ Q Q Q Q QQQQQQQQQQQQQRRRRRR R!R"R#R$R%R&R'R(R)R*R+R,R-R.R/R0R1R2R3R4R5S6S7S8T9T:T;T<T=T>U?U@UAUBUCVDVEVFVGVHVIVJVKVLVMVNVOVPVQVRVSVTVUVVVWVXVYVZV[V\V]V^V_V`VaVbWcWdWeWfWgXhYiYjYkYlYmYnYoYpZqZrZsZtZuZvZwZx[y\z\{\|\}\~\\\\\\\\\\\\\\\\\\\\\\]]^^^^^^^^^^^^^_______________________`````aaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbccccccccccdddddddddddddddddddddddddd d d d d ddddeeeeeefffffffff g!g"g#g$g%g&g'g(h)h*h+h,h-h.h/h0h1h2h3i4i5i6i7i8i9i:i;i<i=i>i?i@iAiBiCiDiEiFiGiHiIiJiKjLjMkNkOkPkQkRkSkTkUkVkWkXkYkZk[l\m]n^n_n`oapbpcpdpepfpgphpipjpkplpmpnpopppqprpsptpupvpwpxpypzp{p|p}p~ppppppppqqqqqqqqqqqqqqqqqqqqqqqqqqrrrrrrrrrrrrssssttttttttttttttuvvwxxxyyyz{||}}}}}}}}}}}}}}}}}}}}}}None<3456789:;<=>?@BADCEHFGLJIKPMONQRSTUVWXYZ[\]^_`abcdef !"< !"\Z[YXVUWNOM?>;<=KI@JTRSLHFGPQ]fBADCecbda`_^E9:873465~None>SXնstack Create an  value from a preexisting Q.stackWrap custom exceptions*NOTE: The only other exception defined in  http-client is TimeoutTriggered but it is currently disabled 2https://github.com/snoyberg/http-client/issues/116stackSet request headersstackExtract the response headersQNone% #stack3Convert to FilePath but don't add a trailing slash.$stackNCollapse intermediate "." and ".." directories from path, then parse it with 0. (probably should be moved to the Path module)%stackNCollapse intermediate "." and ".." directories from path, then parse it with 0. (probably should be moved to the Path module)&stackAdd a relative FilePath to the end of a Path We can't parse the FilePath first because we need to account for ".." in the FilePath (#2895)stack;Collapse intermediate "." and ".." directories from a path. OcollapseFilePath "./foo" == "foo" collapseFilePath "/bar/../baz" == "/baz" collapseFilePath "/../baz" == "/../baz" collapseFilePath "parent/foo/baz/../bar" == "parent/foo/bar" collapseFilePath "parent/foo/baz/../../bar" == "parent/bar" collapseFilePath "parent/foo/.." == "parent" collapseFilePath "/parent/foo/../../bar" == "/bar"(adapted from Text.Pandoc.Shared)'stackDrop the root (either / on POSIX or C:\, D:\, etc. on Windows).(stackIf given file in H does not exist, ensure we have T*. This is to be used in conjunction with  and .Previously the idiom  forgivingAbsence (relsoveFile &)" alone was used, which relied on  throwing m when path does not exist. As it turns out, this behavior is actually not intentional and unreliable, see  .https://github.com/haskell/directory/issues/44. This was fixed  in version 1.2.3.0 of  directoryg package (now it never throws). To make it work with all versions, we need to use the following idiom: 6forgivingAbsence (resolveFile &) >>= rejectMissingFile)stackSee (.*stack7Convert to a lazy ByteString using toFilePath and UTF8.+stack2Convert to a ByteString using toFilePath and UTF8. #$%&'()*+,- #'$%&()+*,-Safed./012345./012354NoneX6stack Get a source for a file. Unlike  sourceFile, doesn't require  ResourceT. Unlike explicit withBinaryFile and  sourceHandle$ usage, you can't accidentally use  WriteMode instead of ReadMode.7stack Same idea as 6, see comments there.8stackLike 7P, but ensures that the file is atomically moved after all contents are written.9stack Path version:stackLike 9-, but the temporary directory is not deleted.;stack:Consume the stdout and stderr of a process feeding strict ^s to the consumers. Throws a ReadProcessException" if unsuccessful in launching, or ProcessExitedUnsuccessfully if the process itself fails.<stack/Consume the stdout of a process feeding strict ^s to a consumer. If the process fails, spits out stdout and stderr as error log level. Should not be used for long-running processes or ones with lots of output; for that use ;. Throws a ReadProcessException if unsuccessful.>stack+Read from the process, ignoring any output. Throws a ReadProcessException exception if the process fails.?stack Use the new @, but retain the working directory from the parent environment.@stack,Remove a trailing carriage return if presentAstacknhIsTerminaDevice does not recognise handles to mintty terminals as terminal devices, but isMinTTYHandle does.BstackRPrompt the user by sending text to stdout, and taking a line of input from stdin.CstackPrompt the user by sending text to stdout, and collecting a line of input from stdin. While taking input from stdin, input echoing is disabled, to hide passwords.<Based on code from cabal-install, Distribution.Client.UploadDstackPrompt the user by sending text to stdout, and collecting a line of input from stdin. If something other than "y" or "n" is entered, then print a message indicating that "y" or "n" is expected, and ask again.;stackCommandstackCommand line argumentsstackSink for stderrstackSink for stdout<stackCommandstackCommand line argumentsstackSink for stdout>stackCommandstackCommand line argumentsT  $%& p'( )*+,|- .onjihg/01234567!"#{89:;<=SV>?@ABCDEFGHTUIYZ[JKLMNOPQWXR\]^_`adefklmqrstvuwzyx}~+     xs !"%$#&'()*,-./012ghijklmnopqrtwvuyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABEDCFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     6789:;<=>?@ABCDT6789:;<=>?@ABCD  $%& p'( )*+,|- .onjihg/01234567!"#{89:;<=SV>?@ABCDEFGHTUIYZ[JKLMNOPQWXR\]^_`adefklmqrstvuwzyx}~+     xs !"%$#&'()*,-./012ghijklmnopqrtwvuyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABEDCFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      None4BEstack8Allows adjust global options depending on their context Note: This was being used to remove ambibuity between the local and global implementation of stack init --resolver option. Now that stack init has no local --resolver this is not being used anymore but the code is kept for any similar future use cases.Fstack%Global options before subcommand nameGstack-Global options following any other subcommandJstack9If argument is True, hides the option from usage and helpEIHGFJJEIHGF None5:MstackParser for a logging level.MMNone6stackCMake sure that a filename with spaces in it gets the proper quotes.bNOPQRSTNbOPQRST NoneP::stack(Run an action, watching for file changesThe action provided takes a callback that is used to set the files to be watched. When any of those files are changed, we rerun the action again.XYXY None.LZstack9Find the location of a file matching the given predicate.[stack>Find the location of a directory matching the given predicate.stack9Find the location of a path matching the given predicate.\stack5Find files matching predicate below a root directory.qNOTE: this skips symbolic directory links, to avoid loops. This may not make sense for all uses of file finding.VTODO: write one of these that traverses symbolic links but efficiently ignores loops.]stackfindInParents f path applies f to path and its s until it finds a U or reaches the root directory.Zstack Start here.stackPredicate to match the file.stack#Do not ascend above this directory.stackAbsolute file path.[stack Start here.stack!Predicate to match the directory.stack#Do not ascend above this directory.stackAbsolute directory path.stackChoose path type from pair.stack Start here.stackPredicate to match the path.stack#Do not ascend above this directory.stackAbsolute path.\stackRoot directory to begin with.stackPredicate to match files.stack,Predicate for which directories to traverse.stackList of matching files.Z[\]Z[\] Noneav^stack2Generate and execute a complicated options parser._stack(Add a command to the options dispatcher.`stack@Add a command that takes sub-commands to the options dispatcher.stack(Add a command to the options dispatcher.astack&Generate a complicated options parser.stackSubparser with --helpM argument. Borrowed with slight modification from Options.Applicative.Extra.stackNon-hidden help option.^ stacknumeric versionstackversion stringstack hpack numeric version, as stringstackheaderstackTprogram description (displayed between usage and options listing in the help output)stackfooterstackcommon settingsstack%optional handler for parser failure;  is called by defaultstackcommands (use _)_stackcommand stringstacktitle of commandstackfooter of command helpstack2constructor to wrap up command in common data typestack common parserstackcommand parser`stackcommand stringstacktitle of commandstackfooter of command helpstack common parserstacksub-commands (use _)stackcommand stringstacktitle of commandstackfooter of command helpstack2constructor to wrap up command in common data typestack common parserstackcommand parserastackmetavar for the sub-commandstackcommon settingsstackcommands (use _)^_`a_`^aNone"#Xy istackEnable/disable flags for a =.jstackEnable/disable flags for a =1, without a default case (to allow chaining with x).kstackEnable/disable flags for a (H =).lstackLike k, but parsing a .mstack"Enable/disable flags for any type.nstackMEnable/disable flags for any type, without a default (to allow chaining with x)ostack Show an extra help option (e.g.  --docker-help shows help for all  --docker* args).'To actually have that help appear, use p" before executing the main parser.pstack<Display extra help if extra help option passed in arguments.GSince optparse-applicative doesn't allow an arbitrary IO action for an S, this was the best way I found that doesn't require manually formatting the help.qstack, specialized to .rstack, specialized to .sstackLike , but returning a .xstackLike , but accepting any 3 e on the W.istack Default valuestack Flag namestack Help suffixjstack Flag namestack Help suffixkstack Flag namestack Help suffixmstack Default valuestack Enabled valuestackDisabled valuestackNamestack Help suffixnstack Enabled valuestackDisabled valuestackNamestack Help suffixostack Hide from the brief description?stackProgram name, e.g. "stack"stackOption glob expression, e.g.  "docker*"stackHelp option name, e.g.  "docker-help"pstackCommand line argumentsstackExtra help option name, e.g.  "docker-help"stack&Option parser for the relevant commandstackOption descriptionbcedgfhijklmnopqrstuvwxyz{|}~ijklmnopqrstuvwxz{|bcedgfhy}~None{!stack Parser for  solverCmdNone %,2>X~stackWrite to the given file.stackRead from the given file. If the read fails, run the given action and write that back to the file. Always starts the file off with the version tag.None7M_stackQUtility newtype wrapper to make make Map's Monoid also use the element's Monoid.NoneNonestackConcatenate two parsers.stackAlternative parsers.stackPure something.stack#Concatting the result of an action.Nonestack#Mode for parsing escape characters.stackParse arguments using .stack Parse using  from a string.stackpA basic argument parser. It supports space-separated text, and string quotation with identity escaping: x -> x.Nonestack3An argument which accepts a list of arguments e.g. --ghc-options="-X P.hs "this"".stack1An option which accepts a list of arguments e.g. --ghc-options="-X P.hs "this"".stack?An option which accepts a command and a list of arguments e.g. --exec "echo hello world"None7PGstackWarning output from .stackMonoid used by ' to track expected fields and warnings.stack:JSON parser that warns about unexpected fields in objects.stackExtends .: warning to include field name.stackExtends .:? warning to include field name.stack version of .:.stack version of .:?.stack version of .!=.stackITell warning parser about an expected field, so it doesn't warn about it.stack version of @.stack Convert a  to a .stackLog JSON warnings.stack Handle warnings in a sub-object.stackHandle warnings in a  Traversable of sub-objects.stackHandle warnings in a Maybe Traversable of sub-objects.     ! #"&%$)('.-,+*3210/456789:;<=>?@ABCDFEIHGLKJONMTSRQPWVUZYX[\]^_`cbadelgikjhfonmwvutsrqp~}|{zyx     ! #"&%$)('.-,+*3210/456789:;<=>?@ABCDFEIHGLKJONMTSRQPWVUZYX[\]^_`cbadelgikjhfonmwvutsrqp~}|{zyxNone&'279XstackFYeah, it looks terrible to use a list here, but fusion should kick instack9May throw a runtime exception if invariants are violated!None stack#Descriptive name for compiler build stackGSuffix to use for filenames/directories constructed with compiler build stack#Parse compiler build from a String.        NonestackGHC build parserNone 27=?MP2 stack A flag name.stack A parse fail.stack!Attoparsec parser for a flag namestackMake a flag name.stack+Convenient way to parse a flag name from a .stack(Convenience function for parsing from a lstack/Produce a string representation of a flag name.stack/Produce a string representation of a flag name.stackConvert from a Cabal flag name.stackConvert to a Cabal flag name.  None27/)stackA ghc-pkg package identifier.stack A parse fail.*stack.Convenient way to parse a package name from a .+stack)A parser for a package-version-hash pair.,stack.Get a string representation of GHC package id.)*+,)+*,None"#7=?X>stacknMaybe have a docker base image name. (Although we will not be able to create any Docker images without this.)?stackJMaybe have a specific ENTRYPOINT list that will be used to create images.@stack]Maybe have some static project content to include in a specific directory in all the images.Astack/Maybe have a name for the image we are creatingBstack:Filenames of executables to add (if Nothing, add them all)Cstack3Image options. Currently only Docker image options.Estack.One or more stanzas for docker image settings.9:;<=BA@?>CDEFGHIJKLMCDE<=BA@?>9:;FGHIJKLMNone"#7=?vVstacknAn uninterpreted representation of nix options. Configurations may be "cascaded" using mappend (left-biased).XstackIs using nix-shell enabled?YstackShould the nix-shell be pureZstack+System packages to use (given to nix-shell)[stackQThe path of a file containing preconfiguration of the environment (e.g shell.nix)\stack1Options to be given to the nix-shell command line]stack$Override parts of NIX_PATH (notably nixpkgs)^stackZShould we register gc roots so running nix-collect-garbage doesn't remove nix dependencies_stackMNix configuration. Parameterize by resolver type to avoid cyclic dependency.cstackEThe system packages to be installed in the environment before it runsdstackQThe path of a file containing preconfiguration of the environment (e.g shell.nix)estack1Options to be given to the nix-shell command linefstackZShould we register gc roots so running nix-collect-garbage doesn't remove nix dependenciesgstackNix enable argument name.hstack$Nix run in pure shell argument name.istack*Nix packages (build inputs) argument name.jstack"shell.nix file path argument name.kstack6Extra options for the nix-shell command argument name.lstackNIX_PATH override argument namemstackAdd GC roots arg namenstackLeft-biased combine Nix optionsostackLeft-biased combine Nix optionspstack0Decode uninterpreted nix options from JSON/YAML.VW^]\[ZYX_`fedcbaghijklm_`fedcbaVW^]\[ZYXghijklmNone 27=?MPԱ ustackA package name.vstack A parse fail.zstack$Attoparsec parser for a package name{stackMake a package name.|stackParse a package name from a .}stackParse a package name from a l.~stack2Produce a string representation of a package name.stack2Produce a string representation of a package name.stack"Convert from a Cabal package name.stack Convert to a Cabal package name.stack&Parse a package name from a file path.stack9An argument which accepts a template name of the format  foo.hsfiles.uvwxyz{|}~uvwxyz|}~{NoneAstack/A single, fully resolved component of a packageNone"#7=?z%stackOptions for the  FinalAction  DoBenchmarksstack)Arguments passed to the benchmark programstackDisable running of benchmarksstackHaddock Optionsstack#Arguments passed to haddock programstackOptions for the  FinalAction DoTestsstack)Whether successful tests will be run gainstack$Arguments passed to the test programstackGenerate a code coverage reportstackDisable running of testsstack!Which subset of packages to buildstackcOnly install packages in the snapshot database, skipping packages intended for the local database.stackEBuild options that may be specified in the stack.yaml or from the CLIstack+Command sum type for conditional arguments.stack5Build options that may only be specified from the CLIstackqBuild options that is interpreted by the build command. This is built up from BuildOptsCLI and BuildOptsMonoidstackBuild haddocks?stackOptions to pass to haddockstackOpen haddocks in the browser?stack Build haddocks for dependencies?stack2Build haddocks for all symbols and packages, like cabal haddock --internalstack3Build hyperlinked source if possible. Fallback to hscolour. Disable for no sources.stack0Install executables to user path after building?stack:Install executables to compiler tools path after building? stackSFetch all packages immediately ^ Watch files for changes and automatically rebuild stack#Keep building/running after failure stack-Keep intermediate files and build directories stack7Force treating all local packages as having dirty files stackTurn on tests for local targetsstackAdditional test argumentsstack$Turn on benchmarks for local targetsstackAdditional test arguments ^ Commands (with arguments) to run after a successful build ^ Only perform the configure step when buildingstack5Perform the configure step even if already configuredstack%Ask Cabal to be verbose in its buildsstackWhether to enable split-objs.stack&Which components to skip when buildingstackJShould we use the interleaved GHC output when building multiple packages?r     r      None=stackParser for package:[-]flag==!Signature Types!(c) 2015-2018, Stack contributorsBSD3!Tim Dysinger <tim@fpcomplete.com> experimentalPOSIXNone2=?>stack Exceptionsstack#Handy wrapper for orphan instances.FstackThe GPG fingerprint.GstackA GPG signature. >?@ABCDEFGHI GHFI>?@ABCDE" GPG Functions!(c) 2015-2018, Stack contributorsBSD3!Tim Dysinger <tim@fpcomplete.com> experimentalPOSIXNoneSX]Xstack)Sign a file path with GPG, returning the  Signature.Ystack Verify the  Signature of a file path returning the  Fingerprint.stackTry to execute gpg2 but fallback to  (as a backup)stack`man gpg-agent` shows that you need GPG_TTY environment variable set to properly deal with interactions with gpg-agent. (Doesn't apply to Windows though)XYXY#None%MIZstackAServices from which templates can be retrieved from a repository.^stack8Details for how to access a template from a remote repo.dstack"an absolute path on the filesystemestackJa relative path on the filesystem, or relative to the template repositoryfstack a full URLhstackA template name.istack9An argument which accepts a template name of the format  foo.hsfiles or foo, ultimately normalized to foo.jstackAn argument which accepts a  key:value pair for specifying parameters.kstack$Parse a template name from a string.lstackMake a template name.mstack/Get a text representation of the template name.nstackGet the path of the template.stack#Parses a template path of the form github:user/template.ostack#Parses a template path of the form  user/template, given a serviceZ[\]^_`abcgdefhijklmnoh^_`abZ[\]cgdeflmnkoij$None7=?O }~ }~%NoneNone 27=?M%stackA package version.stack0A Package upgrade; Latest or a specific version.stack A parse fail.stack(Attoparsec parser for a package version.stack1Convenient way to parse a package version from a .stackMigration function.stack1Get a string representation of a package version.stack1Get a string representation of a package version.stackConvert to a Cabal version.stackConvert from a Cabal version.stackMake a package version.stackDisplay a version rangestack-Check if a version is within a version range.stackBA modified intersection which also simplifies, for better display.stack@Returns the first two components, defaulting to 0 if not presentstacklGiven a version range and a set of versions, find the latest version from the set that is within the range.stack7Get the next major version number for the given versionstack+Get minor version (excludes any patchlevel)stackCurrent Stack versionstack1Current Stack minor version (excludes patchlevel)cc&None.27MXA|stack+Information on the contents of a cabal filestackTake the latest revision of the cabal file available. This isn't reproducible at all, but the running assumption (not necessarily true) is that cabal file revisions do not change semantics of the build.stack-Identify by contents of the cabal file itselfstackLIdentify by revision number, with 0 being the original and counting upward.stackTA SHA256 hash, stored in a static size for more efficient serialization with store.stack%A cryptographic hash of a Cabal file.stackA A combined with optionally specified Hackage cabal file revision.stackA pkg-ver combination.stack$Get the name part of the identifier.stack'Get the version part of the identifier.stack A parse fail.stack Generate a ) value from a base16-encoded SHA256 hash.stack Generate a # value from the contents of a file.stack Convert a # into a base16-encoded SHA256 hash.stack Convert a # into a base16-encoded SHA256 hash.stack Generate a ) value from a base16-encoded SHA256 hash.stack Convert a # into a base16-encoded SHA256 hash.stack Compute a $ value from a cabal file's contents.stack-Convert from a package identifier to a tuple.stack-Convert from a tuple to a package identifier.stack$A parser for a package-version pair.stack4Convenient way to parse a package identifier from a .stack(Convenience function for parsing from a l.stackParse a stack@Get a string representation of the package identifier; name-ver.stackeGet a string representation of the package identifier with revision; name-ver[@hashtype:hash[,size]].stack>Get a Text representation of the package identifier; name-ver.""'None.27=?M^@stack%Information on a single package indexstackSURL for the tarball or, in the case of Hackage Security, the root of the directorystack#URL prefix for downloading packagesstackXRequire that hashes and package size information be available for packages in this index#stackUnique name for a package index&stackZHackage Security provides a different JSON format, we'll have our own JSON parser for it..stacknoffset in bytes into the 01-index.tar file for the .cabal file contents, and size in bytes of the .cabal file0stackCached information about packages in an index. We have a mapping from package name to a version map. Within the version map, we map from the version to information on an individual version. Each version has optional download information (about the package's tarball itself), and cabal file information. The cabal file information is a non-empty list of all cabal file revisions. Each file revision indicates the hash of the contents of the cabal file, and the offset into the index tarball.The reason for each # mapping to a two element list of es is because some older Stackage snapshots have CRs in their cabal files. For compatibility with these older snapshots, both hashes are stored: the first element of the two element list being the original hash, and the (potential) second element with the CRs stripped. [Note: This is was initially stored as a two element list, and cannot be easily packed into more explict ADT or newtype because of some template-haskell that would need to be modified as well: the versionedDecodeOrLoad function call found in the getPackageCaches function in .]YIt's assumed that cabal files appear in the index tarball in the correct revision order. !"#$%&'()*+,-./012)*+,-&'(01./#$%2 !"(None27MbYstackMCached information on whether a package has profiling libraries and haddocks.astackLCached information on whether package have profiling libraries and haddocks. YZ[\]^_`abc ab_`YZ[\]^c)None"#2npstack#Does not include the current actionqstack*Actions which depend on the current actionrstack7Whether this action may be run concurrently with othersstack=Action for building a package's library and executables. If  taskAllInOne is V9, then this will also build benchmarks and tests. It is SI when then library's benchmarks or test-suites have cyclic dependencies.stackiTask for building the package's benchmarks and test-suites. Requires that the library was already built.stack+Task for running the package's test-suites.stack*Task for running the package's benchmarks. stackLSort actions such that those that can't be run concurrently are at the end.stackthreadsstack$keep going after one task has failedstackprogress updatednopqrstuvwxyz{|}~~|}nopqrvwxyz{stu*None .27=?HVvstack/Specifies a compiler and its version number(s).dNote that despite having this datatype, stack isn't in a hurry to support compilers other than GHC.stackWhether the compiler version given is the wanted version (what the stack.yaml file, snapshot file, or --resolver argument request), or the actual installed GHC. Depending on the matching requirements, these values could be different.stackVariety of compiler to use.+None&',.24567=>?HVX`qstack=Most recent Nightly and newest LTS version per major release.stack8The name of an LTS Haskell or Stackage Nightly snapshot.stack[Either an actual resolver value, or an abstract description of one (e.g., latest nightly).stackEHow we resolve which dependencies to install given a set of packages.stack_Use an official snapshot from the Stackage project, either an LTS Haskell or Stackage Nightly.stackRequire a specific compiler version, but otherwise provide no build plan. Intended for use cases where end user wishes to specify all upstream dependencies manually, such as using a dependency solver.stackNA custom resolver based on the given location (as a raw URL or filepath). If customContents is a Either Request FilePath, it represents the parsed location value (with filepaths resolved relative to the directory containing the file referring to the custom snapshot). Once it has been loaded from disk, it will be replaced with a  SnapshotHash- value, which is used to store cached files.stackConvert a Resolver into its TextJ representation for human presentation. When possible, you should prefer sdResolverNameF, as it will handle the human-friendly name inside a custom snapshot.stackParse a Resolver from a Textstack Convert a % into its short representation, e.g. lts-2.8, nightly-2015-03-05.stack$Parse the short representation of a .stackGReturn the first 12 characters of the hash as a B64URL-encoded string.stack Return the raw bytes in the hashstack>Create a new SnapshotHash by SHA256 hashing the given contentsstack/Create a new SnapshotHash from the given digeststack$directory config value was read from!!,None.1stackParser for the resolver-NoneOstack5Extensions for anything that can be a Haskell module. stack@Extensions used for Haskell modules. Excludes preprocessor ones. stackEExtensions for modules that are preprocessed by common preprocessors.stack Name of the stack program, uppercasedstack Name of the stack program.stack,The filename used for the stack config file.stack*Environment variable used to override the  '.stack-work' relative dir.stack*Environment variable used to override the  '~/.stack' location.stack&Option name for the global stack root.stack1Deprecated option name for the global stack root.Deprecated since stack-1.1.0.1TODO: Remove occurences of this variable and use / only after an appropriate deprecation period.stackDEnvironment variable used to indicate stack is running in container.stackEnvironment variable used to indicate stack is running in container. although we already have STACK_IN_NIX_EXTRA_ARGS that is set in the same conditions, it can happen that STACK_IN_NIX_EXTRA_ARGS is set to empty.stack+Just to avoid repetition and magic strings.stackLDeprecated implicit global project directory used when outside of a project.stackMImplicit global project directory used when outside of a project. Normally, getImplicitGlobalProjectDir should be used instead.stack&Deprecated default global config path.stack'Default global config path. Normally, getDefaultUserConfigPath should be used instead.stack?Deprecated default global config path. Note that this will be Nothing on Windows, which is by design.stack'Default global config path. Normally, getDefaultGlobalConfigPath1 should be used instead. Note that this will be Nothing on Windows, which is by design.stack"Path where build plans are stored.stack7Path where binary caches of the build plans are stored.stackEnvironment variable that stores a variant to append to platform-specific directory names. Used to ensure incompatible binaries aren't shared between Docker builds and hoststackProvides --ghc-options for &, and similarly, --ghcjs-options for .stackJThe flag to pass to GHC when we want to force its output to be colorized.stack=The minimum allowed terminal width. Used for pretty-printing.stack=The maximum allowed terminal width. Used for pretty-printing. stackThe default terminal width. Used for pretty-printing when we can't automatically detect it and when the user doesn't supply one. stackTrue if using Windows OS.stack Stack root.stack Stack root.stack Stack rootstack Stack root    .None"#27=?a stack"Exceptions thrown by Stack.Docker. stack*Docker must be enabled to use the command. stack4Command must be run on host OS (not in a container).stackdocker inspect failed.stackImage does not exist.stack Input to docker cleanup has invalid command.stackInvalid output from  docker images.stackInvalid output from  docker ps.stackInvalid output from docker inspect.stackCould not pull a Docker image.stackInstalled version of docker below minimum version.stackInstalled version of docker is prohibited.stackInstalled version of docker* is out of range specified in config file.stackInvalid output from docker --version.stack Version of stack) on host is too old for version in image.stack Version of stack3 in container/image is too old for version on host.stack?Can't determine the project root (where to put docker sandbox).stackdocker --version failed.stack-Using host stack-exe on unsupported platform.stack stack-exe option fails to parse.stack)Newtype for non-orphan FromJSON instance."stack'Options for Docker repository or image.%stackDocker volume mount.'stackWhere to get the stack' executable to run in Docker containers(stackDownload from official bindist)stackHost's stack (linux-x86_64 only)*stackDocker image's stack (versions must match)+stackExecutable at given path,stackqAn uninterpreted representation of docker options. Configurations may be "cascaded" using mappend (left-biased)..stack,Should Docker be defaulted to enabled (does docker: section exist in the config)?/stackIs using Docker enabled?0stackDocker repository name (e.g. fpco/stack-build or fpco/stack-full:lts-2.8)1stack&Does registry require login for pulls?2stack&Optional username for Docker registry.3stack&Optional password for Docker registry.4stackAutomatically pull new images.5stack#Whether to run a detached container6stackLCreate a persistent container (don't remove it when finished). Implied by G.7stack?Container name to use, only makes sense from command-line with H or G.8stackArguments to pass directly to  docker run9stack!Volumes to mount in the container:stack-Environment variables to set in the container;stack!Location of image usage database.<stack1Location of container-compatible stack executable=stack%Set in-container user to match host's>stackSee: P?stackDocker configuration.AstackIs using Docker enabled?Bstack;Exact Docker image tag or ID. Overrides docker-repo-*/tag.Cstack&Does registry require login for pulls?Dstack&Optional username for Docker registry.Estack&Optional password for Docker registry.FstackAutomatically pull new images.Gstack#Whether to run a detached containerHstackLCreate a persistent container (don't remove it when finished). Implied by G.Istack?Container name to use, only makes sense from command-line with H or G.JstackArguments to pass directly to  docker run.Kstack"Volumes to mount in the container.Lstack.Environment variables to set in the container.Mstack!Location of image usage database.Nstack1Location of container-compatible stack executableOstack%Set in-container user to match host'sPstack.Require a version of Docker within this range.QstackParse '.RstackDocker enable argument name.SstackDocker repo arg argument name.TstackDocker image argument name.Ustack$Docker registry login argument name.Vstack'Docker registry username argument name.Wstack'Docker registry password argument name.XstackDocker auto-pull argument name.YstackDocker detach argument name.ZstackDocker run args argument name.[stackDocker mount argument name.\stack*Docker environment variable argument name.]stack$Docker container name argument name.^stackDocker persist argument name._stack#Docker database path argument name.`stack#Docker database path argument name.astack Value for --docker-stack-exe=downloadbstack Value for --docker-stack-exe=hostcstack Value for --docker-stack-exe=imagedstackDocker set-user argument nameestackDocker require-version argument namefstackHArgument name used to pass docker entrypoint data (only used internally)gstack"Command-line argument for "docker"istackCommand-line argument for  docker pull.jstackCommand-line argument for docker cleanup.kstackCommand-line option for --internal-re-exec-version.lstack#Platform that Docker containers runnstack For YAML.ostackShow instance.pstackFor optparse-applicative.qstack"Left-biased combine Docker optionsrstack"Left-biased combine Docker optionssstackParse VersionRange.tstack3Decode uninterpreted docker options from JSON/YAML.b    !"#$%&'+*)(,->=<;:9876543210/.?@PONMLKJIHGFEDCBAQRSTUVWXYZ[\]^_`abcdefghijklb?@PONMLKJIHGFEDCBA,->=<;:9876543210/.'+*)(Q%&"#$ !   RSTUVWXYZ[\]^_`abcdefghijkl/None |stackParser to extract the stack command line embedded inside a comment after validating the placement and formatting rules for a valid interpreter specification.}stackxExtract stack arguments from a correctly placed and correctly formatted comment when it is being used as an interpreter|}|}0None27 ~~1None"#.247=?HMPVWstack(Information on a single package for the  which can be installed.Note that much of the information below (such as the package dependencies or exposed modules) can be conditional in the cabal file, which means it will vary based on flags, arch, and OS.stackThis must$ match the version specified within rpiDef.stackEWhere to get the package from. This could be a few different things:%For a global package, it will be the GhcPkgId~. (If we end up needing to rebuild this because we've changed a dependency, we will take it from the package index with no  CabalFileInfo.For a dependency, it will be a PackageLocation.$For a project package, it will be a  Path Abs Dir.stack!Flags to build this package with.stack.GHC options to use when building this package.stack All packages which must be builtcopied registered before this package.stack)Modules exposed by this package's librarystackkShould this package be hidden in the database. Affects the script interpreter's module name import parser.stacksA fully loaded snapshot combined , including information gleaned from the global database and parsing cabal files.Invariant: a global package may not depend upon a snapshot package, a snapshot may not depend upon a local or project, and all dependencies must be satisfied.stackName of an executable.stack>Information on packages stored in a source control repository.stack(The type of a source control repository.stackA package archive, could be from a URL or a local file path. Local file path archives are assumed to be unchanging over time, and so are allowed in custom snapshots.stackAdd in the possibility of getting packages from the index (including cabal file revisions). We have special handling of this case in many places in the codebase, and therefore represent it with a separate data type from .stackGrab the package from the package index with the given version and (optional) cabal file info to specify the correct revision.stackNWhere to get the contents of a package (including cabal file revisions) from.gA GADT may be more logical than the index parameter, but this plays more nicely with Generic deriving.stackNote that we use FilePath and not Path9s. The goal is: first parse the value raw, and then use canonicalizePath and  parseAbsDir.stack%Stored in a source control repositorystackA definition of a snapshot. This could be a Stackage snapshot or something custom. It does not include information on the global package database, this is added later.It may seem more logic to attach flags, options, etc, directly with the desired package. However, this isn't possible yet: our definition may contain tarballs or Git repos, and we don't actually know the package names contained there. Therefore, we capture all of this additional information by package name, and later in the snapshot load step we will resolve the contents of tarballs and repos, figure out package names, and assigned values appropriately.stackGThe snapshot to extend from. This is either a specific compiler, or a  SnapshotDefT which gives us more information (like packages). Ultimately, we'll end up with a CompilerVersion.stack+The resolver that provides this definition.stack2A user-friendly way of referring to this resolver.stack'Where to grab all of the packages from.stackBPackages present in the parent which should not be included here.stack)Flag values to override from the defaultsstackPackages which should be hidden when registering. This will affect, for example, the import parser in the script command. We use a f instead of just a /? to allow overriding the hidden settings in a parent snapshot.stackGHC options per packagestackcHints about which packages are available globally. When actually building code, we trust the package database provided by GHC itself, since it may be different based on platform or GHC install. However, when we want to check the compatibility of a snapshot with some codebase without installing GHC (e.g., during stack init), we would use this field.stackGA relative file path including a unique string for the given snapshot.stack[Modify the wanted compiler version in this snapshot. This is used when overriding via the compiler) value in a custom snapshot or stack.yaml file. We do _not_ need to modify the snapshot's hash for this: all binary caches of a snapshot are stored in a filepath that encodes the actual compiler version in addition to the hash. Therefore, modifications here will not lead to any invalid data.stack1Determined the desired compiler version for this .AA2None2SXb GstackException running editor. JstackException running pager. MstackARun pager, providing a function that writes to the pager's input. Nstack'Run pager to display a lazy ByteString. OstackRun pager to display a  Pstack*Run pager to display a ByteString-Builder. Qstack(Run pager to display contents of a file. RstackRun pager to display a string. SstackRun editor to edit a file. TstackDRun editor, providing functions to write and read the file contents. UstackRun editor on a ByteString. VstackRun editor on a String. stackShort-circuit first Just. G I H J L K M N O P Q R S T U V M N O P Q R J L K S T U V G I H3Safed? [stack5Get the width, in columns, of the terminal if we can. [ [4None ,7=>?@AHVmD fstackMonadic environment. nstack'Cache of previously parsed cabal files.!TODO: This is really an ugly hack to avoid spamming the user with warnings when we parse cabal files multiple times and bypass performance issues. Ideally: we would just design the system such that it only ever parses a cabal file once. But for now, this is a decent workaround. See:  6https://github.com/commercialhaskell/stack/issues/3591. rstackWith a  f, do the thing rstack use time?stack terminal?stackterminal width overridestackreexec? ` c a b d e f g h i j k l m n o p q r f g h i j k l m n d e o p q ` c a b r5Nonen y y6None"#2p$ {stack=Nix can't be given packages and a shell file at the same time |stack!Interprets NixOptsMonoid options. z { | } | } z {None8=>?@AHMSVXr stack@Tags for each field of state in SGR (Select Graphics Rendition).It's a bit of a hack that  is included.P P 7None=>?4 stackXUse after a label and before the rest of what's being labelled for consistent spacing indentingetc.>For example this is used after "Warning:" in warning messages. stackMake a  from each word in a s stack Wordwrap a s stack Style an   as an error. Should be used sparingly, not to style entire long messages. For example, it's used to style the "Error:" label for an error message, not the entire message. stack Style an   as a warning. Should be used sparingly, not to style entire long messages. For example, it's used to style the "Warning:" label for an error message, not the entire message. stack Style an  ? in a way to emphasize that it is a particularly good thing. stack Style an  o as a shell command, i.e. when suggesting something to the user that should be typed in directly as written. stack Style an   as a filename. See   for directories. stack Style an AsciDoc2 as a URL. For now using the same style as files. stack Style an   as a directory name. See   for files. stack?Style used to highlight part of a recommended course of action. stack Style an   in a way that emphasizes that it is related to a current thing. For example, could be used when talking about the current package we're processing when outputting the name of it. stack Style an   as a module name stackDisplay a bulleted list of  . stackDisplay a bulleted list of  ! with a blank line between each.P P  8None"#&'12@ASX stack2An exception regarding verification of a download. stack/A request together with some checks to perform. stackaDefault to retrying seven times with exponential backoff starting from one hundred milliseconds.@This means the tries will occur after these delays if necessary:0.1s0.2s0.4s0.8s1.6s3.2s6.4sstackLMake sure that the hash digest for a finite stream of bytes is as expected..Throws WrongDigest (VerifiedDownloadException)stack'A more explicitly type-guided sinkHash.stackCTurns a list of hash checks into a ZipSink that checks all of them. stack>Copied and extended version of Network.HTTP.Download.download.YHas the following additional features: * Verifies that response content-length header (if present) matches expected length * Limits the download to (close to) the expected # of bytes * Verifies that the expected # bytes were downloaded (not too few) * Verifies md5 if response includes content-md5 header * Verifies the expected hashespThrows VerifiedDownloadException. Throws IOExceptions related to file system operations. Throws HttpException. stack destinationstackcustom hook to observe progressstack Whether a download was performed  9None2@AJ stackDownload the given URL to the given location. If the file already exists, no download is performed. Otherwise, creates the parent directory, downloads to a temporary file, and on file download completion moves to the appropriate destination.&Throws an exception if things go wrong stackSame as  B, but will download a file a second time if it is already present.Returns V if the file was downloaded, S otherwise stack!Set the user-agent request header stack destinationstackHWas a downloaded performed (True) or did the file already exist (False)? stack destination!?@!   !   ?@ !:None%&',.27>@AHMPSX_a stackInformation on package indices. This is left biased, meaning that packages in an earlier index will shadow those in a later index.YWarning: if you override packages in an index vs what's available upstream, you may correct your compiled snapshots, as different projects may have different definitions of what pkg-ver means! This feature is primarily intended for adding local packages, not overriding. Overriding is better accomplished by adding to your list of packages.TNote that indices specified in a later config file will override previous indices, not extend them.>Using an assoc list instead of a Map to keep track of priority stack~/.stack more often than not stackWant to try updating the index once during a single run for missing package identifiers. We also want to ensure we only update once at a time. Start at True.ETODO: probably makes sense to move this concern into getPackageCaches stack<How many concurrent connections are allowed when downloading stackeIgnore a revision mismatch when loading up cabal files, and fall back to the latest revision. See: 6https://github.com/commercialhaskell/stack/issues/3520stack2Populate the package index caches and return them.stack7Require that an index be present, updating if it isn't. stack!Update all of the package indicesstackUpdate the index tarballstack!Update the index tarball via HTTPstack-Update the index tarball via Hackage SecuritystackDelete the package index cache stackCGet the known versions for a given package from the package caches.See   for performance notes. stack;Load the package caches, or create the caches if necessary.vThis has two levels of caching: in memory, and the on-disk cache. So, feel free to call this function multiple times.stack[Clear the in-memory hackage index cache. This is needed when the hackage index is updated. stack!Root for a specific package index stack!Location of the 01-index.tar filestack#Location of the 01-index.cache filestack#Location of the 00-index.cache filestackLocation of the 00-index.tar file. This file is just a copy of the 01-index.tar file, provided for tools which still look for the 00-index.tar file.stack$Location of the 01-index.tar.gz filestack(Return the number of blocks in an entry.stackurlstackbase URL                                ;None"#&',.1245678=>?@AHMPVX` %stack0Class for environment values that can provide a  . 'stack4Class for environment values which have a GHCVariant )stack2Class for environment values which have a Platform ,stackDocker host user info .stackuid /stackgid 0stackSupplemantal groups 1stackFile creation mask } 2stackAData passed into Docker container for the Docker entrypoint's use 4stackUIDGIDCetc of host user, if we wish to perform UID/GID switch in container 9stack.How PVP bounds should be added to .cabal files >stackRemote or inline  A RstackgBuild of the compiler distribution (e.g. standard, gmp4, tinfo6) | Information for a file to download. TstackURL or absolute file path Xstack;Specialized bariant of GHC (e.g. libgmp4 or integer-simple) YstackStandard bindist Zstack Bindist that uses integer-simple [stackOther bindists \stackHA variant of the platform, used to differentiate Docker builds from host _stackA software control system. cstackAWhere do we get information on global packages for loading up a ? dstack+Accept the hints in the snapshot definition estack8Look up the actual information in the installed compiler wstack $STACK_ROOT , parent dir stackSee:   stackSee:  . stackbuild options. stackDocker options. stack>Options for the execution environment (nix-shell or container) stackSee: configConnectionCount stackSee:  ( stackDeprecated in favour of  stackSee: 'configUrls stackSee:  picIndices stackSee:  . stackSee:  / stackSee:  0 stackSee:  1 stackSee:  2 stackSee:  4 stack Used for overriding the platform stack Used for overriding the platform stack!Used for overriding the GHC build stackSee:  5 stackSee:  8 stackSee:  9 stack'Allow users to override the path to gcc stack.Use Hpack executable (overrides bundled Hpack) stackSee:  : stack,Used to override the binary installation dir stackImage creation options. stackTemplate parameters. stack8Initialize SCM (e.g. git init) when making new projects? stackSee  >. Uses \ so that options from the configs on the right come first, so that they can be overridden. stackSee configGhcOptionsAll. Uses \ so that options from the configs on the right come first, so that they can be overridden. stack-Additional paths to search for executables in stackDAdditional setup info (inline or remote) to use for installing tools stackEOverride the default local programs dir, where e.g. GHC is installed. stackSee  A stackSee  B stackSee  C stackSee  stackSee  E stackSee  stack_The default template to use when none is specified. (If Nothing, the default default is used.) stackKAllow users other than the stack root owner to use the stack installation. stackSee  I stackSee  L stackSee  M stackSee configIgnoreRevisionMismatch stackA project is a collection of packages. We can have multiple stack.yaml files, but only one of them may contain project information. stackYA warning message to display to the user when the auto generated config may have issues. stackNPackages which are actually part of the project (as opposed to dependencies).NOTEb Stack has always allowed these packages to be any kind of package location, but in reality only  PLFilePath2 really makes sense. We could consider replacing [PackageLocation] with  [FilePath] to properly enforce this idea, though it will slightly break backwards compatibility if someone really did want to treat such things as non-deps. stackWDependencies defined within the stack.yaml file, to be applied on top of the snapshot. stack1Flags to be applied on top of the snapshot flags. stackHow we resolve which  SnapshotDef to use stack/When specified, overrides which compiler to usestack3Should a package be treated just like an extra-dep?Vi means, it will only be built as a dependency for others, and its test suite/benchmarks will not be run.,Useful modifying an upstream package, see:  5https://github.com/commercialhaskell/stack/issues/219 5https://github.com/commercialhaskell/stack/issues/386 stackValue returned by V. stackTop-level Stack configuration. stackAction to load the remaining  . stack,The project root directory, if in a project. stack9A view of a local package needed for resolving components stack3Configuration after the environment has been setup. stackaThis is the version of Cabal that stack will use to compile Setup.hs files in the build process.Note that this is not necessarily the same version as the one that stack depends on as a library and which is displayed when running $stack list-dependencies | grep Cabal in the stack project. stack>The actual version of the compiler to be used, as opposed to wantedCompilerL:, which provides the version specified by the build plan. stack Cache for getLocalPackages. stack(The fully resolved snapshot information. stackA superset of   adding information on how to build code. The reason for this breakdown is because we will need some of the information from  ' in order to determine the values here.FThese are the components which know nothing about local configuration. stack Build plan wanted for this build stack0The variant of GHC used to select a GHC bindist. stackLocal packages stack.Extra dependencies specified in configuration.tThese dependencies will not be installed to a shared location, and will override packages provided by the resolver. stackExtra package databases stack Location of the stack.yaml file._Note: if the STACK_YAML environment variable is used, this may be different from projectRootL  / "stack.yaml"gFIXME MSS 2016-12-08: is the above comment still true? projectRootL is defined in terms of bcStackYaml stackPer-package flag overrides stackhAre we loading from the implicit global stack.yaml? This is useful for providing better error messages. stack*Parsed global command-line options monoid. stack%Expected re-exec in container version stackIData used when stack is acting as a Docker entrypoint (internal use only) stack Log level stack#Whether to include timings in logs. stack Config monoid, for passing into  loadConfig stackResolver override stackCompiler override stackWe're in a terminal? stackWhen to use ansi colors stackTerminal width override stackOverride project stack.yaml stack`FilePath is the directory containing the script file, used for resolving custom snapshot files. stack#Parsed global command-line options. stack%Expected re-exec in container version stackIData used when stack is acting as a Docker entrypoint (internal use only) stack Log level stack#Whether to include timings in logs. stack Config monoid, for passing into  loadConfig stackResolver override stackCompiler override stackWe're in a terminal? stack When to use ansi terminal colors stackTerminal width override stackOverride project stack.yaml stack1Controls which version of the environment is used stack:include local project bin directory, GHC_PACKAGE_PATH, etc stack%include the GHC_PACKAGE_PATH variable stack9set the STACK_EXE variable to the current executable name stackset the locale to C.UTF-8 stack,if True, keep GHCRTS variable in environment stackWhich build log files to dump stackdon't dump any logfiles stack!dump logfiles containing warnings stackdump all logfiles stack;Which packages do ghc-options on the command line apply to? stackall local targets stack$all local packages, even non-targets stack every package stack%The top-level Stackage configuration. stack-this allows to override .stack-work directory !stack*Path to user configuration file (usually ~.stack config.yaml) "stackBuild configuration #stackDocker configuration $stack3Execution environment (e.g nix-shell) configuration %stack4Environment variables to be passed to external tools &stack9Non-platform-specific path containing local installations 'stack0Path containing local installations (mainly GHC) (stackJHide the Template Haskell "Loading package ..." messages from the console )stack=The platform we're building for, used in many directory names *stack5Variant of the platform, also used in directory names +stack>The variant of GHC requested by the user. In most cases, use   or  MiniConfig=s version instead, which will have an auto-detected default. ,stackIOverride build of the compiler distribution (e.g. standard, gmp4, tinfo6) -stackURLs for other files used by stack. TODO: Better document e.g. The latest snapshot file. A build plan name (e.g. lts5.9.yaml) is appended when downloading the build plan actually. .stacknShould we use the system-installed GHC (on the PATH) if available? Can be overridden by command line options. /stack}Should we automatically install GHC if missing or the wrong version is available? Can be overridden by command line options. 0stack6Don't bother checking the GHC version or architecture. 1stack&On Windows: don't use a sandboxed MSYS 2stack8Specifies which versions of the compiler are acceptable. 3stack,Directory we should install executables into 4stack-Require a version of stack within this range. 5stackCHow many concurrent jobs to run, defaults to number of capabilities 6stackOptional gcc override path 7stack.Use Hpack executable (overrides bundled Hpack) 8stack-extra-include-dirs arguments 9stack-extra-lib-dirs arguments :stackRun test suites concurrently <stackParameters for templates. =stack5Initialize SCM (e.g. git) when creating new projects. >stack5Additional GHC options to apply to specific packages. ?stack9Additional GHC options to apply to categories of packages @stack=Additional SetupInfo (inline or remote) to use to find tools. Astack0How PVP upper bounds should be added to packages Bstack'Force the code page to UTF-8 on Windows CstackSee  }. T provides the default value. DstackRebuild on GHC options changes Estack;Which packages to ghc-options on the command line apply to? FstackKIgnore version ranges in .cabal files. Funny naming chosen to match cabal. Gstack_The default template to use when none is specified. (If Nothing, the default default is used.) HstackKAllow users other than the stack root owner to use the stack installation. Istack7Dump logs of local non-dependencies when doing a build. JstackU$ when a local project can be found, T; when stack must fall back on the implicit global project. KstackKAre we allowed to build local packages? The script command disallows this. Lstack-Should we save Hackage credentials to a file? Mstack-Hackage base URL used when uploading packages Pstack?Default logging level should be something useful but not crazy. Sstack2Directory containing the project's stack.yaml file TstackRoot directory for the given  Ustack,Package name for the given 'LocalPackageView Vstack&All components available in the given  Wstack'Version for the given 'LocalPackageView stackParse a partial configuration. Used both to parse both a standalone config file and a project file, so that a sub-parser is not required, which would interfere with warnings for missing fields. [stack>Get the URL to request the information on the latest snapshots \stack  ".stack-work" ]stackPer-project work dir ^stack)File containing the installed cache, see Stack.PackageDump _stack.Relative directory for the platform identifier `stackDirectory containing snapshots astack"Installation root for dependencies bstackInstallation root for locals cstack$Installation root for compiler tools dstackHoogle directory. estackGet the hoogle database path.!stackGPath for platform followed by snapshot name followed by compiler name. fstack6Relative directory for the platform and GHC identifier gstackPRelative directory for the platform and GHC identifier without GHC bindist build"stacknRelative directory for the platform and GHC identifier without GHC bindist build (before parsing into a Path) hstackThis is an attempt to shorten stack paths on Windows to decrease our chances of hitting 260 symbol path limit. The idea is to calculate SHA1 hash of the path used on other architectures, encode with base 16 and take first 8 symbols of it. kstack1Package database for installing dependencies into lstack3Package database for installing local packages into mstackExtra package databases nstack,Directory for holding flag cache information ostackWhere to store  caches pstack9Suffix applied to an installation root to get the bin dir qstack9Suffix applied to an installation root to get the doc dir rstack+Where HPC reports and tix files get stored. sstackCGet the extra bin directories (for the PATH). Puts more local first3Bool indicates whether or not to include the locals ustackDefault  EnvSettings, which includes locals and GHC_PACKAGE_PATH.INote that this also passes through the GHCRTS environment variable. See 6https://github.com/commercialhaskell/stack/issues/3444 vstack;Environment settings which do not embellish the environmentINote that this also passes through the GHCRTS environment variable. See 6https://github.com/commercialhaskell/stack/issues/3444 wstack@Get the path for the given compiler ignoring any local binaries. 6https://github.com/commercialhaskell/stack/issues/1052#stack;A PackageEntry for the current directory, used as a default$stack-Render a platform variant to a String suffix. ystack!Render a GHC variant to a String. zstack(Render a GHC variant to a String suffix. {stack Parse GHC variant from a String.%stack"Parse JSON in existing object for  R }stackOProvide an explicit list of package dependencies when running a custom Setup.hs stackThe compiler specified by the  SnapshotDef7. This may be different from the actual compiler used! stackfThe version of the compiler which will actually be used. May be different than that specified in the  and returned by  . stackFor siGHCs and siGHCJSsI fields maps are deeply merged. For all fields the values from the last  SetupInfo win.h     #$%2 ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ^ ] _ ` a b c d e f h g i j k l m n o p q r s t u v w x y z { | } ~                            9 8 ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  ~ ) * + \ ^ ]   9 8 ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 : ; < = > ? @ A B C D E F G H I J K L M N O % & [ } T U W V R S # $ X Y Z [ y z { ' ( ` ! " w        j k l m n o p q r s t u v w x y z { | } ~ f h g i  Z Y X          t u v P #$%2 a b x 5 6 7 8 9 : ; < = | Q _ ` p ^ o c d e ] q n s r a b c d e k m l _ f g h i j \         R S T U V W N O P Q I J K L M A B C D E F G H > ? @ 2 3 4 , - . / 0 1  ~ h<None=>?X stack*Username and password to log into Hackage. Since 0.1.0.0 stackGLoad Hackage credentials, either from a save file or the command line. Since 0.1.0.0 stack'Upload a single tarball with the given Uploader#. Instead of sending a file like  , this sends a lazy bytestring. Since 0.1.2.1 stack'Upload a single tarball with the given Uploader. Since 0.1.0.0 stackHackage base URLstack tar file namestacktar file contents stackHackage base URL stackHackage base URL     =None ,.27>MSXE stackLA path resolved from the .cabal file, which is either main-is or an exposedinternalreferenced module. stack@A descriptor from a .cabal file indicating one of the following:=exposed-modules: Foo other-modules: Foo or main-is: Foo.hs stack Used for storage and comparison. 'stack>A location to install a package into, either snapshot or local *stack9Information on a locally available package of source code ,stackThe PackageV info itself, after resolution with package flags, with tests and benchmarks disabled -stack9Components to build, not including the library component. .stackOComponents explicitly requested for build, that are marked "buildable: false". /stack+Whether this package is wanted as a target. 0stackDUsed for determining if we can use --enable-tests in a normal build. 1stackJUsed for determining if we can use --enable-benchmarks in a normal build. 2stackThis stores the  ^H with tests and benchmarks enabled, if either is asked for by the user. 3stackDirectory of the package. 4stackThe .cabal file 6stackNothing == not dirty, Just == dirty. Note that the Set may be empty if we forced the build to treat packages as dirty. Also, the Set may not include all modified files. 7stackcurrent state of the files 8stackall files used by this package 9stack Where this source code came from :stackGWhere the package's source is located: local directory or package index ;stackFPackage which exist on the filesystem (as opposed to an index tarball) <stackPPackage which is in an index, and the files do not exist on the filesystem yet. >stackPackage build configuration @stackAre tests enabled? AstackAre benchmarks enabled? BstackConfigured flags. CstackConfigured ghc options. Dstack GHC version Estack host platform Fstack(Warning generated when reading a package Gstack/Modules found that are not listed in cabal file HstacknFiles that the package depends on, relative to package directory. Argument is the location of the .cabal file Kstack!Files to get for a cabal package. Nstack7GHC options based on cabal information and ghc-options. RstackThese options can safely have < applied to them, as there are no multi-word options (see 7https://github.com/commercialhaskell/stack/issues/1255) TstacknFiles that the package depends on, relative to package directory. Argument is the location of the .cabal file WstackIs this package being used as a library, or just as a build tool? If the former, we need to ensure that a library actually exists. See 6https://github.com/commercialhaskell/stack/issues/2195 ZstackThe value for a map from dependency name. This contains both the version range and the type of dependency, and provides a semigroup instance. ^stackSome package info. `stackName of the package. astackVersion of the package bstack+The license the package was released under. cstackGet all files of the package. dstackHPackages that the package depends on, both as libraries and build tools. estack\Build tools specified in the legacy manner (build-tools:) that failed the hard-coded lookup. fstack#Original dependencies (not sieved). gstackGhc options used on package. hstackFlags used on package. istackDefaults for unspecified flags. jstack1does the package have a buildable library stanza? kstacknames of internal libraries lstack#names and interfaces of test suites mstacknames of benchmarks nstacknames of executables ostackArgs to pass to GHC. pstack&Does the package have exposed modules? qstackPackage build-type. rstack%If present: custom-setup dependencies sstackILibraries in a package. Since Cabal 2.0, internal libraries are a thing. ustackhthe foreign library names, sub libraries get built automatically without explicit component name passing vstack%All exceptions thrown by the library. stack5Maybe get the module name from the .cabal descriptor. stack3Maybe get the main name from the .cabal descriptor. stackGet the module path. stackGet the main path. stackGet the c file path. stack Get the path. stackGet the installed Version. stackCompares the package name. stackCompares the package name.}                  # " ! $ & % ' ( ) * + 8 7 6 5 4 3 2 1 0 / . - 9 , : < ; = > ? E D C B A @ F G H I J K M L N O S R Q P T U V W Y X Z [ ] \ ^ _ r p o n j i g f e d c m l k h b q a ` s u t v { z y x w | } ~  } v { z y x w s u t ^ _ r p o n j i g f e d c m l k h b q a ` Z [ ] \ W Y X | } T U V N O S R Q P K M L H I J F G > ? E D C B A @ = : < ; ~  * + 8 7 6 5 4 3 2 1 0 / . - 9 , ' ( ) $ & %  # " !                 >None .27=?M7 " stackInformation on a compiled package: the library conf file (if relevant), the sublibraries (if present) and all of the executable paths. stack&.conf file inside the package database stackD.conf file inside the package database, for each of the sublibraries stackFull paths to executables stack2Configure options to be sent to Setup.hs configure stackOptions related to various paths. We separate these out since they do not have an impact on the contents of the compiled binary for checking if we can use an existing precompiled cache. stackBBasic information used to calculate what the configure options are stack:A complete plan of what needs to be built and how to do it stack0Final actions to be taken (test, benchmark, etc) stack4Text is reason we're unregistering, for display only stack>Executables that should be installed after successful building stack^The type of a task, either building local code or something from the package index (upstream) stackDGiven the IDs of any missing packages, produce the configure options stack4Dependencies for which we don't yet have an GhcPkgId stack.Produce the list of options given the missing GhcPkgIds stackA task to perform when building stackthe package/version to be built stack+the task type, telling us how to build this stack+GhcPkgIds of already-installed dependencies stack3indicates that the package can be built in one step stackWere any of the dependencies missing? The reason this is necessary is... hairy. And as you may expect, a bug in Cabal. See:  Chttps://github.com/haskell/cabal/issues/4728#issuecomment-337937673G. The problem is that Cabal may end up generating the same package ID for a dependency, even if the ABI has changed. As a result, without this field, Stack would think that a reconfigure is unnecessary, when in fact we _do_ need to reconfigure. The details here suck. We really need proper hashes for package identifiers. stackwIs the build type of this package Configure. Check out ensureConfigureScript in Stack.Build.Execute for the motivation stack6Stored on disk to know whether the flags have changed. stack"All options used for this package. stackThe GhcPkgIds of all of the dependencies. Since Cabal doesn't take the complete GhcPkgId (only a PackageIdentifier) in the configure options, just using the previous value is insufficient to know if dependencies have changed. stackThe components to be built. It's a bit of a hack to include this in here, as it's not a configure option (just a build option), but this is a convenient way to force compilation when the components change. stackAre haddocks to be built? stack6Stored on disk to know whether the files have changed. stackModification times of files.&stackPackage dependency oracle. stack Render a BaseConfigOpts to an actual list of options'stackSame as  -, but does not include directory path options stack,Get set of wanted package names from locals. stack&One-way conversion to serialized time. stack dependenciesstacklocal non-extra-dep?'stack dependenciesstackis this a local, non-extra-dep?           ! " # ' ) ( * + , 9 - . / 0 1 2 3 4 5 6 7 8 ~                         ' ) (      ~    * + , 9 - . / 0 1 2 3 4 5 6 7 8           ! " # ?None.2>PGb EstackGet the global package database(stackRun the ghc-pkg executable FstackFCreate a package database in the given directory, if it doesn't exist. Gstack>Get the name to use for "ghc-pkg", given the compiler version. Hstack=Get the environment variable to use for the package DB paths.)stackIGet the necessary ghc-pkg flags for setting up the given package database Istack(Get the value of a field of the package.*stackGet the version of the package Kstack:Get the version of Cabal from the global package database. Lstack"Get the value for GHC_PACKAGE_PATH Istackpackage databasesstackpackage identifier, or GhcPkgId*stackpackage databases Jstackpackage database E F G H I J K L E I F J K G H L@None 27>MPSXc Mstack2A single line of input, not including line endings Nstack%Dump information for a single package _stackACall ghc-pkg dump with appropriate flags and stream to the given Sink, for a single database `stackECall ghc-pkg describe with appropriate flags and stream to the given Sink, for a single database+stack%Call ghc-pkg and stream to the given Sink, for a single database astackCreate a new, empty InstalledCache bstackLoad a InstalledCache@ from disk, swallowing any errors and returning an empty cache. cstackSave a InstalledCache to disk dstackKPrune a list of possible packages down to those whose dependencies are met.id uniquely identifies an item$There can be multiple items per name estack}Find the package IDs matching the given constraints with all dependencies installed. Packages not mentioned in the provided Map are allowed to be present too. fstack+Add profiling information to the stream of  DumpPackages gstack)Add haddock information to the stream of  DumpPackages hstack2Add debugging symbol information to the stream of  DumpPackages istack+Convert a stream of bytes into a stream of  DumpPackages jstackVApply the given Sink to each section of output, broken by a single line containing --- kstackGrab each key/value pair,stackGeneral purpose utility _stackif empty, use global `stackif empty, use global+stackif empty, use global dstackextract the name from an idstackthe id of an itemstackget the dependencies of an itemstack(choose the desired of two possible itemsstack input items estackrequire profiling?stackrequire haddock?stackrequire debugging symbols?stackallowed versions-stackentry in directorystackname of library.stacklibrary directorystackname of library M N O Q P X [ \ ] U T V Y R S W Z ^ _ ` a b c d e f g h i j k M j k N O Q P X [ \ ] U T V Y R S W Z ^ i _ ` a b c f g h e dANone %,.7>_hI vstacke.g. ghc-7.8.4, msys2-20150512 wstacke.g. ghcjs-0.1.0_ghc-7.10.2/stackSee  6https://github.com/commercialhaskell/stack/issues/4086. stack2Binary directories for the given installed package p q r s t u v w x y z { | } ~   ~ { | } u v w x y z p q r s t  BNonei stack+Parser for test arguments. FIXME hide args  CNonej stackParser for haddock arguments.  DNonekM stackGHC variant parser  ENonelu stack1Parser for bench arguments. FIXME hiding options  FNone$&'>@AHMSVXu stack8Date and project path where Docker image hash last used. stack:Update last used time and project for a Docker image hash. stack?Get a list of Docker image hashes and when they were last used. stack_Given a list of all existing Docker images, remove any that no longer exist from the database. stackIGet the record of whether an executable is compatible with a Docker image stackJSeet the record of whether an executable is compatible with a Docker image0stackURun an action with the global database. This performs any needed migrations as well.  GNone stackOutput .o/.hi directory. stackGHCi files directory. stackLThe directory containing the files used for dirtiness check of source files. stack3The filename used to mark tests as having succeeded stack/The filename used to mark tests as having built stack0The filename used for dirtiness check of config. stack2The filename used for modification check of .cabal stackDirectory for HPC work. stack,Relative location of directory for HPC work. stack$Package's build artifacts directory. stackPackage's working directory. stack Directory for project templates. stack%Relative location of build artifacts. stack!Docker sandbox from project root. stack$Image staging dir from project root. stackPackage directory. stackPackage directory stackPackage directory stackPackage directory. stackPackage directory. stackPackage directory. stack Project rootstackDocker sandbox stack Project rootstackIndex of imagestackDocker sandbox  HNone"#,2>1stackStack image exceptions.2stack?Unspecified parent docker container makes building impossible3stack@Can't determine the project root (where to put image sandbox). stackJStages the executables & additional content in a staging directory under  '.stack-work' stack4Builds a Docker (OpenContainer) image extending the basew image specified in the project's stack.yaml. Then new image will be extended with an ENTRYPOINT specified for each  entrypoint listed in the config file.4stack,Stage all the Package executables in the usrlocal&bin subdirectory of a temp directory.5stack`Add any additional files into the temp directory, respecting the (Source, Destination) mapping.6stack0Derive an image name from the project directory.7stackdCreate a general purpose docker image from the temporary directory of executables & static content.8stackHExtend the general purpose docker image with entrypoints (if specified).9stack1Fail with friendly error if project root not set. stack)The command name for dealing with images. stack1The command name for building a docker container. stack+Convert image opts monoid to image options.  INone"#2 stack)Exceptions thrown by Stack.Docker.Config. stack7Only LTS resolvers are supported for default image tag. stackInvalid global database path. stack$Interprets DockerOptsMonoid options. stack-Show instance for StackDockerConfigException. stack2Exception instance for StackDockerConfigException.  JNone"# stack#Interprets BuildOptsMonoid options.  KNone "#,>@AX stack2Determine whether we should haddock for a package. stack5Determine whether to build haddocks for dependencies. stack7Generate Haddock index and contents for local packages. stackNGenerate Haddock index and contents for local packages and their dependencies. stack>Generate Haddock index and contents for all snapshot packages.:stack;Generate Haddock index and contents for specified packages.;stack,Find first DumpPackage matching the GhcPkgId<stackPath of haddock index file.=stack/Path of local packages documentation directory.>stackFPath of documentation directory for the dependencies of local packages?stack2Path of snapshot packages documentation directory. stack>Available packages and their locations for the current projectstackBuild targets as determined by ` stackPackages that we want to generate haddocks for in any case (whether or not we are going to generate haddocks for dependencies) stackLocal package dump stackGlobal dump informationstackSnapshot dump informationstackLocal dump information stackGlobal package dumpstackSnapshot package dump  LNone ,.7>@APXʠ@stack=Directory containing files to mark an executable as installed stack$Get all of the installed executables stack&Mark the given executable as installed stack*Mark the given executable as not installed stack@Try to read the dirtiness cache for the given package directory. stack@Try to read the dirtiness cache for the given package directory. stack>Try to read the mod time of the cabal file from the last build stack3Write the dirtiness cache for this package's files. stack;Write the dirtiness cache for this package's configuration. stackSee  stack"Delete the caches for the project. stack7Loads the flag cache for the given installed extra-deps stack%Mark a test suite as having succeeded stack)Mark a test suite as not having succeeded stack&Check if the test suite already passedAstackThe file containing information on the given package/configuration combination. The filename contains a hash of the non-directory configure options for quick lookup if there's a match.jIt also returns an action yielding the location of the precompiled path based on the old binary encoding.We only pay attention to non-directory options. We don't want to avoid a cache hit just because it was installed in a different directory. stack1Write out information about a newly built package stackLCheck the cache for a precompiled package matching the given configuration.Bstack'Check if a filesystem path is too long.Astack dependencies stack dependenciesstacklibrarystack$sublibraries, in the GhcPkgId formatstack executables stacktarget packagestack dependencies  MNone,>@Aٱ stack Options for  . stackRequire profiling libraries? stackRequire haddocks? stackRequire debugging symbols? stackHReturns the new InstalledMap and all of the locally registered packages.Cstack]Outputs both the modified InstalledMap and the Set of all installed packages in this databaseThe goal is to ascertain that the dependencies for a package are present, that it has profiling if necessary, and that it matches the version and location needed by the SourceMapDstackCheck if a can be included in the set of installed packages or not, based on the package selections made by the user. This does not perform any dirtiness or flag change checks. stack*does not contain any installed informationCstack)if Just, profiling or haddock is requiredstack5to determine which installed things we should includestack$package database, Nothing for globalstackfrom parent databases         NNone>\ stack[Checks if the installed executable will be available on the user's PATH. This doesn't use envSearchPath menvO because it includes paths only visible when running in the stack environment.  ONone>YEstack4Passed to all the path printers as a source of info. stackYPrint out useful path information in a human-readable format (and support others later).FstackThe paths of interest to a user. The first tuple string is used for a description that the optparse flag uses, and the second string as a machine-readable key and also for --foo: flags. The user can choose a specific path to list like  --stack-root7. But really it's mainly for the documentation aspect.!When printing output we generate PathInfoi and pass it to the function to generate an appropriate string. Trailing slashes are removed, see #506  PNone,2>XGstack5Exception that might occur when making a new project. stack#Options for creating a new project.stackName of the project to create.stack2Whether to create the project without a directory.stackName of the template to use.stack4Nonce parameters specified just for this invocation.stack,Create a new project with the given options.Hstack/Download and read in a template's text content.Istack,Construct a URL for downloading from a repo.Jstack-Apply and unpack a template into a directory.Kstack5Check if we're going to overwrite any existing files.Lstack)Write files to the new project directory.Mstack.Run any initialization functions, such as Git.stack'Display help for the templates command.Nstack<The default template name you can use if you don't have one.Ostack1The default service to use to download templates.Pstack9Default web URL to get the `stack templates` help output. h   hQNone"#%,.2>@AHPSVWX"QstackContents of the .cabal filestack/Fetch packages into the cache without unpackingstack.Intended to work for the command line command.stackSame as , but for a single package.stackEnsure that all of the given package idents are unpacked into the build unpack directory, and return the paths to all of the subdirectories.stack4Resolve a set of package names and identifiers into  FetchPackage values.RstackDDoes the configuration use a 00-index.tar.gz file for indices? See 6https://github.com/commercialhaskell/stack/issues/3520stack;Turn package identifiers and package names into a list of ResolvedPackageNs. Returns any unresolved names and identifier. These are considered unresolved even if the only mismatch is in the cabal file info (MSS 2017-07-17: old versions of this code had special handling to treat missing cabal file info as a warning, that's no longer necessary or desirable since all info should be present and checked).stack:Add the cabal files to a list of idents with their caches.SstackGiven package identifier and package caches, return list of packages with the same name and the same two first version number components found in the caches.TstackTry to come up with typo corrections for given package identifier using package caches. This should be called before giving up, i.e. when S cannot return anything.UstackFigure out where to fetch from.VstackKDownload the given name,version pairs into the directory expected by cabal.JFor each package it downloads, it will optionally unpack it to the given Path (if present). Note that unpacking is not simply a matter of untarring, but also of grabbing the cabal file from the package index. The destinations should not include package identifiers.HReturns the list of paths unpacked, including package identifiers. E.g.: #fetchPackages [("foo-1.2.3", Just "somedest")] ==> ["somedest/foo-1.2.3"]  Since 0.1.0.0stack)Internal function used to unpack tarball.Takes a path to a .tar.gz file, the name of the directory it should contain, and a destination folder to extract the tarball into. Returns unexpected entries, as pairs of paths and descriptions.WstackLocation of a package tarballstack2when looking up by name, take from this build planstack destinationstacknames or identifiersstackunpack directorystack the dist rename directory, see: (https://github.com/fpco/stack/issues/157stackunpack directorystack the dist rename directory, see: (https://github.com/fpco/stack/issues/157stack2when looking up by name, take from this build planstack2when looking up by name, take from this build planUstackdirectory to unpack into, Nothing means no unpackVstack the dist rename directory, see: (https://github.com/fpco/stack/issues/157          RNone"#%.2=>?PSX_2stackA pair of package descriptions: one which modified the buildable values of test suites and benchmarks depending on whether they are enabled, and one which does not.HFields are intentionally lazy, we may only need one or the other value.VMSS 2017-08-29: The very presence of this data type is terribly ugly, it represents the fact that the Cabal 2.0 upgrade did _not_ go well. Specifically, we used to have a field to indicate whether a component was enabled in addition to buildable, but that's gone now, and this is an ugly proxy. We should at some point clean up the mess of Package, LocalPackage, etc, and probably pull in the definition of PackageDescription from Cabal with our additionally needed metadata. But this is a good enough hack for the moment. Odds are, you're reading this in the year 2024 and thinking "wtf?"Xstack Input to YZstackHA helper function that performs the basic character encoding necessary.stack9Read the raw, unresolved package information from a file."stack Read the [ from the given .#stack)Reads and exposes the package information$stackGet [ and \$ reading info from given directory.%stackRead  package .buildinfo ancillary files produced by some Setup.hs hooks. The file includes Cabal file syntax to be merged into the package description derived from the package's .cabal file.DNOTE: not to be confused with BuildInfo, an Stack-internal datatype.&stack#Resolve a parsed cabal file into a  ^@, which contains all of the info needed for stack to build the  ^" given the current configuration.]stackGenerate GHC options for the package's components, and a list of options which apply generally to the package, not one specific component.YstackGenerate GHC options for the target. Since Cabal also figures out these options, currently this is only used for invoking GHCI (via stack ghci).^stack@Make the .o path from the .c file path for a component. Example: 7executable FOO c-sources: cbits/text_search.c Produces dist-dirbuildFOOFOO-tmpcbits/text_search.oExample:,> makeObjectFilePathFromC $(mkAbsDir "UserschrisRepos$hoogle") CLib $(mkAbsDir "UserschrisReposhoogle .stack-work%Cabal-x.x.x/dist") $(mkAbsFile "UserschrisReposhooglecbitstext_search.c") Just "UserschrisReposhoogle .stack-work Cabal-x.x.xdistbuildcbits<text_search.o" > makeObjectFilePathFromC $(mkAbsDir "UserschrisRepos/hoogle") (CExe "hoogle") $(mkAbsDir "UserschrisReposhoogle .stack-work%Cabal-x.x.x/dist") $(mkAbsFile "UserschrisReposhooglecbitstext_search.c") Just "UserschrisReposhoogle .stack-work Cabal-x.x.xdistbuildhoogle hoogle-tmpcbitstext_search.o" >_stack;Make the global autogen dir if Cabal version is new enough.`stackMake the autogen dir.astackSee bstackKThe directory where generated files are put like .o or .hs (from .x files).cstack5Make the build dir. Note that Cabal >= 2.0 uses the a above for some things.(stack=Get all dependencies of the package (buildable targets only).\Note that for Cabal versions 1.22 and earlier, there is a bug where Cabal requires dependencies for non-buildable components to be present. We're going to use GHC version as a proxy for Cabal library version in this case for simplicity, so we'll check for GHC being 7.10 or earlier. This obviously makes our function a lot more fun to write...dstack=Get all dependencies of the package (buildable targets only).This uses both the new e and old f information.gstack&A hard-coded map for tool dependencieshstackExecutable-only packages which come pre-installed with GHC and do not need to be built. Without this exception, we would either end up unnecessarily rebuilding these packages, or failing because the packages do not appear in the Stackage snapshot.istack Variant of jP from Cabal that, like versions before 2.2, only includes buildable components.kstack(Get all files referenced by the package.lstack>Resolve globbing of files (e.g. data files) to absolute paths.mstack*Get all files referenced by the benchmark.nstack%Get all files referenced by the test.ostack+Get all files referenced by the executable.pstack(Get all files referenced by the library.qstack*Get all files referenced by the component.rstack4Get all C sources and extra source files in a build.sstackGet the target's JS sources.)stackEvaluates the conditions of a [, yielding a resolved \.tstack.Make a map from a list of flag specifications.What is  flagManual for?ustack Generic a ResolveConditions using sensible defaults.vstack+Resolve the condition tree for the library.wstackGet the name of a dependency.xstack&Get the version range of a dependency.ystackTry to resolve the list of base names in the given directory by looking for unique instances of base names applied with the given extensions, plus find any of their module and TemplateHaskell dependencies.zstack.Get the dependencies of a Haskell module file.{stack6Parse a .dump-hi file into a set of modules and files.|stackTry to resolve the list of base names in the given directory by looking for unique instances of base names applied with the given extensions.}stackeFind a candidate for the given module-or-filename from the list of directories and given extensions.~stackpWarn the user that multiple candidates are available for an entry, but that we picked one anyway and continued.stackgLog that we couldn't find a candidate, but there are possibilities for custom preprocessor extensions.IFor example: .erb for a Ruby file might exist in one of the directories.stack;Get the filename for the cabal file in the given directory.WIf no .cabal file is present, or more than one is present, an exception is thrown via +.fIf the directory contains a file named package.yaml, hpack is used to generate a .cabal file from it.stack5Generate .cabal file from package.yaml, if necessary.*stack!Path for the package's build log.stackUResolve the file, if it can't be resolved, warn for the user (purely to be helpful).stackZResolve the directory, if it can't be resolved, warn for the user (purely to be helpful).+stack Extract the PackageIdentifier) given an exploded haskell package path. stack directory holding the cabal filestackprint warnings?#stack'print warnings from cabal file parsing?$stackprint warnings?]stack:Packages to omit from the "-package" / "-package-id" flagsstack'Packages to add to the "-package" flags^stackThe cabal directory.stackThe name of the component.stackDist directory.stackThe path to the .c file.stack*The path to the .o file for the component.lstackcabal file versionustackCompiler versionstackinstallation target platformstack enabled flagsystackPackage component namestackDirectories to look in.stack Base names.stack Extensions.|stackDirectories to look in.stack Base names.stack Extensions.stackpackage directory; > ? @ A B C D E H I J T U V ^ _ ` a q b h k l m c d e f g i j n o p r v w x y z { !"#$%&'()*+;#"$%&' ^ _ ` a q b h k l m c d e f g i j n o p r H I J T U V > ? @ A B C D E* v w x y z {)(+ !SSigning Packages!(c) 2015-2018, Stack contributorsBSD3!Tim Dysinger <tim@fpcomplete.com> experimentalPOSIXNone>SX 5stack\Sign a haskell package with the given url of the signature service and a path to a tarball.6stackSign a haskell package with the given url to the signature service, a package tarball path (package tarball name) and a lazy bytestring of bytes that represent the tarball bytestream. The function will write the bytes to the path in a temp dir and sign the tarball with GPG.7stackBSign a haskell package given the url to the signature service, a PackageIdentifier( and a file path to the package on disk.567576GPG Signatures for Stack!(c) 2015-2018, Stack contributorsBSD3!Tim Dysinger <tim@fpcomplete.com> experimentalPOSIXNoneXY567TNone>PX_8stackSame as 9, but works on a SinglePackageLocation.9stackMResolve a PackageLocation into a path, downloading and cloning as necessary.SReturns the updated PackageLocation value with just a single subdir (if relevant).:stackLParse the cabal files present in the given 'PackageLocationIndex FilePath'.<stack Load and parse cabal files into [s=stack< but supports 8stack project root9stack project rootstack project rootstackURLstackcommit:stack3project root, used for checking out necessary files;stack3project root, used for checking out necessary filesstackprint warnings?<stack3project root, used for checking out necessary filesstackprint warnings?=stack3project root, used for checking out necessary files89:;<=89;:<=UNone"#%&',.27>PẌ >stack Convert a  into a ?stackFully load up a  into a @stackGiven information on a  and a given set of additional packages and configuration values, calculates the new global and snapshot packages, as well as the new local packages.FThe new globals and snapshots must be a subset of the initial values.stackRecalculate a : based on updates to flags, hide values, and GHC options.stackgEnsure that all of the dependencies needed by this package are available in the given Map of packages.stacklLoad a snapshot from the given compiler version, using just the information in the global package database.stackFind the package at the given :, grab any flags, hidden state, and GHC options from the  (removing them from the 5), and add the newly found package to the contained f.stackCSome hard-coded fixes for build plans, only for hysterical raisins.stackConvert a global " to a snapshot one by creating a .stackSplit the packages into those which have their dependencies met, and those that don't. The first argument is packages that are known to be available for use as a dependency. The second argument is the packages to check.GThis works by repeatedly iterating through the list of input packages, adding any that have their dependencies satisfied to a map (eventually this set is the fst of the result tuple). Once an iteration completes without adding anything to this set, it knows it has found everything that has its dependencies met, and exits.stack Calculate a  from the given [?stackEinstalled GHC we should query; if none provided, use the global hintsstack3project root, used for checking out necessary files@stack project rootstack/packages we want to add on top of this snapshotstackflagsstack7overrides whether a package should be registered hiddenstack GHC optionsstack packages in the snapshot to dropstackrootstackhide?stack GHC optionsstackall available packagesstackextra dependencies availablestackhidden?stack GHC options>?@>?@VNone"#%,.2456>HMPVX_ "Fstack0parent directory for making a concrete resolvingGstack;An environment with a subset of BuildConfig used for setup.stackWIf deprecated path exists, use it and print a warning. Otherwise, return the new path.HstackGet the location of the implicit global project directory. If the directory already exists at the deprecated location, its location is returned. Otherwise, the new location is returned.Istack%This is slightly more expensive than t (   getBuildConfig)" and should only be used when no   is at hand.Jstack Download the  value from stackage.org.KstackTurn an  into a .stack+Get the latest snapshot resolver available.stack Create a  U value when we're not using any local configuration files (e.g., the script command)stack9Get the default location of the local programs directory.Lstack Load the G.NstackoLoad the configuration, using current directory, environment variables, and defaults as necessary. The passed Maybe (Path Abs File)> is an override for the location of the project's stack.yaml.stackMLoad the build configuration, adds build-specific values to config loaded by  loadConfig . values.OstackGet packages from EnvConfig, downloading and cloning as necessary. If the packages have already been downloaded, this uses a cached value.stackOCheck if there are any duplicate package names and, if so, throw an exception.stackGet the stack root, e.g. ~/.stack), and determine whether the user owns it.'On Windows, the second value is always V.PstackP dir throws  x if dir" isn't owned by the current user.If dirh doesn't exist, its parent directory is checked instead. If the parent directory doesn't exist either,  t ( dir) is thrown.stack dir returns U (dir, V) when dir6 exists and the current user owns it in the sense of .stack0Check whether the current user (determined with getEffectiveUserId#) is the owner for the given path.Will always return V on Windows.QstackV7 if we are currently running inside a Docker container.RstackV* if we are currently running inside a Nix.stack6Determine the extra config file locations which exist.Returns most local firstSstack8Load and parse YAML from the given config file. Throws  k when there's a decoding error.stack(Load and parse YAML from the given file.Tstack:Get the location of the project config file, if it exists.stackFind the project config file location, respecting environment variables and otherwise traversing parents. If no config is found, we supply a default based on current directory.stackGet the location of the default stack configuration file. If a file already exists at the deprecated location, its location is returned. Otherwise, the new location is returned.stackGet the location of the default user configuration file. If a file already exists at the deprecated location, its location is returned. Otherwise, the new location is returned.stack`Get a fake configuration file location, used when doing a "no config" run (the script command). stackQDescription of file for warning (if Nothing, no deprecation warning is displayed)stackTest for existencestackNew pathstackDeprecated pathstack((Path to use, whether it already exists)Kstack3root of project for resolving custom relative pathsstack stack rootstackstack root, e.g. ~/.stackstackuser config file path, e.g. ~.stack config.yamlstack allow locals?Mstack0Config monoid from parsed command-line argumentsstackOverride resolverstackProject config to use, if anyNstack0Config monoid from parsed command-line argumentsstackOverride resolverstackOverride stack.yamlstackParsed command-line argumentsstackuse config pathTstackOverride stack.yamlstackOverride stack.yamlstack stack rootCFEDGHIJKLMNOPQRSTUVGNMLSUOHIJKPQRVTCFEDWNone,.2>nstackExceptions thrown by  Stack.Nix.stackECan't determine the project root (location of the shell file if any).bstackrIf Nix is enabled, re-runs the currently running OS command in a Nix container. Otherwise, runs the inner action.stack?Shell-escape quotes inside the string and enclose it in quotes.stack1Fail with friendly error if project root not set.cstackCommand-line argument for "nix"bcdbcdXNoneggYNone&',>Xstack;Apply changes to the global configuration, typically at ~.stack config.yaml.stackApply changes to the project  stack.yaml.stackroot directory of projecthijklmnohijkolnmZNone,2>pstackExceptions during cleanup.rstack Options for  stack clean.sstack,Delete the "dist directories" as defined in -b for the given local packages. If no packages are given, all project packages should be cleaned.tstack+Delete all work directories in the project.ustack/Deletes build artifacts in the current project.Throws p.pqrstuurstpq[Nonexstack*Command-line parser for the clean command.xx\None %&'.PX,N |stack%How a package is intended to be built}stack$Build all of the default components.~stackOnly build specific componentsstack#Was a concrete component specified?stack)Only if we're adding this as a dependencystackqRaw command line input, without checking against any databases or list of locals. Does not deal with directoriesstacknEither a fully resolved component, or a component name that could be either an executable, test, or benchmarkstackSThe name of a component, which applies to executables, test suites, and benchmarksstack2Raw target information passed on the command line.stackYDo we need any targets? For example, `stack build` will fail if no targets are provided.stackSame as parseRawTarget*, but also takes directories into account.stackIf this function returns Nothing., the input should be treated as a directory.stack Convert a  into a " (see description on the module).stackcurrent directorystack+raw target information from the commandlinestackglobalsstacksnapshotstack local depsstackproject packagesy{z|}~|}~y{z]None,>P.stack-List the packages inside the current project.stack(List the targets in the current project.^None ,=>?@APX_9 stack5Invoked at the beginning of running with "--coverage"stackiMove a tix file into a sub-directory of the hpc report directory. Deletes the old one if one is present.stack;Get the directory used for hpc reports for the given pkgId.stacknGet the tix file location, given the name of the file (without extension), and the package identifier string.stackVGenerates the HTML coverage report and shows a textual coverage summary for a package.stackModule names which contain E have a package name, and so they weren't built into the executable.stack/Escape HTML symbols (copied from Text.Hastache)  _None &',.2>XPstackFind the set of FlagNames necessary to get the given GenericPackageDescription to compile against the given  BuildPlan. Will only modify non-manual flags, and will prefer default values for flags. Returns the plan which produces least number of dep errorsstackCheck whether with the given set of flags a package's dependency constraints can be satisfied against a given build plan or pool of packages.stackChecks if the given package dependencies can be satisfied by the given set of packages. Will fail if a package is either missing or has a version outside of the version range.stack Combine two s for the same .stack&Given a bundle of packages (a list of GenericPackageDescriptions's) to build and an available package pool (snapshot) check whether the bundle's dependencies can be satisfied. If flags is passed as Nothing flag settings will be chosen automatically.stackCompare , where GT means a better plan.stackCheck a set of [zs and a set of flags against a given snapshot. Returns how well the snapshot satisfies the dependencies of the packages.stackiFind a snapshot and set of flags that is compatible with and matches as best as possible with the given [s.stack6package using dependencies, for constructing DepErrorsstackdependency constraintsstackAvailable package pool or indexstack3project root, used for checking out necessary filesstack3project root, used for checking out necessary files`None,>@APXi stackLike <, but doesn't return values that aren't as commonly needed.stack8Given the build commandline options, does the following:Parses the build targets. Loads the [ from the resolver, with extra-deps shadowing any packages that should be built locally. Loads up the  * info. Builds a  =Q, which contains info for all the packages that will be involved in the build.stackAll flags for a local package.stack_Get the configured options to pass from GHC, based on the build configuration and commandline.stack7Upgrade the initial local package info to a full-blown  LocalPackage" based on the selected componentsstackYEnsure that the flags specified in the stack.yaml file and on the command line are used.stackCompare the current filesystem state to the cached information, and determine (1) if the files are dirty, and (2) the new cache values.stackNReturns entries to add to the build cache for any newly found unlisted modulesstackGets list of Paths for files relevant to a set of components in a package. Note that the library component, if any, is always automatically added to the set of components.stack)Get file modification time, if it exists.stack Create FileCacheInfo for a file.stackGet  > for package given its name.stack@Should this be treated as part of $locals? False for extra-deps.See: Mhttps://github.com/commercialhaskell/stack/issues/3574#issuecomment-346512821stack local depsstacksnapshot, for error messagesstack old cachestackfiles in package = =aNone"#%,127>@AMPXstackLength of dpPathstack Length of package names combinedstackOA path where the packages later in the list depend on those that come earlierstack$Reason why a dependency was not usedstackSee description of  Wstack{The latest applicable version and it's latest cabal file revision. For display purposes only, Nothing if package not foundstack>Recommend adding to extra-deps, give a helpful version number?stackjWarn about tools in the snapshot definition. States the tool name expected and the package name using it.stackOState to be maintained during the calculation of local packages to unregister.stackCexecutable to be installed, and location where the binary is placedstack'why a local package is considered dirtystack$Packages which count as dependenciesstackWarningsstackKWhich packages a given package depends on, along with the package's versionstackThis indicates that the package is already installed, and that we shouldn't build it from source. This is always the case for snapshot packages.stackThis indicates that the package isn't installed, and we know where to find its source (either a hackage package or a local directory).stackyThis indicates that the package is installed and we know where to find its source. We may want to reinstall from source.stack;Computes a build plan. This means figuring out which build  6s to take, and the interdependencies among the build  s. In particular:1) It determines which packages need to be built, based on the transitive deps of the current targets. For local packages, this is indicated by the  /< boolean. For extra packages to build, this comes from the  extraToBuild0 argument of type Set PackageNameJ. These are usually packages that have been specified on the commandline.H2) It will only rebuild an upstream package if it isn't present in the  ., or if some of its dependencies have changed.i3) It will only rebuild a local package if its files are dirty or some of its dependencies have changed.stackfDetermine which packages to unregister based on the given tasks and already registered local packagesstackGiven a  * and its  2 , adds a  ' for running its tests and benchmarks.If  isAllInOne is V, then this means that the build step will also build the tests. Otherwise, this indicates that there's a cyclic dependency and an additional build step needs to be done.LThis will also add all the deps needed to build the tests / benchmarks. If  isAllInOne is Vi (the common case), then all of these should have already been taken care of as part of the build step.stackGiven a u?, adds all of the build tasks to build the package, if needed.3 invokes this on all the target packages, setting  treatAsDep'= to False, because those packages are direct build targets. T invokes this while recursing into the dependencies of a package. As such, it sets  treatAsDep' to True, forcing this package to be marked as a dependency, even if it is directly wanted. This makes sense - if we left out packages that are deps, it would break the --only-dependencies build plan.stackGiven a  : and perhaps an   value, adds build  's for the package and its dependencies.stack'Checks if we need to install the given  ^, given the results of k. If dependencies are missing, the package is dirty, or it's not installed, then it needs to be installed.stack*Is the build type of the package Configurestack}Given a package, recurses into all of its dependencies. The results indicate which packages are missing, meaning that their )s will be figured out during the build, after they've been built. The 2nd part of the tuple result indicates the packages that are already installed which will be used. The 3rd part of the tuple is an  ' . If it is  )K, then the parent package must be installed locally. Otherwise, if it is  (>, then it can either be installed locally or in the snapshot.stackTGet all of the dependencies for a given package, including build tool dependencies.stackStrip out anything from the Plan intended for the local databasestack;Is the given package/version combo defined in the snapshot?stackzGet the shortest reason for the package to be in the build plan. In other words, trace the parent dependencies back to a  package.stack&additional packages that must be builtstacklocally registeredstackload upstream packagestackTasksstack2Reasons why packages are dirty and must be rebuiltstackLocal package database dumpstack[If true, we're doing a special initialBuildSteps build - don't unregister target packages.stack#is this being used by a dependency?stack#is this being used by a dependency?stack#is this being used by a dependency?bNone"#,.>@AHPSVX_stackbHow we deal with output from GHC, either dumping to a log file or the console (with some prefix).stack$Temporary Setup.hs for simple buildsstack@Temporary SetupShim.hs, to provide access to initial-build-stepsstackCompiled version of eeSetupHsstackOStores which packages with custom-setup have already had their Setup.hs built.stack$Has an executable been built or not?stackTFetch the packages necessary for a build, for example in combination with a dry run.stack8Print a description of build plan for human consumption.stack For a dry runstackGet a compiled Setup exestack!Execute a function that takes an .stackPerform the actual planstackWindows can't write over the current executable. Instead, we rename the current executable to something else and then do the copy.stack"Perform the actual plan (internal)stackGenerate the ConfigCachestackCEnsure that the configuration for the package matches what is givenstackThis sets up a context for executing build steps which need to run Cabal (via a compiled Setup.hs). In particular it does the following:HEnsures the package exists in the file system, downloading if necessary.<Opens a log file if the built output shouldn't go to stderr.ZEnsures that either a simple Setup.hs is built, or the package's custom setup is built.>Provides the user a function with which run the Cabal process.stackvGet the build status of all the package executables. Do so by testing whether their expected output file exists, e.g. .stack-workdist x86_64-osxCabal-1.22.4.0buildalphaalpha .stack-workdist x86_64-osxCabal-1.22.4.0buildalphaalpha.exe .stack-workdist x86_64-osxCabal-1.22.4.0buildalphaalpha.jsexe/ (NOTE: a dir)stackJCheck whether the given executable is defined in the given dist directory.stackMCheck if any unlisted files have been found, and add them to the build cache.stack8Determine if all of the dependencies given are installedstackfImplements running a package's tests. Also handles producing coverage reports if coverage is enabled.stack*Implements running a package's benchmarks.stackIStrip Template Haskell "Loading package" lines and making paths absolute.stack[Find the Setup.hs or Setup.lhs in the given directory. If none exists, throw an exception.stackHistory of this function:Normally it would do either all executables or if the user specified requested components, just build them. Afterwards, due to this Cabal bug  ,https://github.com/haskell/cabal/issues/2780;, we had to make Stack build all executables every time.In  6https://github.com/commercialhaskell/stack/issues/3229 this was flagged up as very undesirable behavior on a large project, hence the behavior below that we build all executables once (modulo success), and thereafter pay attention to user-wanted components.stackCDo the current executables satisfy Cabal's bugged out requirements?stackTake the given list of package dependencies and the contents of the global package database, and construct a set of installed package IDs that:-Excludes the Cabal library (it's added later)1Includes all packages depended on by this packageIncludes all global packages, unless: (1) it's hidden, (2) it's shadowed by a depended-on package, or (3) one of its dependencies is not met.See: 5https://github.com/commercialhaskell/stack/issues/941 5https://github.com/commercialhaskell/stack/issues/944 5https://github.com/commercialhaskell/stack/issues/949 stackSetup.hs input filestackSetupShim.hs input filestacktemporary directorystackglobal packagesstacksnapshot packagesstacklocal packagesstackglobal packagesstacksnapshot packagesstacklocal packagesstacknewConfigCachestackpackage directorystackannouncestackcabalstack .cabal filestackwAll dependencies' package ids to provide to Setup.hs. If Nothing, just provide global and snapshot package databases.stackIs this a final build?stackexclude TH loading?stackconvert paths to absolute?stackpackage's root directorystackcompiler we're building withstackproject directorystackdependencies of the packagestackglobal packages  cNone %,27>PXrstackBuild.If a buildLock is passed there is an important contract here. That lock must protect the snapshot, and it must be safe to unlock it if there are no further modifications to the snapshot to be performed by this build.stackVIf all the tasks are local, they don't mutate anything outside of our local directory.stackSee  6https://github.com/commercialhaskell/stack/issues/1198.stackGet the BaseConfigOpts- necessary for constructing configure optionsstackIProvide a function for loading package information from the package indexstackPSet the code page for this process as necessary. Only applies to Windows. See: 5https://github.com/commercialhaskell/stack/issues/738stackPQuery information about the build and print the result to stdout in YAML format.stack$Get the raw build information objectstack*callback after discovering all local filesstack selectorsdNone%,.24>HVWX_`9-stack;Should we use a system compiler installation, if available?stack0If we got the desired GHC version from that filestack&Run a sanity check on the selected GHCstack5Don't check for a compatible GHC version/architecturestack0Do not use a custom msys installation on WindowsstackUpgrade the global Cabal library in the database to the newest version. Only works reliably with a stack-managed installation.stack8Message shown to user for how to resolve the missing GHCstack*Location of the main stack-setup.yaml filestack>Alternate GHC binary distribution (requires custom GHCVariant)stack7Additional ghcjs-boot options, the default is "--clean"stack-Default location of the stack-setup.yaml filestack[Modify the environment variables (like PATH) appropriately, possibly doing installation toostack1Add the include and lib paths to the given ConfigstackUEnsure compiler (ghc or ghcjs) is installed and provide the PATHs to add if necessarystackcDetermine which GHC builds to use depending on which shared libraries are available on the system.stack Encode an OpenBSD version (like "6.1") into a valid argument for CompilerBuildSpecialized, so "maj6-min1". Later version numbers are prefixed with "r". The result r must be such that "ghc-" ++ r is a valid package name, as recognized by parsePackageNameFromString.stack#Ensure Docker container-compatible stack executable is downloadedstackBInstall the newest version or a specific version of Cabal globallystack4Get the version of the system compiler, if availablestack"Download the most recent SetupInfostack8Download and install the first available compiler build.stackQCheck if given processes appear to be present, throwing an exception if missing.stackUnpack a compressed tarball using 7zip. Expects a single directory in the unpacked results, which is renamed to the destination directory.stackBDownload 7z as necessary, and get a function for unpacking things.8Returned function takes an unpack directory and archive.stackGiven a printf format string for the decimal part and a number of bytes, formats the bytes using an appropiate unit and returns the formatted string.bytesfmt "%.2" 512368"500.359375 KiB"stack#Perform a basic sanity check of GHCstackMGet map of environment variables to set to change the GHC's encoding to UTF-8stacknEnsure that the Stack executable download is in the same location as the currently running executable. See: 6https://github.com/commercialhaskell/stack/issues/3232stack8Message to give user when necessary GHC is not availablestackalready installedstackpackage to findstackwhich versions are acceptablestackOS Keystack$Name of tool, used in error messagesstackPath to archive filestackLName of directory expected in archive. If Nothing, expects a single folder.stackDestination directory.stacklabelstack%URL, content-length, sha1, and sha256stack destinationstackoptional version stackacceptable platformsstackdestination directorystack&perform PATH-aware checking, see #3232stack!test the temp exe before renamingstack%location of the newly downloaded file    eNone "#,>@A=2stackKforce a download, even if the downloaded version is older than what we arestackspecific version to downloadstack&git hash at time of building, if knownfNone,.>@AHPVXjX stackaRuns the given inner command with an updated configuration that has the desired GHC on the PATH.stackMerge two separate maps, one defining constraints on package versions and the other defining package flagmap, into a single map of version and flagmap tuples.stackGiven a resolver, user package constraints (versions and flags) and extra dependency constraints determine what extra dependencies are required outside the resolver snapshot and the specified extra dependencies.First it tries by using the snapshot and the input extra dependencies as hard constraints, if no solution is arrived at by using hard constraints it then tries using them as soft constraints or preferences.It returns either conflicting packages when no solution is arrived at or the solution in terms of src package flag settings and extra dependencies.stackGiven a resolver (snpashot, compiler or custom resolver) return the compiler version, package versions and packages flags for that resolver.stackvFinds all directories with a .cabal file or an hpack package.yaml. Subdirectories can be included depending on the recurse parameter. stackCSpecial directories that we don't want to traverse for .cabal filesstackPerform some basic checks on a list of cabal files to be used for creating stack config. It checks for duplicate package names, package name and cabal file name mismatch and reports any issues related to those.+If no error occurs it returns filepath and GenericPackageDescriptionTs pairs as well as any filenames for duplicate packages not included in the pairs.stackVerify the combination of resolver, package flags and extra dependencies in an existing stack.yaml and suggest changes in flags or extra dependencies so that the specified packages can be compiled.stackSame as checkSnapBuildPLan", but set up a real GHC if needed.If we're using a Stackage snapshot, we can use the snapshot hints to determine global library information. This will not be available for custom and GHC resolvers, however. Therefore, we insist that it be installed first. Fortunately, the standard `stack solver` behavior only chooses Stackage snapshots, so the common case will not force the installation of a bunch of GHC versions. stack cabal filesstacksrc constraintsstackdep constraintsstackadditional arguments stacktemp dirstack constraintsstackstack.yaml file locationstack#package dirs containing cabal filesstackK( resolver , src package constraints , extra dependency constraints )stackS(Conflicting packages (resulting src package specs, external dependency specs))stackactually installed compiler stackDirectories to scanstackWhether to scan sub-directoriesstackmodify stack.yaml?stack3project root, used for checking out necessary filesgNone,>@Ay"stack2List of sub directories to search for .cabal files#stack6Use solver to determine required external dependencies$stack1Exclude conflicting or incompatible user packages%stackOverwrite existing stack.yaml&stack>If True, include all .cabal files found in any sub directories'stackGenerate stack.yaml stack.Render a stack.yaml file with comments, see: 5https://github.com/commercialhaskell/stack/issues/226stackGet the default resolver valuestack stack.yamlstack6Src package name: cabal dir, cabal package descriptionstackt( Resolver , Flags for src packages and extra deps , Extra dependencies , Src packages actually considered)stack stack.yamlstack6Src package name: cabal dir, cabal package descriptionstackw( SnapshotDef , Flags for src packages and extra deps , Extra dependencies , Src packages actually considered)stack stack.yamlstack6Src package name: cabal dir, cabal package description !#$%"&'' !#$%"&hNone"#,.>z{ ()*+,-./012 21()*+,-./0iNone"#$,2>PSWX`stack@Function to get command and arguments to run in Docker containerstackParsed Config section of docker inspect output.stackParsed result of docker inspect.3stackCleanup action.7stack Options for A.?stackxIf Docker is enabled, re-runs the currently running OS command in a Docker container. Otherwise, runs the inner action.GThis takes an optional release action which should be taken IFF control is transferring away from the current process to the intra-container one. The main use for this is releasing a lock. After launching reexecution, the host process becomes nothing but an manager for the call into docker and thus may not hold the lock.stackIf Docker is enabled, re-runs the OS command returned by the second argument in a Docker container. Otherwise, runs the inner action.0This takes an optional release action just like ?.@stack Error if running in a container.stack?Run a command in a new Docker container, then exit the process.Astack*Clean-up old docker images and containers.stack"Inspect Docker image or container.stack1Inspect multiple Docker images and/or containers.Bstack=Pull latest version of configured Docker image from registry.stack Pull Docker image from registry.stack4Check docker version (throws exception if incorrect)Cstack$Remove the project's Docker sandbox.DstackThe Docker container "entrypoint": special actions performed when first entering a container, such as switching the UID/GID to the "outside-Docker" user's.stackCMVar used to ensure the Docker entrypoint is performed exactly oncestackdRemove the contents of a directory, without removing the directory itself. This is used instead of Z to clear bind-mounted directories, since removing the root of the bind-mount won't work.stackProduce a strict ) from the stdout of a process. Throws a ReadProcessException? exception if the process fails. Logs process's stderr using logError.stack-Name of home directory within docker sandbox.stackDirectory where stack/ executable is bind-mounted in Docker containerstack4Convenience function to decode ByteString to String. stack1Fail with friendly error if project root not set.!stackEnvironment variable that contained the old sandbox ID. | Use of this variable is deprecated, and only used to detect old images.EstackParse Config section of docker inspect output.FstackParse docker inspect output.stackProject root (maybe)stackAction to run beforestackAction to run afterstackDirectory to remove contents ofstack1Top-level directory names to exclude from removalstack,Top-level file names to exclude from removal+   ghijk3456789:;<=>?@ABCD+A789:;<=>3456jghiD@B?Ck   jNoneKstack(Options parser configuration for Docker.Lstack$Parser for docker cleanup arguments.KLKLkNone ,2>HSVXÈMstackZSpecial exception to throw when you want to fail because of bad results of package check.OstackDirectories to packagePstackPVP Bounds overridesQstack8Whether to ignore check of the package for common errorsRstackWhether to sign the packageSstackThe URL of the signature serverTstackWhether to build the tarballUstackWhere to copy the tarballVstackLGiven the path to a local package, creates its source distribution tarball.While this yields a n, the name of the tarball, this tarball is not written to the disk and instead yielded as a lazy bytestring."stack:Get the PVP bounds-enabled version of the given cabal file#stackTraverse a data type.$stack Read in a  *3 config. This makes some default decisions about  *; fields that might not be appropriate for other use-cases.%stackSReturns a newline-separate list of paths, and the absolute path to the .cabal file.WstacksCheck package in given tarball. This will log all warnings and will throw an exception in case of critical errors.>Note that we temporarily decompress the archive to analyze it.Xstack Version of WI that first saves lazy bytestring to temporary directory and then calls W on it.VstackOverride Config valuestackPath to local packagestackDFilename, tarball contents, and option cabal file revision to upload"stackoptional revisionstack cabal fileWstack"The configuration of what to checkstackAbsolute path to tarball&stackAbsolute path to tarballXstack Tarball namestack!Tarball contents as a byte string'stackLocation of tarballstack/Perform actions given dir with tarball contents(stack,Full path to find the file on the local diskstack,Path to use for the tar Entry in the archive MNOPQRSTUVWX VWXMNOPQRSTUlNone[[mNone:\stack0Command-line arguments parser for configuration.\\nNone"#]stack'Parser for global command-line options.^stack(Create GlobalOpts from GlobalOptsMonoid.]^_]^_oNone`stack Parser for  stack new.``pNone "#,2>P/ )stack,Loaded package description and related info.hstack:Necessary information to load a package or its components.nstackC files.rstackCommand-line options for GHC.stackLaunch a GHCi session for the given local package targets with the given options and configure it with the load paths and extensions of those targets.*stackFigure out the main-is file to load based on the targets. Asks the user for input if there is more than one candidate main-is file.+stack7Load package description information for a ghci target.,stack=Make information necessary to load the given package in GHCi.-stackXRun a command and grab the first line of stdout, dropping stderr's contexts completely.!abcdefghijklmnopqrstuvwxyz{|}~!rstuvwxyz{|}~hijklmnopqabcdefgqNone,>PstackDInformation about a package in the dependency graph, when available.stackThe package version.stack+The license the package was released under.stackThe normal dot options.stack/Separator between the package name and details.stack.Print dependency licenses instead of versions.stackOptions record for  stack dotstackInclude external dependenciesstackInclude dependencies on basestackOLimit the depth of dependency resolution to (Just n) or continue until fixpointstack%Package names to prune from the graphstack'stack TARGETs to trace dependencies forstack,Flags to apply when calculating dependenciesstack9Like the "--test" flag for build, affects the meaning of .stack:Like the "--bench" flag for build, affects the meaning of .stack8Visualize the project's dependencies as a graphviz graph.stackCreate the dependency graph and also prune it as specified in the dot options. Returns a set of local names and and a map from package names to dependencies./stackCreate the dependency graph, the result is a map from a package name to a tuple of dependencies and payload if available. This function mainly gathers the required arguments for resolveDependencies.stack"pruneGraph dontPrune toPrune graph prunes all packages in graph with a name in toPrune3 and removes resulting orphans unless they are in  dontPrune0stack9Make sure that all unreachable nodes (orphans) are prunedstackLResolve the dependency graph up to (Just depth) or until fixpoint is reached1stackUGiven a SourceMap and a dependency loader, load the set of dependencies for a package2stackNResolve the direct (depth 0) external dependencies of the given local packagesstackUPrint a graphviz graph of the edges in the Map and highlight the given local packages3stackAPrint the local nodes with a different style depending on options4stack Print nodes without dependencies5stackprintDedges p ps" prints an edge from p to every ps6stack+Print an edge between the two package names7stack,Convert a package name to a graph node name.8stack!Print a node with no dependencies9stack3Check if the package is wired in (shipped with) ghcstack all localsrNone"#.> stackiEnforce mutual exclusion of every action running via this function, on this path, on this users account.A lock file is created inside the given directory. Currently, stack uses locks per-snapshot. In the future, stack may refine this to an even more fine-grain locking approach.stackSLoads global config, ignoring any configuration which would be loaded due to $PWD.stackhSee issue #2010 for why this exists. Currently just used for the specific case of "stack clean --full".stackJLoad the configuration. Convenience function used throughout this module.stack(Unlock a lock file, if the value is JuststackAction to perform before the build. This will be run on the host OS even if Docker is enabled for builds. The build config is not available in this action, since that would require build tools to be installed on the host OS.stackmAction that uses the build config. If Docker is enabled for builds, this will be run in a Docker container.stackAction to perform after the build. This will be run on the host OS even if Docker is enabled for builds. The build config is not available in this action, since that would require build tools to be installed on the host OS.  sNoneP ~tNone  uNoneP  stackRun a Stack Script:stackThe Stackage project introduced the concept of hidden packages, to deal with conflicting module names. However, this is a relatively recent addition (at time of writing). See:  <http://www.snoyman.com/blog/2017/01/conflicting-module-namest. To kick this thing off a bit better, we're included a blacklist of packages that should never be auto-parsed in.;stackscript filenamevNone stack Parser for stack hpc report.wNone ^stack8Parser for arguments to `stack sdist` and `stack upload`stackEWhether to sign by default `stack upload` does, `stack sdist` doesn'txNone stackParser for exec commandstack(Parser for extra options to exec commandstackmetavaryNone stack#Parser for CLI-only build argumentszNone stackParser for GHCI options{NoneX stackHoogle command.|None ustack#Parser for arguments to `stack dot`stack2Parser for arguments to `stack list-dependencies`.}None"#X UstackList the dependencies<      !"#$%&%'()*+,-./0123456789:;<=>?@ABCDCECFCGCHCICJCKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnmopqrstuvwxyz{|}~      !"#$%&%'()(*(+(,(-(.(/(0(1(2((3(((1(0(4(5(6(6(7(8(9(:(;(<(=(>(?(@(A(B(C(D(EFGFHIJKLMNLMOLMPLMQLMRLMSLMTLMULMVLMWLMXLMYLMZLM[LM\LM]LM^LM_LM`LMaLMbLMcLMdLMeLMfLMgLMhLMiLMjLMkLMlLMmnopqrstrsursvrswrsxrsyrszrs{rs|rs}rs~pppppnnnnmm        IJ !"#"$"%&'&(&)&*&+&,-.-/-0-1--2-3-4-5-6-7-8-9-:-;-<-=>?@>?A>?BCDECDFCDGCDHCDICDJCDKCDLMNOMPQMPRMSTMNUMNVMNWMNXMNYMNZ[\][\^[\_[\`[\a[bc[de[df[dg[dh[di[djklmnlmolmplmqrstuvtuwtuxtuytz{tzu|}~|}|}|}|}|}||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| | | | | |||||||||||||||||| |!|"|#|$|%&|%'|%(|%)|*+|*,|*-|*.|*/|*0|*1|*2|*3|*4|*5|*6|*7|*8|9:|9;|9<|9=|>?@ABCDEEFGHFGIFGJFGKFGLFGMFGNFGOFGPFGQFRSFRTFRUFRVFRWFRXFRYFRZFR[FR\FR]FR^F_`F_aF_bF_cF_dF_eF_fF_gF_hF_iF_jFklFkmFknFkoFkpFkqFkrFksFktFuvFuwFuxyz{yz|yz}yz~yzyzyzyzyzyzyzyzyzyzyzyzyzyzyzyzyzyzyzyzyzyzyzyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy y y y y y y yyyyyyyyyyy !"|#$|#%|#&|#'|#()*)+),)-./.0.1.23456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_ ` a b c d e f g hijklmnopqr s t u v w x y z { |}}~      !"#$%&'())*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPPQRRSTUVWXXYZ[\]^_`abcdefghijjklmnopqrrstuvwxyz{|}~b      !"#b$%e&'()*+,-./0123456789:;<=>?@A B!C!D!E!F!G!H!I!J!K!L!L!M!N!O!P!Q!R!S!T!U!V!W!X!Y!Z!["\"]#^#_#`#a#b#b#c#d#e#f#g#h#i#j#k#l#m#n#o#p#q#r#s#t#u#v#w#x#y#z#{#|#}#~#$$$$$$$$$$$b$$$e$$$%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& & & & & &&&''''''''''''''''''''' ' '!'"'#'$'$'%'%'&'''(')'*'+','-'.'/'0'1'b'2'3'4'5'6'7'8'9':';'<'='>'?'@'A'B'C'D'E'F'G'H'I'J'K(L(L(M(N(O(P(Q(Q(R(R(S(T(U(V(W(X(Y(Z([(\(])^)^)_)`)a)b)c)d)e)e)f)g)h)i)j)j)k)l)m)n)o)p)q)r)s)t)u)v)w)x)y*z*{*|*}*~****************************++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++,,,----------------------------.......... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . !. ". #. $. %. &. '. (. (. ). *. +. ,. -. .. /. 0. 1. 2. 3. 4. 5. 6. 7. 8. 9. :. ;. <. =. >. ?. @. A. B. C. D. E. F. G. H. I. J. K. L. M. N. O. P. Q. R. S. T. U. V. W. X. Y. Z. [.b. \. ]. ^. _. `. a. b/ c/ d0 e0 f0 g0 h0 i0 j0 k0 l0 m0 n0 o0 p0 q0 r0 s0 t0 u0 v0 w0 x0 y0 z0 {0 |1 }1 }1 ~111 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 1 1 1 1 1 1 1 1 1 1 1b1 1 1 1 1 1 1e1 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 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 *2 +2 ,2 -2 .2 /2 02 12 22 32 42 52 63 73 83 93 :3 ;4 <4 =4 >4 ?4 @4 A4 B4 B4 C4 D4 E4 F4 G4 H4 I4 J4 K4 L4 M4 N4 O4 P4 Q4 R4 S5 T6 U6 V6 W6 X6 Y6 Z [ \ ] ^ ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                    7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7778 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 : : : : : : : : : : : : : : : : : : ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; !; "; #; $; %; &; '; (; '; ); *; +; +; ,; -; .; /; 0; 1; 2; 3; 4; 5; 6; 7; 8; 9; :; ;; <; =; >; ?; @; A; B; C; D; E; F; G; H; H; I; J; K; L; M; N; O; P; Q; R; S; T; U; V; W; X; Y; Z; [; \; ]; ^; _; `; a; b; c; d; e; f; g; h; i; j; k; l; m; n; o; p; q; r; s; t; u; v; w; w; x; y; z; {; |; }; ~; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; !; "; #; $; %; &; '; (; ); *; +; ,; -; .; /; 0; 1; 2; 3; 4; 5; 6; 7; 8; 9; :; ;; <; =; >; ?; @; A; B; C; D; E; F; G; H; I; J; K; L; M; N; O;b; P; Q; R; S; T; U; V; W; X; Y;e;(;+; Z; [; \; ]; ^; _; `; a; b; c; d; e; f; g; h; i; j; k; l; m; n; o; p; q; r; s; t; u; v; w; x; y; z; {; |; }; ~; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; < < < < < < < < = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = != "= #= $= %= &= '= (= )= *= += ,= -= .= /= 0= 1= 2= 3= 4= 5= 6= 7= 8= 9= := ;= <= == >= ?= @= A= B= C= D= E= F= G= H= I= J= K= L= M= N= O= P= Q= R= S= T= U= V= W= X= Y= Z= [= \= ]= ^= _= `= a= b= c= d= e= f> g> g> h> i> j> k> k> l> m> n> n> o> p> q> r> s> t> u> v> v> w> x> y> z> {> |> }> ~> ~> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > ? ? ? ? ? ? ? ? @ @ @ @ @ @ @ @ @ @ @ @ @ @@@@@@@@@@ @ @ @ @ @@@@@@@@AAAAAAAAAAAAA A!A"A#A$A%A&A'A(A)B*C+D,E-F.F/F0F1F2F3F4F5F6F7F8F9F:F;F<F=F>F?F@FAFBFCFDFEFFFGFHFIFJFKFLFMFNFOFPFQFRFSFTFUFVFWGXGYGZG[G\G]G^G_G`GaGbGcGGdGeHfHgHhHiHjHkHlImInIoIpIqIrJsJtJuJvKwKxKyKzK{K|L}L~LLLLLLLLLLLLLLLMMMMMMMMMNO7OOOOOOOOPPPPPPPPPPQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSTTTTTTUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWW YW ZXYYYYYYY Y Z Z Z ZZZZZ[\\\\\\\\\\\\\ \\!\!\"\#\$\\%\&\'\(\)\*\+],]-^.^.^/^0^1^2^3^4^5^6^7^8^9_:_;_<_=_>_>_?_@_A_B_C_D_E_F_G_H_I_J_K_L_M_N_O``P`Q`R`SaTaUaVaaaaaaaaaaWaXaYaZa[a\a]a^a_a`aaabacadbebebfbgbhbibjbkblbmbnbocpcpcqcrcsctcucvcwcxdydzdzd{d|d}d~dddddddddddddddddddddddddddeeeeeefffffffffgggggggghhhhhhhhhhhiiiiiiiiiiiiiiiiiiiiiiiijjkkkkkkkkkkkkkklmnnnopppppppppppppppppppppppppppppppppppppq q q q q q q qqqqqqqqqqqqqqqqqqqr r!r"r#r$r%r&r'r(r)r*r+s,s-s.s/t0t1t2t3t4t4t5t6t7t8t9t:t;t<u=v>v?w@xAxBxCyDyEyFzG{H|I|J}K}L}M}N}O}P}Q}R}S}T}U}V}W}X}Y}Z}[}\}]}^}_}`~abcd~e~f~Ftugtuhijkljkmjknopyqrs t utuv w x yz{|z}~z}z}z}(!""#&&)--2888::::::::::::;;;;;;;>>???@@@@AFHHHHHHHHHKKKKKKLLLMMOOPPPPPPPPPPQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR R R R T UUUUUUUUVVVVVVVVV V!V"V#V$V%V&V'W UW(W)WY*Y+Y,\-\.\/\0\1\2\3^4^5^6^7_8_9_:_;_<_=`>`?`@`A`B`C`DaEaFaGaHaIaJaKaLaMaNaOaPaQaRaSaTaUaVaWaXaYaZa[a\a]a^a_a`aabbbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbyczc{c|c}d~dddddddddddddddeefffffggggiiiiiiiiiiiiiiiiikkkkkkkpppppqqqqqqqqqqqquu$stack-1.9.3.1-Cy1tv1B2VcB4E3bvhLgbqY Stack.PreludeStack.Ghci.ScriptStack.Types.VersionData.Aeson.Extended Text.PrettyPrint.Leijen.ExtendedNetwork.HTTP.StackClient Path.Extra Paths_stackStack.Options.UtilsStack.Options.LogLevelParserStack.FileWatch Path.FindOptions.Applicative.Complicated!Options.Applicative.Builder.ExtraStack.Options.SolverParserData.Store.VersionTaggedData.Monoid.MapData.IORef.RunOnceData.Attoparsec.CombinatorsData.Attoparsec.ArgsOptions.Applicative.ArgsStack.StaticBytesStack.Types.CompilerBuildStack.Options.GhcBuildParserStack.Types.FlagNameStack.Types.GhcPkgIdStack.Types.ImageStack.Types.NixStack.Types.PackageNameStack.Types.NamedComponentStack.Types.Config.BuildStack.Options.PackageParserStack.Types.Sig Stack.Sig.GPGStack.Types.TemplateNameStack.Types.UrlsStack.Config.UrlsStack.Types.PackageIdentifierStack.Types.PackageIndexStack.Types.PackageDumpControl.Concurrent.ExecuteStack.Types.CompilerStack.Types.ResolverStack.Options.ResolverParserStack.ConstantsStack.Types.DockerData.Attoparsec.InterpreterStack.Types.VersionIntervalsStack.Types.BuildPlanSystem.Process.PagerEditorSystem.TerminalStack.Types.RunnerStack.DefaultColorWhenStack.Config.NixStack.PrettyPrintNetwork.HTTP.Download.VerifiedNetwork.HTTP.DownloadStack.PackageIndexStack.Types.Config Stack.UploadStack.Types.PackageStack.Types.Build Stack.GhcPkgStack.PackageDumpStack.Setup.InstalledStack.Options.TestParserStack.Options.HaddockParserStack.Options.GhcVariantParserStack.Options.BenchParserStack.Docker.GlobalDBStack.Constants.Config Stack.ImageStack.Config.DockerStack.Config.BuildStack.Build.HaddockStack.Build.CacheStack.Build.InstalledPath.CheckInstall Stack.Path Stack.New Stack.Fetch Stack.PackageStack.Sig.SignStack.PackageLocationStack.Snapshot Stack.Config Stack.NixStack.Options.NixParserStack.ConfigCmd Stack.CleanStack.Options.CleanParserStack.Build.Target Stack.IDEStack.CoverageStack.BuildPlanStack.Build.SourceStack.Build.ConstructPlanStack.Build.Execute Stack.Build Stack.Setup Stack.Upgrade Stack.Solver Stack.InitStack.SetupCmd Stack.DockerStack.Options.DockerParser Stack.SDistStack.Options.BuildMonoidParserStack.Options.ConfigParserStack.Options.GlobalParserStack.Options.NewParser Stack.Ghci Stack.Dot Stack.RunnersStack.Options.CompletionStack.Options.ScriptParser Stack.ScriptStack.Options.HpcReportParserStack.Options.SDistParserStack.Options.ExecParserStack.Options.BuildParserStack.Options.GhciParser Stack.HoogleStack.Options.DotParserStack.Ls5Hackage.Security.Client.Repository.HttpLib.HttpClientStack PackageIndex loadConfig loadSourceMap"Distribution.Simple.LocalBuildInfocomponentBuildDir Stack.SigdistRelativeDirFS removeTreeS ByteStringbaseGHC.Base++ghc-primGHC.PrimseqGHC.Listfilterzip Data.Tuplefstsnd otherwiseassertmap$GHC.Num fromInteger-GHC.Real fromRational GHC.Classes==>=negatefail>>=>>fmapreturn Control.Arrowfirst Data.String fromString fromIntegral realToFrac toInteger toRational Control.Monadguard<>memptymappendmconcatjoin<*>pure*>GHC.EnumBoundedEnumEq GHC.FloatFloating FractionalIntegralMonad Data.DataDataFunctorNumOrdGHC.ReadReadReal RealFloatRealFracGHC.ShowShowData.Typeable.InternalTypeableControl.Monad.Fail MonadFailIsString Applicative Data.FoldableFoldableData.Traversable Traversable GHC.GenericsGeneric SemigroupMonoid GHC.TypesBoolCharDoubleFloatIntGHC.IntInt8Int16Int32Int64 integer-gmpGHC.Integer.TypeInteger GHC.NaturalNatural GHC.MaybeMaybeOrderingRationalIOWordGHC.WordWord8Word16Word32Word64 Data.EitherEitherGHC.Stack.Types CallStackFalseNothingJustTrueLeftRightLTEQGTGHC.STSTbytestring-0.10.8.2Data.ByteString.Short.InternalShortByteStringData.ByteString.Internal byteSwap16 byteSwap32 byteSwap64 Cabal-2.4.0.1Distribution.ModuleName ModuleNameDistribution.Types.VersionRange VersionRangedeepseq-1.4.4.0Control.DeepSeqNFDatarnfcontainers-0.6.0.1Data.Map.InternalMapminmax><not||&&compare<=/=GHC.Errerror undefinedString MonadPlusmzeromplus Alternative<|>somemany<*<$=<<whenliftMliftM2idconst.flip$!asTypeOf+*abssignumsubtractcurryuncurry Data.MaybemaybeisJust isNothing fromMaybe maybeToList listToMaybe catMaybesmapMaybe replicate takeWhile dropWhiletakedropspanbreakreverselookupzipWithshowfromEnumminBoundmaxBoundproperFractiontruncateroundceilingfloor/recipquotremdivmodquotRemdivModevenodd^^^gcdlcm Data.Functor<$>void floatRadix floatDigits floatRange decodeFloat encodeFloatexponent significand scaleFloatisNaN isInfiniteisDenormalizedisNegativeZeroisIEEEatan2piexplogsqrt**logBasesincostanasinacosatansinhcoshtanhasinhacoshatanhData.Ord comparingeither Data.OldListlinesunlineswordsunwordsData.Semigroup.InternalAnygetAnyfoldMapfoldrfoldl'nulllengthelemsumproduct traverse_for_ sequence_concat concatMapandoranyallnotElemGHC.Exception.TypedisplayExceptionGHC.IOFilePathControl.Applicativeoptionaltraverse sequenceAforfilterMfoldMunless Data.ByteString.Builder.InternalBuilder'hashable-1.2.7.0-2SI038axTEd7AEZJ275kpiData.Hashable.ClassHashable text-1.2.3.1Data.Text.InternalText4unordered-containers-0.2.10.0-LgoTL3wbBEY5bZIDJiyxW4Data.HashMap.BaseHashMap$aeson-1.4.2.0-KDbkGdCH8KWK3joT2FuDwN Data.AesoneitherDecodeFileStrict'eitherDecodeStrict' eitherDecode'eitherDecodeFileStricteitherDecodeStrict eitherDecodedecodeFileStrict' decodeStrict'decode'decodeFileStrict decodeStrictdecode encodeFileencodeData.Aeson.TypesfoldableData.Aeson.Types.ClassGToJSON GToEncodingData.Aeson.Types.ToJSON toEncoding2toJSON2 toEncoding1toJSON1genericLiftToEncodinggenericToEncodinggenericLiftToJSON genericToJSONTo1ArgsNoToArgsToArgstoEncodingList toJSONList toEncodingtoJSONToJSON.=KeyValue toJSONKeyList toJSONKey ToJSONKeyToJSONKeyValue ToJSONKeyTextToJSONKeyFunctionliftToEncodingListliftToEncodingliftToJSONList liftToJSONToJSON1liftToEncodingList2liftToEncoding2liftToJSONList2 liftToJSON2ToJSON2Data.Aeson.Encoding.Internalpairs fromEncodingEncodingSeriesData.Aeson.Types.FromJSON.!=.:!fromJSONwithEmbeddedJSONwithBoolwithScientific withArraywithText withObject parseJSON2 parseJSON1genericLiftParseJSONgenericParseJSON gParseJSON GFromJSON From1Args NoFromArgsFromArgs parseJSONList parseJSONFromJSONfromJSONKeyList fromJSONKey FromJSONKeyFromJSONKeyValueFromJSONKeyTextParserFromJSONKeyTextFromJSONKeyCoerceFromJSONKeyFunctionliftParseJSONList liftParseJSON FromJSON1liftParseJSONList2liftParseJSON2 FromJSON2Data.Aeson.Parser.Internaljson'jsonData.Aeson.Types.InternalcamelTo2defaultTaggedObjectdefaultOptionsobjectSuccessErrorResultObjectArrayNullNumberValuefromDotNetTime DotNetTimetagSingleConstructorsunwrapUnaryRecords sumEncodingomitNothingFieldsallNullaryToStringTagconstructorTagModifierfieldLabelModifierOptionscontentsFieldName tagFieldName TwoElemArrayObjectWithSingleField UntaggedValue TaggedObject SumEncodingData.Aeson.Types.GenericZeroOne(exceptions-0.10.1-DdWfqA1lutT4wybeL2xRnxControl.Monad.Catch MonadThrow0annotated-wl-pprint-0.7.0-DGkZQ2VEej1K9q8cmlJu7D!Text.PrettyPrint.Annotated.Leijen noAnnotateannotategroupnest linebreaklinealignhangindentfill fillBreakenclosebracketsanglesparensbracesdquotessquotes softbreaksoftline<+>vcathcatfillCatcatvsephsepfillSepsep punctuate encloseSepDocGHC.IO.Handle.TypesHandle GHC.Conc.SyncThreadId"async-2.2.1-CnEO6bROc7S6QgTCMiGZteControl.Concurrent.Async waitBothSTMwaitEitherSTM_ waitEitherSTMwaitEitherCatchSTM waitAnySTMwaitAnyCatchSTMpollSTM waitCatchSTMwaitSTM asyncThreadIdAsync Data.VoidabsurdVoidgmapMogmapMpgmapMgmapQigmapQgmapQrgmapQlgmapT dataCast2 dataCast1 dataTypeOftoConstrgunfoldgfoldlControl.Concurrent.ChanChanControl.Monad.IO.ClassliftIOMonadIOmfilter<$!> replicateM_foldM_ zipWithM_zipWithMforever<=<>=>forMsequencemapM&&&***secondArrowData.Functor.Identity runIdentityIdentityGHC.IO.Handle.FDstderrstdin writeTVarreadTVarnewTVarSTMTVarGHC.IO.ExceptionSomeAsyncException ExitFailure ExitSuccessExitCodestdoutBlockBuffering LineBuffering NoBuffering BufferMode GHC.IO.DeviceSeekMode GHC.IORefIORef IOException SomeException fromException toException ExceptionData.Functor.ConstgetConstConstmsumasum sequenceA_forM_mapM_toListfold Data.MonoidgetFirstFirstappEndoEndogetSumSum Text.Read readMaybeisRightisLeftpartitionEithersrightslefts Data.ProxyProxyControl.Category>>>Category GHC.IO.IOMode ReadWriteMode AppendMode WriteModeReadModeIOModeForeign.StorableStorablerunST Data.Boolbool Data.Function&onfix$><&>GHC.MVarMVarliftA3liftAliftA2 HasCallStack fromShorttoShorttransformers-0.5.5.0Control.Monad.Trans.ReaderReaderT&conduit-1.3.1.1-5AB8IW7H6qH9Kixr120BHWData.Conduit.Internal.Conduit runConduit.|ConduitM,unliftio-core-0.1.2.0-6l4GP0ylCTM6crlVTDgRiKControl.Monad.IO.Unlift askUnliftIO withRunInIO MonadUnliftIO(primitive-0.6.4.0-1mvPxVOk6Q6KOkWCZxqESfControl.Monad.Primitive PrimMonad PrimState primitiveControl.Monad.Trans.Class MonadTransliftthrowMData.IntMap.InternalIntMapData.IntSet.InternalIntSetData.Sequence.InternalSeqData.Set.InternalSetforce$!!deepseq(http-client-0.6.4-CEuXYrf1LieHzze0oPBlIx%Network.HTTP.Client.MultipartFormData formDataBodypartFileRequestBodypartLBSpartBSNetwork.HTTP.ClientmanagerSetProxyNetwork.HTTP.Client.ManagerproxyEnvironmentuseProxynoProxyNetwork.HTTP.Client.RequestdefaultRequestsetUrigetUri parseRequest_ parseRequest parseUrlThrowNetwork.HTTP.Client.TypesHttpExceptionRequest HttpExceptionStatusCodeExceptionHttpExceptionContent RequestBodyBSRequestBodyLBS RequestBody checkResponserequestHeaderspathRequest responseBodyresponseHeadersresponseStatusResponseManager-http-client-tls-0.3.5.3-ncu2vxUwu5Diyh6WY4KG2Network.HTTP.Client.TLSapplyDigestAuthdisplayDigestAuthExceptiongetGlobalManager)http-conduit-2.3.7-IcLthWAGi9i2Jyk0yhwAV3Network.HTTP.SimplegetResponseBodygetResponseHeadersgetResponseStatusCodesetRequestManagersetRequestBodysetRequestHeaderaddRequestHeadersetRequestMethod(http-types-0.12.3-4L76TmlQodx6G0dPW61wNWNetwork.HTTP.Types.HeaderHeaderNetwork.HTTP.Types.StatuspartialContent206ok200Network.HTTP.Types.Method methodPuthRange hContentMD5hContentLength hCacheControlhAccept HeaderName'microlens-0.4.10-LVgmazyXGvNKvoQElrYSfS Lens.Microlensto^.setoverLens.Micro.InternalsetsLens.Micro.TypeASetterASetter' SimpleGetterGettingLensLens' runReaderT mtl-2.2.2Control.Monad.Reader.Classaskslocalask MonadReaderReader runReader!path-0.6.1-F6a7AfyXOMrHz6y0DcssNCPathAbsRelFileDir Path.Internal toFilePath&unliftio-0.2.10-1qBqSiBXLZs1q1ojYCqYZu UnliftIO.ChannewChan writeChanreadChandupChangetChanContentswriteList2ChanUnliftIO.ExceptionStringExceptionAsyncExceptionWrapperSyncExceptionWrapperHandlercatchcatchIOcatchAny catchDeep catchAnyDeep catchJusthandlehandleIO handleAny handleDeep handleAnyDeep handleJusttrytryIOtryAnytryDeep tryAnyDeeptryJustpureTry pureTryDeepcatches catchesDeepevaluate evaluateDeepbracketbracket_bracketOnErrorbracketOnError_finally withException onExceptionthrowIOtoSyncExceptiontoAsyncExceptionisSyncExceptionisAsyncExceptionmaskuninterruptibleMaskmask_uninterruptibleMask_ throwStringstringExceptionthrowTo impureThrow fromEither fromEitherIO fromEitherM UnliftIO.IOwithFilewithBinaryFilehClosehFlush hFileSize hSetFileSizehIsEOF hSetBuffering hGetBufferinghSeekhTellhIsOpen hIsClosed hIsReadable hIsWritable hIsSeekablehIsTerminalDevicehSetEchohGetEcho hWaitForInputhReadygetMonotonicTimeUnliftIO.IORefnewIORef readIORef writeIORef modifyIORef modifyIORef'atomicModifyIORefatomicModifyIORef'atomicWriteIORef mkWeakIORefUnliftIO.Internals.AsyncEmptyWithNoAlternative ConcExceptionConcrunConcurrently Concurrentlyasync asyncBoundasyncOnasyncWithUnmaskasyncOnWithUnmask withAsyncwithAsyncBound withAsyncOnwithAsyncWithUnmaskwithAsyncOnWithUnmaskwaitpoll waitCatchcanceluninterruptibleCancel cancelWithwaitAny waitAnyCatch waitAnyCancelwaitAnyCatchCancel waitEitherwaitEitherCatchwaitEitherCancelwaitEitherCatchCancel waitEither_waitBothlinklink2racerace_ concurrently concurrently_forConcurrentlyforConcurrently_replicateConcurrentlyreplicateConcurrently_mapConcurrentlymapConcurrently_concrunConcpooledMapConcurrentlyNpooledMapConcurrentlypooledForConcurrentlyNpooledForConcurrentlypooledMapConcurrentlyN_pooledMapConcurrently_pooledForConcurrently_pooledForConcurrentlyN_pooledReplicateConcurrentlyNpooledReplicateConcurrentlypooledReplicateConcurrentlyN_pooledReplicateConcurrently_ UnliftIO.MVar newEmptyMVarnewMVartakeMVarputMVarreadMVarswapMVar tryTakeMVar tryPutMVar isEmptyMVar tryReadMVarwithMVarwithMVarMasked modifyMVar_ modifyMVarmodifyMVarMasked_modifyMVarMasked mkWeakMVarUnliftIO.MemoizeMemoized runMemoized memoizeRef memoizeMVar UnliftIO.STM atomicallyretrySTMcheckSTM newTVarIO readTVarIO registerDelay mkWeakTVar newTMVarIOnewEmptyTMVarIO mkWeakTMVar newTChanIOnewBroadcastTChanIO newTQueueIO newTBQueueIOUnliftIO.TemporarywithSystemTempFilewithSystemTempDirectory withTempFilewithTempDirectoryUnliftIO.TimeouttimeoutwrappedWithRunInIOtoIO withUnliftIO askRunInIOunliftIOUnliftIO stm-2.5.0.0Control.Concurrent.STM.TBQueueTBQueue newTBQueue writeTBQueue readTBQueuetryReadTBQueue peekTBQueuetryPeekTBQueue unGetTBQueueisEmptyTBQueue isFullTBQueueControl.Concurrent.STM.TChanTChannewTChannewBroadcastTChan writeTChan readTChan tryReadTChan peekTChan tryPeekTChandupTChan unGetTChan isEmptyTChan cloneTChanControl.Concurrent.STM.TMVarTMVarnewTMVar newEmptyTMVar takeTMVar tryTakeTMVarputTMVar tryPutTMVar readTMVar tryReadTMVar swapTMVar isEmptyTMVarControl.Concurrent.STM.TQueueTQueue newTQueue writeTQueue readTQueue tryReadTQueue peekTQueue tryPeekTQueue unGetTQueue isEmptyTQueueControl.Concurrent.STM.TVar modifyTVar modifyTVar'swapTVar"rio-0.1.9.2-1bw5TQJRYtd6pPsP5v63SvRIO.Prelude.TracetraceDisplayStacktraceDisplayMarkerIOtraceDisplayMarkertraceDisplayEventIOtraceDisplayEvent traceDisplayMtraceDisplayIOtraceDisplayId traceDisplaytraceShowStacktraceShowMarkerIOtraceShowMarkertraceShowEventIOtraceShowEvent traceShowM traceShowIO traceShowId traceShow traceStack traceMarkerIO traceMarker traceEventIO traceEventtraceMtraceIOtraceIdtraceRIO.Prelude.Simple runSimpleApp SimpleAppRIO.Prelude.RIOnewUnboxedSomeRef newSomeRef modifySomeRef writeSomeRef readSomeRefliftRIOrunRIOunRIORIOSomeRef stateRefL HasStateRef writeRefL HasWriteRefRIO.Prelude.URef modifyURef writeURefreadURefnewURefURefIOURef RIO.Deque freezeDeque dequeToVector dequeToList foldrDeque foldlDeque pushBackDequepushFrontDeque popBackDeque popFrontDeque getDequeSizenewDequeasBDequeasSDequeasUDequeDequeUDequeSDequeBDequeRIO.Prelude.IO readFileUtf8writeFileBinaryreadFileBinary hPutBuilder writeFileUtf8 withLazyFileRIO.Prelude.Logger noLogginglogFuncUseColorLdisplayCallStack setLogUseLocsetLogUseColor setLogUseTimesetLogTerminalsetLogVerboseFormatIOsetLogVerboseFormatsetLogMinLevelIOsetLogMinLevel withLogFunc newLogFunclogOptionsHandlelogOptionsMemory logStickyDone logSticky logOtherS logErrorSlogWarnSlogInfoS logDebugSlogOtherlogErrorlogWarnlogInfologDebug logGeneric mkLogFunc LevelOther LevelError LevelWarn LevelInfo LevelDebugLogLevel LogSourcelogFuncL HasLogFuncLogFunc LogOptionsRIO.Prelude.TextdecodeUtf8LenienttshowRIO.Prelude.Renames yieldThreadfromStrictBytes toStrictBytessappendUVectorSVectorGVector LByteStringLTextRIO.Prelude.LensviewRIO.Prelude.ExtraasIOunlessMwhenMnubOrdfoldMapM forMaybeM mapMaybeM forMaybeA mapMaybeA fromFirstmapLeftRIO.Prelude.ExitexitWith exitSuccess exitFailureRIO.Prelude.DisplaywriteFileUtf8Builderutf8BuilderToLazyTextutf8BuilderToTextdisplayBytesUtf8 displayShowgetUtf8Builder Utf8Builder textDisplaydisplayDisplay&vector-0.12.0.2-H1Eu1OCXL0L9y980iV8EwU Data.VectorVectorData.Vector.Unboxed.BaseUnboxData.HashSet.BaseHashSetUnliftIO.Concurrent myThreadId threadDelaythreadWaitReadthreadWaitWriteisCurrentThreadBoundData.Text.Encoding.ErrorUnicodeException DecodeError EncodeError lenientDecodeData.Text.EncodingdecodeUtf8With decodeUtf8'encodeUtf8Builder encodeUtf8$store-0.5.0.1-7tAjQLPaGvA7Iiurymd0abData.Store.ImplStore setUserAgenthttpJSONhttpLbshttpLBS httpNoBodyhttpSink withResponsewithResponseByManagertoFilePathNoTrailingSepparseCollapsedAbsDirparseCollapsedAbsFileconcatAndColapseAbsDirdropRootrejectMissingFilerejectMissingDirpathToLazyByteStringpathToByteString pathToTexttryGetModificationTimeversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNamewithSourceFile withSinkFilewithSinkFileCautiouswithSystemTempDirwithKeepSystemTempDirsinkProcessStderrStdoutsinkProcessStdoutlogProcessStderrStdoutreadProcessNullwithProcessContextstripCRhIsTerminalDeviceOrMinTTYpromptpromptPassword promptBoolGlobalOptsContextOuterGlobalOptsOtherCmdGlobalOptsBuildCmdGlobalOptsGhciCmdGlobalOptshideMods$fShowGlobalOptsContext$fEqGlobalOptsContextlogLevelOptsParser GhciScriptcmdAddcmdCdGhc cmdModulescriptToLazyByteStringscriptToBuilder scriptToFile$fMonoidGhciScript$fSemigroupGhciScript$fShowGhciCommand fileWatch fileWatchPoll findFileUp findDirUp findFiles findInParentscomplicatedOptions addCommandaddSubCommandscomplicatedParserPathCompleterOpts pcoAbsolute pcoRelative pcoRootDir pcoFileFilter pcoDirFilter boolFlagsboolFlagsNoDefaultmaybeBoolFlagsfirstBoolFlagsenableDisableFlagsenableDisableFlagsNoDefaultextraHelpOption execExtraHelp textOption textArgument optionalFirst absFileOption relFileOption absDirOption relDirOption eitherReader'defaultPathCompleterOpts fileCompleterfileExtCompleter dirCompleterpathCompleterWithunescapeBashArgsolverOptsParserversionedEncodeFileversionedDecodeOrLoadversionedDecodeFilestoreVersionConfig MonoidMap$fMonoidMonoidMap$fSemigroupMonoidMap $fEqMonoidMap$fOrdMonoidMap$fReadMonoidMap$fShowMonoidMap$fGenericMonoidMap$fFunctorMonoidMaprunOnce appending alternatingpured concating EscapingModeEscaping NoEscaping parseArgsparseArgsFromString argsParser$fShowEscapingMode$fEqEscapingMode$fEnumEscapingMode argsArgument argsOption cmdOption JSONWarningJSONUnrecognizedFieldsJSONGeneralWarningWithJSONWarnings WarningParser.:.:?..:..:?..!= tellJSONFieldwithObjectWarningsunWarningParserlogJSONWarningsjsonSubWarningsjsonSubWarningsTjsonSubWarningsTTnoJSONWarnings$fIsStringJSONWarning$fShowJSONWarning$fMonoidWithJSONWarnings$fSemigroupWithJSONWarnings$fFunctorWithJSONWarnings$fIsStringWarningParserMonoid$fMonoidWarningParserMonoid$fSemigroupWarningParserMonoid$fEqJSONWarning$fEqWithJSONWarnings$fGenericWithJSONWarnings$fShowWithJSONWarnings$fGenericWarningParserMonoid StaticBytes DynamicBytesStaticBytesExceptionNotEnoughBytes TooManyBytesBytes128Bytes64Bytes32Bytes16Bytes8 toStaticExact toStaticPadtoStaticTruncatetoStaticPadTruncate fromStatic$fByteArrayAccessBytes8$fByteArrayAccessBytes16$fByteArrayAccessBytes32$fByteArrayAccessBytes64$fByteArrayAccessBytes128$fExceptionStaticBytesException$fDynamicBytesVector$fDynamicBytesVector0$fDynamicBytesVector1$fDynamicBytesByteString $fShowBytes8$fStaticBytesBytes128$fStaticBytesBytes64$fStaticBytesBytes32$fStaticBytesBytes16$fStaticBytesBytes8 $fEqBytes8 $fOrdBytes8$fGenericBytes8$fNFDataBytes8$fHashableBytes8 $fDataBytes8 $fStoreBytes8 $fShowBytes16 $fEqBytes16 $fOrdBytes16$fGenericBytes16$fNFDataBytes16$fHashableBytes16 $fDataBytes16$fStoreBytes16 $fShowBytes32 $fEqBytes32 $fOrdBytes32$fGenericBytes32$fNFDataBytes32$fHashableBytes32 $fDataBytes32$fStoreBytes32 $fShowBytes64 $fEqBytes64 $fOrdBytes64$fGenericBytes64$fNFDataBytes64$fHashableBytes64 $fDataBytes64$fStoreBytes64$fShowBytes128 $fEqBytes128 $fOrdBytes128$fGenericBytes128$fNFDataBytes128$fHashableBytes128$fDataBytes128$fStoreBytes128$fShowStaticBytesException$fEqStaticBytesException CompilerBuildCompilerBuildStandardCompilerBuildSpecializedcompilerBuildNamecompilerBuildSuffixparseCompilerBuild$fFromJSONCompilerBuild$fShowCompilerBuildghcBuildParserFlagNameFlagNameParseFailflagNameParser mkFlagName parseFlagNameparseFlagNameFromStringflagNameString flagNameTextfromCabalFlagNametoCabalFlagName$fShowFlagNameParseFail$fExceptionFlagNameParseFail$fFromJSONKeyFlagName$fFromJSONFlagName$fShowFlagName$fLiftFlagName $fOrdFlagName $fEqFlagName$fDataFlagName$fGenericFlagName$fHashableFlagName$fStoreFlagName$fNFDataFlagName$fToJSONKeyFlagNameGhcPkgId parseGhcPkgIdghcPkgIdParserghcPkgIdString$fExceptionGhcPkgIdParseFail$fShowGhcPkgIdParseFail$fToJSONGhcPkgId$fFromJSONGhcPkgId$fShowGhcPkgId$fStoreGhcPkgId$fNFDataGhcPkgId$fHashableGhcPkgId $fEqGhcPkgId $fOrdGhcPkgId$fDataGhcPkgId$fGenericGhcPkgIdImageOptsMonoidimgMonoidDockersImageDockerOpts imgDockerBaseimgDockerEntrypoints imgDockerAddimgDockerImageNameimgDockerExecutables ImageOpts imgDockers imgArgNameimgDockerOldArgNameimgDockersArgNameimgDockerBaseArgNameimgDockerAddArgNameimgDockerEntrypointsArgNameimgDockerImageNameArgNameimgDockerExecutablesArgName$fFromJSONWithJSONWarnings$fMonoidImageOptsMonoid$fSemigroupImageOptsMonoid$fFromJSONWithJSONWarnings0$fShowImageDockerOpts$fShowImageOpts$fShowImageOptsMonoid$fGenericImageOptsMonoid NixOptsMonoidnixMonoidEnablenixMonoidPureShellnixMonoidPackagesnixMonoidInitFilenixMonoidShellOptions nixMonoidPathnixMonoidAddGCRootsNixOpts nixEnable nixPureShell nixPackages nixInitFilenixShellOptions nixAddGCRootsnixEnableArgNamenixPureShellArgNamenixPackagesArgNamenixInitFileArgNamenixShellOptsArgNamenixPathArgNamenixAddGCRootsArgName$fMonoidNixOptsMonoid$fSemigroupNixOptsMonoid $fShowNixOpts$fEqNixOptsMonoid$fShowNixOptsMonoid$fGenericNixOptsMonoid PackageNamePackageNameParseFailCabalFileNameParseFailCabalFileNameInvalidPackageNamepackageNameParser mkPackageNameparsePackageNameparsePackageNameFromStringpackageNameStringpackageNameTextfromCabalPackageNametoCabalPackageNameparsePackageNameFromFilePathpackageNameArgument$fShowPackageNameParseFail$fExceptionPackageNameParseFail$fFromJSONKeyPackageName$fFromJSONPackageName$fDisplayPackageName$fShowPackageName$fLiftPackageName$fEqPackageName$fOrdPackageName$fDataPackageName$fGenericPackageName$fHashablePackageName$fNFDataPackageName$fStorePackageName$fToJSONPackageName$fToJSONKeyPackageNameNamedComponentCLib CInternalLibCExeCTestCBenchrenderComponentrenderPkgComponentsrenderPkgComponent exeComponentstestComponentsbenchComponentsinternalLibComponentsisCLibisCInternalLibisCExeisCTestisCBench$fShowNamedComponent$fEqNamedComponent$fOrdNamedComponent FileWatchOpts NoFileWatch FileWatch FileWatchPollBenchmarkOptsMonoidbeoMonoidAdditionalArgsbeoMonoidDisableRun BenchmarkOptsbeoAdditionalArgs beoDisableRunHaddockOptsMonoidhoMonoidAdditionalArgs HaddockOptshoAdditionalArgsTestOptsMonoidtoMonoidRerunTeststoMonoidAdditionalArgstoMonoidCoveragetoMonoidDisableRunTestOpts toRerunTeststoAdditionalArgs toCoverage toDisableRun BuildSubsetBSAllBSOnlySnapshotBSOnlyDependenciesBuildOptsMonoidbuildMonoidTracebuildMonoidProfilebuildMonoidNoStripbuildMonoidLibProfilebuildMonoidExeProfilebuildMonoidLibStripbuildMonoidExeStripbuildMonoidHaddockbuildMonoidHaddockOptsbuildMonoidOpenHaddocksbuildMonoidHaddockDepsbuildMonoidHaddockInternal!buildMonoidHaddockHyperlinkSourcebuildMonoidInstallExesbuildMonoidInstallCompilerToolbuildMonoidPreFetchbuildMonoidKeepGoingbuildMonoidKeepTmpFilesbuildMonoidForceDirtybuildMonoidTestsbuildMonoidTestOptsbuildMonoidBenchmarksbuildMonoidBenchmarkOptsbuildMonoidReconfigurebuildMonoidCabalVerbosebuildMonoidSplitObjsbuildMonoidSkipComponentsbuildMonoidInterleavedOutput BuildCommandBuildTestHaddockBenchInstall BuildOptsCLIboptsCLITargetsboptsCLIDryrunboptsCLIGhcOptions boptsCLIFlagsboptsCLIBuildSubsetboptsCLIFileWatch boptsCLIExecboptsCLIOnlyConfigureboptsCLICommandboptsCLIInitialBuildSteps BuildOptsboptsLibProfileboptsExeProfile boptsLibStrip boptsExeStrip boptsHaddockboptsHaddockOptsboptsOpenHaddocksboptsHaddockDepsboptsHaddockInternalboptsHaddockHyperlinkSourceboptsInstallExesboptsInstallCompilerTool boptsPreFetchboptsKeepGoingboptsKeepTmpFilesboptsForceDirty boptsTests boptsTestOptsboptsBenchmarksboptsBenchmarkOptsboptsReconfigureboptsCabalVerboseboptsSplitObjsboptsSkipComponentsboptsInterleavedOutputdefaultBuildOptsdefaultBuildOptsCLIdefaultTestOptsdefaultHaddockOptsdefaultBenchmarkOpts$fMonoidTestOptsMonoid$fSemigroupTestOptsMonoid$fMonoidHaddockOptsMonoid$fSemigroupHaddockOptsMonoid$fMonoidBenchmarkOptsMonoid$fSemigroupBenchmarkOptsMonoid$fFromJSONWithJSONWarnings1$fMonoidBuildOptsMonoid$fSemigroupBuildOptsMonoid$fFromJSONWithJSONWarnings2$fEqBuildCommand$fShowBuildCommand$fShowBuildSubset$fEqBuildSubset $fEqTestOpts$fShowTestOpts$fShowTestOptsMonoid$fGenericTestOptsMonoid$fEqHaddockOpts$fShowHaddockOpts$fShowHaddockOptsMonoid$fGenericHaddockOptsMonoid$fEqBenchmarkOpts$fShowBenchmarkOpts$fShowBuildOpts$fShowBenchmarkOptsMonoid$fGenericBenchmarkOptsMonoid$fShowBuildOptsMonoid$fGenericBuildOptsMonoid$fShowFileWatchOpts$fEqFileWatchOpts$fShowBuildOptsCLIreadFlag SigExceptionGPGFingerprintExceptionGPGNotFoundExceptionGPGSignExceptionGPGVerifyExceptionSigInvalidSDistTarBallSigNoProjectRootExceptionSigServiceException Fingerprint Signature mkFingerprint$fShowSignature$fIsStringFingerprint$fToJSONFingerprint$fFromJSONFingerprint$fShowFingerprint$fFromJSONAeson$fShowSigException$fExceptionSigException$fOrdSignature $fEqSignature$fEqFingerprint$fOrdFingerprint $fOrdAeson $fEqAesongpgSign gpgVerify RepoServiceGithubGitlab BitbucketRepoTemplatePath rtpServicertpUser rtpTemplate TemplatePathAbsPathRelPathUrlPathRepoPath TemplateNametemplateNameArgumenttemplateParamArgumentparseTemplateNameFromStringmkTemplateName templateName templatePathparseRepoPathWithService$fFromJSONTemplateName$fEqRepoService$fOrdRepoService$fShowRepoService$fEqRepoTemplatePath$fOrdRepoTemplatePath$fShowRepoTemplatePath$fEqTemplatePath$fOrdTemplatePath$fShowTemplatePath$fOrdTemplateName$fEqTemplateName$fShowTemplateName UrlsMonoidurlsMonoidLatestSnapshoturlsMonoidLtsBuildPlansurlsMonoidNightlyBuildPlansUrlsurlsLatestSnapshoturlsLtsBuildPlansurlsNightlyBuildPlans$fMonoidUrlsMonoid$fSemigroupUrlsMonoid $fShowUrls$fShowUrlsMonoid$fGenericUrlsMonoidurlsFromMonoid VersionCheck MatchMinor MatchExact NewerMinorIntersectingVersionRangegetIntersectingVersionRangeVersion UpgradeToSpecificLatest versionParser parseVersionparseVersionFromString versionString versionTexttoCabalVersionfromCabalVersion mkVersionversionRangeText withinRangeintersectVersionRangestoMajorVersionlatestApplicableVersionnextMajorVersion checkVersion minorVersion stackVersionstackMinorVersion$fShowVersionParseFail$fExceptionVersionParseFail$fFromJSONKeyVersion$fFromJSONVersion$fToJSONVersion$fDisplayVersion $fShowVersion $fLiftVersion$fHashableVersion $fMonoidIntersectingVersionRange#$fSemigroupIntersectingVersionRange$fFromJSONVersionCheck$fToJSONVersionCheck $fEqVersion $fOrdVersion $fDataVersion$fGenericVersion$fStoreVersion$fNFDataVersion$fShowUpgradeTo$fShowIntersectingVersionRange$fShowVersionCheck$fEqVersionCheck$fOrdVersionCheck CabalFileInfo CFILatestCFIHash CFIRevision StaticSHA256 CabalHashPackageIdentifierRevisionpirIdent pirRevisionPackageIdentifierpackageIdentifierNamepackageIdentifierVersionmkStaticSHA256FromTextmkStaticSHA256FromFilemkStaticSHA256FromDigeststaticSHA256ToTextstaticSHA256ToBase16staticSHA256ToRawmkCabalHashFromSHA256computeCabalHash showCabalHashtoTuple fromTuplepackageIdentifierParserparsePackageIdentifier parsePackageIdentifierFromStringparsePackageIdentifierRevisionpackageIdentifierStringpackageIdentifierRevisionStringpackageIdentifierTexttoCabalPackageIdentifierfromCabalPackageIdentifier%$fExceptionPackageIdentifierParseFail $fShowPackageIdentifierParseFail$fFromJSONPackageIdentifier$fToJSONPackageIdentifier$fDisplayPackageIdentifier$fShowPackageIdentifier$fStorePackageIdentifier$fHashablePackageIdentifier$fNFDataPackageIdentifier$fHashableCabalFileInfo$fNFDataCabalFileInfo$fStoreCabalFileInfo#$fFromJSONPackageIdentifierRevision!$fToJSONPackageIdentifierRevision$fShowPackageIdentifierRevision $fStorePackageIdentifierRevision#$fHashablePackageIdentifierRevision!$fNFDataPackageIdentifierRevision$fEqPackageIdentifier$fOrdPackageIdentifier$fGenericPackageIdentifier$fDataPackageIdentifier$fGenericStaticSHA256$fShowStaticSHA256$fEqStaticSHA256$fNFDataStaticSHA256$fDataStaticSHA256$fOrdStaticSHA256$fHashableStaticSHA256$fStoreStaticSHA256$fGenericCabalHash$fShowCabalHash $fEqCabalHash$fNFDataCabalHash$fDataCabalHash$fOrdCabalHash$fStoreCabalHash$fHashableCabalHash$fGenericCabalFileInfo$fShowCabalFileInfo$fEqCabalFileInfo$fOrdCabalFileInfo$fDataCabalFileInfo$fEqPackageIdentifierRevision$fOrdPackageIdentifierRevision"$fGenericPackageIdentifierRevision$fDataPackageIdentifierRevision indexName indexLocation indexTypeindexDownloadPrefixindexRequireHashesHackageSecurityhsKeyIdshsKeyThreshold IndexTypeITHackageSecurity ITVanilla IndexName unIndexNameHSPackageDownloadunHSPackageDownloadPackageDownloadpdSHA256pdUrlpdSize OffsetSize PackageCache indexNameText$fNFDataOffsetSize$fStoreOffsetSize$fFromJSONPackageDownload$fNFDataPackageDownload$fStorePackageDownload$fMonoidPackageCache$fSemigroupPackageCache$fFromJSONHSPackageDownload$fFromJSONIndexName$fToJSONIndexName$fFromJSONHackageSecurity$fGenericOffsetSize$fEqOffsetSize$fShowOffsetSize$fDataOffsetSize$fShowPackageDownload$fGenericPackageDownload$fEqPackageDownload$fDataPackageDownload$fGenericPackageCache$fEqPackageCache$fShowPackageCache$fDataPackageCache$fStorePackageCache$fNFDataPackageCache$fShowIndexName $fEqIndexName$fOrdIndexName$fHashableIndexName$fStoreIndexName$fShowHackageSecurity$fEqHackageSecurity$fOrdHackageSecurity$fShowIndexType $fEqIndexType$fOrdIndexType$fShowPackageIndexInstalledCacheEntryinstalledCacheProfilinginstalledCacheHaddockinstalledCacheSymbolsinstalledCacheIdentInstalledCacheInnerInstalledCacheinstalledCacheVC$fStoreInstalledCacheEntry$fEqInstalledCacheEntry$fGenericInstalledCacheEntry$fShowInstalledCacheEntry$fDataInstalledCacheEntry$fStoreInstalledCacheInner$fGenericInstalledCacheInner$fEqInstalledCacheInner$fShowInstalledCacheInner$fDataInstalledCacheInner ActionContext acRemaining acDownstream acConcurrency ConcurrencyConcurrencyAllowedConcurrencyDisallowedActionactionId actionDepsactionDoactionConcurrencyActionId ActionTypeATBuild ATBuildFinal ATRunTestsATRunBenchmarks runActions$fShowExecuteException$fExceptionExecuteException$fShowActionType$fEqActionType$fOrdActionType$fShowActionId $fEqActionId $fOrdActionId$fEqConcurrencyCompilerVersion GhcVersion GhcjsVersionCVTypeCVWantedCVActual WhichCompilerGhcGhcjsactualToWantedwantedToActualparseCompilerVersioncompilerVersionTextcompilerVersionString whichCompilerisWantedCompiler getGhcVersioncompilerExeNamehaddockExeName$fFromJSONKeyCompilerVersion$fFromJSONCompilerVersion$fToJSONCompilerVersion$fDisplayCompilerVersion$fNFDataCompilerVersion$fStoreCompilerVersion$fShowWhichCompiler$fEqWhichCompiler$fOrdWhichCompiler$fGenericCompilerVersion$fShowCompilerVersion$fEqCompilerVersion$fOrdCompilerVersion$fDataCompilerVersion SnapshotHash SnapshotssnapshotsNightly snapshotsLtsSnapNameLTSNightlyAbstractResolverARLatestNightly ARLatestLTSARLatestLTSMajor ARResolverARGlobal ResolverWithResolverStackageResolverCompilerResolverCustomResolverLoadedResolverIsLoadedLoaded NotLoadedresolverRawNameparseCustomLocationparseResolverTextreadAbstractResolverrenderSnapName parseSnapNametrimmedSnapshotHashsnapshotHashToBSsnapshotHashFromBSsnapshotHashFromDigest$fDisplaySnapName$fNFDataSnapName$fStoreSnapName$fFromJSONResolverWith$fToJSONResolverWith$fShowBuildPlanTypesException"$fExceptionBuildPlanTypesException$fFromJSONSnapshots$fNFDataSnapshotHash$fStoreSnapshotHash$fNFDataResolverWith$fStoreResolverWith$fGenericSnapName$fShowSnapName$fDataSnapName $fEqSnapName$fGenericResolverWith$fShowResolverWith$fDataResolverWith$fEqResolverWith$fFunctorResolverWith$fFoldableResolverWith$fTraversableResolverWith$fShowAbstractResolver$fShowSnapshots$fGenericSnapshotHash$fShowSnapshotHash$fDataSnapshotHash$fEqSnapshotHashabstractResolverOptsParsercompilerOptsParserreadCompilerVersionhaskellModuleExtsstackProgNameUpper stackProgName stackDotYamlstackWorkEnvVarstackRootEnvVarstackRootOptionNamedeprecatedStackRootOptionNameinContainerEnvVarinNixShellEnvVarwiredInPackagesghcjsBootPackagescabalPackageName"implicitGlobalProjectDirDeprecatedimplicitGlobalProjectDirdefaultUserConfigPathDeprecateddefaultUserConfigPath!defaultGlobalConfigPathDeprecateddefaultGlobalConfigPath buildPlanDirbuildPlanCacheDirplatformVariantEnvVarcompilerOptionsCabalFlagghcColorForceFlagminTerminalWidthmaxTerminalWidthdefaultTerminalWidth osIsWindowsStackDockerExceptionDockerMustBeEnabledExceptionOnlyOnHostExceptionInspectFailedExceptionNotPulledExceptionInvalidCleanupCommandExceptionInvalidImagesOutputExceptionInvalidPSOutputExceptionInvalidInspectOutputExceptionPullFailedExceptionDockerTooOldException DockerVersionProhibitedExceptionBadDockerVersionExceptionInvalidVersionOutputExceptionHostStackTooOldExceptionContainerStackTooOldException#CannotDetermineProjectRootExceptionDockerNotInstalledException(UnsupportedStackExeHostPlatformExceptionDockerStackExeParseExceptionVersionRangeJSONunVersionRangeJSONDockerMonoidRepoOrImageDockerMonoidRepoDockerMonoidImageMountDockerStackExeDockerStackExeDownloadDockerStackExeHostDockerStackExeImageDockerStackExePathDockerOptsMonoiddockerMonoidDefaultEnabledockerMonoidEnabledockerMonoidRepoOrImagedockerMonoidRegistryLogindockerMonoidRegistryUsernamedockerMonoidRegistryPassworddockerMonoidAutoPulldockerMonoidDetachdockerMonoidPersistdockerMonoidContainerNamedockerMonoidRunArgsdockerMonoidMountdockerMonoidEnvdockerMonoidDatabasePathdockerMonoidStackExedockerMonoidSetUser dockerMonoidRequireDockerVersion DockerOpts dockerEnable dockerImagedockerRegistryLogindockerRegistryUsernamedockerRegistryPassworddockerAutoPull dockerDetach dockerPersistdockerContainerName dockerRunArgs dockerMount dockerEnvdockerDatabasePathdockerStackExe dockerSetUserdockerRequireDockerVersionparseDockerStackExedockerEnableArgNamedockerRepoArgNamedockerImageArgNamedockerRegistryLoginArgNamedockerRegistryUsernameArgNamedockerRegistryPasswordArgNamedockerAutoPullArgNamedockerDetachArgNamedockerRunArgsArgNamedockerMountArgNamedockerEnvArgNamedockerContainerNameArgNamedockerPersistArgNamedockerDatabasePathArgNamedockerStackExeArgNamedockerStackExeDownloadValdockerStackExeHostValdockerStackExeImageValdockerSetUserArgName!dockerRequireDockerVersionArgNamedockerEntrypointArgName dockerCmdNamedockerHelpOptNamedockerPullCmdNamedockerCleanupCmdName reExecArgNamedockerContainerPlatform$fFromJSONDockerStackExe$fFromJSONMount $fShowMount $fReadMount$fMonoidDockerOptsMonoid$fSemigroupDockerOptsMonoid$fFromJSONVersionRangeJSON$fShowStackDockerException$fExceptionStackDockerException$fShowDockerStackExe$fShowDockerOpts$fShowDockerMonoidRepoOrImage$fShowDockerOptsMonoid$fGenericDockerOptsMonoidinterpreterArgsParsergetInterpreterArgsVersionIntervalstoVersionRangefromVersionRangewithinIntervalsunionVersionIntervalsintersectVersionIntervals $fNFDataBound $fStoreBound$fNFDataVersionInterval$fStoreVersionInterval$fNFDataVersionIntervals$fStoreVersionIntervals$fGenericBound $fShowBound $fEqBound $fDataBound$fGenericVersionInterval$fShowVersionInterval$fEqVersionInterval$fDataVersionInterval$fGenericVersionIntervals$fShowVersionIntervals$fEqVersionIntervals$fDataVersionIntervals ModuleInfo miModules unModuleNameLoadedPackageInfo lpiVersion lpiLocationlpiFlags lpiGhcOptionslpiPackageDepslpiExposedModuleslpiHideLoadedSnapshotlsCompilerVersion lsGlobals lsPackagesExeName unExeNameReporepoUrl repoCommitrepoType repoSubdirsSubdirsDefaultSubdirsExplicitSubdirsRepoTypeRepoGitRepoHgArchive archiveUrlarchiveSubdirs archiveHashPackageLocationIndexPLIndexPLOtherPackageLocation PLFilePath PLArchivePLRepo SnapshotDefsdParent sdResolversdResolverName sdLocationssdDropPackagessdFlagssdHidden sdGhcOptions sdGlobalHints snapshotDefVC sdRawPathNamesetCompilerVersionloadedSnapshotVCfromCabalModuleName moduleInfoVCsdWantedCompilerVersion$fNFDataArchive$fStoreArchive$fNFDataRepoType$fStoreRepoType$fFromJSONSubdirs$fNFDataSubdirs$fStoreSubdirs $fNFDataRepo $fStoreRepo$fToJSONPackageLocation$fNFDataPackageLocation$fStorePackageLocation$fToJSONPackageLocationIndex$fNFDataPackageLocationIndex$fStorePackageLocationIndex$fNFDataSnapshotDef$fStoreSnapshotDef$fFromJSONGitHubRepo$fNFDataComponent$fStoreComponent$fMonoidDepInfo$fSemigroupDepInfo$fNFDataDepInfo$fStoreDepInfo$fNFDataLoadedPackageInfo$fStoreLoadedPackageInfo$fNFDataLoadedSnapshot$fStoreLoadedSnapshot$fMonoidModuleInfo$fSemigroupModuleInfo$fNFDataModuleInfo$fStoreModuleInfo$fGenericArchive $fShowArchive $fEqArchive $fOrdArchive $fDataArchive$fFunctorArchive$fGenericRepoType$fShowRepoType $fEqRepoType $fOrdRepoType$fDataRepoType$fGenericSubdirs $fShowSubdirs $fEqSubdirs $fDataSubdirs $fGenericRepo $fShowRepo$fEqRepo $fOrdRepo $fDataRepo $fFunctorRepo$fGenericPackageLocation$fShowPackageLocation$fEqPackageLocation$fOrdPackageLocation$fDataPackageLocation$fFunctorPackageLocation$fGenericPackageLocationIndex$fShowPackageLocationIndex$fEqPackageLocationIndex$fOrdPackageLocationIndex$fDataPackageLocationIndex$fFunctorPackageLocationIndex$fShowSnapshotDef$fEqSnapshotDef$fDataSnapshotDef$fGenericSnapshotDef $fShowExeName $fEqExeName $fOrdExeName$fHashableExeName$fIsStringExeName$fGenericExeName$fStoreExeName$fNFDataExeName $fDataExeName$fGenericComponent$fShowComponent $fEqComponent$fOrdComponent$fDataComponent$fEnumComponent$fBoundedComponent$fGenericDepInfo $fShowDepInfo $fEqDepInfo $fDataDepInfo$fShowModuleName$fEqModuleName$fOrdModuleName$fGenericModuleName$fStoreModuleName$fNFDataModuleName$fDataModuleName$fGenericLoadedPackageInfo$fShowLoadedPackageInfo$fEqLoadedPackageInfo$fDataLoadedPackageInfo$fFunctorLoadedPackageInfo$fGenericLoadedSnapshot$fShowLoadedSnapshot$fDataLoadedSnapshot$fEqLoadedSnapshot$fShowModuleInfo$fEqModuleInfo$fOrdModuleInfo$fGenericModuleInfo$fDataModuleInfoEditorExceptionEditorNotFoundEditorExitFailurePagerException PagerNotFoundPagerExitFailure pageWriterpageByteStringpageText pageBuilderpageFile pageStringeditFileeditReaderWritereditByteString editString$fExceptionPagerException$fShowPagerException$fExceptionEditorException$fShowEditorExceptiongetTerminalWidth$fStorableWindowWidth$fEqWindowWidth$fOrdWindowWidth$fShowWindowWidth ColorWhen ColorNever ColorAlways ColorAuto HasRunnerrunnerLRunner runnerReExecrunnerTerminalrunnerUseColor runnerLogFuncrunnerTermWidthrunnerProcessContextrunnerParsedCabalFiles terminalL useColorLreExecL withRunner$fHasLogFuncRunner$fHasProcessContextRunner$fHasRunnerRunner $fEqColorWhen$fShowColorWhen$fGenericColorWhendefaultColorWhenStackNixException)NixCannotUseShellFileAndPackagesExceptionnixOptsFromMonoid nixCompiler$fShowStackNixException$fExceptionStackNixException HasAnsiAnn getAnsiAnn toAnsiDocAnsiAnnAnsiDocAnn displayPlain renderDefault displayAnsi hDisplayAnsiblack dullblackonblack ondullblackreddullredonred ondullredgreen dullgreenongreen ondullgreenyellow dullyellowonyellow ondullyellowbluedullblueonblue ondullbluemagenta dullmagenta onmagenta ondullmagentacyandullcyanoncyan ondullcyanwhite dullwhiteonwhite ondullwhiteboldfaintnormal $fMonoidDoc$fSemigroupDoc $fDisplayDoc$fHasAnsiAnn()$fHasAnsiAnnAnsiAnn $fEqAnsiAnn $fShowAnsiAnn$fSemigroupAnsiAnn$fMonoidAnsiAnn $fEqSGRTag $fOrdSGRTagdisplayWithColor prettyDebug prettyInfo prettyNote prettyWarn prettyErrorprettyWarnNoIndentprettyErrorNoIndent prettyDebugL prettyInfoL prettyNoteL prettyWarnL prettyErrorLprettyWarnNoIndentLprettyErrorNoIndentL prettyDebugS prettyInfoS prettyNoteS prettyWarnS prettyErrorSprettyWarnNoIndentSprettyErrorNoIndentSindentAfterLabelwordDocsflow debugBracket styleError styleWarning styleGood styleShell styleFilestyleUrlstyleDirstyleRecommendation styleCurrent styleTarget styleModuledisplayMilliseconds bulletedListspacedBulletedList$fDisplayModuleName $fDisplay(,) $fDisplayPath$fDisplayPath0VerifiedDownloadExceptionWrongContentLengthWrongStreamLength WrongDigest LengthCheckCheckHexDigestCheckHexDigestStringCheckHexDigestByteStringCheckHexDigestHeader HashCheckhashCheckAlgorithmhashCheckHexDigestDownloadRequest drRequest drHashChecks drLengthCheck drRetryPolicydrRetryPolicyDefaultrecoveringHttpverifiedDownload$fIsStringCheckHexDigest$$fExceptionVerifiedDownloadException$fShowVerifiedDownloadException$fExceptionVerifyFileException$fShowCheckHexDigest$fShowVerifyFileException$fShowHashCheckDownloadExceptionRedownloadInvalidResponseRedownloadHttpErrordownload redownloadsetGithubHeaders$fExceptionDownloadException$fShowDownloadException CabalLoaderclCache clIndices clStackRoot clUpdateRefclConnectionCountclIgnoreRevisionMismatchHasCabalLoader cabalLoaderLupdateAllIndicesgetPackageVersionslookupPackageVersionsgetPackageCachesconfigPackageIndexRootconfigPackageIndex$fShowPackageIndexException $fExceptionPackageIndexException HasEnvConfig envConfigLHasBuildConfig buildConfigL HasConfigconfigL HasGHCVariant ghcVariantL HasPlatform platformLplatformVariantL DockerUserduUidduGidduGroupsduUmaskDockerEntrypointdeUser PvpBoundspbType pbAsRevision PvpBoundsType PvpBoundsNonePvpBoundsUpperPvpBoundsLower PvpBoundsBothSetupInfoLocationSetupInfoFileOrURLSetupInfoInline SetupInfo siSevenzExe siSevenzDllsiMsys2siGHCssiGHCJSssiStackGHCDownloadInfogdiConfigureOptsgdiConfigureEnvgdiDownloadInfoVersionedDownloadInfo vdiVersionvdiDownloadInfo DownloadInfodownloadInfoUrldownloadInfoContentLengthdownloadInfoSha1downloadInfoSha256 GHCVariant GHCStandardGHCIntegerSimple GHCCustomPlatformVariantPlatformVariantNoneSCMGitProjectAndConfigMonoidGlobalInfoSourceGISSnapshotHints GISCompilerWhichSolverCmd IsInitCmd IsSolverCmdIsNewCmdConfigExceptionParseConfigFileExceptionParseCustomSnapshotExceptionNoProjectConfigFoundUnexpectedArchiveContentsUnableToExtractArchiveBadStackVersionExceptionNoMatchingSnapshotResolverMismatchResolverPartialNoSuchDirectoryParseGHCVariantException BadStackRoot3Won'tCreateStackRootInDirectoryOwnedByDifferentUserUserDoesn'tOwnDirectoryFailedToCloneRepo4ManualGHCVariantSettingsAreIncompatibleWithSystemGHCNixRequiresSystemGhc NoResolverWhenUsingNoLocalConfigInvalidResolverForNoLocalConfigDuplicateLocalPackageNames ConfigMonoidconfigMonoidStackRootconfigMonoidWorkDirconfigMonoidBuildOptsconfigMonoidDockerOptsconfigMonoidNixOptsconfigMonoidConnectionCountconfigMonoidHideTHLoadingconfigMonoidLatestSnapshotUrlconfigMonoidUrlsconfigMonoidPackageIndicesconfigMonoidSystemGHCconfigMonoidInstallGHCconfigMonoidSkipGHCCheckconfigMonoidSkipMsysconfigMonoidCompilerCheckconfigMonoidRequireStackVersionconfigMonoidArchconfigMonoidGHCVariantconfigMonoidGHCBuildconfigMonoidJobsconfigMonoidExtraIncludeDirsconfigMonoidExtraLibDirsconfigMonoidOverrideGccPathconfigMonoidOverrideHpackconfigMonoidConcurrentTestsconfigMonoidLocalBinPathconfigMonoidImageOptsconfigMonoidTemplateParametersconfigMonoidScmInitconfigMonoidGhcOptionsByNameconfigMonoidGhcOptionsByCatconfigMonoidExtraPathconfigMonoidSetupInfoLocationsconfigMonoidLocalProgramsBaseconfigMonoidPvpBoundsconfigMonoidModifyCodePageconfigMonoidExplicitSetupDepsconfigMonoidRebuildGhcOptionsconfigMonoidApplyGhcOptionsconfigMonoidAllowNewerconfigMonoidDefaultTemplateconfigMonoidAllowDifferentUserconfigMonoidDumpLogsconfigMonoidSaveHackageCredsconfigMonoidHackageBaseUrl"configMonoidIgnoreRevisionMismatchProjectprojectUserMsgprojectPackagesprojectDependencies projectFlagsprojectResolverprojectCompilerprojectExtraPackageDBs LoadConfiglcConfiglcLoadBuildConfig lcProjectRootLocalPackageView lpvCabalFPlpvGPDlpvLoc LocalPackages lpProjectlpDependencies EnvConfigenvConfigBuildConfigenvConfigCabalVersionenvConfigCompilerVersionenvConfigCompilerBuildenvConfigPackagesRefenvConfigLoadedSnapshot BuildConfigbcConfig bcSnapshotDef bcGHCVariant bcPackagesbcDependenciesbcExtraPackageDBs bcStackYamlbcFlagsbcImplicitGlobalGlobalOptsMonoidglobalMonoidReExecVersionglobalMonoidDockerEntrypointglobalMonoidLogLevelglobalMonoidTimeInLogglobalMonoidConfigMonoidglobalMonoidResolverglobalMonoidCompilerglobalMonoidTerminalglobalMonoidColorWhenglobalMonoidTermWidthglobalMonoidStackYaml StackYamlLoc SYLDefault SYLOverride SYLNoConfig GlobalOptsglobalReExecVersionglobalDockerEntrypointglobalLogLevelglobalTimeInLogglobalConfigMonoidglobalResolverglobalCompilerglobalTerminalglobalColorWhenglobalTermWidthglobalStackYamlEvalOptsevalArg evalExtra ExecOptsExtra ExecOptsPlainExecOptsEmbellished eoEnvSettings eoPackages eoRtsOptionseoCwdSpecialExecCmdExecCmdExecRunExecGhc ExecRunGhcExecOptseoCmdeoArgseoExtra EnvSettingsesIncludeLocalsesIncludeGhcPackagePath esStackExe esLocaleUtf8 esKeepGhcRtsDumpLogs DumpNoLogsDumpWarningLogs DumpAllLogsApplyGhcOptions AGOTargets AGOLocals AGOEverythingHpackExecutable HpackBundled HpackCommandConfig configWorkDirconfigUserConfigPath configBuild configDocker configNixconfigProcessContextSettingsconfigLocalProgramsBaseconfigLocalProgramsconfigHideTHLoadingconfigPlatformconfigPlatformVariantconfigGHCVariant0configGHCBuild configUrlsconfigSystemGHCconfigInstallGHCconfigSkipGHCCheckconfigSkipMsysconfigCompilerCheckconfigLocalBinconfigRequireStackVersion configJobsconfigOverrideGccPathconfigOverrideHpackconfigExtraIncludeDirsconfigExtraLibDirsconfigConcurrentTests configImageconfigTemplateParams configScmInitconfigGhcOptionsByNameconfigGhcOptionsByCatconfigSetupInfoLocationsconfigPvpBoundsconfigModifyCodePageconfigExplicitSetupDepsconfigRebuildGhcOptionsconfigApplyGhcOptionsconfigAllowNewerconfigDefaultTemplateconfigAllowDifferentUserconfigDumpLogsconfigMaybeProjectconfigAllowLocalsconfigSaveHackageCredsconfigHackageBaseUrl configRunnerconfigCabalLoaderdefaultLogLevel readColorWhen stackYamlL projectRootLlpvRootlpvName lpvComponents lpvVersionparseConfigMonoidconfigMonoidSystemGHCNameconfigMonoidInstallGHCNameaskLatestSnapshotUrlworkDirLgetProjectWorkDirconfigInstalledCacheplatformOnlyRelDir snapshotsDirinstallationRootDepsinstallationRootLocalbindirCompilerTools hoogleRoothoogleDatabasePathplatformGhcRelDirplatformGhcVerOnlyRelDiruseShaPathOnWindowsshaPathshaPathForBytespackageDatabaseDepspackageDatabaseLocalpackageDatabaseExtraflagCacheLocalconfigLoadedSnapshotCache bindirSuffix docDirSuffix hpcReportDir extraBinDirsminimalEnvSettingsdefaultEnvSettingsplainEnvSettingsgetCompilerPathparseProjectAndConfigMonoidghcVariantNameghcVariantSuffixparseGHCVariantparsePvpBoundsexplicitSetupDeps stackRootLwantedCompilerVersionLactualCompilerVersionL buildOptsLbuildOptsMonoidHaddockLbuildOptsMonoidTestsLbuildOptsMonoidBenchmarksLbuildOptsMonoidInstallExesLbuildOptsInstallExesLbuildOptsHaddockL globalOptsLglobalOptsBuildOptsMonoidL configUrlsL cabalVersionLloadedSnapshotLwhichCompilerLenvOverrideSettingsL globalHintsLshouldForceGhcColorFlagappropriateGhcColorFlag$fFromJSONApplyGhcOptions$fFromJSONDumpLogs$fToJSONProject$fExceptionConfigException$fShowConfigException$fIsPathRelFile$fIsPathAbsFile$fIsPathRelDir$fIsPathAbsDir $fToJSONSCM $fFromJSONSCM$fFromJSONGHCVariant$fMonoidSetupInfo$fSemigroupSetupInfo$fFromJSONWithJSONWarnings3$fFromJSONWithJSONWarnings4$fFromJSONPvpBounds$fToJSONPvpBounds$fMonoidConfigMonoid$fSemigroupConfigMonoid$fHasLogFuncConfig$fHasRunnerConfig$fHasCabalLoaderConfig$fHasProcessContextConfig$fHasLogFuncBuildConfig$fHasLogFuncLoadConfig$fHasLogFuncEnvConfig$fMonoidGlobalOptsMonoid$fSemigroupGlobalOptsMonoid$fFromJSONKeyGhcOptionKey$fFromJSONGhcOptions$fHasRunnerEnvConfig$fHasRunnerBuildConfig$fHasRunnerLoadConfig$fHasEnvConfigEnvConfig$fHasBuildConfigEnvConfig$fHasBuildConfigBuildConfig$fHasConfigEnvConfig$fHasConfigBuildConfig$fHasConfigLoadConfig$fHasConfigConfig$fHasCabalLoaderEnvConfig$fHasCabalLoaderBuildConfig$fHasCabalLoaderLoadConfig$fHasProcessContextEnvConfig$fHasProcessContextBuildConfig$fHasProcessContextLoadConfig$fHasGHCVariantEnvConfig$fHasGHCVariantBuildConfig$fHasGHCVariantGHCVariant$fHasPlatformEnvConfig$fHasPlatformBuildConfig$fHasPlatformLoadConfig$fHasPlatformConfig$fHasPlatform(,)$fShowHpackExecutable$fReadHpackExecutable$fEqHpackExecutable$fOrdHpackExecutable$fShowApplyGhcOptions$fReadApplyGhcOptions$fEqApplyGhcOptions$fOrdApplyGhcOptions$fEnumApplyGhcOptions$fBoundedApplyGhcOptions$fShowDumpLogs$fReadDumpLogs $fEqDumpLogs $fOrdDumpLogs$fEnumDumpLogs$fBoundedDumpLogs$fShowEnvSettings$fEqEnvSettings$fOrdEnvSettings$fShowSpecialExecCmd$fEqSpecialExecCmd$fShowExecOptsExtra$fShowExecOpts$fShowEvalOpts$fShowStackYamlLoc$fFunctorStackYamlLoc$fFoldableStackYamlLoc$fTraversableStackYamlLoc$fShowPackageEntry $fShowProject $fShowSCM$fShowGHCVariant$fShowDownloadInfo$fShowVersionedDownloadInfo$fShowGHCDownloadInfo$fShowSetupInfo$fShowSetupInfoLocation$fShowPvpBoundsType$fReadPvpBoundsType$fEqPvpBoundsType$fOrdPvpBoundsType$fEnumPvpBoundsType$fBoundedPvpBoundsType$fShowPvpBounds$fReadPvpBounds $fEqPvpBounds$fOrdPvpBounds$fShowConfigMonoid$fGenericConfigMonoid$fReadDockerUser$fShowDockerUser$fReadDockerEntrypoint$fShowDockerEntrypoint$fShowGlobalOptsMonoid$fGenericGlobalOptsMonoid$fShowGlobalOpts$fEqGhcOptionKey$fOrdGhcOptionKey HackageCreds loadCreds uploadBytesuploaduploadRevision $fFromJSON->$fToJSONHackageCreds$fShowHackageCreds InstalledLibrary Executable InstalledMap DotCabalPathDotCabalModulePathDotCabalMainPathDotCabalFilePathDotCabalCFilePathDotCabalDescriptorDotCabalModule DotCabalMain DotCabalFile DotCabalCFileModTime FileCacheInfo fciModTimefciSizefciHashInstalledPackageLocation InstalledTo ExtraGlobalInstallLocationSnapLocal LocalPackage lpPackage lpComponents lpUnbuildablelpWanted lpTestDeps lpBenchDeps lpTestBenchlpDir lpCabalFile lpForceDirty lpDirtyFileslpNewBuildCacheslpComponentFiles lpLocation PackageSourcePSFilesPSIndex SourceMap PackageConfigpackageConfigEnableTestspackageConfigEnableBenchmarkspackageConfigFlagspackageConfigGhcOptionspackageConfigCompilerVersionpackageConfigPlatformPackageWarningUnlistedModulesWarningGetPackageFilesgetPackageFiles CabalFileTypeAllFilesModules BuildInfoOptsbioOptsbioOneWordOptsbioPackageFlagsbioCabalMacrosGetPackageOptsgetPackageOptsDepType AsLibrary AsBuildToolDepValuedvVersionRangedvTypePackage packageNamepackageVersionpackageLicense packageFiles packageDepspackageUnknownToolspackageAllDepspackageGhcOptions packageFlagspackageDefaultFlagspackageLibrariespackageInternalLibraries packageTestspackageBenchmarks packageExes packageOptspackageHasExposedModulespackageBuildTypepackageSetupDepsPackageLibraries NoLibraries HasLibrariesPackageExceptionPackageInvalidCabalFilePackageNoCabalFileFoundPackageMultipleCabalFilesFoundMismatchedCabalNameMismatchedCabalIdentifierpackageIdentifierpackageDefinedFlags piiVersion piiLocationpiiPackageLocationlpFiles modTimeVC testSuccessVCdotCabalModule dotCabalMaindotCabalModulePathdotCabalMainPathdotCabalCFilePathdotCabalGetPathinstalledPackageIdentifierinstalledVersion$fShowPackageException$fExceptionPackageException$fSemigroupDepType$fSemigroupDepValue$fMonoidInstallLocation$fSemigroupInstallLocation$fNFDataFileCacheInfo$fStoreFileCacheInfo$fShowGetPackageFiles $fEqPackage $fOrdPackage$fShowGetPackageOpts$fShowPackageLibraries $fShowDepType $fEqDepType$fShowDepValue$fShowBuildInfoOpts$fShowPackageConfig$fShowInstallLocation$fEqInstallLocation$fShowInstalledPackageLocation$fEqInstalledPackageLocation $fOrdModTime $fShowModTime$fGenericModTime $fEqModTime$fNFDataModTime$fStoreModTime $fDataModTime$fGenericFileCacheInfo$fShowFileCacheInfo$fEqFileCacheInfo$fDataFileCacheInfo$fEqDotCabalDescriptor$fOrdDotCabalDescriptor$fShowDotCabalDescriptor$fEqDotCabalPath$fOrdDotCabalPath$fShowDotCabalPath$fShowInstalled $fEqInstalled$fShowPackageSource$fShowLocalPackage $fShowPackagePrecompiledCache pcLibrary pcSubLibspcExes ConfigureOptscoDirscoNoDirsBaseConfigOpts bcoSnapDB bcoLocalDBbcoSnapInstallRootbcoLocalInstallRoot bcoBuildOptsbcoBuildOptsCLI bcoExtraDBsPlan planTasks planFinalsplanUnregisterLocalplanInstallExesTaskTypeTTFilesTTIndexTaskConfigOpts tcoMissingtcoOptsTask taskProvidestaskTypetaskConfigOpts taskPresent taskAllInOnetaskCachePkgSrctaskAnyMissingtaskBuildTypeConfig CachePkgSrcCacheSrcUpstream CacheSrcLocal ConfigCacheconfigCacheOptsconfigCacheDepsconfigCacheComponentsconfigCacheHaddockconfigCachePkgSrc BuildCachebuildCacheTimes UnusedFlags UFNoPackageUFFlagsNotDefined UFSnapshot FlagSource FSCommandLine FSStackYamlStackBuildExceptionCouldn'tFindPkgIdCompilerVersionMismatchCouldn'tParseTargetsUnknownTargetsTestSuiteFailureTestSuiteTypeUnsupportedConstructPlanFailedCabalExitedUnsuccessfullySetupHsBuildFailureExecutionFailureLocalPackageDoesn'tMatchTargetNoSetupHsFoundInvalidFlagSpecificationTargetParseException SolverGiveUpSolverMissingCabalInstallSomeTargetsNotBuildableTestSuiteExeMissingCabalCopyFailedLocalPackagesPresent buildCacheVC toCachePkgSrc configCacheVCttPackageLocation taskIsTarget taskLocation configureOpts isStackOptwantedLocalPackagesmodTimeprecompiledCacheVC$fExceptionStackBuildException$fShowStackBuildException$fStoreBuildCache$fNFDataBuildCache$fNFDataCachePkgSrc$fStoreCachePkgSrc$fNFDataConfigureOpts$fStoreConfigureOpts$fShowTaskConfigOpts$fNFDataConfigCache$fStoreConfigCache$fNFDataPrecompiledCache$fStorePrecompiledCache$fShowFlagSource$fEqFlagSource$fOrdFlagSource$fShowUnusedFlags$fEqUnusedFlags$fOrdUnusedFlags$fShowPkgDepsOracle$fEqPkgDepsOracle$fHashablePkgDepsOracle$fStorePkgDepsOracle$fNFDataPkgDepsOracle$fGenericBuildCache$fEqBuildCache$fShowBuildCache$fDataBuildCache$fGenericCachePkgSrc$fEqCachePkgSrc$fShowCachePkgSrc$fDataCachePkgSrc$fShowTaskType$fShowBaseConfigOpts$fShowConfigureOpts$fEqConfigureOpts$fGenericConfigureOpts$fDataConfigureOpts $fShowTask $fShowPlan$fGenericConfigCache$fEqConfigCache$fShowConfigCache$fDataConfigCache$fShowPrecompiledCache$fEqPrecompiledCache$fGenericPrecompiledCache$fDataPrecompiledCache getGlobalDBcreateDatabase ghcPkgExeNameghcPkgPathEnvVarfindGhcPkgFieldunregisterGhcPkgIdgetCabalPkgVermkGhcPackagePathLine DumpPackage dpGhcPkgIddpPackageIdentdpParentLibIdent dpLicense dpLibDirs dpLibrariesdpHasExposedModulesdpExposedModules dpDependsdpHaddockInterfaces dpHaddockHtml dpProfiling dpHaddock dpSymbols dpIsExposed ghcPkgDumpghcPkgDescribenewInstalledCacheloadInstalledCachesaveInstalledCache pruneDeps sinkMatching addProfiling addHaddock addSymbolsconduitDumpPackage eachSectioneachPair$fShowPackageDumpException$fExceptionPackageDumpException$fShowDumpPackage$fEqDumpPackage ExtraDirsedBins edIncludeedLibTool ToolGhcjs toolStringtoolNameString parseToolText markInstalledunmarkInstalled listInstalledgetCompilerVersion extraDirs installDirtempInstallDir$fMonoidExtraDirs$fSemigroupExtraDirs$fShowExtraDirs$fGenericExtraDirstestOptsParserhaddockOptsParserghcVariantParserbenchOptsParserDockerImageLastUsedDockerImageExeIdDockerImageProjectIdupdateDockerImageLastUsedgetDockerImagesLastUsedpruneDockerImagesLastUsedgetDockerImageExesetDockerImageExe*$fToBackendKeySqlBackendDockerImageProject!$fPersistEntityDockerImageProject#$fPersistFieldSqlDockerImageProject $fPersistFieldDockerImageProject&$fToBackendKeySqlBackendDockerImageExe$fPersistEntityDockerImageExe$fPersistFieldSqlDockerImageExe$fPersistFieldDockerImageExe $fShowUnique $fShowKey $fReadKey$fEqKey$fOrdKey$fPathPieceKey$fToHttpApiDataKey$fFromHttpApiDataKey$fPersistFieldKey$fPersistFieldSqlKey $fToJSONKey $fFromJSONKey $fShowUnique0 $fShowKey0 $fReadKey0$fEqKey0 $fOrdKey0$fPathPieceKey0$fToHttpApiDataKey0$fFromHttpApiDataKey0$fPersistFieldKey0$fPersistFieldSqlKey0 $fToJSONKey0$fFromJSONKey0$fShowDockerImageProject$fShowDockerImageExeobjectInterfaceDirLghciDirLbuildCachesDirtestSuccessFile testBuiltFileconfigCacheFileconfigCabalMod hpcDirFromDirhpcRelativeDirdistDirFromDirworkDirFromDir templatesDirprojectDockerSandboxDirimageStagingDirstageContainerImageArtifactscreateContainerImageFromStage imgCmdNameimgDockerCmdNameimgOptsFromMonoid$fShowStackImageException$fExceptionStackImageExceptionStackDockerConfigExceptionResolverNotSupportedExceptionInvalidDatabasePathExceptiondockerOptsFromMonoid $fShowStackDockerConfigException%$fExceptionStackDockerConfigExceptionbuildOptsFromMonoidhaddockOptsFromMonoidtestOptsFromMonoidbenchmarkOptsFromMonoidopenHaddocksInBrowsershouldHaddockPackageshouldHaddockDepsgenerateLocalHaddockIndexgenerateDepsHaddockIndexgenerateSnapHaddockIndexgetInstalledExesmarkExeInstalledmarkExeNotInstalledtryGetBuildCachetryGetConfigCachetryGetCabalModwriteBuildCachewriteConfigCache writeCabalMod deleteCachestryGetFlagCachewriteFlagCachesetTestSuccessunsetTestSuccesscheckTestSuccesswritePrecompiledCachereadPrecompiledCacheGetInstalledOptsgetInstalledProfilinggetInstalledHaddockgetInstalledSymbols getInstalled $fEqAllowed $fShowAllowed$fShowLoadHelperwarnInstallSearchPathIssues pathParser$fHasBuildConfigPathInfo$fHasProcessContextPathInfo$fHasCabalLoaderPathInfo$fHasConfigPathInfo$fHasRunnerPathInfo$fHasLogFuncPathInfo$fHasPlatformPathInfoNewOptsnewOptsProjectNamenewOptsCreateBarenewOptsTemplatenewOptsNonceParamsnew templatesHelp$fShowNewException$fExceptionNewExceptionResolvedPackagerpIdent rpDownload rpOffsetSizerpIndex fetchPackagesunpackPackagesunpackPackageIdentunpackPackageIdentsresolvePackagesresolvePackagesAllowMissingwithCabalFiles loadFromIndexuntar$fShowFetchException$fExceptionFetchException$fShowResolvedPackagePackageDescriptionPairpdpOrigBuildablepdpModifiedBuildablereadPackageUnresolvedDirgpdPackageIdentifiergpdPackageName gpdVersionreadPackageUnresolvedIndexreadPackageDirreadPackageDescriptionDirreadDotBuildinforesolvePackagepackageFromPackageDescriptionpackageDependenciesresolvePackageDescription buildLogPathcabalFilePackageId$fHasEnvConfigCtx$fHasBuildConfigCtx$fHasProcessContextCtx$fHasCabalLoaderCtx$fHasConfigCtx$fHasRunnerCtx$fHasLogFuncCtx$fHasGHCVariantCtx$fHasPlatformCtxsign signTarBytes signPackageresolveSinglePackageLocationresolveMultiPackageLocationparseSingleCabalFileIndexparseSingleCabalFileparseMultiCabalFilesparseMultiCabalFilesIndex loadResolver loadSnapshotcalculatePackagePromotion$fShowSnapshotException$fExceptionSnapshotExceptionLocalConfigStatus LCSNoProject LCSProject LCSNoConfig MiniConfiggetImplicitGlobalProjectDir getStackYaml getSnapshotsmakeConcreteResolverloadMiniConfigloadConfigMaybeProjectgetLocalPackagescheckOwnershipgetInContainer getInNixShellloadConfigYamlgetProjectConfigpackagesParserdefaultConfigYaml$fHasLogFuncMiniConfig$fHasRunnerMiniConfig$fHasGHCVariantMiniConfig$fHasPlatformMiniConfig$fHasCabalLoaderMiniConfig$fHasProcessContextMiniConfig$fHasConfigMiniConfig$fShowLocalConfigStatus$fFunctorLocalConfigStatus$fFoldableLocalConfigStatus$fTraversableLocalConfigStatusreexecWithOptionalShell nixCmdNamenixHelpOptName nixOptsParser ConfigCmdSetConfigCmdSetResolverConfigCmdSetSystemGhcConfigCmdSetInstallGhc cfgCmdSet cfgCmdName cfgCmdSetNameconfigCmdSetParserStackCleanExceptionNonLocalPackages CleanOpts CleanShallow CleanFullclean$fExceptionStackCleanException$fShowStackCleanExceptioncleanOptsParser PackageTypeProjectPackage DependencyTarget TargetAll TargetComps RawTargetRTPackageComponent RTComponent RTPackageRTPackageIdentifierUnresolvedComponentResolvedComponent NeedTargetsAllowNoTargetsparseRawTarget parseTargets$fShowUnresolvedComponent$fEqUnresolvedComponent$fOrdUnresolvedComponent$fShowRawTarget $fEqRawTarget$fEqPackageType$fShowPackageType listPackages listTargets HpcReportOpts hroptsInputs hroptsAll hroptsDestDirhroptsOpenBrowserdeleteHpcReports updateTixFilegenerateHpcReportgenerateHpcReportForTargetsgenerateHpcUnifiedReportgenerateHpcMarkupIndex$fShowHpcReportOptsBuildPlanCheckBuildPlanCheckOkBuildPlanCheckPartialBuildPlanCheckFailDepError deVersion deNeededBy DepErrorsBuildPlanExceptionUnknownPackagesSnapshotNotFound"NeitherCompilerOrResolverSpecified gpdPackagesgpdPackageDepsremoveSrcPkgDefaultFlagscheckSnapBuildPlanselectBestSnapshot showItems$fShowBuildPlanException$fExceptionBuildPlanException$fShowBuildPlanCheck$fShowDepErrorloadSourceMapFull getLocalFlags getGhcOptionsaddUnlistedToBuildCache constructPlan $fMonoidW $fSemigroupW$fShowPackageInfo$fShowAddDepRes$fShowToolWarning$fEqBadDependency$fOrdBadDependency$fShowBadDependency$fEqConstructPlanException$fOrdConstructPlanException$fShowConstructPlanException $fGenericW $fEqDepsPath $fOrdDepsPath$fShowDepsPath$fOrdVersionRangeExcludeTHLoading KeepTHLoading ExecuteEnvpreFetch printPlanwithExecuteEnv executePlanwithSingleContext$fShowExecutableBuildStatus$fEqExecutableBuildStatus$fOrdExecutableBuildStatusCabalVersionExceptionunCabalVersionExceptionbuildsplitObjsWarningmkBaseConfigOpts loadPackagequeryBuildInfo $fExceptionCabalVersionException$fShowCabalVersionExceptionStackReleaseInfo SetupOptssoptsInstallIfMissingsoptsUseSystemsoptsWantedCompilersoptsCompilerChecksoptsStackYamlsoptsForceReinstallsoptsSanityChecksoptsSkipGhcCheck soptsSkipMsyssoptsUpgradeCabalsoptsResolveMissingGHCsoptsSetupInfoYamlsoptsGHCBindistURLsoptsGHCJSBootOptsdefaultSetupInfoYamlsetupEnvensureCompilerensureDockerStackExegetSystemCompilergetCabalInstallVersionremoveHaskellEnvVarsdownloadStackReleaseInfopreferredPlatformsdownloadStackExegetDownloadVersion$fShowSetupException$fExceptionSetupException$fAlternativeCheckDependency$fApplicativeCheckDependency$fShowSetupOpts$fFunctorCheckDependency UpgradeOpts upgradeOptsupgrade$fShowBinaryOpts$fShowSourceOpts$fShowUpgradeOptsparseCabalOutputLinemergeConstraintssolveResolverSpecgetResolverConstraints findCabalDirscabalPackagesChecksolveExtraDepscheckSnapBuildPlanActual$fEqConstraintTypeInitOpts searchDirs useSolver omitPackagesforceOverwriteincludeSubDirs initProject SetupCmdOptsscoCompilerVersionscoForceReinstallscoUpgradeCabalscoSetupInfoYamlscoGHCBindistURLscoGHCJSBootOptsscoGHCJSBootClean setupParsersetup CleanupActionCleanupInteractiveCleanupImmediate CleanupDryRun CleanupOptsdcAction"dcRemoveKnownImagesLastUsedDaysAgo#dcRemoveUnknownImagesCreatedDaysAgo$dcRemoveDanglingImagesCreatedDaysAgo'dcRemoveStoppedContainersCreatedDaysAgo'dcRemoveRunningContainersCreatedDaysAgoreexecWithOptionalContainerpreventInContainercleanuppullreset entrypoint$fFromJSONImageConfig$fFromJSONInspect$fShowCleanupAction$fShowCleanupOpts$fShowImageConfig $fShowInspectdockerOptsParserdockerCleanupOptsParser SDistOptssdoptsDirsToWorkWithsdoptsPvpBoundssdoptsIgnoreCheck sdoptsSignsdoptsSignServerUrlsdoptsBuildTarball sdoptsTarPathgetSDistTarballcheckSDistTarballcheckSDistTarball'$fShowCheckException$fExceptionCheckExceptionbuildOptsMonoidParserconfigOptsParserglobalOptsParserglobalOptsFromMonoidinitOptsParser newOptsParser GhciExceptionInvalidPackageOptionLoadingDuplicateModulesMissingFileTargetCan'tSpecifyFilesAndTargetsCan'tSpecifyFilesAndMainIsGhciTargetParseException GhciPkgInfo ghciPkgName ghciPkgOpts ghciPkgDirghciPkgModules ghciPkgCFiles ghciPkgMainIsghciPkgTargetFilesghciPkgPackageGhciOpts ghciTargetsghciArgsghciGhcOptions ghciFlagsghciGhcCommandghciNoLoadModulesghciAdditionalPackages ghciMainIsghciLoadLocalDepsghciSkipIntermediateghciHidePackages ghciNoBuild ghciOnlyMainghci$fShowGhciException$fExceptionGhciException$fShowGhciOpts$fShowGhciPkgInfo DotPayloadpayloadVersionpayloadLicense ListDepsOptslistDepsDotOpts listDepsSeplistDepsLicenseDotOptsdotIncludeExternaldotIncludeBasedotDependencyDepthdotPrune dotTargetsdotFlagsdotTestTargetsdotBenchTargetsdotlistDependencies pruneGraphresolveDependencies printGraph$fEqDotPayload$fShowDotPayloadloadCompilerVersionwithUserFileLockwithConfigAndLockwithGlobalConfigAndLockwithBuildConfigwithBuildConfigAndLockwithBuildConfigAndLockNoDockerwithBuildConfigExtloadConfigWithOptswithMiniConfigAndLock munlockFilewithBuildConfigDotghcOptsCompletertargetCompleter flagCompleterprojectExeCompleter ScriptExecute SEInterpret SECompile SEOptimize ScriptOpts soPackagessoFilesoArgs soCompile soGhcOptionsscriptOptsParser$fShowScriptExecute$fShowScriptOpts scriptCmdhpcReportOptsParserpvpBoundsOptionsdistOptsParserexecOptsParserevalOptsParserexecOptsExtraParserbuildOptsParser targetsParser flagsParserghciOptsParser hoogleCmd dotOptsParserlistDepsOptsParserlsParserlsCmdlistDependenciesCmd$fFromJSONSnapshot$fFromJSONSnapshotData$fExceptionLsException $fShowLsView $fEqLsView $fOrdLsView$fShowSnapshotType$fEqSnapshotType$fOrdSnapshotType$fEqSnapshotOpts$fShowSnapshotOpts$fOrdSnapshotOpts$fShowSnapshot $fEqSnapshot $fOrdSnapshot$fShowSnapshotData$fEqSnapshotData$fOrdSnapshotData$fShowLsException makeHttpLib/hackage-security-0.5.3.0-AsAJMfRjKTaIqCteCi5O7I*Hackage.Security.Client.Repository.HttpLibHttpLib wrapCustomExsetRequestHeaders parseAbsDir parseAbsFilecollapseFilePath$path-io-1.4.2-8bvvPauTaPXDoH7kEyusrzPath.IOforgivingAbsence resolveFilecanonicalizePathSystem.IO.ErrorisDoesNotExistError RIO.ProcessProcessContext quoteFileName fileWatchConf findPathUpparent addCommand' hsubparser' helpOption4optparse-applicative-0.14.3.0-FRQtPH23qvH4AhL0Ir51gKOptions.Applicative.ExtrahandleParseResultOptions.Applicative.Builder abortOptionoptionargument eitherReaderstoreEncodeFileversionedDecodeOrLoadImplWarningParserMonoidParser withPeekD fromWordsDGhcPkgIdParseFailAesongpg gpgWarnTTY parseRepoPathVersionParseFailPackageIdentifierParseFailcabalHashToText sortActionshaskellFileExtshaskellPreprocessorExtsorElseSGRTagTagReset sinkCheckHash sinkHashUsinghashChecksToZipSink populateCache requireIndex updateIndexupdateIndexHTTPupdateIndexHackageSecurity deleteCacheclearPackageCachesconfigPackageIndexCacheconfigPackageIndexCacheOldconfigPackageIndexOldconfigPackageIndexGzentrySizeInBlocksDualTreatLikeExtraDepparseConfigMonoidObjectplatformSnapAndCompilerRelplatformGhcVerOnlyRelDirStrpackageEntryCurrDirplatformVariantSuffixparseDownloadInfoFromObject PkgDepsOracleconfigureOptsNoDirghcPkgpackageDbFlagsfindGhcPkgVersion ghcPkgCmdArgs takeWhileC isProfilinghasDebuggingSymbolswarnAboutGHCJS withGlobalDBStackImageException(StackImageDockerBaseUnspecifiedException-StackImageCannotDetermineProjectRootExceptionstageExesInDirsyncAddContentToDir imageNamecreateDockerImageextendDockerImageWithEntrypointfromMaybeProjectRootgenerateHaddockIndexlookupDumpPackagehaddockIndexFile localDocDirlocalDepsDocDir snapDocDirexeInstalledDirprecompiledCacheFile pathTooLong loadDatabase isAllowedPathInfopaths NewException loadTemplateurlFromRepoTemplatePath applyTemplatecheckForOverwritewriteTemplateFilesrunTemplateInitsdefaultTemplateNamedefaultRepoServicedefaultTemplatesHelpUrltfCabalgetUses00IndexfuzzyLookupCandidatestypoCorrectionCandidates getToFetchfetchPackages'configPackageTarballBioInputgenerateBuildInfoOpts rawParseGPD,Distribution.Types.GenericPackageDescriptionGenericPackageDescription%Distribution.Types.PackageDescriptionPackageDescriptiongeneratePkgDescOptsmakeObjectFilePathFromCpackageAutogenDircomponentAutogenDircomponentOutputDirbuildDirpackageDescToolsDistribution.Types.BuildInfobuildToolDepends buildTools hardCodedMappreInstalledPackages allBuildInfo' allBuildInfopackageDescModulesAndFilesresolveGlobFilesbenchmarkFiles testFilesexecutableFiles libraryFilesresolveComponentFilesbuildOtherSourcestargetJsSourcesflagMapmkResolveConditionsresolveConditionsdepNamedepRangeresolveFilesAndDepsgetDependencies parseDumpHI resolveFiles findCandidate warnMultiplelogPossibilitiesfindOrGenerateCabalFilehpackresolveFileOrWarnresolveDirOrWarn cloneRepo recalculate checkDepsMet loadCompiler findPackage Control.Monad.Trans.State.StrictStateTsnapshotDefFixesglobalToSnapshotsplitUnmetDeps calculatetryDeprecatedPathgetLatestResolverconfigNoLocalConfiggetDefaultLocalProgramsBaseloadBuildConfigcheckDuplicateNamesdetermineStackRootAndOwnershipgetDirAndOwnership isOwnedByUsergetExtraConfigsloadYamlloadProjectConfiggetDefaultGlobalConfigPathgetDefaultUserConfigPathgetFakeConfigPathconfigFromConfigMonoidCannotDetermineProjectRootescapeCommandScopeGlobalCommandScopeProjectcfgCmdSetValue rrComponent rrAddedDep ComponentNameRawInputparseRawTargetDirsresolveRawTarget ResolveResult hpcPkgPath tixFilePathremoveExeModules htmlEscapeselectPackageBuildPlancheckPackageBuildPlancheckPackageDepscombineDepErrorcheckBundleBuildPlancompareBuildPlanCheckloadLocalPackagecheckFlagsUsedcheckBuildCachegetPackageFilesForTargetsgetModTimeMaybecalcFcigetPackageConfigdpLength dpNameLengthdpPath BadDependency HasNoLibraryLatestApplicableVersionUnknownPackage ToolWarningUnregisterStatewInstallwDirtywDeps wWarningswParentsPIOnlyInstalled PIOnlySourcePIBothmkUnregisterLocaladdFinaladdDepaddPackageDepsinstallPackageinstallPackageGivenDepspackageBuildTypeConfigpackageDepsWithTools stripLocals inSnapshotgetShortestDepsPathwanted OutputType eeSetupHs eeSetupShimHs eeSetupExe eeCustomBuiltExecutableBuildStatus displayTask getSetupExewindowsRenameCopy executePlan'getConfigCache ensureConfiggetExecutableBuildStatusescheckExeStatuscheckForUnlistedFiles depsPresent singleTest singleBenchmungeBuildOutput getSetupHs exesToBuildcabalIsSatisfiedaddGlobalPackages singleBuildallLocal/warnIfExecutablesWithSameNameCouldBeOverwritten fixCodePage rawBuildInfo addIncludeLib getGhcBuilds mungeRelease upgradeCabal getSetupInfo#downloadAndInstallPossibleCompilerscheckDependencieswithUnpackedTarball7zsetup7zbytesfmt sanityCheckgetUtf8EnvVarsperformPathCheckinggetInstalledToolinstallMsys2WindowschattyDownload_boForce _boVersion setupCabalEnv ignoredDirs cabalSolvergetCabalConfigreportMissingCabalFilesrenderStackYamlgetDefaultResolvergetWorkingResolverPlancheckBundleResolver GetCmdArgs ImageConfigInspectexecWithOptionalContainerrunContainerAndExitinspectinspects pullImagecheckDockerVersionentrypointMVarremoveDirectoryContentsreadDockerProcess homeDirName hostBinDir decodeUtf8oldSandboxIdEnvVar getCabalLbs gtraverseTreadLocalPackagegetSDistFileListcheckPackageInExtractedTarballwithTempTarGzContents packFileEntry GhciPkgDescfigureOutMainFileloadGhciPkgDescmakeGhciPkgInforunGrabFirstLinecreatePrunedDependencyGraphcreateDependencyGraphpruneUnreachablecreateDepLoaderlocalDependenciesprintLocalNodes printLeaves printEdges printEdgenodeName printLeaf isWiredIn blacklistgetPackagesFromModuleInfo