relude-1.2.2.0: Safe, performant, user-friendly and lightweight Haskell Standard Library

Copyright | (c) 2016 Stephen Diehl (c) 2016-2018 Serokell (c) 2018-2023 Kowainik
License | MIT
Maintainer | Kowainik <xrom.xkov@gmail.com>
Stability | Stable
Portability | Portable
Safe Haskell | Safe
Language | Haskell2010

Relude.Foldable.Fold

Contents

- Monadic functions

Description

Fixes and additions to `Foldable`. Specifically:

- Space-leak free `sum` and `product`
- `elem` and `notElem` are forbidden for `Set` and `HashSet`
- Additional combinators for common idioms

Synopsis

- flipfoldl' :: Foldable f => (a -> b -> b) -> b -> f a -> b
- asumMap :: forall b m f a. (Foldable f, Alternative m) => (a -> m b) -> f a -> m b
- foldMapA :: (Semigroup b, Monoid b, Applicative m, Foldable f) => (a -> m b) -> f a -> m b
- foldMapM :: (Monoid b, Monad m, Foldable f) => (a -> m b) -> f a -> m b
- sum :: forall a f. (Foldable f, Num a) => f a -> a
- product :: forall a f. (Foldable f, Num a) => f a -> a
- elem :: (Foldable f, DisallowElem f, Eq a) => a -> f a -> Bool
- notElem :: (Foldable f, DisallowElem f, Eq a) => a -> f a -> Bool
- allM :: (Foldable f, Monad m) => (a -> m Bool) -> f a -> m Bool
- anyM :: (Foldable f, Monad m) => (a -> m Bool) -> f a -> m Bool
- andM :: (Foldable f, Monad m) => f (m Bool) -> m Bool
- orM :: (Foldable f, Monad m) => f (m Bool) -> m Bool

# Documentation

flipfoldl' :: Foldable f => (a -> b -> b) -> b -> f a -> b #

Similar to `foldl'` but takes a function with its arguments flipped.

    >>> flipfoldl' (/) 5 [2,3] :: Rational
    15 % 2

This function can be useful for constructing containers from lists.

asumMap :: forall b m f a. (Foldable f, Alternative m) => (a -> m b) -> f a -> m b #

Alternative version of `asum` that takes a function to map over.

    >>> asumMap (\x -> if x > 2 then Just x else Nothing) [1..4]
    Just 3

Since: 0.4.0

foldMapA :: (Semigroup b, Monoid b, Applicative m, Foldable f) => (a -> m b) -> f a -> m b #

Polymorphic version of the `concatMapA` function.

    >>> foldMapA @[Int] (Just . replicate 3) [1..3]
    Just [1,1,1,2,2,2,3,3,3]

Since: 0.1.0

foldMapM :: (Monoid b, Monad m, Foldable f) => (a -> m b) -> f a -> m b #

Polymorphic version of the `concatMapM` function.

    >>> foldMapM @[Int] (Just . replicate 3) [1..3]
    Just [1,1,1,2,2,2,3,3,3]

Since: 0.1.0

sum :: forall a f. (Foldable f, Num a) => f a -> a #

Stricter version of `sum`.

    >>> sum [1..10]
    55

product :: forall a f. (Foldable f, Num a) => f a -> a #

Stricter version of `product`.

    >>> product [1..10]
    3628800

elem :: (Foldable f, DisallowElem f, Eq a) => a -> f a -> Bool #

Like `elem` but doesn't work on `Set` and `HashSet` for performance reasons.

    >>> elem 'x' ("abc" :: String)
    False
    >>> elem False (one True :: Set Bool)
    ...
    ... Do not use 'elem' and 'notElem' methods from 'Foldable' on Set
          Suggestions:
              Instead of
                  elem :: (Foldable t, Eq a) => a -> t a -> Bool
              use
                  member :: Ord a => a -> Set a -> Bool
    ...
              Instead of
                  notElem :: (Foldable t, Eq a) => a -> t a -> Bool
              use
                  not . member
    ...

notElem :: (Foldable f, DisallowElem f, Eq a) => a -> f a -> Bool #

Like `notElem` but doesn't work on `Set` and `HashSet` for performance reasons.

    >>> notElem 'x' ("abc" :: String)
    True
    >>> notElem False (one True :: Set Bool)
    ...
    ... Do not use 'elem' and 'notElem' methods from 'Foldable' on Set
          Suggestions:
              Instead of
                  elem :: (Foldable t, Eq a) => a -> t a -> Bool
              use
                  member :: Ord a => a -> Set a -> Bool
    ...
              Instead of
                  notElem :: (Foldable t, Eq a) => a -> t a -> Bool
              use
                  not . member
    ...

# Monadic functions

allM :: (Foldable f, Monad m) => (a -> m Bool) -> f a -> m Bool #

Monadic version of `all`.

    >>> allM (readMaybe >=> pure . even) ["6", "10"]
    Just True
    >>> allM (readMaybe >=> pure . even) ["5", "aba"]
    Just False
    >>> allM (readMaybe >=> pure . even) ["aba", "10"]
    Nothing

anyM :: (Foldable f, Monad m) => (a -> m Bool) -> f a -> m Bool #

Monadic version of `any`.

    >>> anyM (readMaybe >=> pure . even) ["5", "10"]
    Just True
    >>> anyM (readMaybe >=> pure . even) ["10", "aba"]
    Just True
    >>> anyM (readMaybe >=> pure . even) ["aba", "10"]
    Nothing

andM :: (Foldable f, Monad m) => f (m Bool) -> m Bool #

Monadic version of `and`.

    >>> andM [Just True, Just False]
    Just False
    >>> andM [Just True]
    Just True
    >>> andM [Just True, Just False, Nothing]
    Just False
    >>> andM [Just True, Nothing]
    Nothing
    >>> andM [putTextLn "1" >> pure True, putTextLn "2" >> pure False, putTextLn "3" >> pure True]
    1
    2
    False

orM :: (Foldable f, Monad m) => f (m Bool) -> m Bool #

Monadic version of `or`.

    >>> orM [Just True, Just False]
    Just True
    >>> orM [Just True, Nothing]
    Just True
    >>> orM [Nothing, Just True]
    Nothing