SafeHaskell: Added SafeHaskell to base
[packages/base.git] / GHC / Weak.lhs
1 \begin{code}
2 {-# LANGUAGE CPP
3            , NoImplicitPrelude
4            , BangPatterns
5            , MagicHash
6            , UnboxedTuples
7            , DeriveDataTypeable
8            , StandaloneDeriving
9   #-}
10 {-# OPTIONS_HADDOCK hide #-}
11
12 -----------------------------------------------------------------------------
13 -- |
14 -- Module      :  GHC.Weak
15 -- Copyright   :  (c) The University of Glasgow, 1998-2002
16 -- License     :  see libraries/base/LICENSE
17 -- 
18 -- Maintainer  :  cvs-ghc@haskell.org
19 -- Stability   :  internal
20 -- Portability :  non-portable (GHC Extensions)
21 --
22 -- Weak pointers.
23 --
24 -----------------------------------------------------------------------------
25
26 -- #hide
27 module GHC.Weak (
28         Weak(..),
29         mkWeak,
30         deRefWeak,
31         finalize,
32         runFinalizerBatch
33     ) where
34
35 import GHC.Base
36 import Data.Maybe
37 import Data.Typeable
38
39 {-|
40 A weak pointer object with a key and a value.  The value has type @v@.
41
42 A weak pointer expresses a relationship between two objects, the
43 /key/ and the /value/:  if the key is considered to be alive by the
44 garbage collector, then the value is also alive.  A reference from
45 the value to the key does /not/ keep the key alive.
46
47 A weak pointer may also have a finalizer of type @IO ()@; if it does,
48 then the finalizer will be run at most once, at a time after the key
49 has become unreachable by the program (\"dead\").  The storage manager
50 attempts to run the finalizer(s) for an object soon after the object
51 dies, but promptness is not guaranteed.  
52
53 It is not guaranteed that a finalizer will eventually run, and no
54 attempt is made to run outstanding finalizers when the program exits.
55 Therefore finalizers should not be relied on to clean up resources -
56 other methods (eg. exception handlers) should be employed, possibly in
57 addition to finalisers.
58
59 References from the finalizer to the key are treated in the same way
60 as references from the value to the key: they do not keep the key
61 alive.  A finalizer may therefore ressurrect the key, perhaps by
62 storing it in the same data structure.
63
64 The finalizer, and the relationship between the key and the value,
65 exist regardless of whether the program keeps a reference to the
66 'Weak' object or not.
67
68 There may be multiple weak pointers with the same key.  In this
69 case, the finalizers for each of these weak pointers will all be
70 run in some arbitrary order, or perhaps concurrently, when the key
71 dies.  If the programmer specifies a finalizer that assumes it has
72 the only reference to an object (for example, a file that it wishes
73 to close), then the programmer must ensure that there is only one
74 such finalizer.
75
76 If there are no other threads to run, the runtime system will check
77 for runnable finalizers before declaring the system to be deadlocked.
78 -}
79 data Weak v = Weak (Weak# v)
80
81 #include "Typeable.h"
82 INSTANCE_TYPEABLE1(Weak,weakTc,"Weak")
83
84 -- | Establishes a weak pointer to @k@, with value @v@ and a finalizer.
85 --
86 -- This is the most general interface for building a weak pointer.
87 --
88 mkWeak  :: k                            -- ^ key
89         -> v                            -- ^ value
90         -> Maybe (IO ())                -- ^ finalizer
91         -> IO (Weak v)                  -- ^ returns: a weak pointer object
92
93 mkWeak key val (Just finalizer) = IO $ \s ->
94    case mkWeak# key val finalizer s of { (# s1, w #) -> (# s1, Weak w #) }
95 mkWeak key val Nothing = IO $ \s ->
96    case mkWeak# key val (unsafeCoerce# 0#) s of { (# s1, w #) -> (# s1, Weak w #) }
97
98 {-|
99 Dereferences a weak pointer.  If the key is still alive, then
100 @'Just' v@ is returned (where @v@ is the /value/ in the weak pointer), otherwise
101 'Nothing' is returned.
102
103 The return value of 'deRefWeak' depends on when the garbage collector
104 runs, hence it is in the 'IO' monad.
105 -}
106 deRefWeak :: Weak v -> IO (Maybe v)
107 deRefWeak (Weak w) = IO $ \s ->
108    case deRefWeak# w s of
109         (# s1, flag, p #) -> case flag of
110                                 0# -> (# s1, Nothing #)
111                                 _  -> (# s1, Just p #)
112
113 -- | Causes a the finalizer associated with a weak pointer to be run
114 -- immediately.
115 finalize :: Weak v -> IO ()
116 finalize (Weak w) = IO $ \s ->
117    case finalizeWeak# w s of
118         (# s1, 0#, _ #) -> (# s1, () #) -- already dead, or no finaliser
119         (# s1, _,  f #) -> f s1
120
121 {-
122 Instance Eq (Weak v) where
123   (Weak w1) == (Weak w2) = w1 `sameWeak#` w2
124 -}
125
126
127 -- run a batch of finalizers from the garbage collector.  We're given 
128 -- an array of finalizers and the length of the array, and we just
129 -- call each one in turn.
130 --
131 -- the IO primitives are inlined by hand here to get the optimal
132 -- code (sigh) --SDM.
133
134 runFinalizerBatch :: Int -> Array# (IO ()) -> IO ()
135 runFinalizerBatch (I# n) arr = 
136    let  go m  = IO $ \s ->
137                   case m of 
138                   0# -> (# s, () #)
139                   _  -> let !m' = m -# 1# in
140                         case indexArray# arr m' of { (# io #) -> 
141                         case unIO io s of          { (# s', _ #) -> 
142                         unIO (go m') s'
143                         }}
144    in
145         go n
146
147 \end{code}