haskell98-1.1.0.1: Compatibility with Haskell 98

System

Synopsis

- data ExitCode
  - = ExitSuccess
  - | ExitFailure Int
- getArgs :: IO [String]
- getProgName :: IO String
- getEnv :: String -> IO String
- system :: String -> IO ExitCode
- exitWith :: ExitCode -> IO a
- exitFailure :: IO a

# Documentation

data ExitCode Source

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).

Instances

Eq ExitCode |
Ord ExitCode |
Read ExitCode |
Show ExitCode |
Typeable ExitCode |
Exception ExitCode |

getArgs :: IO [String]Source

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`.

This computation may fail with:

- `System.IO.Error.isDoesNotExistError` if 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

- `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.

exitWith :: ExitCode -> IO aSource

Computation `exitWith` `code` throws `ExitCode` `code`. Normally this terminates the program, returning `code` to the program's caller.

On program termination, the standard `Handle`s `stdout` and `stderr` are flushed automatically; any other buffered `Handle`s 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 `Control.Exception.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 aSource

The computation `exitFailure` is equivalent to `exitWith` `(``ExitFailure` exitfail`)`, where exitfail is implementation-dependent.