h$Ǹ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                         None      Safe-Inferred# Safe-InferredJ$ !"#$%&'()*+,-./0123465$65 )4$'&!%,#"210/.-+*3( None7    !"#$%&'()*+,-./0123465None ;7 core-programInformation about the version number of this piece of software and other related metadata related to the project it was built from. This is supplied to your program when you call ?. This value is used if the user requests it by specifying the  --version option on the command-line.>Simply providing an overloaded string literal such as version "1.0" will give you a 7 with that value: ,{-# LANGUAGE OverloadedStrings #-} main ::  () main = do context <-  "1.0"  ( ... *For more complex usage you can populate a 7 object using the ;8 splice below. You can then call various accessors like : to access individual fields.; core-programThis is a splice which includes key built-time metadata, including the number from the version field from your project's .cabal, file (as written by hand or generated from  package.yaml). This uses the evil TemplateHaskell extension.While we generally discourage the use of Template Haskell by beginners (there are more important things to learn first) it is a way to execute code at compile time and that is what what we need in order to have the version number extracted from the .cabal file rather than requiring the user to specify (and synchronize) it in multiple places.To use this, enable the Template Haskell language extension in your Main.hs file. Then use the special $( ... )> "insert splice here" syntax that extension provides to get a 75 object with the desired metadata about your project: -{-# LANGUAGE TemplateHaskell #-} version :: 7 version = $(; ) main ::  () main = do context <-  version  ( ... (Using Template Haskell slows down compilation of this file, but the upside of this technique is that it avoids linking the Haskell build machinery into your executable, saving you about 10 MB in the size of the resultant binary)< core-program,Access the source location of the call site. This is insanely cool, and does not require you to turn on the CPP or TemplateHaskell language extensions! Nevertheless we named it with underscores to compliment the symbols that CPP gives you; the double underscore convention holds across many languages and stands out as a very meta thing, even if it is a proper Haskell value. We have a  instance that simply prints the filename and line number. Doing: main ::  () main =  $ do  < will give you: tests/Snipppet.hs:32 This isn't the full stack trace, just information about the current line. If you want more comprehensive stack trace you need to add $ constraints everywhere, and then...79:8;<7:89;<None 5=SA core-programDifferent ways parsing a simple or complex command-line can fail.B core-programSomething was wrong with the way the user specified [usually a short] option.C core-programUser specified an option that doesn't match any in the supplied configuration.D core-program1Arguments are mandatory, and this one is missing.E core-program+Arguments are present we weren't expecting.F core-programIn a complex configuration, user specified a command that doesn't match any in the configuration.G core-program:In a complex configuration, user didn't specify a command.H core-programIn a complex configuration, usage information was requested with --help., either globally or for the supplied command.I core-program.Display of the program version requested with  --version.J core-programResult of having processed the command-line and the environment. You get at the parsed command-line options and arguments by calling  within a  block.Each option and mandatory argument parsed from the command-line is either standalone (in the case of switches and flags, such as --quiet) or has an associated value. In the case of options the key is the name of the option, and for arguments it is the implicit name specified when setting up the program. For example, in: 2$ ./submit --username=gbmh GraceHopper_Resume.pdf the option has parameter name "username " and value "gmbh"; the argument has parameter name "filename" (assuming that is what was declared in the U entry) and a value being the Admiral's CV. This would be returned as: J  [("username","gbmh"), ("filename","GraceHopper_Resume.pdf")] [] &The case of a complex command such as git or stack, you get the specific mode chosen by the user returned in the first position: $ missiles launch --all would be parsed as: J ( "launch") [("all",Empty)] [] P core-programIndividual parameters read in off the command-line can either have a value (in the case of arguments and options taking a value) or be empty (in the case of options that are just flags).S core-programDeclaration of an optional switch or mandatory argument expected by a program.T takes a long name for the option, a short single character abbreviation if offered for convenience, whether or not the option takes a value (and what label to show in help output) and a description for use when displaying usage via --help.U indicates a mandatory argument and takes the long name used to identify the parsed value from the command-line, and likewise a description for --help output.1By convention option and argument names are both  lower case. If the identifier is two or more words they are joined with a hyphen. Examples:  [ T "quiet" ( 'q') R* "Keep the noise to a minimum." , T "dry-run"  (Q "TIME") "Run a simulation of what would happen at the specified time." , U< "username" "The user to delete from the system." ] By convention a  description is one or more complete sentences each of which ends with a full stop. For options that take values, use  upper case5 when specifying the label to be used in help output.V is special; it indicates that you are expecting a variable number of additional, non-mandatory arguments. This is used for programs which take a list of files to process, for example. It'll show up in the help with the description you supply alongside.  [ ... , V "The files you wish to delete permanently." , ... ] W declares an environment variable that, if present, will be read by the program and stored in its runtime context. By convention these are  upper case. If the identifier is two or more words they are joined with an underscore:  [ ... , W "CRAZY_MODE" "Specify how many crazies to activate." , ... ] X core-programDescription of the command-line structure of a program which has "commands" (sometimes referred to as "subcommands") representing different modes of operation. This is familiar from tools like git and docker.[ core-programThe setup for parsing the command-line arguments of your program. You build a Config with a or b, and pass it to .\ core-program:The name of an option, command, or agument (omitting the "--" prefix in the case of options). This identifier will be used to generate usage text in response to --help and by you later when retreiving the values of the supplied parameters after the program has initialized.Turn on OverloadedStrings+ when specifying configurations, obviously.^ core-programThe description of an option, command, or environment variable (for use when rendering usage information in response to --help on the command-line)._ core-program-Single letter "short" options (omitting the "-" prefix, obviously).`  core-programA completely empty configuration, without the default debugging and logging options. Your program won't process any command-line options or arguments, which would be weird in most cases. Prefer a.a  core-programDeclare a simple (as in normal) configuration for a program with any number of optional parameters and mandatory arguments. For example: main ::  () main = do context <-  "1.0"  (a [ T "host" ( 'h') R [| Specify an alternate host to connect to when performing the frobnication. The default is "localhost". |] , T "port" ( 'p') R [| Specify an alternate port to connect to when frobnicating. |] , T "dry-run"  (Q "TIME") [| Perform a trial run at the specified time but don't actually do anything. |] , T "quiet" ( 'q') R [<| Supress normal output. |] , U "filename" [| The file you want to frobnicate. |] ])  context program 3which, if you build that into an executable called snippet and invoke it with --help, would result in: $ ./snippet --help Usage: snippet [OPTIONS]  filename Available options: -h, --host Specify an alternate host to connect to when performing the frobnication. The default is "localhost". -p, --port Specify an alternate port to connect to when frobnicating. --dry-run= TIME Perform a trial run at the specified time but don't actually do anything. -q, --quiet Supress normal output. -v, --verbose Turn on informational messages. The logging stream will go to standard output on your terminal. --debug Turn on debug level logging. Implies --verbose. Required arguments:  filename( The file you want to frobnicate. $ | For information on how to use the multi-line string literals shown here, see  in Core.Text.Utilities.b  core-programDeclare a complex configuration (implying a larger tool with various "[sub]commands" or "modes"} for a program. You can specify global options applicable to all commands, a list of commands, and environment variables that will be honoured by the program. Each command can have a list of local options and arguments as needed. For example:  program :: * MusicAppStatus () program = ... main ::  () main = do context <-  ( version)  (b [ Y [ T "station-name"  (Q "NAME") [| Specify an alternate radio station to connect to when performing actions. The default is "BBC Radio 1". |] , W "PLAYER_FORCE_HEADPHONES" [| If set to 1, override the audio subsystem to force output to go to the user's headphone jack. |] ] , Z( "play" "Play the music." [ T "repeat"  R [| Request that they play the same song over and over and over again, simulating the effect of listening to a Top 40 radio station. |] ] , Z "rate" "Vote on whether you like the song or not." [ T "academic"  R [| The rating you wish to apply, from A+ to F. This is the default, so there is no reason whatsoever to specify this. But some people are obsessive, compulsive, and have time on their hands. |] , T "numeric"  R [| Specify a score as a number from 0 to 100 instead of an academic style letter grade. Note that negative values are not valid scores, despite how vicerally satisfying that would be for music produced in the 1970s. |] , T "unicode" ( 'c') R [| Instead of a score, indicate your rating with a single character. This allows you to use emoji, so that you can rate a piece '', as so many songs deserve. |] , U "score" [| The rating you wish to apply. |] ] ])  context program is a program with one global option (in addition to the default ones) [and an environment variable] and two commands: play, with one option; and rate, with two options and a required argument. It also is set up to carry its top-level application state around in a type called MusicAppStatus (implementing  and so initialized here with . This is a good pattern to use given we are so early in the program's lifetime). one two -- continue, doing something with both results. For a variant that ingores the return values and just waits for both see  below. (this wraps async's %3) core-program-Fork two threads and wait for both to finish.This is the same as calling  and  twice, except that if either sub-program fails with an exception the other program which is still running will be cancelled and the original exception is then re-thrown. (this wraps async's %4) core-programFork two threads and race them against each other. This blocks until one or the other of the threads finishes. The return value will be   if the first program (one) completes first, and   if it is the second program (two) which finishes first. The sub program which is still running will be cancelled with an exception.  result <- $ one two case result of 3 a -> do -- one finished first + b -> do -- two finished first For a variant that ingores the return value and just races the threads see  below. (this wraps async's %5) core-programFork two threads and race them against each other. When one action completes the other will be cancelled with an exception. This is useful for enforcing timeouts:   (6 300) (do -- We expect this to complete within 5 minutes. performAction )  (this wraps async's %7) None core-programA utility exception for those occasions when you just need to go "boom".  case 89 "James Bond" agents of $ -> do evilPlan  -> do :0 "No Mr Bond, I expect you to die!"    core-programCatch an exception.Some care must be taken. Remember that even though it is constrained by the ;< typeclass,  does not stand for "any" exception type; is has a concrete type when it gets to being used in your code. Things are fairly straight-forward if you know exactly the exception you are looking for:   action (\(e :: FirstWorldProblem) -> do ... )  but more awkward when you don't.If you just need to catch all exceptions, the pattern for that is as follows:   action (\(e :: ;=") -> do ... ) The ;= type is the root type of all exceptions; or rather, all types that have an instance of ;<0 can be converted into this root type. Thus you can catch all synchronous exceptions but you can't tell which type of exception it was originally; you rely on the % instance (which is the default that ;> falls back to) to display a message which will hopefully be of enough utility to figure out what the problem is. In fairness it usually is. (This all seems a bit of a deficiency in the underlying exception machinery but it's what we have)This  function will not catch asynchonous exceptions. If you need to do that, see the more comprehensive exception handling facilities offered by safe-exceptions, which in turn builds on  exceptions and base ). Note that { implements ?@; so you can use the full power available there if required. core-programCatch an exception. Instead of handling an exception in a supplied function, however, return from executing the sub-program with the outcome in an ", with the exception being on the  side if one is thrown. If the sub-program completes normally its result is in the  side."(this is a wrapper around calling safe-exceptions's AB function, which in turn wraps  exceptions's CB , which...) core-programThrow an exception.This will be thrown as a normal synchronous exception that can be caught with  or  above.Don't try and use this from pure code! A common temptation is to be in the middle of a computation, hit a problem, and think "oh, that's bad. I guess I'll throw an exception!". You can't6. Surface the problem back to the I/O level code that {  monad provides, and then+ you can throw an exception if appropriate. When you do throw an exception, we recommend you go to some trouble to make sure that the string or otherwise descriptive message is unique in your codebase. If you do so then when the problem arises you will be able to quickly search for that string and find the place where the exception arose from, even without the benefit of stack traces. For example,   (SomeoneWrongOnInternet "Ashley thinks there are more than three Star Wars movies") which will get you a nice crash message as your world falls down around you: 22:54:39Z (00.002) SomeoneWrongOnInternet "Ashley thinks there are more than three Star Wars movies" $ but if you're in a hurry and don't want to define a local exception type to use,     will work."(experienced users will note that { implements ?D3 and as such this is just a wrapper around calling safe-exceptions's AE function) core-program1Acquire a resource, use it, then release it back.The bracket pattern is common in Haskell for getting a resource  needed for a computation, preforming that computation, then returning the resource back to the system. Common examples are when making database connections and doing file or network operations, where you need to make sure you "close" the connection afterward before continuing the program so that scare resources like file handles are released.Typically you have an open and close action that return and take a resource respectively, so you can use those directly, and use a lambda in the third action to actally get at the resource and do something with it when you need it:   (openConnection) (closeConnection) (c -> do this thatAndNow theOtherThingThatNeeds c )  Note that  does not catch the exception if one is thrown! The finalizer will run, but then the exception will continue to propogate its way out of your program's call stack. Note also that the result of the cleanup action  is ignored (it can be ()) or anythign else; it will be discarded). core-programRun an action and then, run a finalizer afterwards. The second action will run whether or not an exception was raised by the first one. This is like  above, but can be used when you know you have cleanup steps to take after your computation which do have to be run even if (especially if!) an exception is thrown but that that cleanup doesn't depend on the result of that computation or the resources used to do it. The return value % of the subsequent action is ignored. core-programRun an action and then, if an exception was raised (and only if an exception was raised), run the second action. The return value ( of the subsequent action is is ignored.None  j  core-programTrap any exceptions coming out of the given Program action, and discard them. The one and only time you want this is inside an endless loop:  F" $ do  (  obtainResource releaseResource useResource ) This function really will swollow expcetions, which means that you'd better have handled any synchronous checked errors already with a % and/or have released resources with  or  as shown above.An info level message will be sent to the log channel indicating that an uncaught exception was trapped along with a debug level message showing the exception text, if any. core-program=Embelish a program with useful behaviours. See module header Core.Program.Execute< for a detailed description. Internally this function calls / with an appropriate default when initializing. core-programEmbelish a program with useful behaviours, supplying a configuration for command-line options & argument parsing and an initial value for the top-level application state, if appropriate. core-programSafely exit the program with the supplied exit code. Current output and debug queues will be flushed, and then the process will terminate. core-programChange the verbosity level of the program's logging output. This changes whether  and the 9 family of functions emit to the logging stream; they do not affect 2ing to the terminal on the standard output stream. core-programOverride the program name used for logging, etc. At least, that was the idea. Nothing makes use of this at the moment. :/ core-programGet the program name as invoked from the command-line (or as overridden by ). core-program5Retreive the current terminal's width, in characters.'If you are outputting an object with a GH: instance then you may not need this; you can instead use  which is aware of the width of your terminal and will reflow (in as much as the underlying type's Render instance lets it). core-programGet the user supplied application state as originally supplied to . and modified subsequntly by replacement with .  settings <-   core-program5Update the user supplied top-level application state. 1 let settings' = settings { answer = 42 }  settings'  core-programWrite the supplied Bytes to the given Handle. Note that in contrast to $ we don't output a trailing newline.   h b Do not use this to output to stdout0 as that would bypass the mechanism used by the *, , and * functions to sequence output correctly. If you wish to write to the terminal use:   ( b) (which is not unsafe, but will lead to unexpected results if the binary blob you pass in is other than UTF-8 text). core-program,Read the (entire) contents of the specified Handle. core-programExecute an external child process and wait for its output and result. The command is specified first and and subsequent arguments as elements of the list. This helper then logs the command being executed to the debug output, which can be useful when you're trying to find out what exactly what program is being invoked.Keep in mind that this isn't invoking a shell; arguments and their values have to be enumerated separately:   ["/usr/bin/ssh", "-l", "admin", "203.0.113.42", "\'remote command here\'"] having to write out the individual options and arguments and deal with escaping is a bit of an annoyance but that's  execvp(3) for you.The return tuple is the exit code from the child process, its entire stdout and its entire stderr, if any. Note that this is not a streaming interface, so if you're doing something that returns huge amounts of output you'll want to use something like  io-streams instead. (this wraps  typed-process's ) core-programReset the start time (used to calculate durations shown in event- and debug-level logging) held in the Context to zero. This is useful if you want to see the elapsed time taken by a specific worker rather than seeing log entries relative to the program start time which is the default.If you want to start time held on your main program thread to maintain a count of the total elapsed program time, then fork a new thread for your worker and reset the timer there.   I $ do  ... then times output in the log messages will be relative to that call to , not the program start. core-programPause the current thread for the given number of seconds. For example, to delay a second and a half, do:   1.5  (this wraps base's ) core-programRetrieve the values of parameters parsed from options and arguments supplied by the user on the command-line..The command-line parameters are returned in a , mapping from from the option or argument name to the supplied value. You can query this map directly: program = do params <-  let result =  "silence" (paramterValuesFrom params) case result of  ->  () # quiet = case quiet of Q _ ->  NotQuiteRight -- complain that flag doesn't take value R -> 4 "You should be quiet now" -- much better ... which is pattern matching to answer "was this option specified by the user?" or "what was the value of this [mandatory] argument?", and then "if so, did the parameter have a value?"=This is available should you need to differentiate between a Value and an Empty P6, but for many cases as a convenience you can use the , , and  functions below. core-programArguments are mandatory, so by the time your program is running a value has already been identified. This retreives the value for that parameter. program = do file <-  "filename" ...  core-programIn other applications, you want to gather up the remaining arguments on the command-line. You need to have specified V in the configuration. program = do files <-  ...  core-programLook to see if the user supplied a valued option and if so, what its value was. Use of the  LambdaCase extension makes accessing the option (and specifying a default if it is absent) reasonably nice: program = do region <-  "region"  \case  -> 2 "us-west-2" -- Oregon, not a bad default  value ->  value If you require something other than the text value as entered by the user you'll need to do something to parse the returned value and convert it to an appropriate type See  for an alternative that does this automatically in many common cases, i.e. for options that take numberic values. core-programLook to see if the user supplied a valued option and if so, what its value was. This covers the common case of wanting to read a numeric argument from an option: program = do count <-  "count"  \case  ->  (0 ::  )  value ->  value ... ;The return type of this function has the same semantics as ": if the option is absent you get  back (and in the example above we specify a default in that case) and  if a value is present. Unlike the original function, however, here we assume success in reading the value! If the value is unable to be parsed into the nominated Haskell type using  then an exception with an appropriate error message will be thrown@which is what you want if the user specifies something that can't be parsed.Note that the return type is polymorphic so you'll need to ensure the concrete type you actually want is specified either via type inference or by adding a type annotation somewhere. core-programReturns True if the option is present, and False if it is not. program = do overwrite <-  "overwrite" ...  core-programLook to see if the user supplied the named environment variable and if so, return what its value was. core-programRetreive the sub-command mode selected by the user. This assumes your program was set up to take sub-commands via b.  mode <- queryCommandName  core-programIllegal internal state resulting from what should be unreachable code or otherwise a programmer error.*{*{None - core-program>This gives you a function that you can use within your lifted  actions to return to the { monad.The type signature of this function is a bit involved, but the example below shows that the lambda gives you a function+ as its argument (we recommend you name it  runProgram for consistency) which gives you a way to run a subprogram, be that a single action like writing to terminal or logging, or a larger action in a do-notation block: main :: IO () main =  $ do  $ \runProgram -> do -- in IO monad, lifted -- (just as if you had used liftIO) ... runProgram $ do -- now unlifted, back to Program monad ... Think of this as  with an escape hatch.This function is named : because it is a convenience around the following pattern:  context <- % liftIO $ do ... > context $ do -- now in Program monad ...  None  core-program+Watch for changes to a given list of files.Before continuing we insert a 100ms pause to allow whatever the editor was to finish its write and switcheroo sequence.None579:8;JXYJXZJX<J[\J[]J[^J[_J[`JabJX=cdecfgcfhcficfjcfkcflcfmcfncfocdpcdqcdrcdscdtcducdvcdwcdxcdycdzcd{cd|cd}cd~cdcdcdcdcdcdcdcdcdcdcd:   I              2 B E      #$6 HJJJJJJJRJ%JJ-J-J*%J-J88JJ+core-program-0.5.2.0-3XN685QMAilJUcq1PZWoEHCore.System.BaseCore.System.PrettyCore.Program.MetadataCore.Program.ArgumentsCore.Program.Execute Core.ProgramCore.Program.LoggingCore.Program.UnliftCore.Program.ThreadsCore.Program.ExceptionsCore.Program.NotifyCore.System.External Core.System configureNone simpleConfigexecutewriteRgetCommandLineProgramCore.Program.Context executeWith fromPackagesetVerbosityLevelgetApplicationStatesetApplicationStateCore.Telemetry.Observability beginTrace usingTrace encloseSpanCore.Program.Signaltrap_ Control.MonadforeversetProgramNamegetProgramNameControl.Concurrent.AsyncasyncControl.ConcurrentforkIOwaitmapM_mapM waitCatch Data.Eitherrightsleftslinkcancelcatch concurrently concurrently_race sleepThreadrace_Core.Data.Structures containsKeywriteControl.Exception Exception SomeExceptiondisplayExceptionControl.Monad.Catch MonadCatchControl.Exceptions.SafetryControl.Exceptions MonadThrowthrow Conrol.MonadCore.Text.UntilitiesRender forkThreadbaseGHC.IO.Handle.FDstdoutGHC.IO.Handle.TypesHandleControl.Monad.IO.ClassliftIOMonadIO System.IOwithFilestderrstdin GHC.IO.HandlehFlushGHC.Exception.Type fromException toException GHC.IO.IOMode ReadWriteMode AppendMode WriteModeReadModeIOMode GHC.IO.UnsafeunsafePerformIO)prettyprinter-1.7.1-BauxLiNvN3EiJKyXe93SMPrettyprinter.InternalDocPrettyprinter.Symbols.Asciicommarbracelbracerbracketlbracketrparenlparendquotesquote unAnnotateannotateenclose punctuatefillCatvcathcatsepfillSepvsephsep concatWith<+>indenthangflatAltgrouphardline softline'softlineline'linenestemptyDocprettyPrettyVersionprojectNameFromprojectSynopsisFromversionNumberFrom __LOCATION__$fRenderSrcLoc$fIsStringVersion $fShowVersion$fLiftLiftedRepVersionInvalidCommandLine InvalidOption UnknownOptionMissingArgumentUnexpectedArgumentsUnknownCommandNoCommandFound HelpRequestVersionRequest ParameterscommandNameFromparameterValuesFromremainingArgumentsFromenvironmentValuesFromParameterValueValueEmptyOptionsOptionArgument RemainingVariableCommandsGlobalCommandConfigLongName Description ShortName blankConfig complexConfig appendOptionemptyParametersbaselineOptionsparseCommandLineextractValidEnvironments buildUsage buildVersion$fTextualLongName$fPrettyLongName $fKeyLongName$fIsStringParameterValue$fExceptionInvalidCommandLine$fShowInvalidCommandLine$fEqInvalidCommandLine$fShowParameters$fEqParameters $fShowOptions$fShowParameterValue$fEqParameterValue$fShowLongName$fIsStringLongName $fEqLongName$fHashableLongName $fOrdLongName VerbosityOutputVerboseDebugInternalContext$sel:programNameFrom:Context$sel:terminalWidthFrom:Context!$sel:terminalColouredFrom:Context$sel:versionFrom:Context$sel:initialConfigFrom:Context!$sel:initialExportersFrom:Context$sel:commandLineFrom:Context$sel:exitSemaphoreFrom:Context$sel:startTimeFrom:Context$sel:verbosityLevelFrom:Context$sel:outputChannelFrom:Context!$sel:telemetryChannelFrom:Context#$sel:telemetryForwarderFrom:Context$sel:currentDatumFrom:Context $sel:applicationDataFrom:Context Forwarder#$sel:telemetryHandlerFrom:ForwarderExporter$sel:codenameFrom:Exporter$sel:setupConfigFrom:Exporter$sel:setupActionFrom:ExporterTraceSpanDatum$sel:spanIdentifierFrom:Datum$sel:spanNameFrom:Datum$sel:serviceNameFrom:Datum$sel:spanTimeFrom:Datum$sel:traceIdentifierFrom:Datum$sel:parentIdentifierFrom:Datum$sel:durationFrom:Datum$sel:attachedMetadataFrom:Datum emptyDatumunSpanunTrace fmapContextisNone unProgram getContext subProgramhandleCommandLinehandleVerbosityLevelhandleTelemetryChoiceSeverity SeverityNoneSeverityCritical SeverityWarn SeverityInfo SeverityDebugSeverityInternal putMessageformatLogMessagewriteSinfowarncriticalisEventisDebug isInternaldebugdebugSdebugRinternalThreadunThread forkThread_ waitThread waitThread_ waitThread' waitThreads' linkThread cancelThreadconcurrentThreadsconcurrentThreads_ raceThreads raceThreads_Boombracketfinally onException$fExceptionBoom $fShowBoom loopForever terminategetVerbosityLevelgetConsoleWidth outputEntire inputEntire execProcess resetTimer queryArgumentlookupArgumentqueryRemainingqueryOptionValuelookupOptionValuequeryOptionValue'queryOptionFlaglookupOptionFlagqueryEnvironmentValuelookupEnvironmentValuequeryCommandNameinvalid$fExceptionProcessProblem$fExceptionQueryParameterError$fShowQueryParameterError$fShowProcessProblem withContext waitForChangeghc-prim GHC.TypesIO(core-text-0.3.8.0-I6LlNWNPeNi7cc8wYGtU2hCore.Text.UtilitiesGHC.Stack.Types HasCallStack GHC.MaybeNothingJustquoteGHC.BasememptyMonoidsetupSignalHandlersGHC.ShowshowprintrenderShow"async-2.2.4-4JG4UQZhHlOKvfwb7nDkNcAsyncreturnRightLeft Data.FoldableCore.Text.RopeintoRopeAsyncCancelledFalseTrueEither-typed-process-0.2.10.1-L0fOW9b0za6DIqOOXGRVEMSystem.Process.Typed readProcess GHC.Conc.IO threadDelay(core-data-0.3.4.0-Ekktb0y5wet325HLA4J16FMaplookupKeyValue>>=pureIntCore.Encoding.External parseExternal