blob: abf9a829380f6c3b83b9025e715bd666c6ed376e (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
% ------------------------------------------------------------------------------
% $Id: Exception.lhs,v 1.1 2001/06/28 14:15:03 simonmar Exp $
%
% (c) The University of Glasgow, 1998-2000
%
Exceptions and exception-handling functions.
\begin{code}
{-# OPTIONS -fno-implicit-prelude #-}
#ifndef __HUGS__
module GHC.Exception
( module GHC.Exception,
Exception(..), AsyncException(..),
IOException(..), ArithException(..), ArrayException(..),
throw, ioError )
where
import GHC.Base
import GHC.Maybe
import GHC.IOBase
#endif
\end{code}
%*********************************************************
%* *
\subsection{Primitive catch}
%* *
%*********************************************************
catchException used to handle the passing around of the state to the
action and the handler. This turned out to be a bad idea - it meant
that we had to wrap both arguments in thunks so they could be entered
as normal (remember IO returns an unboxed pair...).
Now catch# has type
catch# :: IO a -> (b -> IO a) -> IO a
(well almost; the compiler doesn't know about the IO newtype so we
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
catch m k = catchException m handler
where handler err@(IOException _) = k err
handler err@(UserError _) = 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__
block :: IO a -> IO a
block (IO io) = IO $ blockAsyncExceptions# io
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
\end{code}
|
