Copyright	(c) 2016 Stephen Diehl (c) 2016-2018 Serokell (c) 2018-2021 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 :: forall b m f a. (Semigroup b, Monoid b, Applicative m, Foldable f) => (a -> m b) -> f a -> m b
foldMapM :: forall b m f a. (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 Source #

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 Source #

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 :: forall b m f a. (Semigroup b, Monoid b, Applicative m, Foldable f) => (a -> m b) -> f a -> m b Source #

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 :: forall b m f a. (Monoid b, Monad m, Foldable f) => (a -> m b) -> f a -> m b Source #

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 Source #

Stricter version of sum.

>>> sum [1..10]
55

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

Stricter version of product.

>>> product [1..10]
3628800

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

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

Monadic version of or.

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