Hoogle Search

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

fromAscListWith :: (a -> a -> a) -> [(Key, a)] -> IntMap a

containers Data.IntMap.Lazy

Build a map from a list of key/value pairs where the keys are in ascending order, with a combining function on equal keys. The precondition (input list is ascending) is not checked.
```
fromAscListWith (++) [(3,"b"), (5,"a"), (5,"b")] == fromList [(3, "b"), (5, "ba")]
```
Also see the performance note on fromListWith.
fromAscListWithKey :: (Key -> a -> a -> a) -> [(Key, a)] -> IntMap a

containers Data.IntMap.Lazy

Build a map from a list of key/value pairs where the keys are in ascending order, with a combining function on equal keys. The precondition (input list is ascending) is not checked.
```
let f key new_value old_value = (show key) ++ ":" ++ new_value ++ "|" ++ old_value
fromAscListWithKey f [(3,"b"), (5,"a"), (5,"b")] == fromList [(3, "b"), (5, "5:b|a")]
```
Also see the performance note on fromListWith.
fromDistinctAscList :: [(Key, a)] -> IntMap a

containers Data.IntMap.Lazy

Build a map from a list of key/value pairs where the keys are in ascending order and all distinct. The precondition (input list is strictly ascending) is not checked.
```
fromDistinctAscList [(3,"b"), (5,"a")] == fromList [(3, "b"), (5, "a")]
```

containers	Data.IntMap.Lazy

Create a map from a list of key/value pairs.

fromList [] == empty
fromList [(5,"a"), (3,"b"), (5, "c")] == fromList [(5,"c"), (3,"b")]
fromList [(5,"c"), (3,"b"), (5, "a")] == fromList [(5,"a"), (3,"b")]

fromListWith :: (a -> a -> a) -> [(Key, a)] -> IntMap a

containers Data.IntMap.Lazy

Build a map from a list of key/value pairs with a combining function. See also fromAscListWith.
```
fromListWith (++) [(5,"a"), (5,"b"), (3,"x"), (5,"c")] == fromList [(3, "x"), (5, "cba")]
fromListWith (++) [] == empty
```
Note the reverse ordering of "cba" in the example. The symmetric combining function f is applied in a left-fold over the list, as f new old.
Performance
You should ensure that the given f is fast with this order of arguments. Symmetric functions may be slow in one order, and fast in another. For the common case of collecting values of matching keys in a list, as above: The complexity of (++) a b is <math>, so it is fast when given a short list as its first argument. Thus:
```
fromListWith       (++)  (replicate 1000000 (3, "x"))   -- O(n),  fast
fromListWith (flip (++)) (replicate 1000000 (3, "x"))   -- O(n²), extremely slow
```
because they evaluate as, respectively:
```
fromList [(3, "x" ++ ("x" ++ "xxxxx..xxxxx"))]   -- O(n)
fromList [(3, ("xxxxx..xxxxx" ++ "x") ++ "x")]   -- O(n²)
```
Thus, to get good performance with an operation like (++) while also preserving the same order as in the input list, reverse the input:
```
fromListWith (++) (reverse [(5,"a"), (5,"b"), (5,"c")]) == fromList [(5, "abc")]
```
and it is always fast to combine singleton-list values [v] with fromListWith (++), as in:
```
fromListWith (++) $ reverse $ map (\(k, v) -> (k, [v])) someListOfTuples
```
fromListWithKey :: (Key -> a -> a -> a) -> [(Key, a)] -> IntMap a

containers Data.IntMap.Lazy

Build a map from a list of key/value pairs with a combining function. See also fromAscListWithKey'.
```
let f key new_value old_value = show key ++ ":" ++ new_value ++ "|" ++ old_value
fromListWithKey f [(5,"a"), (5,"b"), (3,"b"), (3,"a"), (5,"c")] == fromList [(3, "3:a|b"), (5, "5:c|5:b|a")]
fromListWithKey f [] == empty
```
Also see the performance note on fromListWith.
toAscList :: IntMap a -> [(Key, a)]

containers Data.IntMap.Lazy

Convert the map to a list of key/value pairs where the keys are in ascending order. Subject to list fusion.
```
toAscList (fromList [(5,"a"), (3,"b")]) == [(3,"b"), (5,"a")]
```
toDescList :: IntMap a -> [(Key, a)]

containers Data.IntMap.Lazy

Convert the map to a list of key/value pairs where the keys are in descending order. Subject to list fusion.
```
toDescList (fromList [(5,"a"), (3,"b")]) == [(5,"a"), (3,"b")]
```
toList :: IntMap a -> [(Key, a)]

containers Data.IntMap.Lazy

Convert the map to a list of key/value pairs. Subject to list fusion.
```
toList (fromList [(5,"a"), (3,"b")]) == [(3,"b"), (5,"a")]
toList empty == []
```

fromAscList :: [(Key, a)] -> IntMap a

containers	Data.IntMap.Strict

Build a map from a list of key/value pairs where the keys are in ascending order.

fromAscList [(3,"b"), (5,"a")]          == fromList [(3, "b"), (5, "a")]
fromAscList [(3,"b"), (5,"a"), (5,"b")] == fromList [(3, "b"), (5, "b")]

Page 35 of many | Previous | Next

Hoogle Search

Performance