Hoogle Search

Within LTS Haskell 24.34 (ghc-9.10.3)

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

Exact lookup

1. imapDefault :: TraversableWithIndex i f => (i -> a -> b) -> f a -> f b

   indexed-traversable	Data.Traversable.WithIndex

   No documentation available.

2. imapM :: (TraversableWithIndex i t, Monad m) => (i -> a -> m b) -> t a -> m (t b)

   indexed-traversable	Data.Traversable.WithIndex

   Map each element of a structure to a monadic action, evaluate these actions from left to right, and collect the results, with access the index. When you don't need access to the index mapM is more liberal in what it can accept.

   mapM ≡ imapM . const
   

3. foldByKeyHashMap :: (Hashable k, Eq k) => Fold a b -> Fold (k, a) (HashMap k b)

   foldl	Control.Foldl

   Given a Fold, produces a HashMap which applies that fold to each a separated by key k.

   >>> List.sort (HashMap.toList (fold (foldByKeyHashMap Control.Foldl.sum) [("a",1), ("b",2), ("b",20), ("a",10)]))
   [("a",11),("b",22)]
   

4. foldByKeyMap :: Ord k => Fold a b -> Fold (k, a) (Map k b)

   foldl	Control.Foldl

   Given a Fold, produces a Map which applies that fold to each a separated by key k.

   >>> fold (foldByKeyMap Control.Foldl.sum) [("a",1), ("b",2), ("b",20), ("a",10)]
   fromList [("a",11),("b",22)]
   

5. foldMap :: Monoid w => (a -> w) -> (w -> b) -> Fold a b

   foldl	Control.Foldl

   Convert a "foldMap" to a Fold

6. hashMap :: (Eq a, Hashable a) => Fold (a, b) (HashMap a b)

   foldl	Control.Foldl

   Fold pairs into a hash-map.

7. postmapM :: Monad m => (a -> m r) -> FoldM m x a -> FoldM m x r

   foldl	Control.Foldl

   (postmapM f folder) returns a new FoldM where f is applied to the final value.

   postmapM pure = id
   
   postmapM (f >=> g) = postmapM g . postmapM f
   

   postmapM k (pure r) = lifts (k r)
   

8. premap :: (a -> b) -> Fold b r -> Fold a r

   foldl	Control.Foldl

   (premap f folder) returns a new Fold where f is applied at each step

   fold (premap f folder) list = fold folder (List.map f list)
   

   >>> fold (premap Sum Foldl.mconcat) [1..10]
   Sum {getSum = 55}
   

   >>> fold Foldl.mconcat (List.map Sum [1..10])
   Sum {getSum = 55}
   

   premap id = id
   
   premap (f . g) = premap g . premap f
   

   premap k (pure r) = pure r
   
   premap k (f <*> x) = premap k f <*> premap k x
   

9. premapM :: Monad m => (a -> m b) -> FoldM m b r -> FoldM m a r

   foldl	Control.Foldl

   (premapM f folder) returns a new FoldM where f is applied to each input element

   premapM return = id
   
   premapM (f <=< g) = premap g . premap f
   

   premapM k (pure r) = pure r
   
   premapM k (f <*> x) = premapM k f <*> premapM k x
   

10. premap :: (a -> b) -> Fold1 b r -> Fold1 a r

    foldl	Control.Foldl.NonEmpty

    (premap f folder) returns a new Fold1 where f is applied at each step

    Foldl1.fold1 (premap f folder) list = Foldl1.fold1 folder (NonEmpty.map f list)
    

    >>> Foldl1.fold1 (premap Sum Foldl1.sconcat) (1 :| [2..10])
    Sum {getSum = 55}
    

    >>> Foldl1.fold1 Foldl1.sconcat $ NonEmpty.map Sum (1 :| [2..10])
    Sum {getSum = 55}
    

    premap id = id
    
    premap (f . g) = premap g . premap f
    

    premap k (pure r) = pure r
    
    premap k (f <*> x) = premap k f <*> premap k x
    

Page 475 of many | Previous | Next