map -text -base
An efficient implementation of ordered maps from keys to values (dictionaries).
This module re-exports the value lazy Lazy API, plus several value strict functions from Strict.
These modules are intended to be imported qualified, to avoid name clashes with Prelude functions, e.g.
> import qualified Data.Map as Map
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, http://www.swiss.ai.mit.edu/~adams/BB/.
* J. Nievergelt and E.M. Reingold, "Binary search trees of bounded balance", SIAM journal of computing 2(1), March 1973.
Note that the implementation is left-biased -- the elements of a first argument are always preferred to the second, for example in union or insert.
Operation comments contain the operation time complexity in the Big-O notation (http://en.wikipedia.org/wiki/Big_O_notation).
A Map from keys k to values a.
O(n) map f xs is the ByteString obtained by applying f to each element of xs
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
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. This function is subject to array fusion.
O(n). Map a function over all values in the map.
> map (++ "x") (fromList [(5,"a"), (3,"b")]) == fromList [(3, "bx"), (5, "ax")]
O(n). Map a function over all values in the map.
> map (++ "x") (fromList [(5,"a"), (3,"b")]) == fromList [(3, "bx"), (5, "ax")]
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
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")])
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")])
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 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.
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 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.
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.
Show more results