Hoogle Search

Within LTS Haskell 24.60 (ghc-9.10.3)

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

Exact lookup

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. toAscList :: Map k a -> [(k, a)]

   containers	Data.Map.Strict.Internal

   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")]
   

4. toDescList :: Map k a -> [(k, a)]

   containers	Data.Map.Strict.Internal

   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")]
   

5. toList :: Map k a -> [(k, a)]

   containers	Data.Map.Strict.Internal

   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 == []
   

6. fromList :: [a] -> Seq a

   containers	Data.Sequence

   Create a sequence from a finite list of elements. There is a function toList in the opposite direction for all instances of the Foldable class, including Seq.

7. fromList :: [a] -> Seq a

   containers	Data.Sequence.Internal

   Create a sequence from a finite list of elements. There is a function toList in the opposite direction for all instances of the Foldable class, including Seq.

8. data IQList e

   containers	Data.Sequence.Internal.Sorting

   No documentation available.

9. data ITQList e a

   containers	Data.Sequence.Internal.Sorting

   No documentation available.

10. data QList e

    containers	Data.Sequence.Internal.Sorting

    No documentation available.

Page 45 of many | Previous | Next