{-# LANGUAGE Unsafe #-}
{-# LANGUAGE NoImplicitPrelude #-}

-----------------------------------------------------------------------------
-- |
-- Module      :  System.IO.Unsafe
-- Copyright   :  (c) The University of Glasgow 2001
-- License     :  BSD-style (see the file libraries/base/LICENSE)
-- 
-- Maintainer  :  libraries@haskell.org
-- Stability   :  provisional
-- Portability :  portable
--
-- \"Unsafe\" IO operations.
--
-----------------------------------------------------------------------------

module System.IO.Unsafe (
   -- * Unsafe 'System.IO.IO' operations
   unsafePerformIO,
   unsafeDupablePerformIO,
   unsafeInterleaveIO,
   unsafeFixIO,
  ) where

import GHC.Base
import GHC.IO
import GHC.IORef
import GHC.Exception
import Control.Exception

-- | A slightly faster version of `System.IO.fixIO` that may not be
-- safe to use with multiple threads.  The unsafety arises when used
-- like this:
--
-- >  unsafeFixIO $ \r -> do
-- >     forkIO (print r)
-- >     return (...)
--
-- In this case, the child thread will receive a @NonTermination@
-- exception instead of waiting for the value of @r@ to be computed.
--
-- @since 4.5.0.0
unsafeFixIO :: (a -> IO a) -> IO a
unsafeFixIO :: forall a. (a -> IO a) -> IO a
unsafeFixIO a -> IO a
k = do
  IORef a
ref <- a -> IO (IORef a)
forall a. a -> IO (IORef a)
newIORef (NonTermination -> a
forall a e. Exception e => e -> a
throw NonTermination
NonTermination)
  a
ans <- IO a -> IO a
forall a. IO a -> IO a
unsafeDupableInterleaveIO (IORef a -> IO a
forall a. IORef a -> IO a
readIORef IORef a
ref)
  a
result <- a -> IO a
k a
ans
  IORef a -> a -> IO ()
forall a. IORef a -> a -> IO ()
writeIORef IORef a
ref a
result
  a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return a
result