Documentation

This function needs to be called in order to use the library successfully from GHCi.

When a process exits with a non-zero exit code we throw this Failure exception.

The only exception to this is when a process is terminated by SIGPIPE in a pipeline, in which case we ignore it.

This class is used to allow most of the operators in Shh to be polymorphic in their return value. This makes using them in an IO context easier (we can avoid having to prepend everything with a runProc).

Create a pipe, and close both ends on exception.

Type used to represent destinations for redirects. Truncate file is like > file in a shell, and Append file is like >> file.

Shortcut for Truncate "/dev/null"

Type representing a series or pipeline (or both) of shell commands.

Run's a Proc in IO. This is usually not required, as most commands in Shh are polymorphic in their return type, and work just fine in IO directly.

Create a Proc from a command and a list of arguments. The boolean represents whether we should delegate control-c or not. Most uses of mkProc' in Shh do not delegate control-c.

Create a Proc from a command and a list of arguments. Does not delegate control-c handling.

Read the stdout of a Proc. This captures stdout, so further piping will not see anything on the input.

This is strict, so the whole output is read into a String. See withRead for a lazy version that can be used for streaming.

Apply a transformation function to the string before the IO action.

Like withRead except it splits the string with split0 first.

Like withRead except it splits the string with lines first.

NB: Please consider using withReadSplit0 where you can.

Like withRead except it splits the string with words first.

Read and write to a Proc. Same as readProc proc <<< input

Some as readWriteProc. Apply a Proc to a String.

>>> apply shasum "Hello"
"f7ff9e8b7bb2e09b70935a5d785e0cc5d9d0abf0  -\n"

Flipped, infix version of writeProc

Infix version of writeProc

Wait on a given ProcessHandle, and throw an exception of type Failure if it's exit code is non-zero (ignoring SIGPIPE)

Trim leading and tailing whitespace.

Allow us to catch Failure exceptions in IO and Proc

Run a Proc action, ignoring any Failure exceptions. This can be used to prevent a process from interrupting a whole pipeline.

>>> false `|>` (sleep 2 >> echo 1)
*** Exception: Command `false` failed [exit 1]

>>> (ignoreFailure  false) `|>` (sleep 2 >> echo 1)
1

Run an Proc action returning the return code if an exception was thrown, and 0 if it wasn't.

Like readProc, but trim leading and tailing whitespace.

A class for things that can be converted to arguments on the command line. The default implementation is to use show.

A class for building up a command

Force a `()` result.

Get all executables on your `$PATH`.

Get all uniquely named executables on your `$PATH` as absolute file names. The uniqueness is determined by the filename, and not the whole path. First one found wins.

Execute the given command. Further arguments can be passed in.

exe "ls" "-l"

See also loadExe and loadEnv.

Create a function for the executable named

Specify how executables should be referenced.

Template Haskell function to create a function from a path that will be called. This does not check for executability at compile time.

$(loadExeAs ref fnName executable) defines a function called fnName which executes the path in executable. If executable is an absolute path it is used directly. If it is just an executable name, then it is searched for in the PATH environment variable. If ref is SearchPath, the short name is retained, and your PATH will be searched at runtime. If ref is Absolute, a executable name will be turned into an absolute path, which will be used at runtime.

Takes a string, and makes a Haskell identifier out of it. There is some chance of overlap. If the string is a path, the filename portion is used. The transformation replaces all non-alphanumeric characters with '_'. If the first character is uppercase it is forced into lowercase. If it starts with a number, it is prefixed with `_`. If it overlaps with a reserved word or a builtin, it is suffixed with an `_`.

Scans your '$PATH' environment variable and creates a function for each executable found. Binaries that would not create valid Haskell identifiers are encoded using the encodeIdentifier function.

Test to see if an executable can be found either on the $PATH or absolute.

Load the given executables into the program, checking their executability and creating a function missingExecutables to do a runtime check for their availability. Uses the encodeIdentifier function to create function names.

Same as load, but allows you to modify the function names.

Like loadEnv, but allows you to modify the function name that would be generated.

Function that splits '\0' separated list of strings. Useful in conjunction with find . "-print0".

A convenience function for reading in a "\NUL" separated list of strings. This is commonly used when dealing with paths.

readSplit0 $ find "-print0"

A convenience function for reading the output lines of a Proc.

Note: Please consider using readSplit0 instead if you can.

Read output into a list of words

Like readProc, but attempts to read the result.

Mimics the shell builtin "cd".

Helper class for variable number of arguments to cd builtin.