blob: c51c2329ca870beced028c3520a0fe0abd57da0e (
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
|
module Exception
(
module Control.Exception,
module Exception
)
where
import Prelude hiding (catch)
#if __GLASGOW_HASKELL__ < 609
import Control.Exception.Extensible as Control.Exception
#else
import Control.Exception
#endif
catchIO :: IO a -> (IOException -> IO a) -> IO a
catchIO = catch
handleIO :: (IOException -> IO a) -> IO a -> IO a
handleIO = flip catchIO
tryIO :: IO a -> IO (Either IOException a)
tryIO = try
-- | A monad that can catch exceptions. A minimal definition
-- requires a definition of 'gcatch'.
--
-- Implementations on top of 'IO' should implement 'gblock' and 'gunblock' to
-- eventually call the primitives 'Control.Exception.block' and
-- 'Control.Exception.unblock' respectively. These are used for
-- implementations that support asynchronous exceptions. The default
-- implementations of 'gbracket' and 'gfinally' use 'gblock' and 'gunblock'
-- thus rarely require overriding.
--
class Monad m => ExceptionMonad m where
-- | Generalised version of 'Control.Exception.catch', allowing an arbitrary
-- exception handling monad instead of just 'IO'.
gcatch :: Exception e => m a -> (e -> m a) -> m a
-- | Generalised version of 'Control.Exception.block', allowing an arbitrary
-- exception handling monad instead of just 'IO'.
gblock :: m a -> m a
-- | Generalised version of 'Control.Exception.unblock', allowing an
-- arbitrary exception handling monad instead of just 'IO'.
gunblock :: m a -> m a
-- | Generalised version of 'Control.Exception.bracket', allowing an arbitrary
-- exception handling monad instead of just 'IO'.
gbracket :: m a -> (a -> m b) -> (a -> m c) -> m c
-- | Generalised version of 'Control.Exception.finally', allowing an arbitrary
-- exception handling monad instead of just 'IO'.
gfinally :: m a -> m b -> m a
gblock = id
gunblock = id
gbracket before after thing =
gblock (do
a <- before
r <- gunblock (thing a) `gonException` after a
after a
return r)
a `gfinally` sequel =
gblock (do
r <- gunblock a `gonException` sequel
sequel
return r)
instance ExceptionMonad IO where
gcatch = catch
gblock = block
gunblock = unblock
gtry :: (ExceptionMonad m, Exception e) => m a -> m (Either e a)
gtry act = gcatch (act >>= \a -> return (Right a))
(\e -> return (Left e))
-- | Generalised version of 'Control.Exception.handle', allowing an arbitrary
-- exception handling monad instead of just 'IO'.
ghandle :: (ExceptionMonad m, Exception e) => (e -> m a) -> m a -> m a
ghandle = flip gcatch
-- | Always executes the first argument. If this throws an exception the
-- second argument is executed and the exception is raised again.
gonException :: (ExceptionMonad m) => m a -> m b -> m a
gonException ioA cleanup = ioA `gcatch` \e ->
do cleanup
throw (e :: SomeException)
|
