module Lifted
(
appendFile
, getContents
, getLine
, interact
, readFile
, writeFile
, getArgs
, openFile
, exitWith
, exitFailure
, exitSuccess
, die
, stToIO
, myThreadId
, getNumCapabilities
, setNumCapabilities
, threadCapability
, isCurrentThreadBound
, mkWeakThreadId
, atomically
) where
import Control.Concurrent (ThreadId)
#if ( __GLASGOW_HASKELL__ >= 710 )
import Control.Monad.ST (RealWorld, ST)
#else
import Control.Monad.ST.Safe (RealWorld, ST)
#endif
import Control.Monad.STM (STM)
import Control.Monad.Trans (MonadIO, liftIO)
import Data.String (String)
import Data.Text (Text)
import Prelude (Bool, FilePath, Int, (>>))
import System.Exit (ExitCode)
import System.IO (Handle, IOMode, stderr)
import qualified System.IO (hPutStrLn)
import System.Mem.Weak (Weak)
import qualified Data.Text.IO as XIO
import qualified System.Environment as XIO
import qualified System.Exit as XIO
import qualified System.IO as XIO (openFile)
#if ( __GLASGOW_HASKELL__ >= 710 )
import qualified Control.Monad.ST as XIO
#else
import qualified Control.Monad.ST.Safe as XIO
#endif
import qualified Control.Concurrent as XIO
import qualified Control.Monad.STM as XIO
appendFile :: MonadIO m => FilePath -> Text -> m ()
appendFile a b = liftIO (XIO.appendFile a b)
getContents :: MonadIO m => m Text
getContents = liftIO XIO.getContents
getLine :: MonadIO m => m Text
getLine = liftIO XIO.getLine
interact :: MonadIO m => (Text -> Text) -> m ()
interact a = liftIO (XIO.interact a)
readFile :: MonadIO m => FilePath -> m Text
readFile a = liftIO (XIO.readFile a)
writeFile :: MonadIO m => FilePath -> Text -> m ()
writeFile a b = liftIO (XIO.writeFile a b)
getArgs :: MonadIO m => m [String]
getArgs = liftIO (XIO.getArgs)
openFile :: MonadIO m => FilePath -> IOMode -> m Handle
openFile a b = liftIO (XIO.openFile a b)
exitWith :: MonadIO m => ExitCode -> m a
exitWith a = liftIO (XIO.exitWith a)
exitFailure :: MonadIO m => m a
exitFailure = liftIO XIO.exitFailure
exitSuccess :: MonadIO m => m a
exitSuccess = liftIO XIO.exitSuccess
die :: MonadIO m => String -> m ()
die err = liftIO (System.IO.hPutStrLn stderr err) >> exitFailure
stToIO :: MonadIO m => ST RealWorld a -> m a
stToIO a = liftIO (XIO.stToIO a)
myThreadId :: MonadIO m => m ThreadId
myThreadId = liftIO XIO.myThreadId
getNumCapabilities :: MonadIO m => m Int
getNumCapabilities = liftIO XIO.getNumCapabilities
setNumCapabilities :: MonadIO m => Int -> m ()
setNumCapabilities a = liftIO (XIO.setNumCapabilities a)
threadCapability :: MonadIO m => ThreadId -> m (Int, Bool)
threadCapability a = liftIO (XIO.threadCapability a)
isCurrentThreadBound :: MonadIO m => m Bool
isCurrentThreadBound = liftIO XIO.isCurrentThreadBound
mkWeakThreadId :: MonadIO m => ThreadId -> m (Weak ThreadId)
mkWeakThreadId a = liftIO (XIO.mkWeakThreadId a)
atomically :: MonadIO m => STM a -> m a
atomically a = liftIO (XIO.atomically a)