úÎ!汩“ÿÅ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹Œ‘’“”•–—˜™š›œŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏĞÑÒÓÔÕÖ×ØÙÚÛÜİŞßàáâãäåæçèéêëìíîïğñòóôõö÷øùúûüışÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹Œ‘’“”•–—˜™š›œŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ ¶ · ¸ ¹ º » ¼ ½ ¾ ¿ À Á  à Ä I SafeGÅÆÇÈÉÊ SafeP"ÅÆÈËÌÍÎÏĞÑÒÓÔÕÖ×ØÙÚÛÜİŞßàáâãäåæçèé None] êëìíîïğñòó None"#PÔôSafe  GFE GFE Safe5Hshake Drop the first directory from a +. Should only be used on relative paths. pdropDirectory1 "aaa/bbb" == "bbb" dropDirectory1 "aaa/" == "" dropDirectory1 "aaa" == "" dropDirectory1 "" == ""IshakeTake the first component of a +. Should only be used on relative paths. ^takeDirectory1 "aaa/bbb" == "aaa" takeDirectory1 "aaa/" == "aaa" takeDirectory1 "aaa" == "aaa"Jshake!Replace the first component of a +. Should only be used on relative paths. ›replaceDirectory1 "root/file.ext" "directory" == "directory/file.ext" replaceDirectory1 "root/foo/bar/file.ext" "directory" == "directory/foo/bar/file.ext"Kshakeÿ Make a path relative. Returns Nothing only when the given paths are on different drives. This will try the pure function makeRelative first. If that fails, the paths are canonicalised (removing any indirection and symlinks) and a relative path is derived from there. ÿ7> -- Given that "/root/a/" is not a symlink > makeRelativeEx "/root/a/" "/root/b/file.out" Just "../b/file.out" > -- Given that "/root/c/" is a symlink to "/root/e/f/g/" > makeRelativeEx "/root/c/" "/root/b/file.out" Just "../../../b/file.out" > -- On Windows > makeRelativeEx "C:\\foo" "D:\\foo\\bar" NothingLshake Normalise a , applying the rules:All C become D (/ on Linux, \ on Windows)foo/bar/../baz becomes foo/baz3 (not universally true in the presence of symlinks) foo/./bar becomes foo/barfoo//bar becomes foo/bar"This function is not based on the  function from the filepath. library, as that function is quite broken.Mshake*Convert to native path separators, namely \ on Windows.NshakeConvert all path separators to /, even on Windows.OshakeThe extension of executables, "exe" on Windows and "" otherwise.= !"#$%&'()*+,-./0123456789:;<=>?@ABCDHIJKLMNO= !"#$%&'()*+,-.239<=>?@ABCD/0145678:;HIJKLMNOSafe2X9PshakeOptions passed to command or cmd' to control how processes are executed.QshakeuChange the current directory in the spawned process. By default uses this processes current directory. Successive Q@ options are joined together, to change into nested directories.RshakedChange the environment variables in the spawned process. By default uses this processes environment.Sshake1Add an environment variable in the child process.Tshake6Remove an environment variable from the child process.Ushake/Add some items to the prefix and suffix of the $PATH variable.Vshake Given as the stdin( of the spawned process. By default the stdin is inherited.Wshake Given as the stdin of the spawned process.Xshake Take the stdin from a file.Yshake…Pass the command to the shell without escaping - any arguments will be joined with spaces. By default arguments are escaped properly.Zshake Treat the stdin/stdout/stderr messages as binary. By default õ results use text encoding and  ByteString results use binary encoding.[shakeName to use with traced, or ""D for no tracing. By default traces using the name of the executable.\shakeMAbort the computation after N seconds, will raise a failure exit code. Calls interruptProcessGroupOf and terminateProcess>, but may sometimes fail to abort the process and not timeout.]shakeShould I include the stdout4 in the exception if the command fails? Defaults to ö.^shakeShould I include the stderr4 in the exception if the command fails? Defaults to ÷._shakeShould I echo the stdout? Defaults to ÷ unless a Stdout result is required or you use a.`shakeShould I echo the stderr? Defaults to ÷ unless a Stderr result is required or you use b.ashakeShould I put the stdout to a file.bshakeShould I put the stderr to a file.cshake#Compute dependencies automatically.dshakeVThe command the user thinks about, before any munging. Defaults to the actual command.eshake Options to fsatrace,, a list of strings with characters such as "r" (reads) "w" (writes). Defaults to "rwmdqt" if the output of fsatrace is required.P\RQSTUVWXYZ[]^_`abcdeSafe%YVøshakeGiven an Int hash we storeøùúSafeY¡ûüıSafeYäşÿSafeZ+None=?SX`Bshakeÿ(Methods for Binary serialisation that go directly between strict ByteString values. When the Database is read each key/value will be loaded as a separate ByteString, and for certain types (e.g. file rules) this may remain the preferred format for storing keys. Optimised for performance. shake0An explicit and more efficient version of Binary      None=?Mb–!shakeUTF8 ByteString"shakeEquivalent to toStandard . normaliseEx from Development.Shake.FilePath.!#$%&"SafefA'shakeCRun with some cleanup scope. Regardless of exceptions/threads, all (5 actions will be run by the time it exits. The (S actions will be run in reverse order, i.e. the last to be added will be run first.)'*(+,-Nonefœ./0123456789:;<=None "#%,MSXuğ >shakeXLike TypeRep, but the Show includes enough information to be unique so I can rely on a == b === show a == show b.?shake`A version number that indicates change, not ordering or compatibilty. Always presented as an @: to the user, but a newtype inside the library for safety.AshakeŒIf a string has any spaces then put quotes around and double up all internal quotes. Roughly the inverse of Windows command line parsing.Bshake7If a string has any spaces then put brackets around it.Cshake Alias for wrapBracket . show.Dshake Version of E which is fast and returns F if the index is not present.GshakeJIs the exception asynchronous, not a "coding error" that should be ignoredHshake*Remove a file, but don't worry if it failsIshakeLike createDirectoryIfMissing TrueV but faster, as it avoids any work in the common case the directory already exists.JshakeInvert K(, which GHC pre-applies in certain cases(LM>NO?PQRSTUVACDWXYZ[\]^_`GabcdefHIghijkNonevÏlNone"#,2|fshake‡Error representing all expected exceptions thrown by Shake. Problems when executing rules will be raising using this exception type.hshake;The target that was being built when the exception occured.ishake4A description of the call stack, one entry per line.jshake)The underlying exception that was raised.fghijmnopqrstuvwxNone"#,EX”kshakewDefine an alias for the six type classes required for things involved in Shake rules. Using this alias requires the ConstraintKinds extension.fTo define your own values meeting the necessary constraints it is convenient to use the extensions GeneralizedNewtypeDeriving and DeriveDataTypeable to write: ^newtype MyType = MyType (String, Bool) deriving (Show, Typeable, Eq, Hashable, Binary, NFData)BShake needs these instances on keys and values. They are used for:V is used to print out keys in errors, profiling, progress messages and diagnostics.² is used because Shake indexes its database by the type of the key and value involved in the rule (overlap is not allowed for type classes and not allowed in Shake either). and GG are used on keys in order to build hash maps from keys to values. â is used on values to test if the value has changed or not (this is used to support unchanging rebuilds, where Shake can avoid rerunning rules if it runs a dependency, but it turns out that no changes occurred.) The Gà instances are only use at runtime (never serialised to disk), so they do not have to be stable across runs. Hashable on values is not used, and only required for a consistent interface. ” is used to serialize keys and values into Shake's build database; this lets Shake cache values across runs and implement unchanging rebuilds.R is used to avoid space and thunk leaks, especially when Shake is parallelized.yzk{|}~None%PÈZ€shakeÃGiven a list of files, return a list of things I can match in this directory plus a list of subdirectories and walks that apply to them. Use WalkTo when the list can be predicted in advanceshakefoo‚shake*ƒshake//„shake"//, but must be at least 1 element…shakeTfoo*, prefix (fixed), infix floaters, suffix e.g. *foo*bar = Stars "" ["foo"] "bar"lshake-A type synonym for file patterns, containing // and *%. For the syntax and semantics of l see n.Most  normaliseExd  values are suitable as l; values which match only that specific file. On Windows \ is treated as equivalent to /.You can write lE values as a literal string, or build them up using the operators ,  and . However, beware that:On Windows, use  from Development.Shake.FilePath instead of from System.FilePath - otherwise  "//*" <.> exe results in  "//*\\.exe".If the second argument of & has a leading path separator (namely //) then the second argument will be returned.mshake Join two l values by inserting two / characters between them. Will first remove any trailing path separators on the first argument, and any leading separators on the second. "dir" <//> "*" == "dir//*"†shakepParse a FilePattern. All optimisations I can think of are invalid because they change the extracted expressions.‡shake5Optimisations that may change the matched expressionsˆshakeA l that will only match ‰ values.‰shakeA non-absolute .ŠshakeˆGiven a pattern, and a list of path components, return a list of all matches (for each wildcard in order, what the wildcard matched).nshakeMatch a l against a  , There are three special forms:*< matches an entire path component, excluding any separators.//U matches an arbitrary number of path components, including absolute path prefixes.** as a path component matches an arbitrary number of path components, but not absolute path prefixes. Currently considered experimental.Some examples:test.c matches test.c and nothing else.*.c matches all .c$ files in the current directory, so file.c matches, but file.h and  dir/file.c don't.//*.c matches all .c) files anywhere on the filesystem, so file.c,  dir/file.c, dir1/dir2/file.c and /path/to/file.c all match, but file.h and  dir/file.h don't.dir/*/*# matches all files one level below dir, so dir/one/file.c and dir/two/file.h match, but file.c, one/dir/file.c,  dir/file.h and dir/one/two/file.c don't.!Patterns with constructs such as  foo/../bar will never match normalised ' values, so are unlikely to be correct.oshakeLike n, but returns F$ on if there is no match, otherwise ‹C with the list of fragments matching each wildcard. For example: o "**/*.c" "test.txt" == Nothing o% "**/*.c" "foo.c" == Just ["","foo"] o5 "**/*.c" "bar/baz/foo.c" == Just ["bar/baz/","foo"] Note that the ** will often contain a trailing /, and even on Windows any \ separators will be replaced by /.Œshake&Is the pattern free from any * and //.shake7Do they have the same * and // counts in the same ordershakeEExtract the items that match the wildcards. The pair must match with n.shakeGiven the result of , substitute it back in to a  pattern. -p '?==' x ==> substitute (extract p x) p == x€‘lm’ˆ‰n“oŒ”m5None2Z½?pshake!The verbosity data type, used by |.qshakeDon't print any messages.rshake0Only print essential messages, typically errors.sshakePrint errors and #  command-name (for  file-name) when running a   command.tshake3Print errors and full command lines when running a ! or " command.ushakeIPrint errors, full command line and status messages when starting a rule.vshake?Print messages for virtually everything (mostly for debugging).•shake+Internal type, copied from Hide in UniplatewshakeXOptions to control the execution of Shake, usually specified by overriding fields in ®:  ®{z=4, ~=["report.html"]}The –$ instance for this type reports the ’ and “$ fields as having the abstract type • , because –$ cannot be defined for functions or —s.yshake Defaults to .shake[. The directory used for storing Shake metadata files. All metadata files will be named y/.shake. file-name , for some  file-name . If the y; directory does not exist it will be created. If set to  "/dev/null": then no shakeFiles are read or written (even on Windows).zshake Defaults to 19. Maximum number of rules to run in parallel, similar to  make --jobs=Nz. For many build systems, a number equal to or slightly less than the number of physical processors works well. Use 02 to match the detected number of processors (when 0, getShakeOptions, will return the number of threads used).{shake Defaults to "1"ÿ . The version number of your build rules. Change the version number to force a complete rebuild, such as when making significant changes to the rules that require a wipe. The version number should be set in the source code, and not passed on the command line.|shake Defaults to s/. What level of messages should be printed out.}shake Defaults to öU. Operate in staunch mode, where building continues even after errors, similar to make --keep-going.~shake Defaults to []º. Write a profiling report to a file, showing which rules rebuilt, why, and how much time they took. Useful for improving the speed of your build systems. If the file extension is .json it will write JSON data; if .js! it will write Javascript; if .trace' it will write trace events (load into about://tracing- in Chrome); otherwise it will write HTML.shake Defaults to F-. Perform sanity checks during building, see § for details.€shake=Directories in which the files will be tracked by the linter.shakeIFile patterns which are ignored from linter tracking, a bit like calling # in every rule.‚shakeJFile patterns whose modification causes an error. Raises an error even if  is F.ƒshake Defaults to []=. Additional options to be passed to all command invocations.„shake Defaults to ‹ 109. How often to flush Shake metadata files in seconds, or FŒ to never flush explicitly. It is possible that on abnormal termination (not Haskell exceptions) any rules that completed in the last „ seconds will be lost.…shakeWhat to rebuild†shake Defaults to []. A list of substrings that should be abbreviated in status messages, and their corresponding abbreviation. Commonly used to replace the long paths (e.g. .make/i586-linux-gcc/output) with an abbreviation (e.g. $OUT).‡shake Defaults to ö. Write a message to y/.shake.storage.log­ whenever a storage event happens which may impact on the current stored progress. Examples include database version number changes, database compaction or corrupt files.ˆshake Defaults to ÷ . Change stdout and stderr' to line buffering while running Shake.‰shake Defaults to ö5. Print timing information for each stage at the end.Šshake Default to ÷.. Should you run command line actions, set to ö† to skip actions whose output streams and exit code are not used. Useful for profiling the non-command portion of the build system.‹shake Default to ¢*. How to check if a file has changed, see ¡ for details.Œshake Default to ÷w. After running a rule to create a file, is it an error if the file does not exist. Provided for compatibility with make and ninja+ (which have ugly file creation semantics).shake Default to []I. After the build system completes, write a list of all files which were liveq in that run, i.e. those which Shake checked were valid or rebuilt. Produces best answers if nothing rebuilds.shake Defaults to ö. Ignore any differences in {.shake Defaults to ö!. Whether to colorize the output.shake Defaults to F9. Whether to use and store outputs in a shared directory.‘shake Defaults to []2. Cloud servers to talk to forming a shared cache.’shakeÿDefaults to no action. A function called when the build starts, allowing progress to be reported. The function is called on a separate thread, and that thread is killed when the build completes. For applications that want to display progress messages, progressSimpleD is often sufficient, but more advanced users should look at the – data type.“shakeDefaults to writing using ˜B. A function called to output messages from Shake, along with the pd at which that message should be printed. This function will be called atomically from all other “ functions. The p, will always be greater than or higher than |.”shake6Defaults to doing nothing. Called for each call of   , with the key, the command and ÷ for starting, ö for stopping.•shakeThis a map which can be used to store arbitrary extra information that a user may need when writing rules. The key of each entry must be the ™& of the value. Insert values using  addShakeExtra and retrieve them using  getShakeExtraq. The correct way to use this field is to define a hidden newtype for the key, so that conflicts cannot occur.–shakegInformation about the current state of the build, obtained by either passing a callback function to $ (asynchronous output) or %= (synchronous output). Typically a build system will pass progressDisplay to $<, which will poll this value and produce status messages.˜shake Starts out F , becomes ‹ a target name if a rule fails.™shakeGNumber of rules which were required, but were already in a valid state.šshake7Number of rules which were have been built in this run.›shakeWNumber of rules which have been built previously, but are not yet known to be required.œshakegNumber of rules which are currently required (ignoring dependencies that do not change), but not built.shakeTime spent building ™ rules in previous runs.shakeTime spent building š rules.ŸshakeTime spent building › rules in previous runs. shakeTime spent building œa rules in previous runs, plus the number which have no known time (have never been built before).¡shake8How should you determine if a file has changed, used by ‹ . The most common values are ¢ (the default, very fast, touch causes files to rebuild) and ¥ (slightly slower, touch and switching git1 branches does not cause input files to rebuild).¢shakehCompare equality of modification timestamps, a file has changed if its last modified time changes. A touch^ will force a rebuild. This mode is fast and usually sufficiently accurate, so is the default.£shakeZCompare equality of file contents digests, a file has changed if its digest changes. A touchb will not force a rebuild. Use this mode if modification times on your file system are unreliable.¤shake»A file is rebuilt if both its modification time and digest have changed. For efficiency reasons, the modification time is checked first, and if that has changed, the digest is checked.¥shakeUse ¤ for input/source files and ¢Ÿ for output files. An input file is one which is a dependency but is not built by Shake as it has no matching rule and already exists on the file system.¦shakeOA file is rebuilt if either its modification time or its digest has changed. A touchw will force a rebuild, but even if a files modification time is reset afterwards, changes will also cause a rebuild.§shake&Which lint checks to perform, used by .¨shakeŸThe most basic form of linting. Checks that the current directory does not change and that results do not change after they are first written. Any calls to needed9 will assert that they do not cause a rule to be rebuilt.©shake?Track which files are accessed by command line programs using  $https://github.com/jacereda/fsatracefsatrace.ªshake:The current assumptions made by the build system, used by …¢. These options allow the end user to specify that any rules run are either to be treated as clean, or as dirty, regardless of what the build system thinks.?These assumptions only operate on files reached by the current &A commands. Any other files in the database are left unchanged.«shakeÕAssume these files are dirty and require rebuilding. for benchmarking rebuild speed and for rebuilding if untracked dependencies have changed. This flag is safe, but may cause more rebuilding than necessary.¬shakeRUseful to reset the rebuild status to how it was before, equivalent to passing no ª flags.­shakeNThis assumption is unsafe, and may lead to incorrect build results in this runU. Assume these files are clean in this run, but test them normally in future runs.®shakeThe default set of w.šshake Apply the …3 flags to a file, determining the desired behaviourBpsqrtuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹Œ‘’“”•–—˜™š›œŸ ¡¢£¤¥¦§¨©ª«¬­®›šœ'None2M\Ÿ ¡¢£(None&'MPX`U¤shake!Run and then call a continuation.¥shakeStrict version¦shake¦Capture a continuation. The continuation should be called at most once. Calling the same continuation, multiple times, in parallel, results in incorrect behaviour. §¨¤©ª¥«¬­®¯¦°)Noneav±shake&Like a barrier, but based on callbacks±²³´µ¶*NoneaÍ·+Safec&¸shake@Remove flags from the first field that are present in the second ¹º»¼½¾¿ÀÁ¸ÂÃÄ,NoneMc™ ÅÆÇÈÉÊËÌÍ-None"#&'f$Îshake(Number of entries in values, initially 0ÏshakeGCapacity that has been used, assuming no gaps from index 0, initially 0ÅÆĞÑÒÓÔÕÖ×ØÙÚÛÜİ.None456=?fÃŞßàáâãäåæçèéêëìíîïğñòóô/NonegV îïğõö÷øùú0None"#Mn³ûshakeıInvariant: The database does not have any cycles where a Key depends on itself. Everything is mutable. intern and status must form a bijecttion. There may be dangling Id's as a result of version changes. Lock is used to prevent any torn updatesüshakeKey |-> Id mappingıshakeId |-> (Key, Status) mappingşshakeRecord all changes to statusÿshakeLEnsure that a Key has a given Id, creating an Id if there is not one already ûÿ  1None4Mo.    2Safep'shake This is a hot-spot, so optimised3None"#qàshakeTIf two buffers can be replaced by one and a copy, do that (only if they start empty) !"#$%&'()*+,-4NoneXy].shake8The inner thread is unmasked even if you started masked./shake³Run an action in a separate thread. After the first action terminates, the thread will be killed. If the action raises an exception it will be rethrown on the parent thread.0shakeµRun the given action in a separate thread. On cleanup, the thread will be killed before continuing. If the action raises an exception it will be rethrown on the parent thread.1.23/05None"#X~£4shakeTReturn either a valid chunk (Right), or a trailing suffix with no information (Left)5shakeIf  writeChunksG and any of the reopen operations are interleaved it will cause issues.6shake@The file is being compacted, if the process fails, use a backup.7shake-The file got corrupted, return a new version. 8945:;<676NoneÔ=shake.Print all withTiming information and clear it.>=?7NonePŒù@shakeëGiven a pool, and a function that breaks the S invariants, restore them. They are only allowed to touch threadsLimit or todo. Assumes only requires spawning a most one job (e.g. can't increase the pool by more than one at a time)AshakeaAdd a new task to the pool. See the top of the module for the relative ordering and semantics.Bshake—Temporarily increase the pool by 1 thread. Call the cleanup action to restore the value. After calling cleanup you should requeue onto a new thread.Cshake­Make sure the pool cannot run out of tasks (and thus everything finishes) until after the cancel is called. Ensures that a pool that will requeue in time doesn't go idle.DshakeRun all the tasks in the pool on the given number of works. If any thread throws an exception, the exception will be reraised. EFGHIJKABCD8None"#=?MX˜›LshakeThe version and key, serialisedMshakeA list oft witnesses, savedNshakelStorage of heterogeneous things. In the particular case of Shake, k ~ QTypeRep, v ~ (Key, Status{Value}).òThe storage starts with a witness table saying what can be contained. If any entries in the witness table don't have a current Witness then a fake error witness is manufactured. If the witness ever changes the entire DB is rewritten.OshakeÆGiven the current witness table, and the serialised one from last time, return (witnesses that got removed, way to deserialise an entry into an Id, and (if the witness remains) the key and value)NshakeStorage optionsshakeLogging functionshake WitnessesN9None &',EHSX™ PQRSTUVWX:None4™‰YZ[\]^_`;None"#PXPashake7The path under which everything relating to a Key livesbshake=The list of files containing Entry values, given a result of acshakeFGiven a way to get the identity, see if you can a stored cloud versiondecfgh<NoneŸijkl=None "#%24=?EMXê >mshakeThe stack that ran to get here.nshakeLThe builtinVersion of the rule you are running stack scoped local variablesoshake!Verbosity, may be changed locallypshakeCReason to block apply, or Nothing to allow mutable local variablesqshake!Dependencies, built up in reversershake?Time spend building dependencies (may be negative for parallel)sshakeTraces, built in reversetshake"Things that are allowed to be usedushake Calls to  lintTrackReadvshake Calls to lintTrackWritewshake-Things this rule produces, True to check themxshakeIs it valid to cache the resultyshake5Database, contains knowledge of the state of each keyzshakePool, for queuing new elements{shakeCleanup operations|shake/Clock saying how many seconds through the build}shakeRules for this build~shakeOutput functionshake Shake options€shakeDebugging functionshakeactions to run after each rule‚shake3Operations to run on success, e.g. removeFilesAfterƒshake/Tracked things, in rule fst, snd must be absent„shakeRequest current progress state…shakeThe active shared state, if any†shakeJI am running in one-shot mode so don't need to store BS's for Result/Error‡shake5Does Versioned exist anywhere within userRuleContentsˆshakeThe actual rules‰shakeA ‰` data type, representing user-defined rules associated with a particular type. As an example > and ? will add entries to the ‰ data type.ŠshakeAdded to the state with  addUserRule :: Typeable a => a -> Rules ().‹shakeRules combined with the Œ / .shakeRules defined under priority.shakeRule defined under  alternatives, matched in order.shakeRule defined under  versioned, attaches a version.¯shakeProduce an identity for a valueÿ1 that can be used to do direct equality. If you have a custom notion of equality then the result should return only one member from each equivalence class, as values will be compared for literal equality. The result of the identity should be reasonably short (if it is excessively long, hash it).2For rules where the value is never compatible use @A, which returns FA. This will disable shared caches of anything that depends on it.°shakeThe action performed by --lint for a given key/valueJ pair. At the end of the build the lint action will be called for each key) that was built this run, passing the value it produced. Return F@ to indicate the value has not changed and is acceptable, or ‹& an error message to indicate failure.dFor builtin rules where the value is expected to change, or has no useful checks to perform. use @B.±shakeDefine a rule between key and value. As an example, a typical ± will look like: Rrun key oldStore mode = do ... return $ RunResult change newStore newValueWhere you have:key=, how to identify individual artifacts, e.g. with file names.oldStoreO, the value stored in the database previously, e.g. the file modification time.mode , either ½I (none of your dependencies changed, you can probably not rebuild) or ¾/ (your dependencies changed, probably rebuild).change, usually one of either ¸ (no work was required) or »= (I reran the rule and it should be considered different).newStoreO, the new value to store in the database, which will be passed in next time as oldStore.newValue, the result that C& will return when asked for the given key.‘shake"the result associated with the Key’shakewhen it was actually run“shake#the step for deciding if it's valid”shake#dependencies (don't run them early)•shake/how long it took when it was last run (seconds)–shakeQa trace of the expensive operations (start/end in seconds since beginning of run)—shakeI have a value˜shake#I have been run and raised an error™shakeLoaded from the databasešshake2Currently in the process of being checked or built›shake2I am only here because I got into the Intern table²shakeThe result of ±.´shake How has the ²& changed from what happened last time.µshake)The value to store in the Shake database.¶shakeThe value to return from C.·shake%How the output of a rule has changed.¸shakeNothing has changed.¹shake]The stored value has changed, but in a way that should be considered identical (used rarely).ºshake+I recomputed the value and it was the same.»shake,I recomputed the value and it was different.¼shake9What mode a rule is running in, passed as an argument to ±.½shake!My dependencies have not changed.¾shake`At least one of my dependencies from last time have changed, or I have no recorded dependencies.¿shakeThe ¿ monad, use  to raise œ actions into it, and D0 to execute files. Action values are used by  addUserRule and action. The ¿H monad tracks the dependencies of a rule. To raise an exception call ,  or  . Ÿ. shakeIAfterwards each Id must occur at most once and there are no empty Dependszÿû¡¢mnopqrstuvwx£¤¥yz{|}~€‚ƒ„¦…§¨†©ª«‡ˆ‰Š‹¬­®¯°±²³¯°±´µ¶·¸‘’“”•–¹˜—™š›º»¼½¾¿ÀÁÂÃÄŲ³´µ¶·¸¹º»¼½¾¿ÆÇÈÉÊËÌÍÎÏĞÑÒÓÔ ÕÖ×ØÙENone"#,2EHMSVX<²ÀshakeThe type mapping between the key or a rule and the resulting value . See Í and apply.ÁshakeLDefine a set of rules. Rules can be created with calls to functions such as ? or Ñ(. Rules are combined with either the " instance, or (more commonly) the Œ instance and do; notation. To define your own custom types of rule, see Development.Shake.Rule.ÂshakeGet the w that were used.ÚshakeìInternal variant, more flexible, but not such a nice API Same args as getuserRuleMaybe, but returns (guaranteed version, items, error to throw if wrong number) Fields are returned lazily, in particular ver can be looked up cheaperÃshakeEGet the user rules that were added at a particular type which return ‹m on a given function. Return all equally applicable rules, paired with the version of the rule (set by Ï"). Where rules are specified with Ğ or Î3 the less-applicable rules will not be returned.1If you can only deal with zero/one results, call Ä or Å$, which raise informative errors.Äshake A version of Ã; that fails if there is more than one result Requires a key for better error messages.Åshake A version of Ã= that fails if there is not exactly one result Requires a key for better error messages.Æshake?Get all targets registered in the given rules. The names in F and G$ as well as the file patterns in ?, H and I: are registered as targets, plus any explicit calls to ÈA. Returns the command, paired with the documentation (if any).Çshake†Add a user rule. In general these should be specialised to the type expected by a builtin rule. The user rules can be retrieved by Ã.Èshake-Register a target, as available when passing --help or through Æ+. Called automatically by rules such as F and ? - to avoid that use Ê*. To add documentation to a target use É.ÉshakeFor all È targets within the ÁS prodivde the specified documentation, if they don't already have documentation.ÊshakejRemove all targets specified in a set of rules, typically because they are internal details. Overrides È.Ëshake A suitable ° that always succeeds.Ìshake A suitable ¯; that always fails with a runtime error, incompatible with /. Use this function if you don't care about h, or if your rule provides a dependency that can never be cached (in which case you should also call J).ÍshakeWDefine a builtin rule, passing the functions to run in the right circumstances. The key and value types will be what is used by C. As a start, you can use Ë and ÌF as the first two functions, but are required to supply a suitable ±.6Raises an error if any other rule exists at this type.ÛshakeUnexpected version of Í, which also lets me set the  .Îshake÷Change the priority of a given set of rules, where higher priorities take precedence. All matching rules at a given priority must be disjoint, or an error is raised. All builtin Shake rules have priority between 0 and 1. Excessive use of Î is discouraged. As an example: Î 4 $ "hello.*" %> \out ->  writeFile' out "hello.*" Î 8 $ "*.txt" %> \out ->  writeFile' out "*.txt" In this example  hello.txtI will match the second rule, instead of raising an error about ambiguity.The Î function obeys the invariants: Î p1 (Î p2 r1) === Î p1 r1 Î p1 (r1 >> r2) === Î p1 r1 >> Î p1 r2 Ïshake¹Indicate that the nested rules have a given version. If you change the semantics of the rule then updating (or adding) a version will cause the rule to rebuild in some circumstances. Ï 1 $ "hello.*" %> \out ->  writeFile'0 out "Writes v1 now" -- previously wrote out v0 You should only use Ïr to track changes in the build source, for standard runtime dependencies you should use other mechanisms, e.g. K.Ğshake±Change the matching behaviour of rules so rules do not have to be disjoint, but are instead matched in order. Only recommended for small blocks containing a handful of rules. Ğ $ do "hello.*" %> \out ->  writeFile'& out "hello.*" "*.txt" %> \out ->  writeFile' out "*.txt" In this example  hello.txtS will match the first rule, instead of raising an error about ambiguity. Inside Ğ the ΋ of each rule is not used to determine which rule matches, but the resulting match uses that priority compared to the rules outside the Ğ block.ÑshakeBRun an action, usually used for specifying top-level requirements. main = L ® $ do Ñ $ do b <- M "file.src" when b $ D ["file.out"] This Ñ builds file.out, but only if file.src exists. The Ñ1 will be run in every build execution (unless ÒØ is used), so only cheap operations should be performed. On the flip side, consulting system information (e.g. environment variables) can be done directly as the information will not be cached. All calls to Ñ& may be run in parallel, in any order.%For the standard requirement of only D!ing a fixed list of files in the Ñ , see N.Òshake}Remove all actions specified in a set of rules, usually used for implementing command line specification of what to build.ÀÁÂÚÃÄÅÜÆÇÈÉÊËÌÍİÎÏĞÑÒONone"#PBŞshakeEnqueue an Action into the pool and return a Fence to wait for it. Returns the value along with how long it spent executing.ßshakeLike ޼ but doesn't provide a fence to wait for it - a fire and forget version. Warning: If Action throws an exception, it would be lost, so must be executed with try. Seconds are not tracked.ŞßàáâãäPNone"#$%,PX«åshakeµApply a modification, run an action, then run an undo action after. Doesn't actually require exception handling because we don't have the ability to catch exceptions to the user.æshakeñTurn a normal exception into a ShakeException, giving it a stack and printing it out if in staunch mode. If the exception is already a ShakeException (e.g. it's a child of ours who failed and we are rethrowing) then do nothing with it.Óshake!If an exception is raised by the ¿, perform some œ then reraise the exception.Ôshake After an ¿, perform some œ , even if there is an exception.Õshake+If a syncronous exception is raised by the ¿f, perform some handler. Note that there is no guarantee that the handler will run on shutdown (use Ô for that), and that Õ cannot9 catch exceptions thrown by dependencies, e.g. raised by needH (to do so would allow untracked dependencies on failure conditions).Öshake Retry an ¿$ if it throws an exception, at most n times (where n‘ must be positive). If you need to call this function, you should probably try and fix the underlying cause (but you also probably know that).×shakeGet the initial w1, these will not change during the build process.ØshakeGet the current –$ structure, as would be returned by ’.ÙshakecSpecify an action to be run after the database has been closed, if building completes successfully.Úshake<Write an unimportant message to the output, only shown when | is higher than normal (t€ or above). The output will not be interleaved with any other Shake messages (other than those generated by system commands).ÛshakeCWrite a normal priority message to the output, only supressed when | is r or qv. The output will not be interleaved with any other Shake messages (other than those generated by system commands).Üshake>Write an important message to the output, only supressed when | is qv. The output will not be interleaved with any other Shake messages (other than those generated by system commands).İshake3Get the current verbosity level, originally set by |U. If you want to output information to the console, you are recommended to use Ú / Û / Üc, which ensures multiple messages are not interleaved. The verbosity can be modified locally by Ş.ŞshakeHRun an action with a particular verbosity level. Will not update the | returned by ×$ and will not have any impact on v tracing.ßshakeRun an action with r/ verbosity, in particular messages produced by à (including from " or !<) will not be printed to the screen. Will not update the | returned by × and will not turn off any v tracing.àshakebWrite an action to the trace list, along with the start/end time of running the IO action. The " and ! functions automatically call àU with the name of the executable. The trace list is used for profile reports (see ~). By default àH prints some useful extra context about what Shake is building, e.g.: !# traced message (for myobject.o)To suppress the output of à> (for example you want more control over the message using Û ), use the ß combinator.,It is recommended that the string passed to àÍ is short and that only a small number of unique strings are used (makes profiling work better). The string does not need to make sense on its own, only in conjunction with the target it is building.áshakeETrack that a key has been used/read by the action preceeding it when  is active.âshakeJTrack that a key has been changed/written by the action preceding it when  is active.ãshake%Allow any matching key recorded with á or âC in this action, after this call, to violate the tracking rules.äshakeThis rule should not be cached or recorded in the history because it makes use of untracked dependencies (e.g. files in a system directory or items on the $PATH$), or is trivial to compute locally.çshake A version of produces% that checks the files actually existèshake A version of produces that does not check.åshakeZRun an action but do not depend on anything the action uses. A more general version of  orderOnly.æshake A version of Q3 that runs in IO, and can be called before calling L. Most people should use Q instead.çshake³Run an action without counting to the thread limit, typically used for actions that execute on remote machines using barely any local CPU resources. Unsafe as it allows the z< limit to be exceeded. You cannot depend on a rule (e.g. needI) while the extra thread is executing. If the rule blocks (e.g. calls  withResource^) then the extra thread may be used by some other action. Only really suitable for calling cmd / command.èshake5Execute a list of actions in parallel. In most cases need6 will be more appropriate to benefit from parallelism.éshake&Batch different outputs into a single ¿D, typically useful when a command has a high startup cost - e.g. apt-get install foo bar baz2 is a lot cheaper than three separate calls to apt-get install2. As an example, if we have a standard build rule: "*.out" ? \out -> do D [out -<.> "in"] " "build-multiple" [out -<.> "in"] Assuming that build-multipleŒ can compile multiple files in a single run, and that the cost of doing so is a lot less than running each individually, we can write: é 3 ("*.out" ?) (\out -> do D [out -<.>" "in"]; return out) (\outs -> " "build-multiple" [out -<.> "in" | out <- outs]) ‘In constrast to the normal call, we have specified a maximum batch size of 3, an action to run on each output individually (typically all the needg dependencies), and an action that runs on multiple files at once. If we were to require lots of *.out6 files, they would typically be built in batches of 3.©If Shake ever has nothing else to do it will run batches before they are at the maximum, so you may see much smaller batches, especially at high parallelism settings.êshakeôGiven a running task, deprioritize so it only continues after all other pending tasks, and all deprioritized tasks with a higher priority. Note that due to parallelism there is no guarantee that all actions of a higher priority will have  completedg before the action resumes. Only useful if the results are being interactively reported or consumed.éshakeHooked up to --share-removeêshakeHooked up to --share-listéshake.Maximum number to run in a single batch, e.g. 3, must be positive.shakeWay to match an entry, e.g. "*.ext" %>.shake4Preparation to run individually on each, e.g. using need.shake-Combination action to run on all, e.g. using cmd.&æÓÔÕÖ×ØÙëÚÛÜİŞßìíàáâîãïğäçèñåæçèéêòóéêRNone"#%ÅÊ ôshake&Some number of resources are availableõshakeWSome users are blocked (non-empty), plus an action to call once we go back to Availableöshake'number of currently available resources÷shakeSqueue of people with how much they want and the action when it is allocated to themëshakepA type representing an external resource which the build system should respect. There are two ways to create ë s in Shake:SP creates a finite resource, stopping too many actions running simultaneously.T] creates a throttled resource, stopping too many actions running over a short time period.These resources are used with UA when defining rules. Typically only system commands (such as ") should be run inside U, not commands such as D.'Be careful that the actions run within U± do not themselves require further resources, or you may get a "thread blocked indefinitely in an MVar operation" exception. If an action requires multiple resources, use V to avoid deadlock.øshakedKey used for Eq/Ord operations. To make withResources work, we require newResourceIO < newThrottleIOùshakeString used for Showúshake+Acquire the resource and call the function.ûshakeLYou should only ever releaseResource that you obtained with acquireResource.ìshakeIRun an action which uses part of a finite resource. For more details see ë'. You cannot depend on a rule (e.g. need) while a resource is held.íshake A version of S3 that runs in IO, and can be called before calling L. Most people should use S instead.îshake A version of T3 that runs in IO, and can be called before calling L. Most people should use T instead.ëìíîWNone "#$%&',PSXÛK üshake6Lookup the value for a single Id, may need to spawn itıshakeKBuild a key, must currently be either Loaded or Missing, changes to WaitingşshakeCCompute the value for a given RunMode and a restore function to runÿshakeHave the dependencies changedïshake§Execute a rule, returning the associated values. If possible, the rules will be run in parallel. This function requires that appropriate rules have been added with Í . All key values passed to ï become dependencies of the ¿.ğshake+Apply a single rule, equivalent to calling ï/ with a singleton list. Where possible, use ï to allow parallelism.ñshakeILoad a value from the history. Given a version from any user rule (or 0)), return the payload that was stored by ó.If this function returns ‹< it will also have restored any files that were saved by ó.òshake Is the history enabled, returns ÷ if you have a  or ‘, and haven't called ä so far in this rule.óshakeHSave a value to the history. Record the version of any user rule (or 0 ), and a payload. Must be run at the end of the rule, after any dependencies have been captured. If history is enabled, stores the information in a cache.This function relies on producesi to have been called correctly to describe which files were written during the execution of this rule.ïğñòóNoneÛ¢¯°±²³´µ¶·¸¹º»¼½¾ÃÄÅÇËÌÍáâãïğñòóͰ˯̱¼½¾·¸¹º»²³´µ¶ïğÇÃÄÅáâãòóñXNone2HMVXãêôshakeiAlways rerun the associated action. Useful for defining rules that query the environment. For example: "ghcVersion.txt" ? \out -> do ô Y stdout <- " "ghc --numeric-version" Z out stdout In make, the .PHONY8 attribute on file-producing rules has a similar effect. Note that ôM is applied when a rule is executed. Modifying an existing rule to insert ô will not$ cause that rule to rerun next time.ô[None ,2HMVX®õshakeaAdd extra information which rules can depend on. An oracle is a function from a question type q, to an answer type aa. As an example, we can define an oracle allowing you to depend on the current version of GHC: ’newtype GhcVersion = GhcVersion () deriving (Show,Typeable,Eq,Hashable,Binary,NFData) type instance RuleResult GhcVersion = String rules = do õ $ \(GhcVersion _) -> fmap \ $ "< "ghc --numeric-version" :: Action String ... rules ... If a rule calls ø (GhcVersion ())J, that rule will be rerun whenever the GHC version changes. Some notes: We define  GhcVersion with a newtype around (), allowing the use of GeneralizedNewtypeDeriving6. All the necessary type classes are exported from Development.Shake.Classes.The  type instance requires the extension  TypeFamilies. Each call to õ' must use a different type of question.Actions passed to õò will be run in every build they are required, even if nothing else changes, so be careful of slow actions. If the result of an oracle does not change it will not invalidate any rules depending on it. To always rerun files rules see ].FAs a more complex example, consider tracking Haskell package versions: ÿCnewtype GhcPkgList = GhcPkgList () deriving (Show,Typeable,Eq,Hashable,Binary,NFData) type instance RuleResult GhcPkgList = [(String, String)] newtype GhcPkgVersion = GhcPkgVersion String deriving (Show,Typeable,Eq,Hashable,Binary,NFData) type instance RuleResult GhcPkgVersion = Maybe String rules = do getPkgList <- õ- $ \GhcPkgList{} -> do Stdout out <- "™ "ghc-pkg list --simple-output" return [(reverse b, reverse a) | x <- words out, let (a,_:b) = break (== '-') $ reverse x] getPkgVersion <- õß $ \(GhcPkgVersion pkg) -> do pkgs <- getPkgList $ GhcPkgList () return $ lookup pkg pkgs "myrule" %> \_ -> do getPkgVersion $ GhcPkgVersion "shake" ... rule using the shake version ... >Using these definitions, any rule depending on the version of shake should call %getPkgVersion $ GhcPkgVersion "shake" to rebuild when shake is upgraded. If you apply Ï] to an oracle it will cause that oracle result to be discarded, and not do early-termination.öshakeAn alternative to to õ that relies on the E; function providing a perfect equality, doesn't support --skip, but requires less storage.÷shakeA combination of õ and newCached - an action that only runs when its dependencies change, whose result is stored in the database.jDoes the information need recomputing every time? e.g. looking up stuff in the environment? If so, use õ instead.:Is the action mostly deserisalising some file? If so, use newCache.FIs the operation expensive computation from other results? If so, use ÷.An alternative to using ÷¯ is introducing an intermediate file containing the result, which requires less storage in the Shake database and can be inspected by existing file-system viewing tools.øshake&Get information previously added with õ or ÷D. The question/answer types must match those provided previously.ùshakeA parallel version of ø.õö÷øù^None"#$%,2=?HMVX€ˆ shakeAn equality check and a cost.shakeThe equality check was cheap.shakeIThe equality check was expensive, as the results are not trivially equal.shakeThe values are not equal.shakeDThe file rules we use, first is the name (as pretty as you can get). shakeThe results of the various   rules. shake"The types of file rule that occur. shakeAn action with no file value shake!An action that produces this file shake4An action that looks up a file someone else producedshake_Result of a File rule, may contain raw file information and whether the rule did run this buildshake=Raw information about the file built by this rule. Set to F for  files.shake!Should we lint the resulting fileshakeRaw information about a file.shakeAThe unique key we use to index File rules, to avoid name clashes.shakedArguments: options; is the file an input; a message for failure if the file does not exist; filenameúshakeqHas a file changed. This function will only give the correct answer if called in the rule producing the file, beforej the rule has modified the file in question. Best avoided, but sometimes necessary in conjunction with üE to cause rebuilds to happen if the result is deleted or modified.shake-Internal method for adding forwarding actionsûshakeÉAdd a dependency on the file arguments, ensuring they are built before continuing. The file arguments may be built in parallel, in any order. This function is particularly necessary when calling " or !. As an example:  "//*.rot13"  \out -> do let src = _ out û [src] " "rot13" [src] "-o" [out] Usually need [foo,bar] is preferable to need [foo] >> need [bar]H as the former allows greater parallelism, while the latter requires foo- to finish building before starting to build bar.8This function should not be called with wildcards (e.g. *.txt - use getDirectoryFiles1 to expand them), environment variables (e.g. $HOME - use getEnvw to expand them) or directories (directories cannot be tracked directly - track files within the directory instead).üshakeLike û[ but returns a list of rebuilt dependencies since the calling rule last built successfully.TThe following example writes a list of changed dependencies to a file as its action.  "target" O \out -> do let sourceList = ["source1", "source2"] rebuildList <- ü sourceList ` out rebuildList dThis function can be used to alter the action depending on which dependency needed to be rebuild.YNote that a rule can be run even if no dependency has changed, for example because of …e or because the target has changed or been deleted. To detect the latter case you may wish to use ú.ıshakeLike û , but if  is set, check that the file does not rebuild. Used for adding dependencies on files that have already been used in this rule.şshake;Track that a file was read by the action preceeding it. If N is activated then these files must be dependencies of this rule. Calls to ş" are automatically inserted in © mode.ÿshake>Track that a file was written by the action preceeding it. If € is activated then these files must either be the target of this rule, or never referred to by the build system. Calls to ÿ are automatically inserted in © mode.shake=Allow accessing a file in this rule, ignoring any subsequent ş / ÿ calls matching the pattern.shake¢This rule builds the following files, in addition to any defined by its target. At the end of the rule these files must have been written. These files must notc be tracked as part of the build system - two rules cannot produce the same file and you cannot û the files it produces.shakeSRequire that the argument files are built by the rules, used to specify the target. main = L ® $ do  ["Main.exe"] ... This program will build Main.exe/, given sufficient rules. All arguments to all 1 calls may be built in parallel, in any order.%This function is defined in terms of Ñ and û, use Ñ* if you need more complex targets than  allows.shakeŞDeclare a Make-style phony action. A phony target does not name a file (despite living in the same namespace as file rules); rather, it names some action to be executed when explicitly requested. You can demand  rules using . (And û&, although that's not recommended.)YPhony actions are intended to define recipes that can be executed by the user. If you ûİ a phony action in a rule then every execution where that rule is required will rerun both the rule and the phony action. However, note that phony actions are never executed more than once in a single build run. In make, the .PHONYx attribute on non-file-producing rules has a similar effect. However, while in make it is acceptable to omit the .PHONYÇ attribute as long as you don't create the file in question, a Shake rule which behaves this way will fail lint. For file-producing rules which should be rerun every execution of Shake, see ].shakeA predicate version of  , return ‹ with the ¿ for the matching rules.shakeInfix operator alias for /, for sake of consistency with normal rules.shake<Define a rule to build files. If the first argument returns ÷L for a given file, the second argument will be used to build it. Usually  is sufficient, but _ gives additional power. For any file used by the build system, only one rule should return ÷O. This function will create the directory for the result file, if necessary. (all isUpper . a)  \out -> do let src = b* out $ map toLower $ takeBaseName out c out . map toUpper =<< d src If the ¿_ completes successfully the file is considered up-to-date, even if the file has not changed.shakeaDefine a set of patterns, and if any of them match, run the associated rule. Defined in terms of . Think of it as the OR (||) equivalent of .shakeDefine a rule that matches a l, see nÑ for the pattern rules. Patterns with no wildcards have higher priority than those with wildcards, and no file required by the system may be matched by more than one pattern at the same priority (see Î and Ği to modify this behaviour). This function will create the directory for the result file, if necessary.  "*.asm.o"  \out -> do let src = _ out û [src] " "as" [src] "-o" [out] MTo define a build system for multiple compiled languages, we recommend using .asm.o, .cpp.o, .hs.oH, to indicate which language produces an object file. I.e., the file foo.cpp produces object file  foo.cpp.o.6Note that matching is case-sensitive, even on Windows.If the ¿_ completes successfully the file is considered up-to-date, even if the file has not changed.úûüışÿ1111eNoneŒ) shakeÿNDefine order-only dependencies, these are dependencies that will always be built before continuing, but which aren't dependencies of this action. Mostly useful for defining generated dependencies you think might be real dependencies. If they turn out to be real dependencies, you should add an explicit dependency afterwards. "source.o" %> \out -> do   ["header.h"] cmd_5 "gcc -c source.c -o source.o -MMD -MF source.m" neededMakefileDependencies "source.m" If header.h is included by source.c then the call to needMakefileDependenciesk will cause it to be added as a real dependency. If it isn't, then the rule won't rebuild if it changes. fNone %,2HMVX¤ shakeWDefine a rule for building multiple files at the same time. Think of it as the AND (&&) equivalent of =. As an example, a single invocation of GHC produces both .hi and .o files: ["*.o","*.hi"]   \[o,hi] -> do let hs = o 9 "hs" D% ... -- all files the .hs import " "ghc -c" [hs] ?However, in practice, it's usually easier to define rules with  and make the .hi depend on the .o9. When defining rules that build multiple files, all the l* values must have the same sequence of // and *j wildcards in the same order. This function will create directories for the result files, if necessary. shakemDefine a rule for building multiple files at the same time, a more powerful and more dangerous version of  . Think of it as the AND (&&) equivalent of .Given an application  test &?> ..., test should return Just^ if the rule applies, and should return the list of files that will be produced. This list mustI include the file passed as an argument and should obey the invariant: SforAll $ \x ys -> test x == Just ys ==> x `elem` ys && all ((== Just ys) . test) ys§Intuitively, the function defines a set partitioning, mapping each element to the partition that contains it. As an example of a function satisfying the invariaint:  test x | :& x `elem` [".hi",".o"] = Just [6 x 7 "hi", 6 x 7 "o"] test _ = Nothing Regardless of whether Foo.hi or Foo.o( is passed, the function always returns [Foo.hi, Foo.o].   1 1gNoneXß shake9Get a checksum of a list of files, suitable for using as {n. This will trigger a rebuild when the Shake rules defined in any of the files are changed. For example: main = do ver <-   ["Shakefile.hs"]  shakeArgs ®{{ = ver} ... BTo automatically detect the name of the current file, turn on the TemplateHaskell extension and write -$(LitE . StringL . loc_filename <$> location).IThis feature can be turned off during development by passing the flag --no-rule-version or setting  to ÷. shakeGet an item from •o, using the requested type as the key. Fails if the value found at this key does not match the requested type.shake A version of   in Á.shake"Add a properly structued value to • which can be retrieved with  .shakecopyFile' old new copies the existing file from old to new . The oldV file will be tracked as a dependency. Also creates the new directory if necessary.shakecopyFileChanged old new copies the existing file from old to new', if the contents have changed. The oldV file will be tracked as a dependency. Also creates the new directory if necessary.shakeRead a file, after calling û4. The argument file will be tracked as a dependency.shakeWrite a file, lifted to the ¿ monad.shake A version of _ which also splits the result into lines. The argument file will be tracked as a dependency.shake A version of " which writes out a list of lines.shake4Write a file, but only if the contents would change.shake™Create a temporary file in the temporary directory. The file will be deleted after the action completes (provided the file is not still open). The  will not have any file extension, will exist, and will be zero bytes long. If you require a file with a specific name, use .shakeLike ( but using a custom temporary directory.shakeCreate a temporary directory inside the system temporary directory. The directory will be deleted after the action completes. As an example:  $ \mydir -> do Û$ $ "Temp directory is " ++ mydir 2 (mydir </> "test.txt") "writing out a temp file" shakeLike ( but using a custom temporary directory.shakeA è version of .shake-Execute two operations in parallel, based on è.shakeÿZCreate a finite resource, given a name (for error messages) and a quantity of the resource that exists. Shake will ensure that actions using the same finite resource do not execute in parallel. As an example, only one set of calls to the Excel API can occur at one time, therefore Excel is a finite resource of quantity 1. You can write: L h{i =2} $ do N ["a.xls","b.xls"] excel <- S "Excel" 1 "*.xls" ? \out -> U excel 1 $ " "excel" out ... Now the two calls to excel will not happen in parallel.ßAs another example, calls to compilers are usually CPU bound but calls to linkers are usually disk bound. Running 8 linkers will often cause an 8 CPU system to grid to a halt. We can limit ourselves to 4 linkers with: disk <- S "Disk" 4 N [show i  "exe" | i <- [1..100]] "*.exe" ? \out -> U disk 1 $ " "ld -o" [out] ... "*.o" ? \out -> " "cl -o" [out] ... shake^Create a throttled resource, given a name (for error messages) and a number of resources (the @+) that can be used per time period (the  ü in seconds). Shake will ensure that actions using the same throttled resource do not exceed the limits. As an example, let us assume that making more than 1 request every 5 seconds to Google results in our client being blacklisted, we can write:  google <- T "Google" 1 5 "*.url" ? \out -> do U google 1 $ "$ "wget" ["https://google.com?q=" ++ a out] "-O" [out] ¬Now we will wait at least 5 seconds after querying Google before performing another query. If Google change the rules to allow 12 requests per minute we can instead use T "Google" 12 60, which would allow greater parallelisation, and avoid throttling entirely if only a small number of requests are necessary.eIn the original example we never make a fresh request until 5 seconds after the previous request has  completedH. If we instead want to throttle requests since the previous request started we can write:  google <- T "Google" 1 5 "*.url" ? \out -> do U google 1 $ return () "$ "wget" ["https://google.com?q=" ++ a out] "-O" [out] =However, the rule may not continue running immediately after Uß completes, so while we will never exceed an average of 1 request every 5 seconds, we may end up running an unbounded number of requests simultaneously. If this limitation causes a problem in practice it can be fixed.shakeÜRun an action which uses part of several finite resources. Acquires the resources in a stable order, to prevent deadlock. If all rules requiring more than one resource acquire those resources with a single call to , resources will not deadlock. shakeêGiven an action on a key, produce a cached version that will execute the action at most once per key per run. Using the cached result will still result include any dependencies that the action requires - e.g. if the action does û[ then those dependencies will be added to every rule that uses that cache. Each call to  D creates a separate cache that is independent of all other calls to  .›The operations will not be cached between runs and nothing will be persisted to the Shake database. For an alternative that does persist the cache, see j.ÌThis function is useful when creating files that store intermediate values, to avoid the overhead of repeatedly reading from disk, particularly if the file requires expensive parsing. As an example:  digits <-  ] $ \file -> do src <- readFile' file return $ length $ filter isDigit src "*.digits" ? \x -> do v1 <- digits ( dropExtension x) v2 <- digits ( dropExtension x) c x $ show (v1,v2) To create the result MyFile.txt.digits the file  MyFile.txtB will be read and counted, but only at most once per execution.   None"#$&'2=?MUVX‚?#!shake'Class to convert an a to a CmdArgument"shakeConversion to a CmdArgument#shakeThe arguments to M - see M for examples and semantics.$shakeArguments to cmd%shakeThe arguments to M - see M for examples and semantics.'shake£A type annotation, equivalent to the first argument, but in variable argument contexts, gives a clue as to what return type is expected (not actually enforced).(shake`A class for specifying what results you want to collect from a process. Values are formed of ?, 9, 3 and tuples of those.)shakeThe allowable õ"-like values that can be captured.*shake–Collect the command line used for the process. This command line will be approximate - suitable for user diagnostics, but not for direct execution.-shakeOCollect the time taken to execute the process. Can be used in conjunction with *B to write helper functions that print out the time of a result.  timer :: (( r, MonadIO m) => (forall r . (& r => m r) -> m r timer act = do (- t, *ƒ x, r) <- act liftIO $ putStrLn $ "Command " ++ x ++ " took " ++ show t ++ " seconds" return r run :: IO () run = timer $ M "ghc --version" 0shake Collect the !m of the process. If you do collect the process handle, the command will run asyncronously and the call to M / K7 will return as soon as the process is spawned. Any ? / 9$ captures will return empty strings.3shake Collect the "= of the process. If you do not collect the exit code, any # will cause an exception.6shake Collect the stdout and stderr! of the process. If used, the stderr and stdout8 will not be echoed to the terminal, unless you include _ and `". The value type may be either õ, or either lazy or strict  ByteString.9shake Collect the stderr! of the process. If used, the stderr8 will not be echoed to the terminal, unless you include `". The value type may be either õ, or either lazy or strict  ByteString.<shakeLike ?1 but remove all leading and trailing whitespaces.?shake Collect the stdout! of the process. If used, the stdout8 will not be echoed to the terminal, unless you include _". The value type may be either õ, or either lazy or strict  ByteString.PNote that most programs end their output with a trailing newline, so calling ghc --numeric-version will result in ? of  "6.8.3\n"A. If you want to automatically trim the resulting string, see <.BshakeThe results produced by fsatraceE. All files will be absolute paths. You can get the results for a M" by requesting a value of type [B].CshakeWriting to a fileDshakeReading from a fileEshakeDeleting a fileFshake*Moving, arguments destination, then sourceGshakeQuerying/stat on a fileHshakeTouching a fileIshake Deprecated: Use U4. This function will be removed in a future version.Add a prefix and suffix to the $PATH# environment variable. For example: opt <- I ["/usr/special"] [] M opt "userbinary --version" Would prepend  /usr/special to the current $PATH , and the command would pick /usr/special/userbinary+, if it exists. To add other variables see J.Jshake Deprecated: Use S4. This function will be removed in a future version.6Add a single variable to the environment. For example: opt <- J [("CFLAGS","-O2")] M opt "gcc -c main.c" #Would add the environment variable $CFLAGS with value -O2. If the variable $CFLAGSG was already defined it would be overwritten. If you wish to modify $PATH see I.$shake Parse the B1 entries, ignoring anything you don't understand.%shake;Given explicit operations, apply the Action ones, like skiptrace track/autodep&shakeUGiven a very explicit set of CmdOption, translate them to a General.Process structure'shakeFApply all environment operations, to produce a new environment to use.(shake¡If the user specifies a custom $PATH, and not Shell, then try and resolve their prog ourselves. Tricky, because on Windows it doesn't look in the $PATH first.)shakeŠGiven a list of directories, and a file name, return the complete path if you can find it. Like findExecutable, but with a custom PATH.Kshake)Execute a system command. Before running K make sure you D+ any files that are used by the command.2This function takes a list of options (often just [], see Pd for the available options), the name of the executable (either a full name, or a program on the $PATH2) and a list of arguments. The result is often ()%, but can be a tuple containg any of ?, 9 and 3. Some examples: Li [] "gcc" ["-c","myfile.c"] -- compile a file, throwing an exception on failure 3 c <- KW [] "gcc" ["-c",myfile] -- run a command, recording the exit code (3 c, 9 err) <- KY [] "gcc" ["-c","myfile.c"] -- run a command, recording the exit code and error output ? out <- KO [] "gcc" ["-MM","myfile.c"] -- run a command, recording the output L [QP "generated"] "gcc" ["-c",myfile] -- run a command in a directory Unless you retrieve the " using 3, any #' will throw an error, including the 9. in the exception message. If you capture the ? or 9N, that stream will not be echoed to the console, unless you use the option _ or `. If you use K inside a doc block and do not use the result, you may get a compile-time error about being unable to deduce (. To avoid this error, use L.By default the stderrZ stream will be captured for use in error messages, and also echoed. To only echo pass ^ öN, which causes no streams to be captured by Shake, and certain programs (e.g. gcc.) to detect they are running in a terminal.Lshake A version of K\ where you do not require any results, used to avoid errors about being unable to deduce (.Mshake)Execute a system command. Before running M make sure you D+ any files that are used by the command.StringC arguments are treated as a list of whitespace separated arguments.[String]6 arguments are treated as a list of literal arguments.P arguments are used as options.3Typically only string literals should be passed as String+ arguments. When using variables prefer [myvar] so that if myvar+ contains spaces they are properly escaped.HAs some examples, here are some calls, and the resulting command string: NF "git log --pretty=" "oneline" -- git log --pretty= oneline NF "git log --pretty=" ["oneline"] -- git log --pretty= oneline NE "git log" ("--pretty=" ++ "oneline") -- git log --pretty=oneline NF "git log" ("--pretty=" ++ "one line") -- git log --pretty=one line NH "git log" ["--pretty=" ++ "one line"] -- git log "--pretty=one line" [More examples, including return values, see this translation of the examples given for the K function: Nm "gcc -c myfile.c" -- compile a file, throwing an exception on failure 3 c <- M[ "gcc -c" [myfile] -- run a command, recording the exit code (3 c, 9 err) <- M] "gcc -c myfile.c" -- run a command, recording the exit code and error output ? out <- MS "gcc -MM myfile.c" -- run a command, recording the output M (Q# "generated") "gcc -c" [myfile] :: ¿, () -- run a command in a directory  If you use M inside a doc block and do not use the result, you may get a compile-time error about being unable to deduce (. To avoid this error, use N. If you enable OverloadedStrings or OverloadedListsW you may have to give type signatures to the arguments, or use the more constrained K instead.The M! function can also be run in the œ monad, but then [? is ignored and command lines are not echoed. As an example: M (Q "generated") Y "gcc -c myfile.c" :: IO () NshakeSee M . Same as M except with a unit result. M is to N as K is to L.*shakeGiven the parametershake;Call with the revised params, program name and command line+shakeGiven the parametershake;Call with the revised params, program name and command lineEP\RQSTUVWXYZ[]^_`abcde!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNEKLMN%&#$!"'?@A<=>9:;678345012-./*+,BCDEFGH()P\RQSTUVWXYZ[]^_`abcdeIJkNone ,2HMVXÌ; shakeReturns ÷ if the file exists. The existence of the file is tracked as a dependency, and if the file is created or deleted the rule will rerun in subsequent builds.You should not call 3 on files which can be created by the build system.€shakeReturns ÷« if the directory exists. The existence of the directory is tracked as a dependency, and if the directory is created or delete the rule will rerun in subsequent builds.You should not call €9 on directories which can be created by the build system.shakeReturn ‹+ the value of the environment variable, or F½ if the variable is not set. The environment variable is tracked as a dependency, and if it changes the rule will rerun in subsequent builds. This function is a tracked version of  /  lookupEnv from the base library. flags <- getEnv "CFLAGS" cmd' "gcc -c" [out] (maybe [] words flags) ‚shake‚ def var/ returns the value of the environment variable var, or the default value def if it is not set. Similar to . ,flags <- getEnvWithDefault "-Wall" "CFLAGS" cmd "gcc -c" [out] flags ƒshake`Get the contents of a directory. The result will be sorted, and will not contain the entries . or ..ÿ (unlike the standard Haskell version). The resulting paths will be relative to the first argument. The result itself is tracked as a dependency, but the files in the result are not. If the list of files changes in subsequent builds any rule calling it will rerun.%It is usually simpler to call either „ or ….„shake|Get the files anywhere under a directory that match any of a set of patterns. For the interpretation of the patterns see nù. All results will be relative to the directory argument. The result itself is tracked as a dependency, but the files in the result are not. If the list of files changes in subsequent builds any rule calling it will rerun. Some examples: ÿXgetDirectoryFiles "Config" ["//*.xml"] -- All .xml files anywhere under the Config directory -- If Config/foo/bar.xml exists it will return ["foo/bar.xml"] getDirectoryFiles "Modules" ["*.hs","*.lhs"] -- All .hs or .lhs in the Modules directory -- If Modules/foo.hs and Modules/foo.lhs exist, it will return ["foo.hs","foo.lhs"]?If you require a qualified file name it is often easier to use "" as the G argument, for example the following two expressions are equivalent: ifmap (map ("Config" </>)) (getDirectoryFiles "Config" ["//*.xml"]) getDirectoryFiles "" ["Config//*.xml"]MIf the first argument directory does not exist it will raise an error. If fooH does not exist, then the first of these error, but the second will not. VgetDirectoryFiles "foo" ["//*"] -- error getDirectoryFiles "" ["foo//*"] -- returns []HThis function is tracked and serves as a dependency. If a rule calls getDirectoryFiles "" ["*.c"] and someone adds foo.cL to the directory, that rule will rebuild. If someone changes one of the .c files, but the list of .c› files doesn't change, then it will not rebuild. As a consequence of being tracked, if the contents change during the build (e.g. you are generating .cs files in this directory) then the build not reach a stable point, which is an error - detected by running with --lintH. You should normally only call this function returning source files.For an untracked variant see †.…shake2Get the directories in a directory, not including . or ..ó. All directories are relative to the argument directory. The result itself is tracked as a dependency, but the directories in the result are not. If the list of directories changes in subsequent builds any rule calling it will rerun.†shake A version of „# that is in IO, and thus untracked.‡shakeeRemove all files and directories that match any of the patterns within a directory. Some examples: ‡> "output" ["//*"] -- delete everything inside 'output' ‡3 "output" ["//"] -- delete 'output' itself ‡; "." ["//*.hi","//*.o"] -- delete all '.hi' and '.o' files |If the argument directory is missing no error is raised. This function will follow symlinks, so should be used with care.-This function is often useful when writing a clean- action for your build system, often as a phony rule.ˆshakeRemove files, like ‡<, but executed after the build completes successfully using Ù. Useful for implementing cleanB actions that delete files Shake may have open for building, e.g.  shakeFilesP. Where possible, delete the files as a normal part of the build, e.g. using  $ ‡ dir pats. ,€‚ƒ„…†‡ˆlNoneÌ-mSafeÌá./012345nNoneÍ86789:oNone%Ğÿ;shakeDTemplate Engine. Perform the following replacements on a line basis: script src="foo" /script ==>  script[[foo]] /script link-href="foo" rel="stylesheet" type="text/css" / ==>  styletype="text/css"[[foo]] /style;pNone"#%P÷y<shake0A machine that takes inputs and produces outputs=shake3return (number of seconds, percentage, explanation)‰shake|Given a sampling interval (in seconds) and a way to display the status message, produce a function suitable for using as $8. This function polls the progress information every nR seconds, produces a status message and displays it using the display function..Typical status messages will take the form of  1m25s (15%)ÿ„, indicating that the build is predicted to complete in 1 minute 25 seconds (85 seconds total), and 15% of the necessary build time has elapsed. This function uses past observations to predict future behaviour, and as such, is only guessing. The time is likely to go up as well as down, and will be less accurate from a clean build (as the system has fewer past observations).FThe current implementation is to predict the time remaining (based on   ) and the work already done ((). The percentage is then calculated as remaining / (done + remaining)., while time left is calculated by scaling  remaining5 by the observed work rate in this build, roughly done / time_elapsed.>shakeTGiven a list of progress inputs, what would you have suggested (seconds, percentage)?shake8Given a trace, display information about how well we didŠshake^Set the title of the current console window to the given text. If the environment variable $TERM is set to xtermf this uses xterm escape sequences. On Windows, if not detected as an xterm, this function uses the SetConsoleTitle API.‹shakeCall the program shake-progress if it is on the $PATH8. The program is called with the following arguments:--title=string - the string passed to progressProgram.--state=Normal , or one of  NoProgress, Normal, or Error9 to indicate what state the progress bar should be in. --value=25: - the percent of the build that has completed, if not in  NoProgress state.;The program will not be called consecutively with the same --state and --value options.nWindows 7 or higher users can get taskbar progress notifications by placing the following program in their $PATH:  ,https://github.com/ndmitchell/shake/releases.ŒshakeHA simple method for displaying progress messages, suitable for using as $X. This function writes the current progress to the titlebar every five seconds using Š, and calls any shake-progress program on the $PATH using ‹. @ABCDEF‰>?Š‹ŒqNoneûòGshake3Messages that haven't yet been printed, in reverse.HshakeLast progress message.Ishake.the traced items, in the order we display themJshake(Number of lines we used last time aroundKshake?Run a compact UI, with the ShakeOptions modifier, combined withKrNone"#ÛLshakeÓGiven a map of representing a dependency order (with a show for error messages), find an ordering for the items such that no item points to an item before itself. Raise an error if you end up with a cycle.MshakeCEliminate all errors from the database, pretending they don't existNshake;Generates an report given some build system profiling data.NsNone "#$%,HPVXshakePRun a set of IO actions, treated as "after" actions, typically returned from tF. The actions will be run with diagnostics etc as specified in the w.OPQRSTUNone"#&üshake4The type of an open Shake database. Created with  or ‘. Used with •/. You may not execute simultaneous calls using 1 on separate threads (it will raise an error).shake~Given some options and rules, return a pair. The first component opens the database, the second cleans it up. The creation does note need to be run masked, because the cleanup is able to run at any point. Most users should prefer ‘8 which handles exceptions duration creation properly.shake:Declare that a just-openned database will be used to call •N at most once. If so, an optimisation can be applied to retain less memory.‘shake'Given some options and rules, create a ' that can be used to run executions.’shakeGiven a Q, what files did the execution ensure were up-to-date in the previous call to •5. Corresponds to the list of files written out to .“shakeGiven a N, generate profile information to the given file about the latest run. See ~- for the types of file that can be generated.”shakeGiven a t, what files did the execution reach an error on last time. Some special considerations when using this function:ÿ)The presence of an error does not mean the build will fail, specifically if a previously required dependency was run and raised an error, then the thing that previously required it will be run. If the build system has changed in an untracked manner, the build may succeed this time round.)If the previous run actually failed then •i will have thrown an exception. You probably want to catch that exception so you can make the call to ”.¤You may see a single failure reported multiple times, with increasingly large call stacks, showing the ways in which the error lead to further errors throughout.The V( values are highly likely to be of type f.5If you want as many errors as possile in one run set }=True.•shakeGiven an open ., run both whatever actions were added to the Á, plus the list of ¿› given here. Returns the results from the explicitly passed actions along with a list of actions to run after the database was closed, as added with u and v. ‘’“”• ‘•’“”wNone)ÜWshakeRequire the user to press y before continuing.XshakeReplace exceptions with ö.Yshake7Require a condition to be true, or exit with a message.ZxNonePbF–shake[Main entry point for running Shake build systems. For an example see the top of the module Development.Shake . Use w% to specify how the system runs, and ÁV to specify what to build. The function will throw an exception if the build fails.$To use command line flags to modify w see —.—shakeiRun a build system using command line arguments for configuration. The available flags are those from š!, along with a few additional make. compatible flags that are not represented in w , such as --print-directory-. If there are no file arguments then the Á8 are used directly, otherwise the file arguments are ed (after calling Ò). As an example: main = — ®{y = "_make", ’ = Œ } $ do  "clean" $ v "_make" ["//*"] 8 ["_make/neil.txt","_make/emily.txt"] "_make/*.txt" + \out -> ... build action here ... +This build system will default to building neil.txt and  emily.txtW, while showing progress messages, and putting the Shake files in locations such as _make/.database". Some example command line flags:main --no-progress! will turn off progress messages.main -j6 will build on 6 threads. main --help( will display a list of supported flags. main clean. will not build anything, but will remove the _make! directory, including the any y.main _make/henry.txt will not build neil.txt or  emily.txt, but will instead build  henry.txt.˜shake A version of —I with more flexible handling of command line arguments. The caller of ˜‡ can add additional flags (the second argument) and chose how to convert the flags/arguments into rules (the third argument). Given: ˜. opts flags (\flagValues argValues -> result) opts is the initial w` value, which may have some fields overriden by command line flags. This argument is usually ®&, perhaps with a few fields overriden.flags8 is a list of flag descriptions, which either produce a õS containing an error message (typically for flags with invalid arguments, .e.g. [ "could not parse as int"#), or a value that is passed as  flagValues$. If you have no custom flags, pass []. flagValues6 is a list of custom flags that the user supplied. If  flags == [] then this list will be []. argValuesQ is a list of non-flag arguments, which are often treated as files and passed to 3. If arguments are specified then typically the * calls from the rules are discarded using Ò.result should produce a F8 to indicate that no building needs to take place, or a ‹, providing the rules that should be used.4As an example of a build system that can use either gcc or distcc for compiling: import System.Console.GetOpt data Flags = DistCC deriving Eq flags = [Option "" ["distcc"] (NoArg $ Right DistCC) "Run distributed."] main = ˜ ®’ flags $ \flags targets -> return $ Just $ do let compiler = if DistCC `elem` flags then "distcc" else "gcc" let rules = do "*.o"  \out -> do û ... cmd compiler ... @ ["target.exe"] ... if null targets then rules else  targets >> Ò rules Now you can pass --distcc to use the distcc compiler.™shakeLike ˜#, but also lets you manipulate the w.šshake:A list of command line options that can be used to modify w}. Each option returns either an error message (invalid argument to the flag) or a function that changes some fields in w. The command line flags are makei compatible where possbile, but additional flags have been added for the extra options Shake supports.\shake1True if it has a potential effect on ShakeOptions–—˜™šNone,HVhc›shake Deprecated: Alias for .œshake Deprecated: Alias for  .shake Deprecated: Alias for  .shake Deprecated: Alias for  . Note that *>- clashes with a Prelude operator in GHC 7.10.Ÿshake Deprecated: Alias for . shake Deprecated: Alias for  .¡shake Deprecated: Replace ¡ q a by ø q since the À' type family now fixes the result type.õP\RQSTUVWXYZ[]^_`abcdefghijklmnopsqrtuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹Œ‘’“”•–—˜™š›œŸ ¡¢£¤¥¦§¨©ª«¬­®¿ÀÁÂÆÈÉÊÎÏĞÑÒÓÔÕÖ×ØÙÚÛÜİŞßàäåæçèéêëìíîôõö÷øùúûüışÿ      ()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMN€‚ƒ„…†‡ˆ‰Š‹Œ–—˜™š›œŸ ¡õ–®ÁÑÒĞÎÏ¿àÓÔÕÖÙfghijwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹Œ‘’“”•ª«¬­§¨©¡¢£¤¥¦×  —˜™šÆÈÉÊ–—˜™š›œŸ Œ‰Š‹ØpsqrtuvİÚÛÜŞßKLMN?@A<=>9:;678345012-./*+,BCDEFGH()P\RQSTUVWXYZ[]^_`abcdeIJ臈û   ålnmoışÿ€ƒ„…†‚kÀõ÷öøùôëíìîç æäüúé꟠›œ¡›1œ111Ÿ1 1None‹6¢shake“Given the text of a Makefile, extract the list of targets and dependencies. Assumes a small subset of Makefile syntax, mostly that generated by gcc -MM. >parseMakefile "a: b c\nd : e" == [("a",["b","c"]),("d",["e"])]£shakeXDepend on the dependencies listed in a Makefile. Does not depend on the Makefile itself. _needMakefileDependencies file = need . concatMap snd . parseMakefile =<< liftIO (readFile file)¤shakeˆDepend on the dependencies listed in a Makefile. Does not depend on the Makefile itself. Use this function to indicate that you have already used the files in question. cneededMakefileDependencies file = needed . concatMap snd . parseMakefile =<< liftIO (readFile file)¥shakeLike ˜·, but instead of accumulating a list of flags, apply functions to a default value. Usually used to populate a record structure. As an example of a build system that can use either gcc or distcc for compiling: ¯import System.Console.GetOpt data Flags = Flags {distCC :: Bool} deriving Eq flags = [Option "" ["distcc"] (NoArg $ Right $ \x -> x{distCC=True}) "Run distributed."] main = ¥ ®U flags (Flags False) $ \flags targets -> return $ Just $ do if null targets then  ["result.exe"] else O targets let compiler = if distCC flags then "distcc" else "gcc" "*.o"  \out -> do û ... M compiler ... ... Now you can pass --distcc to use the distcc compiler.¦shakeLike —' but also takes a pruning function. If --prune‘ is passed, then after the build has completed, the second argument is called with a list of the files that the build checked were up-to-date.§shake A version of ¦0 that also takes a list of extra options to use.¢£¤¥¦§¢£¤¥¦§None %2HMSVX’;¨shake#Run a forward-defined build system.©shakeHRun a forward-defined build system, interpreting command-line arguments.ªshake Given an ¿, turn it into a Á& structure which runs in forward mode.«shakeGiven a w7, set the options necessary to execute in forward mode.¬shakeQCache an action. The name of the action must be unique for all different actions.­shake%Apply caching to an external command.¨©ª«¬­¨©«ª­¬ None2HMV©_µshake{Read a config file, returning a list of the variables and their bindings. Config files use the Ninja lexical syntax: 3https://ninja-build.org/manual.html#_lexical_syntax¶shake—Read a config file with an initial environment, returning a list of the variables and their bindings. Config files use the Ninja lexical syntax: 3https://ninja-build.org/manual.html#_lexical_syntax·shakeSpecify the file to use with ¹.¸shakeSpecify the values to use with ¹, generally prefer ·C unless you also need access to the values of variables outside ¿.¹shake6Obtain the value of a configuration variable, returns FD to indicate the variable has no binding. Any build system using ¹ must call either · or ¸. The ¹à function will introduce a dependency on the configuration variable (but not the whole configuration file), and if the configuration variable changes, the rule will be rerun. As an example: · "myconfiguration.cfg" "*.o"  \out -> do cflags <- ¹ "CFLAGS" M "gcc" [out -<.> "c"] (fromMaybe "" cflags) ºshake9Obtain the configuration keys. Any build system using º must call either · or ¸ . The ºß function will introduce a dependency on the configuration keys (but not the whole configuration file), and if the configuration keys change, the rule will be rerun. Usually use as part of an action. As an example: · "myconfiguration.cfg" Ñ $ need =<< getConfigKeys µ¶·¸¹ºµ¶·¸¹º]yz{yz|}~}€}‚ƒ}„…}~†}~‡}~ˆyz‰Š‹ŒŠ‹Š‹Š‹‘’‘“”•”•–”•—”•˜™š›”•œ”•”•”•Ÿ”• ”•¡”•¢”•£”•¤”•¥”•¦”•§”•¨”•b”•a”•©”•ª”•«”•¬”•­”•®”•¯”•°”•±”•²”•³”•´”•µ”•¶”•·”•¸”•¹”•º”•_”•”•»”•¼”•½”•¾”•¿”•À”•Á”•Â”•Ã”•Ä”•Å”•Æ”•ÇÈÉÊÈÉËÈÉÌÍÎÏĞÑÒÓÔÕÖ×ØÙÚÛÜİŞßàáâãäåæçèéêëëìíîïğñòóôõö÷øùúúûiüışÿ     $ !"#$%&'()*+,h=-=.=/=0=0=1=2=3=4=5=6=7=8=9=:=;=<E=E>E?E@EAEBECEDEEEFEGEBEAEHEIEJEKE&ELPMPNPOPPPQP%PuPRPSPTPUPVPWP PXPYPZPJP[P\P]P^P_P`RaRURbRcWCWdWeWfWgX][K[h[j[i[j^k^D^l^m^n^o^#^p^N^F^q^G^>^H^?erfIfsgtgugvgwgxgygdgcgzg`gZg{g|g}g~gg€gSgTgVgQ‚ƒ„……†‡ˆ‰‰Š‹‹Œ‘‘’““”••–YY\—˜™š›œŸ! "¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏĞÑkMkÒkÓkÔkÕkÖk×kØkÙkvpÚpÛpÜpİsŞßàáâãäåtxLxæxçxèxéêëìíîïğñòóôõö÷øùúûüışÿ                 ×   Ÿ              ! ! q " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < =}>?y@Ay@BCDEFGHIJKLMNOPQRST}UVWXYYTZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰y@Š‹Œ}}‘’“”•–}—˜}™š™››ˆœ‰Ÿ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊË+ÌÍÎÏ=ĞÑÒÓ}‘ÔÕÖ×ØËÙÚÛÜİ}Şß}àá}âã}äåæçè'é'ê'ë'ì'í'î'ï(ğ(ñ(ò(ó(ô(õ(ö(÷(ø(ù(ú(û(ü)ı)ş)ÿ)))*+}}}} } } + + ++++,,,,,,,,N,---------- -!-N-"-#--.$.$.%.%.&.&.'.'.(.(.).).*.*.+.+.,.-.../.0.1.2/3/4/5/6/7/8090:0;0<0=0>0?0@0A0B0C0D0E0F0G0H1I1J1K1L1M1N1O1P1Q2R2ñ3S3T3T3U3V3W3X3Y3Z3[3\3]3^3_3`3a3b3c3d3e3f3g3h3i4j4k4l4m4n4o5p5q5r5s5t5u5v5w5x6y6z6{7|7}7~77€77‚7ƒ7„7…7†7‡8ˆ8‰8Š8‹9Œ9999999N9::‘:’:“:”:•:–:—;˜;™;š;›;œ;;;Ÿ< <¡<¢<£=¤=¥=¦=§=¨=©=ª=«=¬=­=®=¯=°=±=²=³=´=µ=¶=·=¸=¹=º=»=¼=½=¾=¿=À=À=Á}>Â}>Ã=Ä=Å=Æ=Ç=È=É=Ê=Ë=Ì=Í=Î=Ï=Ğ=Ñy@Ò}ÓÔ}ÕÖ}„×=Ø=Ù=Ù=Ú=Ú=Û=Ü=İ=Ş=ß=à=à=á=á=â=ã=ä=å=æ=ç=è=è=é=ê=ê=ë=ì=ì=í=î=ï=ğ=ñ=ñ=ò=ò=ó=ó=<=ô=õ=ö=÷=ø=ù=ú=û=ü=ı=ş=ÿ=======EEE E O O O OOOOPPPPPPPPPPPPPPP R!R"R#R$R%R&R'R(W)W*W+W,W-W.W/X0^1^2^3^4^5^6^7^8^9^:^;^<^=^>^?^@^A^>^?^B^C^D^E^F^GeHfI}JKy@LMNO}PQ}PRSTUVWXYZk[l\m]m^m_m`mambmcmdnenfngnhniojpkplpmpnpopopppqprpsptquqvqwqxqyrzr{r|s}s~ss€ss‚sƒ}„…w†w‡wˆw‰}Š‹xŒ!shake-0.18-6QNxq9Fv9So97AwQaQQkw8Development.Shake.ClassesDevelopment.ShakeDevelopment.Shake.FilePathDevelopment.Shake.CommandDevelopment.Shake.RuleDevelopment.Shake.DatabaseDevelopment.Shake.UtilDevelopment.Shake.ForwardDevelopment.Shake.ConfigDevelopment.Ninja.EnvDevelopment.Ninja.TypeDevelopment.Ninja.LexerDevelopment.Ninja.Parse$Development.Shake.Internal.CmdOption(Development.Shake.Internal.History.Bloom*Development.Shake.Internal.History.Network(Development.Shake.Internal.History.TypesGeneral.BilistGeneral.Binary#Development.Shake.Internal.FileNameGeneral.CleanupGeneral.EscCodes General.Extra*Development.Shake.Internal.History.Symlink!Development.Shake.Internal.Errors Development.Shake.Internal.Value&Development.Shake.Internal.FilePattern<.>"Development.Shake.Internal.Optionstracedcommandcmd trackAllow shakeProgress getProgressaction#Development.Shake.Internal.FileInfo%Development.Shake.Internal.Core.Monad General.FenceGeneral.FileLockGeneral.GetOptGeneral.Intern General.Ids,Development.Shake.Internal.History.Serialise)Development.Shake.Internal.History.Server(Development.Shake.Internal.Core.DatabaseGeneral.ListBuilderGeneral.MakefileGeneral.ProcessGeneral.ThreadGeneral.ChunksGeneral.Timing General.Pool'Development.Shake.Internal.Core.StorageGeneral.TypeMap General.Wait)Development.Shake.Internal.History.Shared(Development.Shake.Internal.History.Cloud%Development.Shake.Internal.Core.Types?>%>Development.Shake.Rules noIdentitynoLintapplyneed%Development.Shake.Internal.Core.Rulesphony~>|%>&%>historyDisable addOracleshake doesFileExistwant$Development.Shake.Internal.Core.Pool&Development.Shake.Internal.Core.ActionnewCache#Development.Shake.Internal.Resource newResource newThrottle withResource withResources%Development.Shake.Internal.Core.Build&Development.Shake.Internal.Rules.RerunStdoutwriteFileChanged'Development.Shake.Internal.Rules.Oracle fromStdout alwaysRerun%Development.Shake.Internal.Rules.File dropExtensionwriteFileLines takeBaseNamereplaceBaseName writeFile' readFile'*Development.Shake.Internal.Rules.OrderOnly&Development.Shake.Internal.Rules.Files"Development.Shake.Internal.Derived shakeOptions shakeThreadsaddOracleCache*Development.Shake.Internal.Rules.Directory(Development.Shake.Internal.Rules.Default Paths_shake Development.Shake.Internal.PathsGeneral.Template#Development.Shake.Internal.Progress$Development.Shake.Internal.CompactUI"Development.Shake.Internal.Profile#Development.Shake.Internal.Core.RunshakeRunDatabaserunAfterremoveFilesAfterDevelopment.Shake.Internal.DemoDevelopment.Shake.Internal.Argsghc-prim GHC.Classes==EqbaseGHC.ShowShowData.Typeable.InternalTypeableControl.Monad.IO.ClassliftIOGHC.IOFilePathshowListshow showsPrec/=binary-0.8.6.0Data.Binary.ClassputListgetputBinarydeepseq-1.4.4.0Control.DeepSeqrnfNFDatafilepath-1.4.2.1System.FilePath.Posix makeRelativedropTrailingPathSeparator normalise#extra-1.6.15-GC5k3iL3ckoIV2rMw7GPQlControl.Monad.Extraunit isAbsolute isRelative makeValidisValid equalFilePathjoinPathsplitDirectories splitPathcombinereplaceDirectory takeDirectoryaddTrailingPathSeparatorhasTrailingPathSeparator takeFileName dropFileNamereplaceFileName splitFileNameisDrivehasDrive dropDrive takeDrive joinDrive splitDrivereplaceExtensionstakeExtensionsdropExtensionssplitExtensionsstripExtension isExtensionOf hasExtension addExtensionreplaceExtension-<.> takeExtensionsplitExtension getSearchPathsplitSearchPathisExtSeparator extSeparatorisSearchPathSeparatorsearchPathSeparatorisPathSeparatorpathSeparators pathSeparator'hashable-1.2.7.0-2SI038axTEd7AEZJ275kpiData.Hashable.Classhash hashWithSaltHashabledropDirectory1takeDirectory1replaceDirectory1makeRelativeEx normaliseExtoNative toStandardexe CmdOptionCwdEnvAddEnvRemEnvAddPathStdinStdinBS FileStdinShell BinaryPipesTracedTimeout WithStdout WithStderr EchoStdout EchoStderr FileStdout FileStderrAutoDeps UserCommand FSAOptionsShakeExceptionshakeExceptionTargetshakeExceptionStackshakeExceptionInner ShakeValue FilePattern?== filePattern VerbositySilentQuietNormalLoudChatty Diagnostic ShakeOptions shakeFiles shakeVersionshakeVerbosity shakeStaunch shakeReport shakeLintshakeLintInsideshakeLintIgnoreshakeLintWatchshakeCommandOptions shakeFlush shakeRebuildshakeAbbreviationsshakeStorageLogshakeLineBuffering shakeTimingsshakeRunCommands shakeChangeshakeCreationCheckshakeLiveFilesshakeVersionIgnore shakeColor shakeShare shakeCloud shakeOutput shakeTrace shakeExtraProgress isFailure countSkipped countBuilt countUnknown countTodo timeSkipped timeBuilt timeUnknowntimeTodoChange ChangeModtime ChangeDigestChangeModtimeAndDigestChangeModtimeAndDigestInputChangeModtimeOrDigestLint LintBasic LintFSATraceRebuild RebuildNow RebuildNormal RebuildLaterBuiltinIdentity BuiltinLint BuiltinRun RunResult runChangedrunStorerunValue RunChangedChangedNothing ChangedStoreChangedRecomputeSameChangedRecomputeDiffRunModeRunDependenciesSameRunDependenciesChangedAction RuleResultRulesgetShakeOptionsRulesgetUserRuleListgetUserRuleMaybegetUserRuleOne getTargets addUserRule addTargetwithTargetDocswithoutTargetsaddBuiltinRulepriority versioned alternativeswithoutActionsactionOnException actionFinally actionCatch actionRetrygetShakeOptionsputLoud putNormalputQuiet getVerbosity withVerbosityquietly lintTrackReadlintTrackWritelintTrackAlloworderOnlyAction newCacheIOunsafeExtraThreadparallelbatch deprioritizeResource newResourceIO newThrottleIOapply1 historyLoadhistoryIsEnabled historySave addOracleHash askOracle askOraclesresultHasChangedneedHasChangedneeded trackRead trackWriteproducesphonys orderOnly&?>getHashedShakeVersion getShakeExtragetShakeExtraRules addShakeExtra copyFile'copyFileChanged readFileLines withTempFilewithTempFileWithin withTempDirwithTempDirWithinforPpar IsCmdArgument toCmdArgument CmdArguments cmdArguments CmdArgument:-> CmdResult CmdStringCmdLine fromCmdLineCmdTime fromCmdTimeProcess fromProcessExitfromExit Stdouterr fromStdouterrStderr fromStderr StdoutTrimfromStdoutTrimFSATraceFSAWriteFSARead FSADeleteFSAMoveFSAQueryFSATouchaddPathaddEnvcommand_cmd_ $fShowPID$fEqPID$fMonadTempDirAction$fMonadTempDirIO$fCmdStringByteString$fCmdStringByteString0 $fCmdString[] $fCmdString()$fUnitm$fUnit->$fCmdResult(,,,,)$fCmdResult(,,,)$fCmdResult(,,)$fCmdResult(,) $fCmdResult()$fCmdResultStdouterr$fCmdResultStderr$fCmdResultStdoutTrim$fCmdResultStdout $fCmdResult[]$fCmdResultCmdTime$fCmdResultCmdLine$fCmdResultProcessHandle$fCmdResultProcess$fCmdResultExitCode$fCmdResultExit$fCmdArgumentsCmdArgument$fCmdArgumentsIO$fCmdArgumentsAction$fIsCmdArgumentMaybe$fIsCmdArgument[]$fIsCmdArgumentCmdOption$fIsCmdArgument[]0$fIsCmdArgument[]1$fCmdArguments->$fEqStr $fShowStr$fShowFSATrace $fEqFSATrace $fOrdFSATrace$fDataFSATrace $fEqResult $fShowResult $fShowParams$fEqCmdArgument$fSemigroupCmdArgument$fMonoidCmdArgument$fShowCmdArgumentdoesDirectoryExistgetEnvgetEnvWithDefaultgetDirectoryContentsgetDirectoryFilesgetDirectoryDirsgetDirectoryFilesIO removeFilesprogressDisplayprogressTitlebarprogressProgramprogressSimple shakeRunAfter ShakeDatabaseshakeOpenDatabaseshakeOneShotDatabaseshakeWithDatabaseshakeLiveFilesDatabaseshakeProfileDatabaseshakeErrorsDatabase shakeArgs shakeArgsWithshakeArgsOptionsWithshakeOptDescrs**>?>>*>>*>|*>&*> askOracleWith parseMakefileneedMakefileDependenciesneededMakefileDependenciesshakeArgsAccumulateshakeArgsPruneshakeArgsPruneWith shakeForwardshakeArgsForward forwardRuleforwardOptions cacheActioncache $fShowForward $fShowCommand$fHashableForward $fEqForward$fNFDataForward$fBinaryForward$fBinaryCommandreadConfigFilereadConfigFileWithEnvusingConfigFile usingConfig getConfig getConfigKeys $fShowConfig $fEqConfig$fHashableConfig$fBinaryConfig$fNFDataConfig$fShowConfigKeys$fEqConfigKeys$fHashableConfigKeys$fBinaryConfigKeys$fNFDataConfigKeysnewEnvscopeEnvaskEnvfromEnvRuleruleBindBuildenvruleName depsNormal depsImplicit depsOrderOnly buildBindNinjasourcesrulessingles multiplesdefaultspoolsExprVarExprsLitFileStrStraskExpraskVaraddBindaddBindsnewNinjaLexemeLexBindLexBuild LexInclude LexSubninjaLexRuleLexPool LexDefault LexDefine lexerFileparseGHC.BaseString GHC.TypesFalseTrueBloom bloomTest bloomCreateConnconnectpost BS_IdentityBS_StoreBS_Key BS_QTypeRepBilisttoListisEmptyconssnocunconsBinaryExBinaryOpForeign.StorableStorableputExgetExBuildergetOpputOp binaryOpMap binarySplit binarySplit2 binarySplit3unsafeBinarySplit sizeBuilder runBuilder putExStorable getExStorableputExStorableListgetExStorableList putExList getExListputExNgetExNFileNamefilepathNormalisefileNameToStringfileNameToByteStringfileNameFromStringfileNameFromByteString withCleanupregisterCleanup newCleanup unprotectreleaseallocateColorBlackRedGreenYellowBlueMagentaCyanWhite checkEscCodesremoveEscCodesescWindowTitle escCursorUp escClearLine escForeground escNormalQTypeRepVerInt wrapQuote wrapBracket showBracketfastAtGHC.List!! GHC.MaybeNothingisAsyncException removeFile_createDirectoryRecursiveparseCallStack GHC.ExceptionprettyCallStack GHC.StackwithFrozenCallStackPartial fromQTypeRepLocatedNoShow maximumBy'maximum'unconcat zipWithExactzipExactgetProcessorCountfindGcc randomElemusingLineBufferingshowDurationSecswiths forNothingMusingNumCapabilitiescatchIOtryIOhandleIOhandleSynchronousdoesFileExist_doesDirectoryExist_whenLeft callStackTop callStackFullcallStackFromExceptionmakeVer copyFileLinkthrowM throwImpure errorInternalerrorStructurederrorDirectoryNotFileerrorNoRuleToBuildTypeerrorRuleDefinedMultipleTimeserrorMultipleRulesMatch errorNoHasherrorRuleRecursionerrorComplexRecursion errorNoApplyValueKeynewKeynewValuetypeKeyfromKey fromValueWalkStarSkipSkip1StarsoptimiseisRelativePatternisRelativePathmatchJustsimple compatibleextract substituteWalkTo internalTest?==*walkHidden Data.DataData Data.TypeableTypeRep System.IOputStrLn Data.Dynamic dynTypeRepshakeRebuildApplyshakeOptionsFieldsshakeAbbreviationsApplyFileSizeModTimeFileHash noFileHash isNoFileHash getFileHash getFileInforunRAWputRW captureRAWCaptureRAWgetROgetRWmodifyRWcatchRAWtryRAWthrowRAW finallyRAWstepRAWFencenewFence signalFence waitFence testFence exceptFence usingLockFile removeOverlapSystem.Console.GetOptOptDescrOptionArgDescrNoArgReqArgOptArggetOptfmapFmapOptDescr showOptDescr mergeOptDescr optionsEnumoptionsEnumDescIdInternemptyinsertaddlookupfromListcapacityusedIdssizeUpperBoundsizetoMap forWithKeyM_forCopy forMutateelemsnull SendUploadSendDownloadFiles RecvOneKey SendOneKey RecvAllKeys SendAllKeysWithKeys WithTypeReps BuildTreeDoneDepend withTypeRepswithKeyswithIds withoutKeysServer newServer serverAllKeys serverOneKeyserverDownloadFiles serverUpload DatabasePolyinternstatusjournalmkIdLocked runLockedcreateDatabasegetValueFromKeygetKeyValueFromId getKeyValuesgetKeyValuesFromId getIdFromKeysetMem modifyAllMemsetDiskTreeEmptyLeafBranch ListBuilder flattenTree unflattenTreenewListBuilderrunListBuilderlinesCRoptimiseBuffers ProcessOpts poCommandpoCwdpoEnv poTimeoutpoStdinpoStdoutpoStderrpoAsync DestinationDestEchoDestFile DestString DestBytesSourceSrcFile SrcStringSrcBytesBuffer newBuffer readBufferprocessnewThreadFinallywithThreadSlaveallocateThreadThread stopThreadswithThreadsBoth readChunkMaxusingWriteChunksresetChunksCompactresetChunksCorruptChunks readChunk writeChunkrestoreChunksBackup usingChunks getTimings resetTimings addTimingstepaddPool increasePool keepAlivePoolrunPool PoolPriority PoolException PoolResume PoolStart PoolBatchPoolDeprioritizePoolWitness Witnesses usingStorage loadWitnessMap singleton unionWithmapWaitNowLaterrunWait fromLaterquicklyfirstJustWaitUnorderedfirstLeftWaitUnordered sharedFileDirsharedFileKeys lookupSharedShared newShared addShared removeShared listSharedCloudnewCloudaddCloud lookupCloud localStacklocalBuiltinVersionlocalVerbositylocalBlockApply localDepends localDiscount localTraceslocalTrackAllowslocalTrackReadlocalTrackWrite localProduces localHistoryglobalDatabase globalPool globalCleanupglobalTimestamp globalRules globalOutput globalOptionsglobalDiagnosticglobalRuleFinished globalAfterglobalTrackAbsentglobalProgress globalShared globalOneShotuserRuleVersioneduserRuleContentsUserRule UnorderedMonadMonoidPriority Alternative Versionedresultbuiltchangeddepends executiontracesReadyErrorLoadedRunningMissingIOGHC.ErrerrorControl.Monad.Fail MonadFailthrowIO nubDependsLocalGlobal globalBuildglobalUserRules globalCloud globalStepDatabaseUserRuleVersioned BuiltinRulebuiltinVersion builtinLintbuiltinIdentity builtinRun builtinKeybuiltinLocationDepends fromDependsResultStatusTrace traceMessage traceStarttraceEndStackRootStepKeyStep fromAction runActionincStepstepKeyrootKeyexceptionStack showTopStackaddStack addCallStacktopStack emptyStacknewTrace statusType getResult userRuleSize addDiscountnewLocallocalClearMutablelocalMergeMutablegetUserRuleInternaladdBuiltinRuleInternalrunRulesaddBuiltinRuleEx addPoolWait addPoolWait_actionFenceStealactionFenceRequeueactionFenceRequeueByactionAlwaysRequeueactionAlwaysRequeuePriority actionBracketshakeExceptionproducesCheckedproducesUncheckedactionShareRemoveactionShareListputWhenunsafeAllowApply blockApplylintTrackFinishedlintCurrentDirectory lintWatch producesCheck getCurrentKeygetLocalThrottleAvailableThrottleWaitingfiniteAvailable finiteWaiting resourceOrd resourceShowacquireResourcereleaseResource lookupOnebuildOne buildRunModebuildRunDependenciesChangedgetDatabaseValuegetDatabaseValueGeneric applyKeyValuedefaultRuleRerun EqualCost EqualCheapEqualExpensiveNotEqualFileRuleAnswerMode ModePhony ModeDirect ModeForwardFileRansweruseLintFileAFileQstoredValueError fileForward fromFileQfileStoredValuefileEqualValuedefaultRuleFileneedBSneededBS orderOnlyBSdefaultRuleFilesData.TraversableforMDoubleprocess-1.6.3.0System.Process.Common ProcessHandleGHC.IO.ExceptionExitCode ExitFailureparseFSAcommandExplicitActioncommandExplicitIO resolveEnv resolvePathfindExecutableWithremoveOptionShellremoveOptionFSATracedefaultRuleDirectory defaultRulesversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameshakeVersionStringinitDataDirectoryreadDataFileHTML hasManualDatacopyManualData runTemplateMealymessageprogressReplaywriteProgressReport ProgressEntry idealSecs idealPerc actualSecs actualPercprogresssOutput sProgresssTracessUnwind compactUIdependencyOrder resultsOnly writeProfileRunStateopenresetrunliveFilesState profileState errorsStateGHC.Exception.Type SomeExceptionyesNowraprequiredemo Data.EitherLeft shakeOptsEx