Hoogle Search

Within LTS Haskell 24.4 (ghc-9.10.2)

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

  1. fromListWith :: Ord k => (a -> a -> a) -> [(k, a)] -> Map k a

    containers Data.Map.Strict.Internal

    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

  2. fromListWithKey :: Ord k => (k -> a -> a -> a) -> [(k, a)] -> Map k a

    containers Data.Map.Strict.Internal

    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.

  3. fromListWith :: (v -> v -> v) -> [(Key, v)] -> KeyMap v

    aeson Data.Aeson.KeyMap

    Construct a map from a list of elements. Uses the provided function, f, to merge duplicate entries with (f newVal oldVal).

  4. fromListWith :: (Eq k, Hashable k) => (v -> v -> v) -> [(k, v)] -> HashMap k v

    unordered-containers Data.HashMap.Internal

    Construct a map from a list of elements. Uses the provided function f to merge duplicate entries with (f newVal oldVal).

    Examples

    Given a list xs, create a map with the number of occurrences of each element in xs: 
    let xs = ['a', 'b', 'a']
in fromListWith (+) [ (x, 1) | x <- xs ]

= fromList [('a', 2), ('b', 1)]
    Given a list of key-value pairs xs :: [(k, v)], group all values by their keys and return a HashMap k [v]. 
    let xs = [('a', 1), ('b', 2), ('a', 3)]
in fromListWith (++) [ (k, [v]) | (k, v) <- xs ]

= fromList [('a', [3, 1]), ('b', [2])]
    Note that the lists in the resulting map contain elements in reverse order from their occurrences in the original list. More generally, duplicate entries are accumulated as follows; this matters when f is not commutative or not associative. 
    fromListWith f [(k, a), (k, b), (k, c), (k, d)]
= fromList [(k, f d (f c (f b a)))]

  5. fromListWithKey :: (Eq k, Hashable k) => (k -> v -> v -> v) -> [(k, v)] -> HashMap k v

    unordered-containers Data.HashMap.Internal

    Construct a map from a list of elements. Uses the provided function to merge duplicate entries.

    Examples

    Given a list of key-value pairs where the keys are of different flavours, e.g: 
    data Key = Div | Sub
    and the values need to be combined differently when there are duplicates, depending on the key: 
    combine Div = div
combine Sub = (-)
    then fromListWithKey can be used as follows: 
    fromListWithKey combine [(Div, 2), (Div, 6), (Sub, 2), (Sub, 3)]
= fromList [(Div, 3), (Sub, 1)]
    More generally, duplicate entries are accumulated as follows; 
    fromListWith f [(k, a), (k, b), (k, c), (k, d)]
= fromList [(k, f k d (f k c (f k b a)))]

  6. fromList' :: Int -> [a] -> Array a

    unordered-containers Data.HashMap.Internal.Array

    No documentation available.

  7. fromListWith :: (Eq k, Hashable k) => (v -> v -> v) -> [(k, v)] -> HashMap k v

    unordered-containers Data.HashMap.Internal.Strict

    Construct a map from a list of elements. Uses the provided function f to merge duplicate entries with (f newVal oldVal).

    Examples

    Given a list xs, create a map with the number of occurrences of each element in xs: 
    let xs = ['a', 'b', 'a']
in fromListWith (+) [ (x, 1) | x <- xs ]

= fromList [('a', 2), ('b', 1)]
    Given a list of key-value pairs xs :: [(k, v)], group all values by their keys and return a HashMap k [v]. 
    let xs = ('a', 1), ('b', 2), ('a', 3)]
in fromListWith (++) [ (k, [v]) | (k, v) <- xs ]

= fromList [('a', [3, 1]), ('b', [2])]
    Note that the lists in the resulting map contain elements in reverse order from their occurrences in the original list. More generally, duplicate entries are accumulated as follows; this matters when f is not commutative or not associative. 
    fromListWith f [(k, a), (k, b), (k, c), (k, d)]
= fromList [(k, f d (f c (f b a)))]

  8. fromListWithKey :: (Eq k, Hashable k) => (k -> v -> v -> v) -> [(k, v)] -> HashMap k v

    unordered-containers Data.HashMap.Internal.Strict

    Construct a map from a list of elements. Uses the provided function to merge duplicate entries.

    Examples

    Given a list of key-value pairs where the keys are of different flavours, e.g: 
    data Key = Div | Sub
    and the values need to be combined differently when there are duplicates, depending on the key: 
    combine Div = div
combine Sub = (-)
    then fromListWithKey can be used as follows: 
    fromListWithKey combine [(Div, 2), (Div, 6), (Sub, 2), (Sub, 3)]
= fromList [(Div, 3), (Sub, 1)]
    More generally, duplicate entries are accumulated as follows; 
    fromListWith f [(k, a), (k, b), (k, c), (k, d)]
= fromList [(k, f k d (f k c (f k b a)))]

  9. fromListWith :: (Eq k, Hashable k) => (v -> v -> v) -> [(k, v)] -> HashMap k v

    unordered-containers Data.HashMap.Lazy

    Construct a map from a list of elements. Uses the provided function f to merge duplicate entries with (f newVal oldVal).

    Examples

    Given a list xs, create a map with the number of occurrences of each element in xs: 
    let xs = ['a', 'b', 'a']
in fromListWith (+) [ (x, 1) | x <- xs ]

= fromList [('a', 2), ('b', 1)]
    Given a list of key-value pairs xs :: [(k, v)], group all values by their keys and return a HashMap k [v]. 
    let xs = [('a', 1), ('b', 2), ('a', 3)]
in fromListWith (++) [ (k, [v]) | (k, v) <- xs ]

= fromList [('a', [3, 1]), ('b', [2])]
    Note that the lists in the resulting map contain elements in reverse order from their occurrences in the original list. More generally, duplicate entries are accumulated as follows; this matters when f is not commutative or not associative. 
    fromListWith f [(k, a), (k, b), (k, c), (k, d)]
= fromList [(k, f d (f c (f b a)))]

  10. fromListWithKey :: (Eq k, Hashable k) => (k -> v -> v -> v) -> [(k, v)] -> HashMap k v

    unordered-containers Data.HashMap.Lazy

    Construct a map from a list of elements. Uses the provided function to merge duplicate entries.

    Examples

    Given a list of key-value pairs where the keys are of different flavours, e.g: 
    data Key = Div | Sub
    and the values need to be combined differently when there are duplicates, depending on the key: 
    combine Div = div
combine Sub = (-)
    then fromListWithKey can be used as follows: 
    fromListWithKey combine [(Div, 2), (Div, 6), (Sub, 2), (Sub, 3)]
= fromList [(Div, 3), (Sub, 1)]
    More generally, duplicate entries are accumulated as follows; 
    fromListWith f [(k, a), (k, b), (k, c), (k, d)]
= fromList [(k, f k d (f k c (f k b a)))]

Page 40 of many | Previous | Next