X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=GHC%2FException.lhs;h=5cee08fff1e1c909f416f6c58fe7c6b2c774aeb4;hb=17de35d4d566bd83a6d15ab72dec3d0fe1dfe1dd;hp=50af7929877147163a020ee80c94f239fe7782d3;hpb=7de50399a42ee49b0473b7b6eea2b44a2f941a12;p=haskell-directory.git diff --git a/GHC/Exception.lhs b/GHC/Exception.lhs index 50af792..5cee08f 100644 --- a/GHC/Exception.lhs +++ b/GHC/Exception.lhs @@ -1,28 +1,29 @@ -% ------------------------------------------------------------------------------ -% $Id: Exception.lhs,v 1.3 2002/02/05 17:32:26 simonmar Exp $ -% -% (c) The University of Glasgow, 1998-2000 -% - -Exceptions and exception-handling functions. - \begin{code} -{-# OPTIONS -fno-implicit-prelude #-} - -#ifndef __HUGS__ +{-# OPTIONS_GHC -fno-implicit-prelude #-} +----------------------------------------------------------------------------- +-- | +-- Module : GHC.Exception +-- Copyright : (c) The University of Glasgow, 1998-2002 +-- License : see libraries/base/LICENSE +-- +-- Maintainer : cvs-ghc@haskell.org +-- Stability : internal +-- Portability : non-portable (GHC extensions) +-- +-- Exceptions and exception-handling functions. +-- +----------------------------------------------------------------------------- + +-- #hide module GHC.Exception ( module GHC.Exception, Exception(..), AsyncException(..), IOException(..), ArithException(..), ArrayException(..), - throw, ioError ) + throw, throwIO, ioError ) where -import Data.Either - import GHC.Base import GHC.IOBase - -#endif \end{code} %********************************************************* @@ -45,79 +46,78 @@ have to work around that in the definition of catchException below). \begin{code} catchException :: IO a -> (Exception -> IO a) -> IO a -#ifdef __HUGS__ -catchException m k = ST (\s -> unST m s `primCatch'` \ err -> unST (k err) s) -#else catchException (IO m) k = IO $ \s -> catch# m (\ex -> unIO (k ex)) s -#endif -catch :: IO a -> (Exception -> IO a) -> IO a +-- | The 'catch' function establishes a handler that receives any 'IOError' +-- raised in the action protected by 'catch'. An 'IOError' is caught by +-- the most recent handler established by 'catch'. These handlers are +-- not selective: all 'IOError's are caught. Exception propagation +-- must be explicitly provided in a handler by re-raising any unwanted +-- exceptions. For example, in +-- +-- > f = catch g (\e -> if IO.isEOFError e then return [] else ioError e) +-- +-- the function @f@ returns @[]@ when an end-of-file exception +-- (cf. 'System.IO.Error.isEOFError') occurs in @g@; otherwise, the +-- exception is propagated to the next outer handler. +-- +-- When an exception propagates outside the main program, the Haskell +-- system prints the associated 'IOError' value and exits the program. +-- +-- Non-I\/O exceptions are not caught by this variant; to catch all +-- exceptions, use 'Control.Exception.catch' from "Control.Exception". +catch :: IO a -> (IOError -> IO a) -> IO a catch m k = catchException m handler - where handler err@(IOException _) = k err + where handler (IOException err) = k err handler other = throw other \end{code} %********************************************************* %* * -\subsection{Try and bracket} -%* * -%********************************************************* - -The construct @try comp@ exposes errors which occur within a -computation, and which are not fully handled. It always succeeds. - -These are the IO-only try/bracket. For the full exception try/bracket -see hslibs/lang/Exception.lhs. - -\begin{code} -try :: IO a -> IO (Either Exception a) -try f = catch (do r <- f - return (Right r)) - (return . Left) - -bracket :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c -bracket before after m = do - x <- before - rs <- try (m x) - after x - case rs of - Right r -> return r - Left e -> ioError e - --- variant of the above where middle computation doesn't want x -bracket_ :: IO a -> (a -> IO b) -> IO c -> IO c -bracket_ before after m = do - x <- before - rs <- try m - after x - case rs of - Right r -> return r - Left e -> ioError e -\end{code} - - -%********************************************************* -%* * \subsection{Controlling asynchronous exception delivery} %* * %********************************************************* \begin{code} -#ifndef __HUGS__ +-- | Applying 'block' to a computation will +-- execute that computation with asynchronous exceptions +-- /blocked/. That is, any thread which +-- attempts to raise an exception in the current thread will be +-- blocked until asynchronous exceptions are enabled again. There\'s +-- no need to worry about re-enabling asynchronous exceptions; that is +-- done automatically on exiting the scope of +-- 'block'. block :: IO a -> IO a -block (IO io) = IO $ blockAsyncExceptions# io +-- | To re-enable asynchronous exceptions inside the scope of +-- 'block', 'unblock' can be +-- used. It scopes in exactly the same way, so on exit from +-- 'unblock' asynchronous exception delivery will +-- be disabled again. unblock :: IO a -> IO a -unblock (IO io) = IO $ unblockAsyncExceptions# io -#else --- Not implemented yet in Hugs. -block :: IO a -> IO a -block (IO io) = IO io -unblock :: IO a -> IO a -unblock (IO io) = IO io -#endif +block (IO io) = IO $ blockAsyncExceptions# io +unblock (IO io) = IO $ unblockAsyncExceptions# io \end{code} - +\begin{code} +-- | Forces its argument to be evaluated when the resultant 'IO' action +-- is executed. It can be used to order evaluation with respect to +-- other 'IO' operations; its semantics are given by +-- +-- > evaluate x `seq` y ==> y +-- > evaluate x `catch` f ==> (return $! x) `catch` f +-- > evaluate x >>= f ==> (return $! x) >>= f +-- +-- /Note:/ the first equation implies that @(evaluate x)@ is /not/ the +-- same as @(return $! x)@. A correct definition is +-- +-- > evaluate x = (return $! x) >>= return +-- +evaluate :: a -> IO a +evaluate a = IO $ \s -> case a `seq` () of () -> (# s, a #) + -- NB. can't write + -- a `seq` (# s, a #) + -- because we can't have an unboxed tuple as a function argument +\end{code}