haskell98-1.0.1.1: Compatibility with Haskell 98Source codeContentsIndex
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
Constructors
ExitSuccessindicates successful termination;
ExitFailure Intindicates 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).
show/hide Instances
getArgs :: IO [String]Source
Computation getArgs returns a list of the program's command line arguments (not including the program name).
getProgName :: IO StringSource

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 StringSource

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 ExitCodeSource

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. Before the program terminates, any open or semi-closed handles are first closed.

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.
Produced by Haddock version 2.6.1