Hoogle Search

Within LTS Haskell 24.64 (ghc-9.10.3)

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

Exact lookup

1. fromList :: Monoid a => [(Int, a)] -> Path a

   lca	Data.LCA.Online.Monoidal

   Build a Path from a list of (ID, value) pairs.

2. fromList :: [(Int, a)] -> Path a

   lca	Data.LCA.Online.Naive

   Build a Path from a list of (ID, value) pairs.

3. fromList :: MonadUnliftIO m => [a] -> m (InputStream a)

   unliftio-streams	UnliftIO.Streams.List

   No documentation available.

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

   xmonad-contrib	XMonad.Prelude

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

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

   singletons-base	Data.List.NonEmpty.Singletons

   No documentation available.

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

   hetero-parameter-list	Data.HeteroParList

   No documentation available.

7. type FromList = NonEmpty TableRef

   postgresql-syntax	PostgresqlSyntax.Ast

   References

   from_list:
   | table_ref
   | from_list ',' table_ref
   

8. 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).

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

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

Page 35 of many | Previous | Next