map -text -base -bytestring

map :: (Key -> Key) -> IntSet -> IntSet
containers Data.IntSet
O(n*min(n,W)). map f s is the set obtained by applying f to each element of s. It's worth noting that the size of the result may be smaller if, for some (x,y), x /= y && f x == f y
map :: (a -> b) -> IntMap a -> IntMap b
containers Data.IntMap.Strict, containers Data.IntMap.Lazy
O(n). Map a function over all values in the map. > map (++ "x") (fromList [(5,"a"), (3,"b")]) == fromList [(3, "bx"), (5, "ax")]
map :: (a -> b) -> Map k a -> Map k b
containers Data.Map.Lazy, containers Data.Map.Strict
O(n). Map a function over all values in the map. > map (++ "x") (fromList [(5,"a"), (3,"b")]) == fromList [(3, "bx"), (5, "ax")]
map :: Ord b => (a -> b) -> Set a -> Set b
containers Data.Set
O(n*log n). map f s is the set obtained by applying f to each element of s. It's worth noting that the size of the result may be smaller if, for some (x,y), x /= y && f x == f y
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
mapAccum :: (a -> b -> (a, c)) -> a -> IntMap b -> (a, IntMap c)
containers Data.IntMap.Strict, containers Data.IntMap.Lazy
O(n). The function mapAccum threads an accumulating argument through the map in ascending order of keys. > let f a b = (a ++ b, b ++ "X") > mapAccum f "Everything: " (fromList [(5,"a"), (3,"b")]) == ("Everything: ba", fromList [(3, "bX"), (5, "aX")])
mapAccum :: (a -> b -> (a, c)) -> a -> Map k b -> (a, Map k c)
containers Data.Map.Lazy, containers Data.Map.Strict
O(n). The function mapAccum threads an accumulating argument through the map in ascending order of keys. > let f a b = (a ++ b, b ++ "X") > mapAccum f "Everything: " (fromList [(5,"a"), (3,"b")]) == ("Everything: ba", fromList [(3, "bX"), (5, "aX")])
mapAccumRWithKey :: (a -> Key -> b -> (a, c)) -> a -> IntMap b -> (a, IntMap c)
containers Data.IntMap.Strict, containers Data.IntMap.Lazy
O(n). The function mapAccumR threads an accumulating argument through the map in descending order of keys.
mapAccumRWithKey :: (a -> k -> b -> (a, c)) -> a -> Map k b -> (a, Map k c)
containers Data.Map.Lazy, containers Data.Map.Strict
O(n). The function mapAccumR threads an accumulating argument through the map in descending order of keys.
mapAccumWithKey :: (a -> Key -> b -> (a, c)) -> a -> IntMap b -> (a, IntMap c)
containers Data.IntMap.Strict, containers Data.IntMap.Lazy
O(n). The function mapAccumWithKey threads an accumulating argument through the map in ascending order of keys. > let f a k b = (a ++ " " ++ (show k) ++ "-" ++ b, b ++ "X") > mapAccumWithKey f "Everything:" (fromList [(5,"a"), (3,"b")]) == ("Everything: 3-b 5-a", fromList [(3, "bX"), (5, "aX")])
mapAccumWithKey :: (a -> k -> b -> (a, c)) -> a -> Map k b -> (a, Map k c)
containers Data.Map.Lazy, containers Data.Map.Strict
O(n). The function mapAccumWithKey threads an accumulating argument through the map in ascending order of keys. > let f a k b = (a ++ " " ++ (show k) ++ "-" ++ b, b ++ "X") > mapAccumWithKey f "Everything:" (fromList [(5,"a"), (3,"b")]) == ("Everything: 3-b 5-a", fromList [(3, "bX"), (5, "aX")])
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
mapEither :: (a -> Either b c) -> IntMap a -> (IntMap b, IntMap c)
containers Data.IntMap.Strict, containers Data.IntMap.Lazy
O(n). Map values and separate the Left and Right results. > let f a = if a < "c" then Left a else Right a > mapEither f (fromList [(5,"a"), (3,"b"), (1,"x"), (7,"z")]) > == (fromList [(3,"b"), (5,"a")], fromList [(1,"x"), (7,"z")]) > > mapEither (\ a -> Right a) (fromList [(5,"a"), (3,"b"), (1,"x"), (7,"z")]) > == (empty, fromList [(5,"a"), (3,"b"), (1,"x"), (7,"z")])
mapEither :: (a -> Either b c) -> Map k a -> (Map k b, Map k c)
containers Data.Map.Lazy, containers Data.Map.Strict
O(n). Map values and separate the Left and Right results. > let f a = if a < "c" then Left a else Right a > mapEither f (fromList [(5,"a"), (3,"b"), (1,"x"), (7,"z")]) > == (fromList [(3,"b"), (5,"a")], fromList [(1,"x"), (7,"z")]) > > mapEither (\ a -> Right a) (fromList [(5,"a"), (3,"b"), (1,"x"), (7,"z")]) > == (empty, fromList [(5,"a"), (3,"b"), (1,"x"), (7,"z")])

Show more results