O(n) map f xs is the ByteString obtained by applying f to each element of xs.

O(n) map f xs is the ByteString obtained by applying f to each element of xs

O(n) map f xs is the ShortByteString obtained by applying f to each element of xs.

O(n) map f t is the Text obtained by applying f to each element of t. Example:

>>> let message = pack "I am not angry. Not at all."

>>> T.map (\c -> if c == '.' then '!' else c) message
"I am not angry! Not at all!"

Performs replacement on invalid scalar values.

O(n) map f xs is the Stream Char obtained by applying f to each element of xs. Properties

unstream . map f . stream = map f

O(n) map f t is the Text obtained by applying f to each element of t. Performs replacement on invalid scalar values.

Map a function over all values in the map.

map (++ "x") (fromList [(5,"a"), (3,"b")]) == fromList [(3, "bx"), (5, "ax")]

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 function over all values in the map.

map (++ "x") (fromList [(5,"a"), (3,"b")]) == fromList [(3, "bx"), (5, "ax")]

map f s is the set obtained by applying f to each element of s. If f is monotonically non-decreasing, this function takes <math> time. It's worth noting that the size of the result may be smaller if, for some (x,y), x /= y && f x == f y

Transform this map by applying a function to every value.

Transform this set by applying a function to every value. The resulting set may be smaller than the source.

>>> HashSet.map show (HashSet.fromList [1,2,3])
HashSet.fromList ["1","2","3"]

Apply a function to each element of a Stream, lazily

Map a function over all values in the map.

map (++ "x") (fromList [(5,"a"), (3,"b")]) == fromList [(3, "bx"), (5, "ax")]

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

Finite Maps (lazy interface)

This module re-exports the value lazy Data.Map.Lazy API. The Map k v type represents a finite map (sometimes called a dictionary) from keys of type k to values of type v. A Map is strict in its keys but lazy in its values. The functions in Data.Map.Strict are careful to force values before installing them in a Map. This is usually more efficient in cases where laziness is not essential. The functions in this module do not do so. When deciding if this is the correct data structure to use, consider:

• If you are using Int keys, you will get much better performance for most operations using Data.IntMap.Lazy.
• If you don't care about ordering, consider using Data.HashMap.Lazy from the unordered-containers package instead.

For a walkthrough of the most commonly used functions see the maps introduction. This module is intended to be imported qualified, to avoid name clashes with Prelude functions, e.g.

import Data.Map (Map)
import qualified Data.Map as Map

Note that the implementation is generally left-biased. Functions that take two maps as arguments and combine them, such as union and intersection, prefer the values in the first argument to those in the second.

Warning

The size of a Map must not exceed maxBound :: Int. Violation of this condition is not detected and if the size limit is exceeded, its behaviour is undefined.

Implementation

The implementation of Map is based on size balanced binary trees (or trees of bounded balance) as described by:

• Stephen Adams, "Efficient sets—a balancing act", Journal of Functional Programming 3(4):553-562, October 1993, https://doi.org/10.1017/S0956796800000885, https://groups.csail.mit.edu/mac/users/adams/BB/index.html.
• J. Nievergelt and E.M. Reingold, "Binary search trees of bounded balance", SIAM journal of computing 2(1), March 1973. https://doi.org/10.1137/0202005.
• Yoichi Hirai and Kazuhiko Yamamoto, "Balancing weight-balanced trees", Journal of Functional Programming 21(3):287-307, 2011, https://doi.org/10.1017/S0956796811000104

Bounds for union, intersection, and difference are as given by

• Guy Blelloch, Daniel Ferizovic, and Yihan Sun, "Parallel Ordered Sets Using Join", https://arxiv.org/abs/1602.02120v4.

Performance information

The time complexity is given for each operation in big-O notation, with <math> referring to the number of entries in the map. Operations like lookup, insert, and delete take <math> time. Binary set operations like union and intersection take <math> time, where <math> and <math> are the sizes of the smaller and larger input maps respectively.

A Map from keys k to values a.

Not on Stackage, so not searched. Class of key-value maps

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.

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.

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.

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.