map -containers -bytestring

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

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.

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.

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.

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.

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.

Constructs a new array derived from the original array by applying a function to each of the elements.

This function maps one exception into another as proposed in the paper "A semantics for imprecise exceptions".

Constructs a new array derived from the original array by applying a function to each of the indices.

mapM f is equivalent to sequence . map f.

Prelude	map :: (a -> b) -> [a] -> [b]
base	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, ...]
Data.List	map :: (a -> b) -> [a] -> [b]
base	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, ...]
Data.List	mapAccumL :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])
base	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.
Data.Traversable	mapAccumL :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
base	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.
Data.List	mapAccumR :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])
base	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.
Data.Traversable	mapAccumR :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
base	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.
Control.Monad	mapAndUnzipM :: Monad m => (a -> m (b, c)) -> [a] -> m ([b], [c])
base	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.
Data.Array.MArray	mapArray :: (MArray a e' m, MArray a e m, Ix i) => (e' -> e) -> a i e' -> m (a i e)
array	Constructs a new array derived from the original array by applying a function to each of the elements.
Control.Monad.Cont	mapCont :: (r -> r) -> Cont r a -> Cont r a
mtl
Control.Monad.Cont	mapContT :: (m r -> m r) -> ContT r m a -> ContT r m a
mtl
Control.Monad.Error	mapErrorT :: (m (Either e a) -> n (Either e' b)) -> ErrorT e m a -> ErrorT e' n b
mtl
Control.Exception	mapException :: (Exception e1, Exception e2) => (e1 -> e2) -> a -> a
base	This function maps one exception into another as proposed in the paper "A semantics for imprecise exceptions".
Control.OldException	mapException :: (Exception -> Exception) -> a -> a
base	This function maps one exception into another as proposed in the paper "A semantics for imprecise exceptions".
Control.Exception.Base	mapException :: (Exception e1, Exception e2) => (e1 -> e2) -> a -> a
base	This function maps one exception into another as proposed in the paper "A semantics for imprecise exceptions".
Data.Graph.Inductive.Query.Monad	mapFst :: (a -> b) -> (a, c) -> (b, c)
fgl
Data.Array.MArray	mapIndices :: (MArray a e m, Ix i, Ix j) => (i, i) -> (i -> j) -> a j e -> m (a i e)
array	Constructs a new array derived from the original array by applying a function to each of the indices.
Control.Monad.List	mapListT :: (m [a] -> n [b]) -> ListT m a -> ListT n b
mtl
Prelude	mapM :: Monad m => (a -> m b) -> [a] -> m [b]
base	mapM f is equivalent to sequence . map f.
Control.Monad	mapM :: Monad m => (a -> m b) -> [a] -> m [b]
base	mapM f is equivalent to sequence . map f.
Data.Traversable	mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
base
	Show more results

Searching for map