Safe Haskell	Safe

Eta.Classes.Foldable

Synopsis

Documentation

class Foldable t where #

Minimal complete definition

foldMap | foldr

Methods

foldMap :: Monoid m => (a -> m) -> t a -> m #

foldr :: (a -> b -> b) -> b -> t a -> b #

Instances

Foldable []
Methods fold :: Monoid m => [m] -> m foldMap :: Monoid m => (a -> m) -> [a] -> m # foldr :: (a -> b -> b) -> b -> [a] -> b # foldr' :: (a -> b -> b) -> b -> [a] -> b foldl :: (b -> a -> b) -> b -> [a] -> b foldl' :: (b -> a -> b) -> b -> [a] -> b foldr1 :: (a -> a -> a) -> [a] -> a foldl1 :: (a -> a -> a) -> [a] -> a toList :: [a] -> [a] null :: [a] -> Bool length :: [a] -> Int elem :: Eq a => a -> [a] -> Bool maximum :: Ord a => [a] -> a minimum :: Ord a => [a] -> a sum :: Num a => [a] -> a product :: Num a => [a] -> a
Foldable Maybe
Methods fold :: Monoid m => Maybe m -> m foldMap :: Monoid m => (a -> m) -> Maybe a -> m # foldr :: (a -> b -> b) -> b -> Maybe a -> b # foldr' :: (a -> b -> b) -> b -> Maybe a -> b foldl :: (b -> a -> b) -> b -> Maybe a -> b foldl' :: (b -> a -> b) -> b -> Maybe a -> b foldr1 :: (a -> a -> a) -> Maybe a -> a foldl1 :: (a -> a -> a) -> Maybe a -> a toList :: Maybe a -> [a] null :: Maybe a -> Bool length :: Maybe a -> Int elem :: Eq a => a -> Maybe a -> Bool maximum :: Ord a => Maybe a -> a minimum :: Ord a => Maybe a -> a sum :: Num a => Maybe a -> a product :: Num a => Maybe a -> a
Foldable V1
Methods fold :: Monoid m => V1 m -> m foldMap :: Monoid m => (a -> m) -> V1 a -> m # foldr :: (a -> b -> b) -> b -> V1 a -> b # foldr' :: (a -> b -> b) -> b -> V1 a -> b foldl :: (b -> a -> b) -> b -> V1 a -> b foldl' :: (b -> a -> b) -> b -> V1 a -> b foldr1 :: (a -> a -> a) -> V1 a -> a foldl1 :: (a -> a -> a) -> V1 a -> a toList :: V1 a -> [a] null :: V1 a -> Bool length :: V1 a -> Int elem :: Eq a => a -> V1 a -> Bool maximum :: Ord a => V1 a -> a minimum :: Ord a => V1 a -> a sum :: Num a => V1 a -> a product :: Num a => V1 a -> a
Foldable U1
Methods fold :: Monoid m => U1 m -> m foldMap :: Monoid m => (a -> m) -> U1 a -> m # foldr :: (a -> b -> b) -> b -> U1 a -> b # foldr' :: (a -> b -> b) -> b -> U1 a -> b foldl :: (b -> a -> b) -> b -> U1 a -> b foldl' :: (b -> a -> b) -> b -> U1 a -> b foldr1 :: (a -> a -> a) -> U1 a -> a foldl1 :: (a -> a -> a) -> U1 a -> a toList :: U1 a -> [a] null :: U1 a -> Bool length :: U1 a -> Int elem :: Eq a => a -> U1 a -> Bool maximum :: Ord a => U1 a -> a minimum :: Ord a => U1 a -> a sum :: Num a => U1 a -> a product :: Num a => U1 a -> a
Foldable Par1
Methods fold :: Monoid m => Par1 m -> m foldMap :: Monoid m => (a -> m) -> Par1 a -> m # foldr :: (a -> b -> b) -> b -> Par1 a -> b # foldr' :: (a -> b -> b) -> b -> Par1 a -> b foldl :: (b -> a -> b) -> b -> Par1 a -> b foldl' :: (b -> a -> b) -> b -> Par1 a -> b foldr1 :: (a -> a -> a) -> Par1 a -> a foldl1 :: (a -> a -> a) -> Par1 a -> a toList :: Par1 a -> [a] null :: Par1 a -> Bool length :: Par1 a -> Int elem :: Eq a => a -> Par1 a -> Bool maximum :: Ord a => Par1 a -> a minimum :: Ord a => Par1 a -> a sum :: Num a => Par1 a -> a product :: Num a => Par1 a -> a
Foldable Sum
Methods fold :: Monoid m => Sum m -> m foldMap :: Monoid m => (a -> m) -> Sum a -> m # foldr :: (a -> b -> b) -> b -> Sum a -> b # foldr' :: (a -> b -> b) -> b -> Sum a -> b foldl :: (b -> a -> b) -> b -> Sum a -> b foldl' :: (b -> a -> b) -> b -> Sum a -> b foldr1 :: (a -> a -> a) -> Sum a -> a foldl1 :: (a -> a -> a) -> Sum a -> a toList :: Sum a -> [a] null :: Sum a -> Bool length :: Sum a -> Int elem :: Eq a => a -> Sum a -> Bool maximum :: Ord a => Sum a -> a minimum :: Ord a => Sum a -> a sum :: Num a => Sum a -> a product :: Num a => Sum a -> a
Foldable Product
Methods fold :: Monoid m => Product m -> m foldMap :: Monoid m => (a -> m) -> Product a -> m # foldr :: (a -> b -> b) -> b -> Product a -> b # foldr' :: (a -> b -> b) -> b -> Product a -> b foldl :: (b -> a -> b) -> b -> Product a -> b foldl' :: (b -> a -> b) -> b -> Product a -> b foldr1 :: (a -> a -> a) -> Product a -> a foldl1 :: (a -> a -> a) -> Product a -> a toList :: Product a -> [a] null :: Product a -> Bool length :: Product a -> Int elem :: Eq a => a -> Product a -> Bool maximum :: Ord a => Product a -> a minimum :: Ord a => Product a -> a sum :: Num a => Product a -> a product :: Num a => Product a -> a
Foldable Last
Methods fold :: Monoid m => Last m -> m foldMap :: Monoid m => (a -> m) -> Last a -> m # foldr :: (a -> b -> b) -> b -> Last a -> b # foldr' :: (a -> b -> b) -> b -> Last a -> b foldl :: (b -> a -> b) -> b -> Last a -> b foldl' :: (b -> a -> b) -> b -> Last a -> b foldr1 :: (a -> a -> a) -> Last a -> a foldl1 :: (a -> a -> a) -> Last a -> a toList :: Last a -> [a] null :: Last a -> Bool length :: Last a -> Int elem :: Eq a => a -> Last a -> Bool maximum :: Ord a => Last a -> a minimum :: Ord a => Last a -> a sum :: Num a => Last a -> a product :: Num a => Last a -> a
Foldable First
Methods fold :: Monoid m => First m -> m foldMap :: Monoid m => (a -> m) -> First a -> m # foldr :: (a -> b -> b) -> b -> First a -> b # foldr' :: (a -> b -> b) -> b -> First a -> b foldl :: (b -> a -> b) -> b -> First a -> b foldl' :: (b -> a -> b) -> b -> First a -> b foldr1 :: (a -> a -> a) -> First a -> a foldl1 :: (a -> a -> a) -> First a -> a toList :: First a -> [a] null :: First a -> Bool length :: First a -> Int elem :: Eq a => a -> First a -> Bool maximum :: Ord a => First a -> a minimum :: Ord a => First a -> a sum :: Num a => First a -> a product :: Num a => First a -> a
Foldable Dual
Methods fold :: Monoid m => Dual m -> m foldMap :: Monoid m => (a -> m) -> Dual a -> m # foldr :: (a -> b -> b) -> b -> Dual a -> b # foldr' :: (a -> b -> b) -> b -> Dual a -> b foldl :: (b -> a -> b) -> b -> Dual a -> b foldl' :: (b -> a -> b) -> b -> Dual a -> b foldr1 :: (a -> a -> a) -> Dual a -> a foldl1 :: (a -> a -> a) -> Dual a -> a toList :: Dual a -> [a] null :: Dual a -> Bool length :: Dual a -> Int elem :: Eq a => a -> Dual a -> Bool maximum :: Ord a => Dual a -> a minimum :: Ord a => Dual a -> a sum :: Num a => Dual a -> a product :: Num a => Dual a -> a
Foldable ZipList
Methods fold :: Monoid m => ZipList m -> m foldMap :: Monoid m => (a -> m) -> ZipList a -> m # foldr :: (a -> b -> b) -> b -> ZipList a -> b # foldr' :: (a -> b -> b) -> b -> ZipList a -> b foldl :: (b -> a -> b) -> b -> ZipList a -> b foldl' :: (b -> a -> b) -> b -> ZipList a -> b foldr1 :: (a -> a -> a) -> ZipList a -> a foldl1 :: (a -> a -> a) -> ZipList a -> a toList :: ZipList a -> [a] null :: ZipList a -> Bool length :: ZipList a -> Int elem :: Eq a => a -> ZipList a -> Bool maximum :: Ord a => ZipList a -> a minimum :: Ord a => ZipList a -> a sum :: Num a => ZipList a -> a product :: Num a => ZipList a -> a
Foldable (Either a)
Methods fold :: Monoid m => Either a m -> m foldMap :: Monoid m => (a -> m) -> Either a a -> m # foldr :: (a -> b -> b) -> b -> Either a a -> b # foldr' :: (a -> b -> b) -> b -> Either a a -> b foldl :: (b -> a -> b) -> b -> Either a a -> b foldl' :: (b -> a -> b) -> b -> Either a a -> b foldr1 :: (a -> a -> a) -> Either a a -> a foldl1 :: (a -> a -> a) -> Either a a -> a toList :: Either a a -> [a] null :: Either a a -> Bool length :: Either a a -> Int elem :: Eq a => a -> Either a a -> Bool maximum :: Ord a => Either a a -> a minimum :: Ord a => Either a a -> a sum :: Num a => Either a a -> a product :: Num a => Either a a -> a
Foldable f => Foldable (Rec1 f)
Methods fold :: Monoid m => Rec1 f m -> m foldMap :: Monoid m => (a -> m) -> Rec1 f a -> m # foldr :: (a -> b -> b) -> b -> Rec1 f a -> b # foldr' :: (a -> b -> b) -> b -> Rec1 f a -> b foldl :: (b -> a -> b) -> b -> Rec1 f a -> b foldl' :: (b -> a -> b) -> b -> Rec1 f a -> b foldr1 :: (a -> a -> a) -> Rec1 f a -> a foldl1 :: (a -> a -> a) -> Rec1 f a -> a toList :: Rec1 f a -> [a] null :: Rec1 f a -> Bool length :: Rec1 f a -> Int elem :: Eq a => a -> Rec1 f a -> Bool maximum :: Ord a => Rec1 f a -> a minimum :: Ord a => Rec1 f a -> a sum :: Num a => Rec1 f a -> a product :: Num a => Rec1 f a -> a
Foldable (URec Char)
Methods fold :: Monoid m => URec Char m -> m foldMap :: Monoid m => (a -> m) -> URec Char a -> m # foldr :: (a -> b -> b) -> b -> URec Char a -> b # foldr' :: (a -> b -> b) -> b -> URec Char a -> b foldl :: (b -> a -> b) -> b -> URec Char a -> b foldl' :: (b -> a -> b) -> b -> URec Char a -> b foldr1 :: (a -> a -> a) -> URec Char a -> a foldl1 :: (a -> a -> a) -> URec Char a -> a toList :: URec Char a -> [a] null :: URec Char a -> Bool length :: URec Char a -> Int elem :: Eq a => a -> URec Char a -> Bool maximum :: Ord a => URec Char a -> a minimum :: Ord a => URec Char a -> a sum :: Num a => URec Char a -> a product :: Num a => URec Char a -> a
Foldable (URec Double)
Methods fold :: Monoid m => URec Double m -> m foldMap :: Monoid m => (a -> m) -> URec Double a -> m # foldr :: (a -> b -> b) -> b -> URec Double a -> b # foldr' :: (a -> b -> b) -> b -> URec Double a -> b foldl :: (b -> a -> b) -> b -> URec Double a -> b foldl' :: (b -> a -> b) -> b -> URec Double a -> b foldr1 :: (a -> a -> a) -> URec Double a -> a foldl1 :: (a -> a -> a) -> URec Double a -> a toList :: URec Double a -> [a] null :: URec Double a -> Bool length :: URec Double a -> Int elem :: Eq a => a -> URec Double a -> Bool maximum :: Ord a => URec Double a -> a minimum :: Ord a => URec Double a -> a sum :: Num a => URec Double a -> a product :: Num a => URec Double a -> a
Foldable (URec Float)
Methods fold :: Monoid m => URec Float m -> m foldMap :: Monoid m => (a -> m) -> URec Float a -> m # foldr :: (a -> b -> b) -> b -> URec Float a -> b # foldr' :: (a -> b -> b) -> b -> URec Float a -> b foldl :: (b -> a -> b) -> b -> URec Float a -> b foldl' :: (b -> a -> b) -> b -> URec Float a -> b foldr1 :: (a -> a -> a) -> URec Float a -> a foldl1 :: (a -> a -> a) -> URec Float a -> a toList :: URec Float a -> [a] null :: URec Float a -> Bool length :: URec Float a -> Int elem :: Eq a => a -> URec Float a -> Bool maximum :: Ord a => URec Float a -> a minimum :: Ord a => URec Float a -> a sum :: Num a => URec Float a -> a product :: Num a => URec Float a -> a
Foldable (URec Int)
Methods fold :: Monoid m => URec Int m -> m foldMap :: Monoid m => (a -> m) -> URec Int a -> m # foldr :: (a -> b -> b) -> b -> URec Int a -> b # foldr' :: (a -> b -> b) -> b -> URec Int a -> b foldl :: (b -> a -> b) -> b -> URec Int a -> b foldl' :: (b -> a -> b) -> b -> URec Int a -> b foldr1 :: (a -> a -> a) -> URec Int a -> a foldl1 :: (a -> a -> a) -> URec Int a -> a toList :: URec Int a -> [a] null :: URec Int a -> Bool length :: URec Int a -> Int elem :: Eq a => a -> URec Int a -> Bool maximum :: Ord a => URec Int a -> a minimum :: Ord a => URec Int a -> a sum :: Num a => URec Int a -> a product :: Num a => URec Int a -> a
Foldable (URec Word)
Methods fold :: Monoid m => URec Word m -> m foldMap :: Monoid m => (a -> m) -> URec Word a -> m # foldr :: (a -> b -> b) -> b -> URec Word a -> b # foldr' :: (a -> b -> b) -> b -> URec Word a -> b foldl :: (b -> a -> b) -> b -> URec Word a -> b foldl' :: (b -> a -> b) -> b -> URec Word a -> b foldr1 :: (a -> a -> a) -> URec Word a -> a foldl1 :: (a -> a -> a) -> URec Word a -> a toList :: URec Word a -> [a] null :: URec Word a -> Bool length :: URec Word a -> Int elem :: Eq a => a -> URec Word a -> Bool maximum :: Ord a => URec Word a -> a minimum :: Ord a => URec Word a -> a sum :: Num a => URec Word a -> a product :: Num a => URec Word a -> a
Foldable (URec (Ptr ()))
Methods fold :: Monoid m => URec (Ptr ()) m -> m foldMap :: Monoid m => (a -> m) -> URec (Ptr ()) a -> m # foldr :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b # foldr' :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b foldl :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b foldl' :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b foldr1 :: (a -> a -> a) -> URec (Ptr ()) a -> a foldl1 :: (a -> a -> a) -> URec (Ptr ()) a -> a toList :: URec (Ptr ()) a -> [a] null :: URec (Ptr ()) a -> Bool length :: URec (Ptr ()) a -> Int elem :: Eq a => a -> URec (Ptr ()) a -> Bool maximum :: Ord a => URec (Ptr ()) a -> a minimum :: Ord a => URec (Ptr ()) a -> a sum :: Num a => URec (Ptr ()) a -> a product :: Num a => URec (Ptr ()) a -> a
Foldable ((,) a)
Methods fold :: Monoid m => (a, m) -> m foldMap :: Monoid m => (a -> m) -> (a, a) -> m # foldr :: (a -> b -> b) -> b -> (a, a) -> b # foldr' :: (a -> b -> b) -> b -> (a, a) -> b foldl :: (b -> a -> b) -> b -> (a, a) -> b foldl' :: (b -> a -> b) -> b -> (a, a) -> b foldr1 :: (a -> a -> a) -> (a, a) -> a foldl1 :: (a -> a -> a) -> (a, a) -> a toList :: (a, a) -> [a] null :: (a, a) -> Bool length :: (a, a) -> Int elem :: Eq a => a -> (a, a) -> Bool maximum :: Ord a => (a, a) -> a minimum :: Ord a => (a, a) -> a sum :: Num a => (a, a) -> a product :: Num a => (a, a) -> a
Foldable (Array i)
Methods fold :: Monoid m => Array i m -> m foldMap :: Monoid m => (a -> m) -> Array i a -> m # foldr :: (a -> b -> b) -> b -> Array i a -> b # foldr' :: (a -> b -> b) -> b -> Array i a -> b foldl :: (b -> a -> b) -> b -> Array i a -> b foldl' :: (b -> a -> b) -> b -> Array i a -> b foldr1 :: (a -> a -> a) -> Array i a -> a foldl1 :: (a -> a -> a) -> Array i a -> a toList :: Array i a -> [a] null :: Array i a -> Bool length :: Array i a -> Int elem :: Eq a => a -> Array i a -> Bool maximum :: Ord a => Array i a -> a minimum :: Ord a => Array i a -> a sum :: Num a => Array i a -> a product :: Num a => Array i a -> a
Foldable (Proxy *)
Methods fold :: Monoid m => Proxy * m -> m foldMap :: Monoid m => (a -> m) -> Proxy * a -> m # foldr :: (a -> b -> b) -> b -> Proxy * a -> b # foldr' :: (a -> b -> b) -> b -> Proxy * a -> b foldl :: (b -> a -> b) -> b -> Proxy * a -> b foldl' :: (b -> a -> b) -> b -> Proxy * a -> b foldr1 :: (a -> a -> a) -> Proxy * a -> a foldl1 :: (a -> a -> a) -> Proxy * a -> a toList :: Proxy * a -> [a] null :: Proxy * a -> Bool length :: Proxy * a -> Int elem :: Eq a => a -> Proxy * a -> Bool maximum :: Ord a => Proxy * a -> a minimum :: Ord a => Proxy * a -> a sum :: Num a => Proxy * a -> a product :: Num a => Proxy * a -> a
Foldable (K1 i c)
Methods fold :: Monoid m => K1 i c m -> m foldMap :: Monoid m => (a -> m) -> K1 i c a -> m # foldr :: (a -> b -> b) -> b -> K1 i c a -> b # foldr' :: (a -> b -> b) -> b -> K1 i c a -> b foldl :: (b -> a -> b) -> b -> K1 i c a -> b foldl' :: (b -> a -> b) -> b -> K1 i c a -> b foldr1 :: (a -> a -> a) -> K1 i c a -> a foldl1 :: (a -> a -> a) -> K1 i c a -> a toList :: K1 i c a -> [a] null :: K1 i c a -> Bool length :: K1 i c a -> Int elem :: Eq a => a -> K1 i c a -> Bool maximum :: Ord a => K1 i c a -> a minimum :: Ord a => K1 i c a -> a sum :: Num a => K1 i c a -> a product :: Num a => K1 i c a -> a
(Foldable f, Foldable g) => Foldable ((:+:) f g)
Methods fold :: Monoid m => (f :+: g) m -> m foldMap :: Monoid m => (a -> m) -> (f :+: g) a -> m # foldr :: (a -> b -> b) -> b -> (f :+: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :+: g) a -> b foldl :: (b -> a -> b) -> b -> (f :+: g) a -> b foldl' :: (b -> a -> b) -> b -> (f :+: g) a -> b foldr1 :: (a -> a -> a) -> (f :+: g) a -> a foldl1 :: (a -> a -> a) -> (f :+: g) a -> a toList :: (f :+: g) a -> [a] null :: (f :+: g) a -> Bool length :: (f :+: g) a -> Int elem :: Eq a => a -> (f :+: g) a -> Bool maximum :: Ord a => (f :+: g) a -> a minimum :: Ord a => (f :+: g) a -> a sum :: Num a => (f :+: g) a -> a product :: Num a => (f :+: g) a -> a
(Foldable f, Foldable g) => Foldable ((:*:) f g)
Methods fold :: Monoid m => (f :: g) m -> m foldMap :: Monoid m => (a -> m) -> (f :: g) a -> m # foldr :: (a -> b -> b) -> b -> (f :: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :: g) a -> b foldl :: (b -> a -> b) -> b -> (f :: g) a -> b foldl' :: (b -> a -> b) -> b -> (f :: g) a -> b foldr1 :: (a -> a -> a) -> (f :: g) a -> a foldl1 :: (a -> a -> a) -> (f :: g) a -> a toList :: (f :: g) a -> [a] null :: (f :: g) a -> Bool length :: (f :: g) a -> Int elem :: Eq a => a -> (f :: g) a -> Bool maximum :: Ord a => (f :: g) a -> a minimum :: Ord a => (f :: g) a -> a sum :: Num a => (f :: g) a -> a product :: Num a => (f :: g) a -> a
(Foldable f, Foldable g) => Foldable ((:.:) f g)
Methods fold :: Monoid m => (f :.: g) m -> m foldMap :: Monoid m => (a -> m) -> (f :.: g) a -> m # foldr :: (a -> b -> b) -> b -> (f :.: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :.: g) a -> b foldl :: (b -> a -> b) -> b -> (f :.: g) a -> b foldl' :: (b -> a -> b) -> b -> (f :.: g) a -> b foldr1 :: (a -> a -> a) -> (f :.: g) a -> a foldl1 :: (a -> a -> a) -> (f :.: g) a -> a toList :: (f :.: g) a -> [a] null :: (f :.: g) a -> Bool length :: (f :.: g) a -> Int elem :: Eq a => a -> (f :.: g) a -> Bool maximum :: Ord a => (f :.: g) a -> a minimum :: Ord a => (f :.: g) a -> a sum :: Num a => (f :.: g) a -> a product :: Num a => (f :.: g) a -> a
Foldable f => Foldable (M1 i c f)
Methods fold :: Monoid m => M1 i c f m -> m foldMap :: Monoid m => (a -> m) -> M1 i c f a -> m # foldr :: (a -> b -> b) -> b -> M1 i c f a -> b # foldr' :: (a -> b -> b) -> b -> M1 i c f a -> b foldl :: (b -> a -> b) -> b -> M1 i c f a -> b foldl' :: (b -> a -> b) -> b -> M1 i c f a -> b foldr1 :: (a -> a -> a) -> M1 i c f a -> a foldl1 :: (a -> a -> a) -> M1 i c f a -> a toList :: M1 i c f a -> [a] null :: M1 i c f a -> Bool length :: M1 i c f a -> Int elem :: Eq a => a -> M1 i c f a -> Bool maximum :: Ord a => M1 i c f a -> a minimum :: Ord a => M1 i c f a -> a sum :: Num a => M1 i c f a -> a product :: Num a => M1 i c f a -> a

foldRight :: Foldable f => (a -> b -> b) -> b -> f a -> b #

The Foldable type class defines that a type can have a foldRight operation which can be used to reduce it by passing a binary operation and a neutral element. This reduces starting from the right.

The List type is an example of Foldable

>>> foldRight (+) 0 [1, 2, 3]
6

Mnemonic: Reduceable

foldLeft :: Foldable f => (b -> a -> b) -> b -> f a -> b #

foldLeft starts from the left, using the lazy evaluation capabilities of Eta. Note that this will get stuck in an infite loop if you pass an infite list to it.

strictFoldRight :: Foldable f => (a -> b -> b) -> b -> f a -> b #

A version of foldRight that evaluates the operations inline, hence strict, the opposite of lazy.

strictFoldLeft :: Foldable f => (b -> a -> b) -> b -> f a -> b #

A version of foldLeft that evaluates the operations inline, hence strict, the opposite of lazy.

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

A version of foldRight that applies functions that are flatmappable, in the context of a type that implements a monad, and returns the result produced by the reduction of the structure, wrapped in that type:

>>> :{
 addIntoMaybe :: Int -> Int -> Maybe Int
 addIntoMaybe a b = Just (a + b)
:}

>>> monadicFoldRight addIntoMaybe 0 [1,2,3]
Just 6

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

Left-biased version of monadicFoldRight

toList :: Foldable f => f a -> [a] #

Converts a type that implements Foldable into a list

isEmpty :: Foldable f => f a -> Bool #

Checks if a Foldable structure is empty.

length :: Foldable f => f a -> Int #

Returns the size of a structure.

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

Checks if the element is contained in the structure.

maximum :: (Ord a, Foldable f) => f a -> Maybe a #

Largest element in a structure. Returns Nothing if the structure is empty.

maximumBy :: Foldable f => (a -> a -> Ordering) -> f a -> Maybe a #

Given some comparison function, return the maximum of a structure. Returns Nothing if the structure is empty.

unsafeMaximum :: (Ord a, Foldable f) => f a -> a #

Warning: Partial functions should be avoided

Largest element in a structure. Errors if the structure is empty

minimum :: (Ord a, Foldable f) => f a -> Maybe a #

Smallest element in a structure Returns Nothing if the structure is empty.

minimumBy :: Foldable f => (a -> a -> Ordering) -> f a -> Maybe a #

Given some comparison function, return the minimum of a structure. Returns Nothing if the structure is empty.

unsafeMinimum :: (Ord a, Foldable f) => f a -> a #

Warning: Partial functions should be avoided

Largest element in a structure. Errors if the structure is empty

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

Sum of the numbers of a structure

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

Product of the numbers of a structure

findBy :: Foldable f => (a -> Bool) -> f a -> Maybe a #

Given some predicate, findBy will return the first element that matches the predicate or Nothing if there is no such element

any :: Foldable f => (a -> Bool) -> f a -> Bool #

Determines if any element satisfies the predicate

>>> any (== 1) [1, 2, 3]
True
>>> any (== 5) [1, 2, 3]
False

all :: Foldable f => (a -> Bool) -> f a -> Bool #

Determines if all elements satisfy the predicate

>>> all (== 1) [1, 2, 3]
False
>>> all (< 5) [1, 2, 3]
True

discardTraverse :: (Foldable f, Applicative m) => (a -> m b) -> f a -> m () #

Sometimes we need to apply an action to each one of the elements. The function discardTraverse maps an action over each of the elements of the structure

>>> discardTraverse printLine ["Hello", "world", "!"]
Hello
world
!

foreach :: (Foldable f, Applicative m) => f a -> (a -> m b) -> m () #

Another alternative to discardTraverse is to use the foreach function, which is very familiar to a lot of developers.

>>> foreach [1..3] printShow
1
2
3