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.

Exact lookup

1. fromList :: IsList l => [Item l] -> l

   xmonad-contrib	XMonad.Prelude

   The fromList function constructs the structure l from the given list of Item l

2. type family FromList (a1 :: [a]) :: NonEmpty a

   singletons-base	Data.List.NonEmpty.Singletons

   No documentation available.

3. class FromList (ss :: [k])

   hetero-parameter-list	Data.HeteroParList

   No documentation available.

4. type FromList = NonEmpty TableRef

   postgresql-syntax	PostgresqlSyntax.Ast

   References

   from_list:
   | table_ref
   | from_list ',' table_ref
   

5. fromListN :: IsList l => Int -> [Item l] -> l

   base	GHC.Exts

   The fromListN function takes the input list's length and potentially uses it to construct the structure l more efficiently compared to fromList. If the given number does not equal to the input list's length the behaviour of fromListN is not specified.

   fromListN (length xs) xs == fromList xs
   

6. fromListN :: IsList l => Int -> [Item l] -> l

   base	GHC.IsList

   The fromListN function takes the input list's length and potentially uses it to construct the structure l more efficiently compared to fromList. If the given number does not equal to the input list's length the behaviour of fromListN is not specified.

   fromListN (length xs) xs == fromList xs
   

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

   containers	Data.IntMap.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
   

8. fromListWithKey :: (Key -> a -> a -> a) -> [(Key, a)] -> IntMap a

   containers	Data.IntMap.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.

9. 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
   

10. 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.

Page 38 of many | Previous | Next