    {-# LANGUAGE MagicHash #-}
    {-# LANGUAGE NoImplicitPrelude #-}
    {-# LANGUAGE UnboxedTuples #-}
    {-# LANGUAGE Unsafe #-}

    {-# OPTIONS_HADDOCK not-home #-}

    -----------------------------------------------------------------------------
    -- |
    -- Module      :  GHC.Weak
    -- 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)
    --
    -- Weak pointers.
    --
    -----------------------------------------------------------------------------

    module GHC.Weak (
            Weak(..),
            mkWeak,
            deRefWeak,
            finalize,

            -- * Handling exceptions
            -- | When an exception is thrown by a finalizer called by the
            -- garbage collector, GHC calls a global handler which can be set with
            -- 'setFinalizerExceptionHandler'. Note that any exceptions thrown by
            -- this handler will be ignored.
            setFinalizerExceptionHandler,
            getFinalizerExceptionHandler
        ) where

    import GHC.Base
    import GHC.Weak.Finalize

    {-|
    A weak pointer object with a key and a value.  The value has type @v@.

    A weak pointer expresses a relationship between two objects, the
    /key/ and the /value/:  if the key is considered to be alive by the
    garbage collector, then the value is also alive.  A reference from
    the value to the key does /not/ keep the key alive.

    A weak pointer may also have a finalizer of type @IO ()@; if it does,
    then the finalizer will be run at most once, at a time after the key
    has become unreachable by the program (\"dead\").  The storage manager
    attempts to run the finalizer(s) for an object soon after the object
    dies, but promptness is not guaranteed.

    It is not guaranteed that a finalizer will eventually run, and no
    attempt is made to run outstanding finalizers when the program exits.
    Therefore finalizers should not be relied on to clean up resources -
    other methods (eg. exception handlers) should be employed, possibly in
    addition to finalizers.

    References from the finalizer to the key are treated in the same way
    as references from the value to the key: they do not keep the key
    alive.  A finalizer may therefore resurrect the key, perhaps by
    storing it in the same data structure.

    The finalizer, and the relationship between the key and the value,
    exist regardless of whether the program keeps a reference to the
    'Weak' object or not.

    There may be multiple weak pointers with the same key.  In this
    case, the finalizers for each of these weak pointers will all be
    run in some arbitrary order, or perhaps concurrently, when the key
    dies.  If the programmer specifies a finalizer that assumes it has
    the only reference to an object (for example, a file that it wishes
    to close), then the programmer must ensure that there is only one
    such finalizer.

    If there are no other threads to run, the runtime system will check
    for runnable finalizers before declaring the system to be deadlocked.

    WARNING: weak pointers to ordinary non-primitive Haskell types are
    particularly fragile, because the compiler is free to optimise away or
    duplicate the underlying data structure.  Therefore attempting to
    place a finalizer on an ordinary Haskell type may well result in the
    finalizer running earlier than you expected.  This is not a problem
    for caches and memo tables where early finalization is benign.

    Finalizers /can/ be used reliably for types that are created explicitly
    and have identity, such as @IORef@, @MVar@, and @TVar@.  However, to
    place a finalizer on one of these types, you should use the specific
    operation provided for that type, e.g. @mkWeakIORef@, @mkWeakMVar@ and
    @mkWeakTVar@ respectively.  These operations attach the finalizer to
    the primitive object inside the box (e.g. @MutVar#@ in the case of
    @IORef@), because attaching the finalizer to the box itself fails when
    the outer box is optimised away by the compiler.

    -}
    data Weak v = Weak (Weak# v)

    -- | Establishes a weak pointer to @k@, with value @v@ and a finalizer.
    --
    -- This is the most general interface for building a weak pointer.
    --
    mkWeak  :: k                            -- ^ key
            -> v                            -- ^ value
            -> Maybe (IO ())                -- ^ finalizer
            -> IO (Weak v)                  -- ^ returns: a weak pointer object

    mkWeak :: forall k v. k -> v -> Maybe (IO ()) -> IO (Weak v)
    mkWeak k
    key v
    val (Just (IO State# RealWorld -> (# State# RealWorld, () #)
    finalizer)) = (State# RealWorld -> (# State# RealWorld, Weak v #)) -> IO (Weak v)
    forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
    IO ((State# RealWorld -> (# State# RealWorld, Weak v #))
     -> IO (Weak v))
    -> (State# RealWorld -> (# State# RealWorld, Weak v #))
    -> IO (Weak v)
    forall a b. (a -> b) -> a -> b
    $ \State# RealWorld
    s ->
       case k
    -> v
    -> (State# RealWorld -> (# State# RealWorld, () #))
    -> State# RealWorld
    -> (# State# RealWorld, Weak# v #)
    forall a b c.
    a
    -> b
    -> (State# RealWorld -> (# State# RealWorld, c #))
    -> State# RealWorld
    -> (# State# RealWorld, Weak# b #)
    mkWeak# k
    key v
    val State# RealWorld -> (# State# RealWorld, () #)
    finalizer State# RealWorld
    s of { (# State# RealWorld
    s1, Weak# v
    w #) -> (# State# RealWorld
    s1, Weak# v -> Weak v
    forall v. Weak# v -> Weak v
    Weak Weak# v
    w #) }
    mkWeak k
    key v
    val Maybe (IO ())
    Nothing = (State# RealWorld -> (# State# RealWorld, Weak v #)) -> IO (Weak v)
    forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
    IO ((State# RealWorld -> (# State# RealWorld, Weak v #))
     -> IO (Weak v))
    -> (State# RealWorld -> (# State# RealWorld, Weak v #))
    -> IO (Weak v)
    forall a b. (a -> b) -> a -> b
    $ \State# RealWorld
    s ->
       case k -> v -> State# RealWorld -> (# State# RealWorld, Weak# v #)
    forall a b.
    a -> b -> State# RealWorld -> (# State# RealWorld, Weak# b #)
    mkWeakNoFinalizer# k
    key v
    val State# RealWorld
    s of { (# State# RealWorld
    s1, Weak# v
    w #) -> (# State# RealWorld
    s1, Weak# v -> Weak v
    forall v. Weak# v -> Weak v
    Weak Weak# v
    w #) }

    {-|
    Dereferences a weak pointer.  If the key is still alive, then
    @'Just' v@ is returned (where @v@ is the /value/ in the weak pointer), otherwise
    'Nothing' is returned.

    The return value of 'deRefWeak' depends on when the garbage collector
    runs, hence it is in the 'IO' monad.
    -}
    deRefWeak :: Weak v -> IO (Maybe v)
    deRefWeak :: forall v. Weak v -> IO (Maybe v)
    deRefWeak (Weak Weak# v
    w) = (State# RealWorld -> (# State# RealWorld, Maybe v #))
    -> IO (Maybe v)
    forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
    IO ((State# RealWorld -> (# State# RealWorld, Maybe v #))
     -> IO (Maybe v))
    -> (State# RealWorld -> (# State# RealWorld, Maybe v #))
    -> IO (Maybe v)
    forall a b. (a -> b) -> a -> b
    $ \State# RealWorld
    s ->
       case Weak# v -> State# RealWorld -> (# State# RealWorld, Int#, v #)
    forall a.
    Weak# a -> State# RealWorld -> (# State# RealWorld, Int#, a #)
    deRefWeak# Weak# v
    w State# RealWorld
    s of
            (# State# RealWorld
    s1, Int#
    flag, v
    p #) -> case Int#
    flag of
                                    Int#
    0# -> (# State# RealWorld
    s1, Maybe v
    forall a. Maybe a
    Nothing #)
                                    Int#
    _  -> (# State# RealWorld
    s1, v -> Maybe v
    forall a. a -> Maybe a
    Just v
    p #)

    -- | Causes a the finalizer associated with a weak pointer to be run
    -- immediately.
    finalize :: Weak v -> IO ()
    finalize :: forall v. Weak v -> IO ()
    finalize (Weak Weak# v
    w) = (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
    forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
    IO ((State# RealWorld -> (# State# RealWorld, () #)) -> IO ())
    -> (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \State# RealWorld
    s ->
       case Weak# v
    -> State# RealWorld
    -> (# State# RealWorld, Int#,
          State# RealWorld -> (# State# RealWorld, () #) #)
    forall a b.
    Weak# a
    -> State# RealWorld
    -> (# State# RealWorld, Int#,
          State# RealWorld -> (# State# RealWorld, b #) #)
    finalizeWeak# Weak# v
    w State# RealWorld
    s of
            (# State# RealWorld
    s1, Int#
    0#, State# RealWorld -> (# State# RealWorld, () #)
    _ #) -> (# State# RealWorld
    s1, () #) -- already dead, or no finalizer
            (# State# RealWorld
    s1, Int#
    _,  State# RealWorld -> (# State# RealWorld, () #)
    f #) -> State# RealWorld -> (# State# RealWorld, () #)
    f State# RealWorld
    s1

    {-
    Instance Eq (Weak v) where
      (Weak w1) == (Weak w2) = w1 `sameWeak#` w2
    -}