Relude.Foldable.Fold

Fixes and additions to Foldable.

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 :: (Foldable f, Alternative m) => (a -> m b) -> f a -> m b

Alternative version of asum.

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

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

Polymorphic version of concatMapA function.

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

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

Polymorphic version of concatMapM function.

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

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

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

Internals

type family DisallowElem (f :: Type -> Type) :: Constraint where ...

Type family that produces compile-time errors when elem and notElem functions are used with Set and HashSet.

Equations

DisallowElem Set = TypeError (ElemErrorMessage Set SetMemberType)

DisallowElem HashSet = TypeError (ElemErrorMessage HashSet HashSetMemberType)

DisallowElem f = ()

type family ElemErrorMessage (t :: k) (msg :: Symbol) :: ErrorMessage where ...

Equations

ElemErrorMessage t msg = (((((((((((Text "Do not use 'elem' and 'notElem' methods from 'Foldable' on " :<>: ShowType t) :$$: Text "Suggestions:") :$$: Text " Instead of") :$$: Text " elem :: (Foldable t, Eq a) => a -> t a -> Bool") :$$: Text " use") :$$: (Text " member :: " :<>: Text msg)) :$$: Text "") :$$: Text " Instead of") :$$: Text " notElem :: (Foldable t, Eq a) => a -> t a -> Bool") :$$: Text " use") :$$: Text " not . member") :$$: Text ""