map -containers

map :: (a -> b) -> [a] -> [b]
base Prelude, base Data.List
map f xs is the list obtained by applying f to each element of xs, i.e., > map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn] > map f [x1, x2, ...] == [f x1, f x2, ...]
map :: (Char -> Char) -> ByteString -> ByteString
bytestring Data.ByteString.Char8, bytestring Data.ByteString.Lazy.Char8
O(n) map f xs is the ByteString obtained by applying f to each element of xs
map :: (Char -> Char) -> Text -> Text
text Data.Text, text Data.Text.Lazy
O(n) map f t is the Text obtained by applying f to each element of t. Subject to fusion. Performs replacement on invalid scalar values.
map :: (Word8 -> Word8) -> ByteString -> ByteString
bytestring Data.ByteString.Lazy
O(n) map f xs is the ByteString obtained by applying f to each element of xs.
map :: (Word8 -> Word8) -> ByteString -> ByteString
bytestring Data.ByteString
O(n) map f xs is the ByteString obtained by applying f to each element of xs. This function is subject to array fusion.
mapM :: Monad m => (a -> m b) -> [a] -> m [b]
base Prelude, base Control.Monad
mapM f is equivalent to sequence . map f.
mapM_ :: Monad m => (a -> m b) -> [a] -> m ()
base Prelude, base Control.Monad
mapM_ f is equivalent to sequence_ . map f.
mapAccumL :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])
base Data.List
The mapAccumL function behaves like a combination of map and foldl; it applies a function to each element of a list, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new list.
mapAccumL :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
base Data.Traversable
The mapAccumL function behaves like a combination of fmap and foldl; it applies a function to each element of a structure, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new structure.
mapAccumR :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])
base Data.List
The mapAccumR function behaves like a combination of map and foldr; it applies a function to each element of a list, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new list.
mapAccumR :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
base Data.Traversable
The mapAccumR function behaves like a combination of fmap and foldr; it applies a function to each element of a structure, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new structure.
mapAndUnzipM :: Monad m => (a -> m (b, c)) -> [a] -> m ([b], [c])
base Control.Monad
The mapAndUnzipM function maps its first argument over a list, returning the result as a pair of lists. This function is mainly used with complicated data structures or a state-transforming monad.
mapException :: (Exception -> Exception) -> a -> a
base Control.OldException
This function maps one exception into another as proposed in the paper "A semantics for imprecise exceptions".
mapException :: (Exception e1, Exception e2) => (e1 -> e2) -> a -> a
base Control.Exception.Base, base Control.Exception
This function maps one exception into another as proposed in the paper "A semantics for imprecise exceptions".
mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
base Data.Traversable
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.
mapMaybe :: (a -> Maybe b) -> [a] -> [b]
base Data.Maybe
The mapMaybe function is a version of map which can throw out elements. In particular, the functional argument returns something of type Maybe b. If this is Nothing, no element is added on to the result list. If it just Just b, then b is included in the result list.
mappend :: Monoid a => a -> a -> a
base Data.Monoid
map1 :: (Map1 m, ControlPoint c, Domain d) => StateVar (Maybe (m c d))
OpenGL Graphics.Rendering.OpenGL.GL.Evaluators
map2 :: (Map2 m, ControlPoint c, Domain d) => StateVar (Maybe (m c d))
OpenGL Graphics.Rendering.OpenGL.GL.Evaluators
mapAccumL :: (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)
text Data.Text, text Data.Text.Lazy
O(n) Like a combination of map and foldl'. Applies a function to each element of a Text, passing an accumulating parameter from left to right, and returns a final Text. Performs replacement on invalid scalar values.
mapAccumL :: (acc -> Char -> (acc, Char)) -> acc -> ByteString -> (acc, ByteString)
bytestring Data.ByteString.Lazy.Char8
The mapAccumL function behaves like a combination of map and foldl; it applies a function to each element of a ByteString, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new ByteString.
mapAccumL :: (acc -> Char -> (acc, Char)) -> acc -> ByteString -> (acc, ByteString)
bytestring Data.ByteString.Char8
The mapAccumL function behaves like a combination of map and foldl; it applies a function to each element of a ByteString, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new list.
mapAccumL :: (acc -> Word8 -> (acc, Word8)) -> acc -> ByteString -> (acc, ByteString)
bytestring Data.ByteString.Lazy
The mapAccumL function behaves like a combination of map and foldl; it applies a function to each element of a ByteString, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new ByteString.
mapAccumL :: (acc -> Word8 -> (acc, Word8)) -> acc -> ByteString -> (acc, ByteString)
bytestring Data.ByteString
The mapAccumL function behaves like a combination of map and foldl; it applies a function to each element of a ByteString, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new list.
mapAccumR :: (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)
text Data.Text, text Data.Text.Lazy
The mapAccumR function behaves like a combination of map and a strict foldr; it applies a function to each element of a Text, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new Text. Performs replacement on invalid scalar values.
mapAccumR :: (acc -> Char -> (acc, Char)) -> acc -> ByteString -> (acc, ByteString)
bytestring Data.ByteString.Char8, bytestring Data.ByteString.Lazy.Char8
The mapAccumR function behaves like a combination of map and foldr; it applies a function to each element of a ByteString, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new ByteString.
mapAccumR :: (acc -> Word8 -> (acc, Word8)) -> acc -> ByteString -> (acc, ByteString)
bytestring Data.ByteString, bytestring Data.ByteString.Lazy
The mapAccumR function behaves like a combination of map and foldr; it applies a function to each element of a ByteString, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new ByteString.
mapArray :: (MArray a e' m, MArray a e m, Ix i) => (e' -> e) -> a i e' -> m (a i e)
array Data.Array.MArray, array Data.Array.MArray.Safe
Constructs a new array derived from the original array by applying a function to each of the elements.
mapBuffer :: BufferTarget -> BufferAccess -> IO (Maybe (Ptr a))
OpenGL Graphics.Rendering.OpenGL.GL.BufferObjects
mapBufferRange :: BufferTarget -> Offset -> Length -> [MapBufferUsage] -> IO (Maybe (Ptr a))
OpenGL Graphics.Rendering.OpenGL.GL.BufferObjects
mapColor :: StateVar Capability
OpenGL Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelTransfer
mapCont :: (r -> r) -> Cont r a -> Cont r a
transformers Control.Monad.Trans.Cont, mtl Control.Monad.Cont
Apply a function to transform the result of a continuation-passing computation. *  (mapCont f m) = f . runCont
mapContT :: (m r -> m r) -> ContT r m a -> ContT r m a
transformers Control.Monad.Trans.Cont, mtl Control.Monad.Cont
Apply a function to transform the result of a continuation-passing computation. *  (mapContT f m) = f . runContT
mapErrorT :: (m (Either e a) -> n (Either e' b)) -> ErrorT e m a -> ErrorT e' n b
transformers Control.Monad.Trans.Error, mtl Control.Monad.Error
Map the unwrapped computation using the given function. *  (mapErrorT f m) = f (runErrorT >  
mapFst :: (a -> b) -> (a, c) -> (b, c)
fgl Data.Graph.Inductive.Query.Monad
mapGrid1 :: Domain d => StateVar (GLint, (d, d))
OpenGL Graphics.Rendering.OpenGL.GL.Evaluators
mapGrid2 :: Domain d => StateVar ((GLint, (d, d)), (GLint, (d, d)))
OpenGL Graphics.Rendering.OpenGL.GL.Evaluators
mapIdentityT :: (m a -> n b) -> IdentityT m a -> IdentityT n b
transformers Control.Monad.Trans.Identity
Lift a unary operation to the new monad.
mapIndices :: (MArray a e m, Ix i, Ix j) => (i, i) -> (i -> j) -> a j e -> m (a i e)
array Data.Array.MArray, array Data.Array.MArray.Safe
Constructs a new array derived from the original array by applying a function to each of the indices.
mapListT :: (m [a] -> n [b]) -> ListT m a -> ListT n b
transformers Control.Monad.Trans.List, mtl Control.Monad.List
Map between ListT computations. *  (mapListT f m) = f (runListT >  
mapMaybeT :: (m (Maybe a) -> n (Maybe b)) -> MaybeT m a -> MaybeT n b
transformers Control.Monad.Trans.Maybe
Transform the computation inside a MaybeT. *  (mapMaybeT f m) = f (runMaybeT >  
mapProp :: Testable prop => (Prop -> Prop) -> prop -> Property
QuickCheck Test.QuickCheck.Property
mapReader :: (a -> b) -> Reader r a -> Reader r b
transformers Control.Monad.Trans.Reader, mtl Control.Monad.Reader
Transform the value returned by a Reader. *  (mapReader f m) = f . > runReader
mapReaderT :: (m a -> n b) -> ReaderT r m a -> ReaderT r n b
transformers Control.Monad.Trans.Reader, mtl Control.Monad.Reader
Transform the computation inside a ReaderT. *  (mapReaderT f m) = f . > runReaderT
mapResult :: Testable prop => (Result -> Result) -> prop -> Property
QuickCheck Test.QuickCheck.Property
mapRoseResult :: Testable prop => (Rose Result -> Rose Result) -> prop -> Property
QuickCheck Test.QuickCheck.Property
mapRWS :: ((a, s, w) -> (b, s, w')) -> RWS r w s a -> RWS r w' s b
transformers Control.Monad.Trans.RWS.Lazy, transformers Control.Monad.Trans.RWS.Strict, mtl Control.Monad.RWS.Lazy, mtl Control.Monad.RWS.Strict
Map the return value, final state and output of a computation using the given function. *  (mapRWS f m) r s = f (runRWS m r >  
mapRWST :: (m (a, s, w) -> n (b, s, w')) -> RWST r w s m a -> RWST r w' s n b
transformers Control.Monad.Trans.RWS.Lazy, transformers Control.Monad.Trans.RWS.Strict, mtl Control.Monad.RWS.Lazy, mtl Control.Monad.RWS.Strict
Map the inner computation using the given function. *  (mapRWST f m) r s = f (runRWST m > r  
mapSize :: Testable prop => (Int -> Int) -> prop -> Property
QuickCheck Test.QuickCheck.Property, QuickCheck Test.QuickCheck
Changes the maximum test case size for a property.
mapSnd :: (a -> b) -> (c, a) -> (c, b)
fgl Data.Graph.Inductive.Query.Monad
mapState :: ((a, s) -> (b, s)) -> State s a -> State s b
transformers Control.Monad.Trans.State.Lazy, transformers Control.Monad.Trans.State.Strict, mtl Control.Monad.State.Lazy, mtl Control.Monad.State.Strict
Map both the return value and final state of a computation using the given function. *  (mapState f m) = f . runState
mapStateT :: (m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b
transformers Control.Monad.Trans.State.Lazy, transformers Control.Monad.Trans.State.Strict, mtl Control.Monad.State.Lazy, mtl Control.Monad.State.Strict
Map both the return value and final state of a computation using the given function. *  (mapStateT f m) = f . > runStateT
mapStencil :: StateVar Capability
OpenGL Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelTransfer
mapTotalResult :: Testable prop => (Result -> Result) -> prop -> Property
QuickCheck Test.QuickCheck.Property
mapWriter :: ((a, w) -> (b, w')) -> Writer w a -> Writer w' b
transformers Control.Monad.Trans.Writer.Lazy, transformers Control.Monad.Trans.Writer.Strict, mtl Control.Monad.Writer.Lazy, mtl Control.Monad.Writer.Strict
Map both the return value and output of a computation using the given function. *  (mapWriter f m) = f (runWriter >  
mapWriterT :: (m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b
transformers Control.Monad.Trans.Writer.Lazy, transformers Control.Monad.Trans.Writer.Strict, mtl Control.Monad.Writer.Lazy, mtl Control.Monad.Writer.Strict
Map both the return value and output of a computation using the given function. *  (mapWriterT f m) = f > (runWriterT  
class Map1 m
OpenGL Graphics.Rendering.OpenGL.GL.Evaluators
class Map2 m
OpenGL Graphics.Rendering.OpenGL.GL.Evaluators
data MapBufferUsage
OpenGL Graphics.Rendering.OpenGL.GL.BufferObjects

Show more results