| Safe Haskell | Trustworthy |
|---|---|
| Language | Haskell98 |
System
Documentation
Defines the exit codes that a program can return.
Constructors
| ExitSuccess | indicates successful termination; |
| ExitFailure Int | indicates program failure with an exit code. The exact interpretation of the code is operating-system dependent. In particular, some values may be prohibited (e.g. 0 on a POSIX-compliant system). |
Computation getArgs returns a list of the program's command
line arguments (not including the program name).
getProgName :: IO String Source
Computation getProgName returns the name of the program as it was
invoked.
However, this is hard-to-impossible to implement on some non-Unix
OSes, so instead, for maximum portability, we just return the leafname
of the program as invoked. Even then there are some differences
between platforms: on Windows, for example, a program invoked as foo
is probably really FOO.EXE, and that is what getProgName will return.
getEnv :: String -> IO String Source
Computation getEnv var returns the value
of the environment variable var. For the inverse, POSIX users
can use putEnv.
This computation may fail with:
isDoesNotExistErrorif the environment variable does not exist.
system :: String -> IO ExitCode Source
Computation system cmd returns the exit code produced when the
operating system runs the shell command cmd.
This computation may fail with one of the following
IOErrorType exceptions:
PermissionDenied- The process has insufficient privileges to perform the operation.
ResourceExhausted- Insufficient resources are available to perform the operation.
UnsupportedOperation- The implementation does not support system calls.
On Windows, system passes the command to the Windows command
interpreter (CMD.EXE or COMMAND.COM), hence Unixy shell tricks
will not work.
On Unix systems, see waitForProcess for the meaning of exit codes
when the process died as the result of a signal.
exitWith :: ExitCode -> IO a Source
Computation exitWith code throws ExitCode code.
Normally this terminates the program, returning code to the
program's caller.
On program termination, the standard Handles stdout and
stderr are flushed automatically; any other buffered Handles
need to be flushed manually, otherwise the buffered data will be
discarded.
A program that fails in any other way is treated as if it had
called exitFailure.
A program that terminates successfully without calling exitWith
explicitly is treated as it it had called exitWith ExitSuccess.
As an ExitCode is not an IOError, exitWith bypasses
the error handling in the IO monad and cannot be intercepted by
catch from the Prelude. However it is a SomeException, and can
be caught using the functions of Control.Exception. This means
that cleanup computations added with bracket
(from Control.Exception) are also executed properly on exitWith.
Note: in GHC, exitWith should be called from the main program
thread in order to exit the process. When called from another
thread, exitWith will throw an ExitException as normal, but the
exception will not cause the process itself to exit.
exitFailure :: IO a Source
The computation exitFailure is equivalent to
exitWith (ExitFailure exitfail),
where exitfail is implementation-dependent.