Map -containers +base

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, ...]
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
concatMap :: (a -> [b]) -> [a] -> [b]
base Prelude, base Data.List
Map a function over a list and concatenate the results.
fmap :: Functor f => (a -> b) -> f a -> f b
base Prelude, base Data.Functor, base Control.Monad, base Control.Monad.Instances
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.
fmapDefault :: Traversable t => (a -> b) -> t a -> t b
base Data.Traversable
This function may be used as a value for fmap in a Functor instance.
foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m
base Data.Foldable
foldMapDefault :: (Traversable t, Monoid m) => (a -> m) -> t a -> m
base Data.Traversable
This function may be used as a value for Data.Foldable.foldMap in a Foldable instance.

Show more results