map -containers -opengl

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
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.
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
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

Show more results