( module GHC.Exception,
Exception(..), AsyncException(..),
IOException(..), ArithException(..), ArrayException(..),
- throw, ioError )
+ throw, throwIO, ioError )
where
-import Data.Either
-
import GHC.Base
import GHC.IOBase
catchException (IO m) k = IO $ \s -> catch# m (\ex -> unIO (k ex)) s
#endif
-catch :: IO a -> (Exception -> IO a) -> IO a
+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
+
+#ifndef __HUGS__
+block (IO io) = IO $ blockAsyncExceptions# io
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