[IO a] -> IO [a]

sequence :: Monad m => [m a] -> m [a]
base Prelude, base Control.Monad
Evaluate each action in the sequence from left to right, and collect the results.
sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)
base Data.Traversable
sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
base Data.Traversable
many :: Alternative f => f a -> f [a]
base Control.Applicative
some :: Alternative f => f a -> f [a]
base Control.Applicative
replicateM :: Monad m => Int -> m a -> m [a]
base Control.Monad
replicateM n act performs the action n times, gathering the results.
getPixelMapComponents :: (PixelMap m, PixelMapComponent c) => m c -> IO [c]
OpenGL Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelMap
qRunIO :: Quasi m => IO a -> m a
template-haskell Language.Haskell.TH.Syntax
liftIO :: MonadIO m => IO a -> m a
cgi Network.CGI, transformers Control.Monad.IO.Class
liftIO :: MonadIO m => forall a. IO a -> m a
cgi Network.CGI
Lift a computation from the IO monad.
toList :: Foldable t => t a -> [a]
base Data.Foldable
List of elements of a structure.
getMatrixComponents :: (Matrix m, MatrixComponent c) => MatrixOrder -> m c -> IO [c]
OpenGL Graphics.Rendering.OpenGL.GL.CoordTrans
ext1 :: (Data a, Typeable1 t) => c a -> (forall d. Data d => c (t d)) -> c a
syb Data.Generics.Aliases
Flexible type extension
concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
base Data.Foldable
Map a function over all the elements of a container and concatenate the resulting lists.
ext1R :: (Monad m, Data d, Typeable1 t) => m d -> (forall e. Data e => m (t e)) -> m d
syb Data.Generics.Aliases
Type extension of readers for type constructors
traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()
base Data.Foldable
Map each element of a structure to an action, evaluate these actions from left to right, and ignore the results.
for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
base Data.Foldable
for_ is traverse_ with its arguments flipped.
mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
base Data.Foldable
Map each element of a structure to a monadic action, evaluate these actions from left to right, and ignore the results.
forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
base Data.Foldable
forM_ is mapM_ with its arguments flipped.
foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b
base Data.Foldable
Monadic fold over the elements of a structure, associating to the right, i.e. from right to left.

Show more results