base-4.20.2.0: Core data structures and operations

Copyright | (c) The University of Glasgow 2001-2002
License | see libraries/base/LICENSE
Maintainer | ghc-devs@haskell.org
Stability | internal
Portability | non-portable (GHC Extensions)
Safe Haskell | Safe
Language | Haskell2010

GHC.TopHandler

Description

Support for catching exceptions raised during top-level computations (e.g. `Main.main`, `forkIO`, and foreign exports)

The API of this module is unstable and not meant to be consumed by the general public. If you absolutely must depend on it, make sure to use a tight upper bound, e.g., `base < 4.X` rather than `base < 5`, because the interface can change rapidly without much warning.

Synopsis

- runMainIO :: IO a -> IO a
- runIO :: IO a -> IO a
- runIOFastExit :: IO a -> IO a
- runNonIO :: a -> IO a
- topHandler :: SomeException -> IO a
- topHandlerFastExit :: SomeException -> IO a
- reportStackOverflow :: IO ()
- reportError :: SomeException -> IO ()
- flushStdHandles :: IO ()

# Documentation

runMainIO :: IO a -> IO a Source #

`runMainIO` is wrapped around `main` (or whatever main is called in the program). It catches otherwise uncaught exceptions, and also flushes stdout/stderr before exiting.

runIO :: IO a -> IO a Source #

`runIO` is wrapped around every `foreign export` and `foreign import "wrapper"` to mop up any uncaught exceptions. Thus, the result of running `exitWith` in a foreign-exported function is the same as in the main thread: it terminates the program.

runIOFastExit :: IO a -> IO a Source #

Like `runIO`, but in the event of an exception that causes an exit, we don't shut down the system cleanly, we just exit. This is useful in some cases, because the safe exit version will give other threads a chance to clean up first, which might shut down the system in a different way. For example, try

main = forkIO (runIO (exitWith (ExitFailure 1))) >> threadDelay 10000

This will sometimes exit with "interrupted" and code 0, because the main thread is given a chance to shut down when the child thread calls safeExit. There is a race to shut down between the main and child threads.

runNonIO :: a -> IO a Source #

The same as `runIO`, but for non-IO computations. Used for wrapping `foreign export` and `foreign import "wrapper"` when these are used to export Haskell functions with non-IO types.

topHandler :: SomeException -> IO a Source #

topHandlerFastExit :: SomeException -> IO a Source #

reportStackOverflow :: IO () Source #

reportError :: SomeException -> IO () Source #

flushStdHandles :: IO () Source #