STM.Base

Documentation

module IO.Base

module Control.Concurrent.STM.TVar

module Control.Concurrent.STM.TMVar

module Control.Concurrent.STM.TBChan

data IO a :: * -> *

A value of type IO a is a computation which, when performed, does some I/O before returning a value of type a.

There is really only one way to "perform" an I/O action: bind it to Main.main in your program. When your program is run, the I/O will be performed. It isn't possible to perform I/O from an arbitrary function, unless that function is itself in the IO monad and called at some point, directly or indirectly, from Main.main.

IO is a monad, so IO actions can be combined using either the do-notation or the >> and >>= operations from the Monad class.

Instances

Monad IO

Methods

(>>=) :: IO a -> (a -> IO b) -> IO b

(>>) :: IO a -> IO b -> IO b

return :: a -> IO a

fail :: String -> IO a

Functor IO

Methods

fmap :: (a -> b) -> IO a -> IO b

(<$) :: a -> IO b -> IO a

MonadFix IO

Methods

mfix :: (a -> IO a) -> IO a

MonadFail IO

Methods

fail :: String -> IO a

Applicative IO

Methods

pure :: a -> IO a

(<*>) :: IO (a -> b) -> IO a -> IO b

(*>) :: IO a -> IO b -> IO b

(<*) :: IO a -> IO b -> IO a

Alternative IO

Methods

empty :: IO a

(<|>) :: IO a -> IO a -> IO a

some :: IO a -> IO [a]

many :: IO a -> IO [a]

MonadPlus IO

Methods

mzero :: IO a

mplus :: IO a -> IO a -> IO a

MonadIO IO

Methods

liftIO :: IO a -> IO a

MonadThrow IO

Methods

throwM :: Exception e => e -> IO a

MonadCatch IO

Methods

catch :: Exception e => IO a -> (e -> IO a) -> IO a

MonadMask IO

Methods

mask :: ((forall a. IO a -> IO a) -> IO b) -> IO b

uninterruptibleMask :: ((forall a. IO a -> IO a) -> IO b) -> IO b

PrimMonad IO

Associated Types

type PrimState (IO :: * -> *) :: *

Methods

primitive :: (State# (PrimState IO) -> (#VoidRep, PtrRepLifted, State# (PrimState IO), a#)) -> IO a

PrimBase IO

Methods

internal :: IO a -> State# (PrimState IO) -> (#VoidRep, PtrRepLifted, State# (PrimState IO), a#)

Apply IO

Methods

(<.>) :: IO (a -> b) -> IO a -> IO b

(.>) :: IO a -> IO b -> IO b

(<.) :: IO a -> IO b -> IO a

Bind IO

Methods

(>>-) :: IO a -> (a -> IO b) -> IO b

join :: IO (IO a) -> IO a

Quasi IO

Methods

qNewName :: String -> IO Name

qReport :: Bool -> String -> IO ()

qRecover :: IO a -> IO a -> IO a

qLookupName :: Bool -> String -> IO (Maybe Name)

qReify :: Name -> IO Info

qReifyFixity :: Name -> IO (Maybe Fixity)

qReifyInstances :: Name -> [Type] -> IO [Dec]

qReifyRoles :: Name -> IO [Role]

qReifyAnnotations :: Data a => AnnLookup -> IO [a]

qReifyModule :: Module -> IO ModuleInfo

qReifyConStrictness :: Name -> IO [DecidedStrictness]

qLocation :: IO Loc

qRunIO :: IO a -> IO a

qAddDependentFile :: FilePath -> IO ()

qAddTopDecls :: [Dec] -> IO ()

qAddModFinalizer :: Q () -> IO ()

qGetQ :: Typeable * a => IO (Maybe a)

qPutQ :: Typeable * a => a -> IO ()

qIsExtEnabled :: Extension -> IO Bool

qExtsEnabled :: IO [Extension]

MonadBaseControl IO IO

Associated Types

type StM (IO :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase IO IO -> IO a) -> IO a

restoreM :: StM IO a -> IO a

MonadBase IO IO

Methods

liftBase :: IO α -> IO α

MArray IOArray e IO

Methods

getBounds :: Ix i => IOArray i e -> IO (i, i)

getNumElements :: Ix i => IOArray i e -> IO Int

newArray :: Ix i => (i, i) -> e -> IO (IOArray i e)

newArray_ :: Ix i => (i, i) -> IO (IOArray i e)

unsafeNewArray_ :: Ix i => (i, i) -> IO (IOArray i e)

unsafeRead :: Ix i => IOArray i e -> Int -> IO e

unsafeWrite :: Ix i => IOArray i e -> Int -> e -> IO ()

Monoid a => Monoid (IO a)

Methods

mempty :: IO a

mappend :: IO a -> IO a -> IO a

mconcat :: [IO a] -> IO a

(~) * a () => PrintfType (IO a)

Methods

spr :: String -> [UPrintf] -> IO a

(~) * a () => HPrintfType (IO a)

Methods

hspr :: Handle -> String -> [UPrintf] -> IO a

type PrimState IO

type PrimState IO = RealWorld

type StM IO a

type StM IO a = a

data STM a :: * -> *

A monad supporting atomic memory transactions.

Instances

Monad STM

Methods

(>>=) :: STM a -> (a -> STM b) -> STM b

(>>) :: STM a -> STM b -> STM b

return :: a -> STM a

fail :: String -> STM a

Functor STM

Methods

fmap :: (a -> b) -> STM a -> STM b

(<$) :: a -> STM b -> STM a

Applicative STM

Methods

pure :: a -> STM a

(<*>) :: STM (a -> b) -> STM a -> STM b

(*>) :: STM a -> STM b -> STM b

(<*) :: STM a -> STM b -> STM a

Alternative STM

Methods

empty :: STM a

(<|>) :: STM a -> STM a -> STM a

some :: STM a -> STM [a]

many :: STM a -> STM [a]

MonadPlus STM

Methods

mzero :: STM a

mplus :: STM a -> STM a -> STM a

MonadThrow STM

Methods

throwM :: Exception e => e -> STM a

MonadCatch STM

Methods

catch :: Exception e => STM a -> (e -> STM a) -> STM a

MonadBaseControl STM STM

Associated Types

type StM (STM :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase STM STM -> STM a) -> STM a

restoreM :: StM STM a -> STM a

MonadBase STM STM

Methods

liftBase :: STM α -> STM α

type StM STM a

type StM STM a = a

atomically :: MonadBase IO m => STM α -> m α

atomically lifted to MonadBase IO.

newTVarIO :: MonadBase IO m => a -> m (TVar a)

newTVarIO at the top level, lifted.

newTMVarIO :: MonadBase IO m => a -> m (TMVar a)

newTMVarIO at the top level, lifted.

newEmptyTMVarIO :: MonadBase IO m => m (TMVar a)

newTMVarIO at the top level, lifted.

newTBChanIO :: (MonadBase IO m, Integral l) => l -> m (TBChan a)

newTBChanIO at the top level, lifted, only with a saturated length.

newTBChan :: Integral l => l -> STM (TBChan a)