Copyright	Ross Paterson 2005
License	BSD-style (see the LICENSE file in the distribution)
Maintainer	libraries@haskell.org
Stability	experimental
Portability	portable
Safe Haskell	Trustworthy
Language	Haskell2010

Data.Foldable

Contents

Description

Class of data structures that can be folded to a summary value.

Synopsis

classFoldable twhere
- fold ::Monoid m => t m -> m
- foldMap ::Monoid m => (a -> m) -> t a -> m
- foldr :: (a -> b -> b) -> b -> t a -> b
- foldr' :: (a -> b -> b) -> b -> t a -> b
- foldl :: (b -> a -> b) -> b -> t a -> b
- foldl' :: (b -> a -> b) -> b -> t a -> b
- foldr1 :: (a -> a -> a) -> t a -> a
- foldl1 :: (a -> a -> a) -> t a -> a
- toList :: t a -> [a]
- null :: t a ->Bool
- length :: t a ->Int
- elem ::Eq a => a -> t a ->Bool
- maximum ::forall a.Ord a => t a -> a
- minimum ::forall a.Ord a => t a -> a
- sum ::Num a => t a -> a
- product ::Num a => t a -> a
foldrM :: (Foldable t,Monad m) => (a -> b -> m b) -> b -> t a -> m b
foldlM :: (Foldable t,Monad m) => (b -> a -> m b) -> b -> t a -> m b
traverse_ :: (Foldable t,Applicative f) => (a -> f b) -> t a -> f ()
for_ :: (Foldable t,Applicative f) => t a -> (a -> f b) -> f ()
sequenceA_ :: (Foldable t,Applicative f) => t (f a) -> f ()
asum :: (Foldable t,Alternative f) => t (f a) -> f a
mapM_ :: (Foldable t,Monad m) => (a -> m b) -> t a -> m ()
forM_ :: (Foldable t,Monad m) => t a -> (a -> m b) -> m ()
sequence_ :: (Foldable t,Monad m) => t (m a) -> m ()
msum :: (Foldable t,MonadPlus m) => t (m a) -> m a
concat ::Foldable t => t [a] -> [a]
concatMap ::Foldable t => (a -> [b]) -> t a -> [b]
and ::Foldable t => tBool ->Bool
or ::Foldable t => tBool ->Bool
any ::Foldable t => (a ->Bool) -> t a ->Bool
all ::Foldable t => (a ->Bool) -> t a ->Bool
maximumBy ::Foldable t => (a -> a ->Ordering) -> t a -> a
minimumBy ::Foldable t => (a -> a ->Ordering) -> t a -> a
notElem :: (Foldable t,Eq a) => a -> t a ->Bool
find ::Foldable t => (a ->Bool) -> t a ->Maybe a

Documentation

classFoldable twhereSource #

Data structures that can be folded.

For example, given a data type

data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a)

a suitable instance would be

instance Foldable Tree where   foldMap f Empty = mempty   foldMap f (Leaf x) = f x   foldMap f (Node l k r) = foldMap f l `mappend` f k `mappend` foldMap f r

This is suitable even for abstract types, as the monoid is assumed to satisfy the monoid laws. Alternatively, one could definefoldr:

instance Foldable Tree where   foldr f z Empty = z   foldr f z (Leaf x) = f x z   foldr f z (Node l k r) = foldr f (f k (foldr f z r)) l

Foldable instances are expected to satisfy the following laws:

foldr f z t = appEndo (foldMap (Endo . f) t ) z

foldl f z t = appEndo (getDual (foldMap (Dual . Endo . flip f) t)) z

fold = foldMap id

length = getSum . foldMap (Sum . const  1)

sum,product,maximum, andminimum should all be essentially equivalent tofoldMap forms, such as

sum = getSum . foldMap Sum

but may be less defined.

If the type is also aFunctor instance, it should satisfy

foldMap f = fold . fmap f

which implies that

foldMap f . fmap g = foldMap (f . g)

Minimal complete definition

foldMap |foldr

Methods

fold ::Monoid m => t m -> mSource #

Combine the elements of a structure using a monoid.

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

Map each element of the structure to a monoid, and combine the results.

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

Right-associative fold of a structure.

In the case of lists,foldr, when applied to a binary operator, a starting value (typically the right-identity of the operator), and a list, reduces the list using the binary operator, from right to left:

foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)

Note that, since the head of the resulting expression is produced by an application of the operator to the first element of the list,foldr can produce a terminating expression from an infinite list.

For a generalFoldable structure this should be semantically identical to,

foldr f z =foldr f z .toList

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

Right-associative fold of a structure, but with strict application of the operator.

foldl :: (b -> a -> b) -> b -> t a -> bSource #

Left-associative fold of a structure.

In the case of lists,foldl, when applied to a binary operator, a starting value (typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right:

foldl f z [x1, x2, ..., xn] == (...((z `f` x1) `f` x2) `f`...) `f` xn

Note that to produce the outermost application of the operator the entire input list must be traversed. This means thatfoldl' will diverge if given an infinite list.

Also note that if you want an efficient left-fold, you probably want to usefoldl' instead offoldl. The reason for this is that latter does not force the "inner" results (e.g.zf x1 in the above example) before applying them to the operator (e.g. to(f x2)). This results in a thunk chainO(n) elements long, which then must be evaluated from the outside-in.

For a generalFoldable structure this should be semantically identical to,

foldl f z =foldl f z .toList

foldl' :: (b -> a -> b) -> b -> t a -> bSource #

Left-associative fold of a structure but with strict application of the operator.

This ensures that each step of the fold is forced to weak head normal form before being applied, avoiding the collection of thunks that would otherwise occur. This is often what you want to strictly reduce a finite list to a single, monolithic result (e.g.length).

For a generalFoldable structure this should be semantically identical to,

foldl f z =foldl' f z .toList

foldr1 :: (a -> a -> a) -> t a -> aSource #

A variant offoldr that has no base case, and thus may only be applied to non-empty structures.

foldr1 f =foldr1 f .toList

foldl1 :: (a -> a -> a) -> t a -> aSource #

A variant offoldl that has no base case, and thus may only be applied to non-empty structures.

foldl1 f =foldl1 f .toList

toList :: t a -> [a]Source #

List of elements of a structure, from left to right.

null :: t a ->Bool Source #

Test whether the structure is empty. The default implementation is optimized for structures that are similar to cons-lists, because there is no general way to do better.

length :: t a ->Int Source #

Returns the size/length of a finite structure as anInt. The default implementation is optimized for structures that are similar to cons-lists, because there is no general way to do better.

elem ::Eq a => a -> t a ->Boolinfix 4Source #

Does the element occur in the structure?

maximum ::forall a.Ord a => t a -> aSource #

The largest element of a non-empty structure.

minimum ::forall a.Ord a => t a -> aSource #

The least element of a non-empty structure.

sum ::Num a => t a -> aSource #

Thesum function computes the sum of the numbers of a structure.

product ::Num a => t a -> aSource #

Theproduct function computes the product of the numbers of a structure.

Instances

Foldable []Source #	Since: 2.1
Instance details Defined inData.Foldable Methods fold ::Monoid m => [m] -> mSource # foldMap ::Monoid m => (a -> m) -> [a] -> mSource # foldr :: (a -> b -> b) -> b -> [a] -> bSource # foldr' :: (a -> b -> b) -> b -> [a] -> bSource # foldl :: (b -> a -> b) -> b -> [a] -> bSource # foldl' :: (b -> a -> b) -> b -> [a] -> bSource # foldr1 :: (a -> a -> a) -> [a] -> aSource # foldl1 :: (a -> a -> a) -> [a] -> aSource # toList :: [a] -> [a]Source # null :: [a] ->Bool Source # length :: [a] ->Int Source # elem ::Eq a => a -> [a] ->Bool Source # maximum ::Ord a => [a] -> aSource # minimum ::Ord a => [a] -> aSource # sum ::Num a => [a] -> aSource # product ::Num a => [a] -> aSource #
Foldable MaybeSource #	Since: 2.1
Instance details Defined inData.Foldable Methods fold ::Monoid m =>Maybe m -> mSource # foldMap ::Monoid m => (a -> m) ->Maybe a -> mSource # foldr :: (a -> b -> b) -> b ->Maybe a -> bSource # foldr' :: (a -> b -> b) -> b ->Maybe a -> bSource # foldl :: (b -> a -> b) -> b ->Maybe a -> bSource # foldl' :: (b -> a -> b) -> b ->Maybe a -> bSource # foldr1 :: (a -> a -> a) ->Maybe a -> aSource # foldl1 :: (a -> a -> a) ->Maybe a -> aSource # toList ::Maybe a -> [a]Source # null ::Maybe a ->Bool Source # length ::Maybe a ->Int Source # elem ::Eq a => a ->Maybe a ->Bool Source # maximum ::Ord a =>Maybe a -> aSource # minimum ::Ord a =>Maybe a -> aSource # sum ::Num a =>Maybe a -> aSource # product ::Num a =>Maybe a -> aSource #
Foldable Par1Source #	Since: 4.9.0.0
Instance details Defined inData.Foldable Methods fold ::Monoid m =>Par1 m -> mSource # foldMap ::Monoid m => (a -> m) ->Par1 a -> mSource # foldr :: (a -> b -> b) -> b ->Par1 a -> bSource # foldr' :: (a -> b -> b) -> b ->Par1 a -> bSource # foldl :: (b -> a -> b) -> b ->Par1 a -> bSource # foldl' :: (b -> a -> b) -> b ->Par1 a -> bSource # foldr1 :: (a -> a -> a) ->Par1 a -> aSource # foldl1 :: (a -> a -> a) ->Par1 a -> aSource # toList ::Par1 a -> [a]Source # null ::Par1 a ->Bool Source # length ::Par1 a ->Int Source # elem ::Eq a => a ->Par1 a ->Bool Source # maximum ::Ord a =>Par1 a -> aSource # minimum ::Ord a =>Par1 a -> aSource # sum ::Num a =>Par1 a -> aSource # product ::Num a =>Par1 a -> aSource #
Foldable NonEmptySource #	Since: 4.9.0.0
Instance details Defined inData.Foldable Methods fold ::Monoid m =>NonEmpty m -> mSource # foldMap ::Monoid m => (a -> m) ->NonEmpty a -> mSource # foldr :: (a -> b -> b) -> b ->NonEmpty a -> bSource # foldr' :: (a -> b -> b) -> b ->NonEmpty a -> bSource # foldl :: (b -> a -> b) -> b ->NonEmpty a -> bSource # foldl' :: (b -> a -> b) -> b ->NonEmpty a -> bSource # foldr1 :: (a -> a -> a) ->NonEmpty a -> aSource # foldl1 :: (a -> a -> a) ->NonEmpty a -> aSource # toList ::NonEmpty a -> [a]Source # null ::NonEmpty a ->Bool Source # length ::NonEmpty a ->Int Source # elem ::Eq a => a ->NonEmpty a ->Bool Source # maximum ::Ord a =>NonEmpty a -> aSource # minimum ::Ord a =>NonEmpty a -> aSource # sum ::Num a =>NonEmpty a -> aSource # product ::Num a =>NonEmpty a -> aSource #
Foldable DownSource #	Since: 4.12.0.0
Instance details Defined inData.Foldable Methods fold ::Monoid m =>Down m -> mSource # foldMap ::Monoid m => (a -> m) ->Down a -> mSource # foldr :: (a -> b -> b) -> b ->Down a -> bSource # foldr' :: (a -> b -> b) -> b ->Down a -> bSource # foldl :: (b -> a -> b) -> b ->Down a -> bSource # foldl' :: (b -> a -> b) -> b ->Down a -> bSource # foldr1 :: (a -> a -> a) ->Down a -> aSource # foldl1 :: (a -> a -> a) ->Down a -> aSource # toList ::Down a -> [a]Source # null ::Down a ->Bool Source # length ::Down a ->Int Source # elem ::Eq a => a ->Down a ->Bool Source # maximum ::Ord a =>Down a -> aSource # minimum ::Ord a =>Down a -> aSource # sum ::Num a =>Down a -> aSource # product ::Num a =>Down a -> aSource #
Foldable ProductSource #	Since: 4.8.0.0
Instance details Defined inData.Foldable Methods fold ::Monoid m =>Product m -> mSource # foldMap ::Monoid m => (a -> m) ->Product a -> mSource # foldr :: (a -> b -> b) -> b ->Product a -> bSource # foldr' :: (a -> b -> b) -> b ->Product a -> bSource # foldl :: (b -> a -> b) -> b ->Product a -> bSource # foldl' :: (b -> a -> b) -> b ->Product a -> bSource # foldr1 :: (a -> a -> a) ->Product a -> aSource # foldl1 :: (a -> a -> a) ->Product a -> aSource # toList ::Product a -> [a]Source # null ::Product a ->Bool Source # length ::Product a ->Int Source # elem ::Eq a => a ->Product a ->Bool Source # maximum ::Ord a =>Product a -> aSource # minimum ::Ord a =>Product a -> aSource # sum ::Num a =>Product a -> aSource # product ::Num a =>Product a -> aSource #
Foldable SumSource #	Since: 4.8.0.0
Instance details Defined inData.Foldable Methods fold ::Monoid m =>Sum m -> mSource # foldMap ::Monoid m => (a -> m) ->Sum a -> mSource # foldr :: (a -> b -> b) -> b ->Sum a -> bSource # foldr' :: (a -> b -> b) -> b ->Sum a -> bSource # foldl :: (b -> a -> b) -> b ->Sum a -> bSource # foldl' :: (b -> a -> b) -> b ->Sum a -> bSource # foldr1 :: (a -> a -> a) ->Sum a -> aSource # foldl1 :: (a -> a -> a) ->Sum a -> aSource # toList ::Sum a -> [a]Source # null ::Sum a ->Bool Source # length ::Sum a ->Int Source # elem ::Eq a => a ->Sum a ->Bool Source # maximum ::Ord a =>Sum a -> aSource # minimum ::Ord a =>Sum a -> aSource # sum ::Num a =>Sum a -> aSource # product ::Num a =>Sum a -> aSource #
Foldable DualSource #	Since: 4.8.0.0
Instance details Defined inData.Foldable Methods fold ::Monoid m =>Dual m -> mSource # foldMap ::Monoid m => (a -> m) ->Dual a -> mSource # foldr :: (a -> b -> b) -> b ->Dual a -> bSource # foldr' :: (a -> b -> b) -> b ->Dual a -> bSource # foldl :: (b -> a -> b) -> b ->Dual a -> bSource # foldl' :: (b -> a -> b) -> b ->Dual a -> bSource # foldr1 :: (a -> a -> a) ->Dual a -> aSource # foldl1 :: (a -> a -> a) ->Dual a -> aSource # toList ::Dual a -> [a]Source # null ::Dual a ->Bool Source # length ::Dual a ->Int Source # elem ::Eq a => a ->Dual a ->Bool Source # maximum ::Ord a =>Dual a -> aSource # minimum ::Ord a =>Dual a -> aSource # sum ::Num a =>Dual a -> aSource # product ::Num a =>Dual a -> aSource #
Foldable LastSource #	Since: 4.8.0.0
Instance details Defined inData.Foldable Methods fold ::Monoid m =>Last m -> mSource # foldMap ::Monoid m => (a -> m) ->Last a -> mSource # foldr :: (a -> b -> b) -> b ->Last a -> bSource # foldr' :: (a -> b -> b) -> b ->Last a -> bSource # foldl :: (b -> a -> b) -> b ->Last a -> bSource # foldl' :: (b -> a -> b) -> b ->Last a -> bSource # foldr1 :: (a -> a -> a) ->Last a -> aSource # foldl1 :: (a -> a -> a) ->Last a -> aSource # toList ::Last a -> [a]Source # null ::Last a ->Bool Source # length ::Last a ->Int Source # elem ::Eq a => a ->Last a ->Bool Source # maximum ::Ord a =>Last a -> aSource # minimum ::Ord a =>Last a -> aSource # sum ::Num a =>Last a -> aSource # product ::Num a =>Last a -> aSource #
Foldable FirstSource #	Since: 4.8.0.0
Instance details Defined inData.Foldable Methods fold ::Monoid m =>First m -> mSource # foldMap ::Monoid m => (a -> m) ->First a -> mSource # foldr :: (a -> b -> b) -> b ->First a -> bSource # foldr' :: (a -> b -> b) -> b ->First a -> bSource # foldl :: (b -> a -> b) -> b ->First a -> bSource # foldl' :: (b -> a -> b) -> b ->First a -> bSource # foldr1 :: (a -> a -> a) ->First a -> aSource # foldl1 :: (a -> a -> a) ->First a -> aSource # toList ::First a -> [a]Source # null ::First a ->Bool Source # length ::First a ->Int Source # elem ::Eq a => a ->First a ->Bool Source # maximum ::Ord a =>First a -> aSource # minimum ::Ord a =>First a -> aSource # sum ::Num a =>First a -> aSource # product ::Num a =>First a -> aSource #
Foldable IdentitySource #	Since: 4.8.0.0
Instance details Defined inData.Functor.Identity Methods fold ::Monoid m =>Identity m -> mSource # foldMap ::Monoid m => (a -> m) ->Identity a -> mSource # foldr :: (a -> b -> b) -> b ->Identity a -> bSource # foldr' :: (a -> b -> b) -> b ->Identity a -> bSource # foldl :: (b -> a -> b) -> b ->Identity a -> bSource # foldl' :: (b -> a -> b) -> b ->Identity a -> bSource # foldr1 :: (a -> a -> a) ->Identity a -> aSource # foldl1 :: (a -> a -> a) ->Identity a -> aSource # toList ::Identity a -> [a]Source # null ::Identity a ->Bool Source # length ::Identity a ->Int Source # elem ::Eq a => a ->Identity a ->Bool Source # maximum ::Ord a =>Identity a -> aSource # minimum ::Ord a =>Identity a -> aSource # sum ::Num a =>Identity a -> aSource # product ::Num a =>Identity a -> aSource #
Foldable ZipListSource #	Since: 4.9.0.0
Instance details Defined inControl.Applicative Methods fold ::Monoid m =>ZipList m -> mSource # foldMap ::Monoid m => (a -> m) ->ZipList a -> mSource # foldr :: (a -> b -> b) -> b ->ZipList a -> bSource # foldr' :: (a -> b -> b) -> b ->ZipList a -> bSource # foldl :: (b -> a -> b) -> b ->ZipList a -> bSource # foldl' :: (b -> a -> b) -> b ->ZipList a -> bSource # foldr1 :: (a -> a -> a) ->ZipList a -> aSource # foldl1 :: (a -> a -> a) ->ZipList a -> aSource # toList ::ZipList a -> [a]Source # null ::ZipList a ->Bool Source # length ::ZipList a ->Int Source # elem ::Eq a => a ->ZipList a ->Bool Source # maximum ::Ord a =>ZipList a -> aSource # minimum ::Ord a =>ZipList a -> aSource # sum ::Num a =>ZipList a -> aSource # product ::Num a =>ZipList a -> aSource #
Foldable OptionSource #	Since: 4.9.0.0
Instance details Defined inData.Semigroup Methods fold ::Monoid m =>Option m -> mSource # foldMap ::Monoid m => (a -> m) ->Option a -> mSource # foldr :: (a -> b -> b) -> b ->Option a -> bSource # foldr' :: (a -> b -> b) -> b ->Option a -> bSource # foldl :: (b -> a -> b) -> b ->Option a -> bSource # foldl' :: (b -> a -> b) -> b ->Option a -> bSource # foldr1 :: (a -> a -> a) ->Option a -> aSource # foldl1 :: (a -> a -> a) ->Option a -> aSource # toList ::Option a -> [a]Source # null ::Option a ->Bool Source # length ::Option a ->Int Source # elem ::Eq a => a ->Option a ->Bool Source # maximum ::Ord a =>Option a -> aSource # minimum ::Ord a =>Option a -> aSource # sum ::Num a =>Option a -> aSource # product ::Num a =>Option a -> aSource #
Foldable LastSource #	Since: 4.9.0.0
Instance details Defined inData.Semigroup Methods fold ::Monoid m =>Last m -> mSource # foldMap ::Monoid m => (a -> m) ->Last a -> mSource # foldr :: (a -> b -> b) -> b ->Last a -> bSource # foldr' :: (a -> b -> b) -> b ->Last a -> bSource # foldl :: (b -> a -> b) -> b ->Last a -> bSource # foldl' :: (b -> a -> b) -> b ->Last a -> bSource # foldr1 :: (a -> a -> a) ->Last a -> aSource # foldl1 :: (a -> a -> a) ->Last a -> aSource # toList ::Last a -> [a]Source # null ::Last a ->Bool Source # length ::Last a ->Int Source # elem ::Eq a => a ->Last a ->Bool Source # maximum ::Ord a =>Last a -> aSource # minimum ::Ord a =>Last a -> aSource # sum ::Num a =>Last a -> aSource # product ::Num a =>Last a -> aSource #
Foldable FirstSource #	Since: 4.9.0.0
Instance details Defined inData.Semigroup Methods fold ::Monoid m =>First m -> mSource # foldMap ::Monoid m => (a -> m) ->First a -> mSource # foldr :: (a -> b -> b) -> b ->First a -> bSource # foldr' :: (a -> b -> b) -> b ->First a -> bSource # foldl :: (b -> a -> b) -> b ->First a -> bSource # foldl' :: (b -> a -> b) -> b ->First a -> bSource # foldr1 :: (a -> a -> a) ->First a -> aSource # foldl1 :: (a -> a -> a) ->First a -> aSource # toList ::First a -> [a]Source # null ::First a ->Bool Source # length ::First a ->Int Source # elem ::Eq a => a ->First a ->Bool Source # maximum ::Ord a =>First a -> aSource # minimum ::Ord a =>First a -> aSource # sum ::Num a =>First a -> aSource # product ::Num a =>First a -> aSource #
Foldable MaxSource #	Since: 4.9.0.0
Instance details Defined inData.Semigroup Methods fold ::Monoid m =>Max m -> mSource # foldMap ::Monoid m => (a -> m) ->Max a -> mSource # foldr :: (a -> b -> b) -> b ->Max a -> bSource # foldr' :: (a -> b -> b) -> b ->Max a -> bSource # foldl :: (b -> a -> b) -> b ->Max a -> bSource # foldl' :: (b -> a -> b) -> b ->Max a -> bSource # foldr1 :: (a -> a -> a) ->Max a -> aSource # foldl1 :: (a -> a -> a) ->Max a -> aSource # toList ::Max a -> [a]Source # null ::Max a ->Bool Source # length ::Max a ->Int Source # elem ::Eq a => a ->Max a ->Bool Source # maximum ::Ord a =>Max a -> aSource # minimum ::Ord a =>Max a -> aSource # sum ::Num a =>Max a -> aSource # product ::Num a =>Max a -> aSource #
Foldable MinSource #	Since: 4.9.0.0
Instance details Defined inData.Semigroup Methods fold ::Monoid m =>Min m -> mSource # foldMap ::Monoid m => (a -> m) ->Min a -> mSource # foldr :: (a -> b -> b) -> b ->Min a -> bSource # foldr' :: (a -> b -> b) -> b ->Min a -> bSource # foldl :: (b -> a -> b) -> b ->Min a -> bSource # foldl' :: (b -> a -> b) -> b ->Min a -> bSource # foldr1 :: (a -> a -> a) ->Min a -> aSource # foldl1 :: (a -> a -> a) ->Min a -> aSource # toList ::Min a -> [a]Source # null ::Min a ->Bool Source # length ::Min a ->Int Source # elem ::Eq a => a ->Min a ->Bool Source # maximum ::Ord a =>Min a -> aSource # minimum ::Ord a =>Min a -> aSource # sum ::Num a =>Min a -> aSource # product ::Num a =>Min a -> aSource #
Foldable ComplexSource #	Since: 4.9.0.0
Instance details Defined inData.Complex Methods fold ::Monoid m =>Complex m -> mSource # foldMap ::Monoid m => (a -> m) ->Complex a -> mSource # foldr :: (a -> b -> b) -> b ->Complex a -> bSource # foldr' :: (a -> b -> b) -> b ->Complex a -> bSource # foldl :: (b -> a -> b) -> b ->Complex a -> bSource # foldl' :: (b -> a -> b) -> b ->Complex a -> bSource # foldr1 :: (a -> a -> a) ->Complex a -> aSource # foldl1 :: (a -> a -> a) ->Complex a -> aSource # toList ::Complex a -> [a]Source # null ::Complex a ->Bool Source # length ::Complex a ->Int Source # elem ::Eq a => a ->Complex a ->Bool Source # maximum ::Ord a =>Complex a -> aSource # minimum ::Ord a =>Complex a -> aSource # sum ::Num a =>Complex a -> aSource # product ::Num a =>Complex a -> aSource #
Foldable (Either a)Source #	Since: 4.7.0.0
Instance details Defined inData.Foldable Methods fold ::Monoid m =>Either a m -> mSource # foldMap ::Monoid m => (a0 -> m) ->Either a a0 -> mSource # foldr :: (a0 -> b -> b) -> b ->Either a a0 -> bSource # foldr' :: (a0 -> b -> b) -> b ->Either a a0 -> bSource # foldl :: (b -> a0 -> b) -> b ->Either a a0 -> bSource # foldl' :: (b -> a0 -> b) -> b ->Either a a0 -> bSource # foldr1 :: (a0 -> a0 -> a0) ->Either a a0 -> a0Source # foldl1 :: (a0 -> a0 -> a0) ->Either a a0 -> a0Source # toList ::Either a a0 -> [a0]Source # null ::Either a a0 ->Bool Source # length ::Either a a0 ->Int Source # elem ::Eq a0 => a0 ->Either a a0 ->Bool Source # maximum ::Ord a0 =>Either a a0 -> a0Source # minimum ::Ord a0 =>Either a a0 -> a0Source # sum ::Num a0 =>Either a a0 -> a0Source # product ::Num a0 =>Either a a0 -> a0Source #
Foldable (V1 ::Type ->Type)Source #	Since: 4.9.0.0
Instance details Defined inData.Foldable Methods fold ::Monoid m =>V1 m -> mSource # foldMap ::Monoid m => (a -> m) ->V1 a -> mSource # foldr :: (a -> b -> b) -> b ->V1 a -> bSource # foldr' :: (a -> b -> b) -> b ->V1 a -> bSource # foldl :: (b -> a -> b) -> b ->V1 a -> bSource # foldl' :: (b -> a -> b) -> b ->V1 a -> bSource # foldr1 :: (a -> a -> a) ->V1 a -> aSource # foldl1 :: (a -> a -> a) ->V1 a -> aSource # toList ::V1 a -> [a]Source # null ::V1 a ->Bool Source # length ::V1 a ->Int Source # elem ::Eq a => a ->V1 a ->Bool Source # maximum ::Ord a =>V1 a -> aSource # minimum ::Ord a =>V1 a -> aSource # sum ::Num a =>V1 a -> aSource # product ::Num a =>V1 a -> aSource #
Foldable (U1 ::Type ->Type)Source #	Since: 4.9.0.0
Instance details Defined inData.Foldable Methods fold ::Monoid m =>U1 m -> mSource # foldMap ::Monoid m => (a -> m) ->U1 a -> mSource # foldr :: (a -> b -> b) -> b ->U1 a -> bSource # foldr' :: (a -> b -> b) -> b ->U1 a -> bSource # foldl :: (b -> a -> b) -> b ->U1 a -> bSource # foldl' :: (b -> a -> b) -> b ->U1 a -> bSource # foldr1 :: (a -> a -> a) ->U1 a -> aSource # foldl1 :: (a -> a -> a) ->U1 a -> aSource # toList ::U1 a -> [a]Source # null ::U1 a ->Bool Source # length ::U1 a ->Int Source # elem ::Eq a => a ->U1 a ->Bool Source # maximum ::Ord a =>U1 a -> aSource # minimum ::Ord a =>U1 a -> aSource # sum ::Num a =>U1 a -> aSource # product ::Num a =>U1 a -> aSource #
Foldable ((,) a)Source #	Since: 4.7.0.0
Instance details Defined inData.Foldable Methods fold ::Monoid m => (a, m) -> mSource # foldMap ::Monoid m => (a0 -> m) -> (a, a0) -> mSource # foldr :: (a0 -> b -> b) -> b -> (a, a0) -> bSource # foldr' :: (a0 -> b -> b) -> b -> (a, a0) -> bSource # foldl :: (b -> a0 -> b) -> b -> (a, a0) -> bSource # foldl' :: (b -> a0 -> b) -> b -> (a, a0) -> bSource # foldr1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0Source # foldl1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0Source # toList :: (a, a0) -> [a0]Source # null :: (a, a0) ->Bool Source # length :: (a, a0) ->Int Source # elem ::Eq a0 => a0 -> (a, a0) ->Bool Source # maximum ::Ord a0 => (a, a0) -> a0Source # minimum ::Ord a0 => (a, a0) -> a0Source # sum ::Num a0 => (a, a0) -> a0Source # product ::Num a0 => (a, a0) -> a0Source #
Foldable (Proxy ::Type ->Type)Source #	Since: 4.7.0.0
Instance details Defined inData.Foldable Methods fold ::Monoid m =>Proxy m -> mSource # foldMap ::Monoid m => (a -> m) ->Proxy a -> mSource # foldr :: (a -> b -> b) -> b ->Proxy a -> bSource # foldr' :: (a -> b -> b) -> b ->Proxy a -> bSource # foldl :: (b -> a -> b) -> b ->Proxy a -> bSource # foldl' :: (b -> a -> b) -> b ->Proxy a -> bSource # foldr1 :: (a -> a -> a) ->Proxy a -> aSource # foldl1 :: (a -> a -> a) ->Proxy a -> aSource # toList ::Proxy a -> [a]Source # null ::Proxy a ->Bool Source # length ::Proxy a ->Int Source # elem ::Eq a => a ->Proxy a ->Bool Source # maximum ::Ord a =>Proxy a -> aSource # minimum ::Ord a =>Proxy a -> aSource # sum ::Num a =>Proxy a -> aSource # product ::Num a =>Proxy a -> aSource #
Foldable (Arg a)Source #	Since: 4.9.0.0
Instance details Defined inData.Semigroup Methods fold ::Monoid m =>Arg a m -> mSource # foldMap ::Monoid m => (a0 -> m) ->Arg a a0 -> mSource # foldr :: (a0 -> b -> b) -> b ->Arg a a0 -> bSource # foldr' :: (a0 -> b -> b) -> b ->Arg a a0 -> bSource # foldl :: (b -> a0 -> b) -> b ->Arg a a0 -> bSource # foldl' :: (b -> a0 -> b) -> b ->Arg a a0 -> bSource # foldr1 :: (a0 -> a0 -> a0) ->Arg a a0 -> a0Source # foldl1 :: (a0 -> a0 -> a0) ->Arg a a0 -> a0Source # toList ::Arg a a0 -> [a0]Source # null ::Arg a a0 ->Bool Source # length ::Arg a a0 ->Int Source # elem ::Eq a0 => a0 ->Arg a a0 ->Bool Source # maximum ::Ord a0 =>Arg a a0 -> a0Source # minimum ::Ord a0 =>Arg a a0 -> a0Source # sum ::Num a0 =>Arg a a0 -> a0Source # product ::Num a0 =>Arg a a0 -> a0Source #
Foldable f =>Foldable (Rec1 f)Source #	Since: 4.9.0.0
Instance details Defined inData.Foldable Methods fold ::Monoid m =>Rec1 f m -> mSource # foldMap ::Monoid m => (a -> m) ->Rec1 f a -> mSource # foldr :: (a -> b -> b) -> b ->Rec1 f a -> bSource # foldr' :: (a -> b -> b) -> b ->Rec1 f a -> bSource # foldl :: (b -> a -> b) -> b ->Rec1 f a -> bSource # foldl' :: (b -> a -> b) -> b ->Rec1 f a -> bSource # foldr1 :: (a -> a -> a) ->Rec1 f a -> aSource # foldl1 :: (a -> a -> a) ->Rec1 f a -> aSource # toList ::Rec1 f a -> [a]Source # null ::Rec1 f a ->Bool Source # length ::Rec1 f a ->Int Source # elem ::Eq a => a ->Rec1 f a ->Bool Source # maximum ::Ord a =>Rec1 f a -> aSource # minimum ::Ord a =>Rec1 f a -> aSource # sum ::Num a =>Rec1 f a -> aSource # product ::Num a =>Rec1 f a -> aSource #
Foldable (URec Char ::Type ->Type)Source #	Since: 4.9.0.0
Instance details Defined inData.Foldable Methods fold ::Monoid m =>URec Char m -> mSource # foldMap ::Monoid m => (a -> m) ->URec Char a -> mSource # foldr :: (a -> b -> b) -> b ->URec Char a -> bSource # foldr' :: (a -> b -> b) -> b ->URec Char a -> bSource # foldl :: (b -> a -> b) -> b ->URec Char a -> bSource # foldl' :: (b -> a -> b) -> b ->URec Char a -> bSource # foldr1 :: (a -> a -> a) ->URec Char a -> aSource # foldl1 :: (a -> a -> a) ->URec Char a -> aSource # toList ::URec Char a -> [a]Source # null ::URec Char a ->Bool Source # length ::URec Char a ->Int Source # elem ::Eq a => a ->URec Char a ->Bool Source # maximum ::Ord a =>URec Char a -> aSource # minimum ::Ord a =>URec Char a -> aSource # sum ::Num a =>URec Char a -> aSource # product ::Num a =>URec Char a -> aSource #
Foldable (URec Double ::Type ->Type)Source #	Since: 4.9.0.0
Instance details Defined inData.Foldable Methods fold ::Monoid m =>URec Double m -> mSource # foldMap ::Monoid m => (a -> m) ->URec Double a -> mSource # foldr :: (a -> b -> b) -> b ->URec Double a -> bSource # foldr' :: (a -> b -> b) -> b ->URec Double a -> bSource # foldl :: (b -> a -> b) -> b ->URec Double a -> bSource # foldl' :: (b -> a -> b) -> b ->URec Double a -> bSource # foldr1 :: (a -> a -> a) ->URec Double a -> aSource # foldl1 :: (a -> a -> a) ->URec Double a -> aSource # toList ::URec Double a -> [a]Source # null ::URec Double a ->Bool Source # length ::URec Double a ->Int Source # elem ::Eq a => a ->URec Double a ->Bool Source # maximum ::Ord a =>URec Double a -> aSource # minimum ::Ord a =>URec Double a -> aSource # sum ::Num a =>URec Double a -> aSource # product ::Num a =>URec Double a -> aSource #
Foldable (URec Float ::Type ->Type)Source #	Since: 4.9.0.0
Instance details Defined inData.Foldable Methods fold ::Monoid m =>URec Float m -> mSource # foldMap ::Monoid m => (a -> m) ->URec Float a -> mSource # foldr :: (a -> b -> b) -> b ->URec Float a -> bSource # foldr' :: (a -> b -> b) -> b ->URec Float a -> bSource # foldl :: (b -> a -> b) -> b ->URec Float a -> bSource # foldl' :: (b -> a -> b) -> b ->URec Float a -> bSource # foldr1 :: (a -> a -> a) ->URec Float a -> aSource # foldl1 :: (a -> a -> a) ->URec Float a -> aSource # toList ::URec Float a -> [a]Source # null ::URec Float a ->Bool Source # length ::URec Float a ->Int Source # elem ::Eq a => a ->URec Float a ->Bool Source # maximum ::Ord a =>URec Float a -> aSource # minimum ::Ord a =>URec Float a -> aSource # sum ::Num a =>URec Float a -> aSource # product ::Num a =>URec Float a -> aSource #
Foldable (URec Int ::Type ->Type)Source #	Since: 4.9.0.0
Instance details Defined inData.Foldable Methods fold ::Monoid m =>URec Int m -> mSource # foldMap ::Monoid m => (a -> m) ->URec Int a -> mSource # foldr :: (a -> b -> b) -> b ->URec Int a -> bSource # foldr' :: (a -> b -> b) -> b ->URec Int a -> bSource # foldl :: (b -> a -> b) -> b ->URec Int a -> bSource # foldl' :: (b -> a -> b) -> b ->URec Int a -> bSource # foldr1 :: (a -> a -> a) ->URec Int a -> aSource # foldl1 :: (a -> a -> a) ->URec Int a -> aSource # toList ::URec Int a -> [a]Source # null ::URec Int a ->Bool Source # length ::URec Int a ->Int Source # elem ::Eq a => a ->URec Int a ->Bool Source # maximum ::Ord a =>URec Int a -> aSource # minimum ::Ord a =>URec Int a -> aSource # sum ::Num a =>URec Int a -> aSource # product ::Num a =>URec Int a -> aSource #
Foldable (URec Word ::Type ->Type)Source #	Since: 4.9.0.0
Instance details Defined inData.Foldable Methods fold ::Monoid m =>URec Word m -> mSource # foldMap ::Monoid m => (a -> m) ->URec Word a -> mSource # foldr :: (a -> b -> b) -> b ->URec Word a -> bSource # foldr' :: (a -> b -> b) -> b ->URec Word a -> bSource # foldl :: (b -> a -> b) -> b ->URec Word a -> bSource # foldl' :: (b -> a -> b) -> b ->URec Word a -> bSource # foldr1 :: (a -> a -> a) ->URec Word a -> aSource # foldl1 :: (a -> a -> a) ->URec Word a -> aSource # toList ::URec Word a -> [a]Source # null ::URec Word a ->Bool Source # length ::URec Word a ->Int Source # elem ::Eq a => a ->URec Word a ->Bool Source # maximum ::Ord a =>URec Word a -> aSource # minimum ::Ord a =>URec Word a -> aSource # sum ::Num a =>URec Word a -> aSource # product ::Num a =>URec Word a -> aSource #
Foldable (URec (Ptr ()) ::Type ->Type)Source #	Since: 4.9.0.0
Instance details Defined inData.Foldable Methods fold ::Monoid m =>URec (Ptr ()) m -> mSource # foldMap ::Monoid m => (a -> m) ->URec (Ptr ()) a -> mSource # foldr :: (a -> b -> b) -> b ->URec (Ptr ()) a -> bSource # foldr' :: (a -> b -> b) -> b ->URec (Ptr ()) a -> bSource # foldl :: (b -> a -> b) -> b ->URec (Ptr ()) a -> bSource # foldl' :: (b -> a -> b) -> b ->URec (Ptr ()) a -> bSource # foldr1 :: (a -> a -> a) ->URec (Ptr ()) a -> aSource # foldl1 :: (a -> a -> a) ->URec (Ptr ()) a -> aSource # toList ::URec (Ptr ()) a -> [a]Source # null ::URec (Ptr ()) a ->Bool Source # length ::URec (Ptr ()) a ->Int Source # elem ::Eq a => a ->URec (Ptr ()) a ->Bool Source # maximum ::Ord a =>URec (Ptr ()) a -> aSource # minimum ::Ord a =>URec (Ptr ()) a -> aSource # sum ::Num a =>URec (Ptr ()) a -> aSource # product ::Num a =>URec (Ptr ()) a -> aSource #
Foldable f =>Foldable (Alt f)Source #	Since: 4.12.0.0
Instance details Defined inData.Foldable Methods fold ::Monoid m =>Alt f m -> mSource # foldMap ::Monoid m => (a -> m) ->Alt f a -> mSource # foldr :: (a -> b -> b) -> b ->Alt f a -> bSource # foldr' :: (a -> b -> b) -> b ->Alt f a -> bSource # foldl :: (b -> a -> b) -> b ->Alt f a -> bSource # foldl' :: (b -> a -> b) -> b ->Alt f a -> bSource # foldr1 :: (a -> a -> a) ->Alt f a -> aSource # foldl1 :: (a -> a -> a) ->Alt f a -> aSource # toList ::Alt f a -> [a]Source # null ::Alt f a ->Bool Source # length ::Alt f a ->Int Source # elem ::Eq a => a ->Alt f a ->Bool Source # maximum ::Ord a =>Alt f a -> aSource # minimum ::Ord a =>Alt f a -> aSource # sum ::Num a =>Alt f a -> aSource # product ::Num a =>Alt f a -> aSource #
Foldable f =>Foldable (Ap f)Source #	Since: 4.12.0.0
Instance details Defined inData.Foldable Methods fold ::Monoid m =>Ap f m -> mSource # foldMap ::Monoid m => (a -> m) ->Ap f a -> mSource # foldr :: (a -> b -> b) -> b ->Ap f a -> bSource # foldr' :: (a -> b -> b) -> b ->Ap f a -> bSource # foldl :: (b -> a -> b) -> b ->Ap f a -> bSource # foldl' :: (b -> a -> b) -> b ->Ap f a -> bSource # foldr1 :: (a -> a -> a) ->Ap f a -> aSource # foldl1 :: (a -> a -> a) ->Ap f a -> aSource # toList ::Ap f a -> [a]Source # null ::Ap f a ->Bool Source # length ::Ap f a ->Int Source # elem ::Eq a => a ->Ap f a ->Bool Source # maximum ::Ord a =>Ap f a -> aSource # minimum ::Ord a =>Ap f a -> aSource # sum ::Num a =>Ap f a -> aSource # product ::Num a =>Ap f a -> aSource #
Foldable (Const m ::Type ->Type)Source #	Since: 4.7.0.0
Instance details Defined inData.Functor.Const Methods fold ::Monoid m0 =>Const m m0 -> m0Source # foldMap ::Monoid m0 => (a -> m0) ->Const m a -> m0Source # foldr :: (a -> b -> b) -> b ->Const m a -> bSource # foldr' :: (a -> b -> b) -> b ->Const m a -> bSource # foldl :: (b -> a -> b) -> b ->Const m a -> bSource # foldl' :: (b -> a -> b) -> b ->Const m a -> bSource # foldr1 :: (a -> a -> a) ->Const m a -> aSource # foldl1 :: (a -> a -> a) ->Const m a -> aSource # toList ::Const m a -> [a]Source # null ::Const m a ->Bool Source # length ::Const m a ->Int Source # elem ::Eq a => a ->Const m a ->Bool Source # maximum ::Ord a =>Const m a -> aSource # minimum ::Ord a =>Const m a -> aSource # sum ::Num a =>Const m a -> aSource # product ::Num a =>Const m a -> aSource #
Foldable (K1 i c ::Type ->Type)Source #	Since: 4.9.0.0
Instance details Defined inData.Foldable Methods fold ::Monoid m =>K1 i c m -> mSource # foldMap ::Monoid m => (a -> m) ->K1 i c a -> mSource # foldr :: (a -> b -> b) -> b ->K1 i c a -> bSource # foldr' :: (a -> b -> b) -> b ->K1 i c a -> bSource # foldl :: (b -> a -> b) -> b ->K1 i c a -> bSource # foldl' :: (b -> a -> b) -> b ->K1 i c a -> bSource # foldr1 :: (a -> a -> a) ->K1 i c a -> aSource # foldl1 :: (a -> a -> a) ->K1 i c a -> aSource # toList ::K1 i c a -> [a]Source # null ::K1 i c a ->Bool Source # length ::K1 i c a ->Int Source # elem ::Eq a => a ->K1 i c a ->Bool Source # maximum ::Ord a =>K1 i c a -> aSource # minimum ::Ord a =>K1 i c a -> aSource # sum ::Num a =>K1 i c a -> aSource # product ::Num a =>K1 i c a -> aSource #
(Foldable f,Foldable g) =>Foldable (f:+: g)Source #	Since: 4.9.0.0
Instance details Defined inData.Foldable Methods fold ::Monoid m => (f:+: g) m -> mSource # foldMap ::Monoid m => (a -> m) -> (f:+: g) a -> mSource # foldr :: (a -> b -> b) -> b -> (f:+: g) a -> bSource # foldr' :: (a -> b -> b) -> b -> (f:+: g) a -> bSource # foldl :: (b -> a -> b) -> b -> (f:+: g) a -> bSource # foldl' :: (b -> a -> b) -> b -> (f:+: g) a -> bSource # foldr1 :: (a -> a -> a) -> (f:+: g) a -> aSource # foldl1 :: (a -> a -> a) -> (f:+: g) a -> aSource # toList :: (f:+: g) a -> [a]Source # null :: (f:+: g) a ->Bool Source # length :: (f:+: g) a ->Int Source # elem ::Eq a => a -> (f:+: g) a ->Bool Source # maximum ::Ord a => (f:+: g) a -> aSource # minimum ::Ord a => (f:+: g) a -> aSource # sum ::Num a => (f:+: g) a -> aSource # product ::Num a => (f:+: g) a -> aSource #
(Foldable f,Foldable g) =>Foldable (f:*: g)Source #	Since: 4.9.0.0
Instance details Defined inData.Foldable Methods fold ::Monoid m => (f:: g) m -> mSource # foldMap ::Monoid m => (a -> m) -> (f:: g) a -> mSource # foldr :: (a -> b -> b) -> b -> (f:: g) a -> bSource # foldr' :: (a -> b -> b) -> b -> (f:: g) a -> bSource # foldl :: (b -> a -> b) -> b -> (f:: g) a -> bSource # foldl' :: (b -> a -> b) -> b -> (f:: g) a -> bSource # foldr1 :: (a -> a -> a) -> (f:: g) a -> aSource # foldl1 :: (a -> a -> a) -> (f:: g) a -> aSource # toList :: (f:: g) a -> [a]Source # null :: (f:: g) a ->Bool Source # length :: (f:: g) a ->Int Source # elem ::Eq a => a -> (f:: g) a ->Bool Source # maximum ::Ord a => (f:: g) a -> aSource # minimum ::Ord a => (f:: g) a -> aSource # sum ::Num a => (f:: g) a -> aSource # product ::Num a => (f:: g) a -> aSource #
(Foldable f,Foldable g) =>Foldable (Sum f g)Source #	Since: 4.9.0.0
Instance details Defined inData.Functor.Sum Methods fold ::Monoid m =>Sum f g m -> mSource # foldMap ::Monoid m => (a -> m) ->Sum f g a -> mSource # foldr :: (a -> b -> b) -> b ->Sum f g a -> bSource # foldr' :: (a -> b -> b) -> b ->Sum f g a -> bSource # foldl :: (b -> a -> b) -> b ->Sum f g a -> bSource # foldl' :: (b -> a -> b) -> b ->Sum f g a -> bSource # foldr1 :: (a -> a -> a) ->Sum f g a -> aSource # foldl1 :: (a -> a -> a) ->Sum f g a -> aSource # toList ::Sum f g a -> [a]Source # null ::Sum f g a ->Bool Source # length ::Sum f g a ->Int Source # elem ::Eq a => a ->Sum f g a ->Bool Source # maximum ::Ord a =>Sum f g a -> aSource # minimum ::Ord a =>Sum f g a -> aSource # sum ::Num a =>Sum f g a -> aSource # product ::Num a =>Sum f g a -> aSource #
(Foldable f,Foldable g) =>Foldable (Product f g)Source #	Since: 4.9.0.0
Instance details Defined inData.Functor.Product Methods fold ::Monoid m =>Product f g m -> mSource # foldMap ::Monoid m => (a -> m) ->Product f g a -> mSource # foldr :: (a -> b -> b) -> b ->Product f g a -> bSource # foldr' :: (a -> b -> b) -> b ->Product f g a -> bSource # foldl :: (b -> a -> b) -> b ->Product f g a -> bSource # foldl' :: (b -> a -> b) -> b ->Product f g a -> bSource # foldr1 :: (a -> a -> a) ->Product f g a -> aSource # foldl1 :: (a -> a -> a) ->Product f g a -> aSource # toList ::Product f g a -> [a]Source # null ::Product f g a ->Bool Source # length ::Product f g a ->Int Source # elem ::Eq a => a ->Product f g a ->Bool Source # maximum ::Ord a =>Product f g a -> aSource # minimum ::Ord a =>Product f g a -> aSource # sum ::Num a =>Product f g a -> aSource # product ::Num a =>Product f g a -> aSource #
Foldable f =>Foldable (M1 i c f)Source #	Since: 4.9.0.0
Instance details Defined inData.Foldable Methods fold ::Monoid m =>M1 i c f m -> mSource # foldMap ::Monoid m => (a -> m) ->M1 i c f a -> mSource # foldr :: (a -> b -> b) -> b ->M1 i c f a -> bSource # foldr' :: (a -> b -> b) -> b ->M1 i c f a -> bSource # foldl :: (b -> a -> b) -> b ->M1 i c f a -> bSource # foldl' :: (b -> a -> b) -> b ->M1 i c f a -> bSource # foldr1 :: (a -> a -> a) ->M1 i c f a -> aSource # foldl1 :: (a -> a -> a) ->M1 i c f a -> aSource # toList ::M1 i c f a -> [a]Source # null ::M1 i c f a ->Bool Source # length ::M1 i c f a ->Int Source # elem ::Eq a => a ->M1 i c f a ->Bool Source # maximum ::Ord a =>M1 i c f a -> aSource # minimum ::Ord a =>M1 i c f a -> aSource # sum ::Num a =>M1 i c f a -> aSource # product ::Num a =>M1 i c f a -> aSource #
(Foldable f,Foldable g) =>Foldable (f:.: g)Source #	Since: 4.9.0.0
Instance details Defined inData.Foldable Methods fold ::Monoid m => (f:.: g) m -> mSource # foldMap ::Monoid m => (a -> m) -> (f:.: g) a -> mSource # foldr :: (a -> b -> b) -> b -> (f:.: g) a -> bSource # foldr' :: (a -> b -> b) -> b -> (f:.: g) a -> bSource # foldl :: (b -> a -> b) -> b -> (f:.: g) a -> bSource # foldl' :: (b -> a -> b) -> b -> (f:.: g) a -> bSource # foldr1 :: (a -> a -> a) -> (f:.: g) a -> aSource # foldl1 :: (a -> a -> a) -> (f:.: g) a -> aSource # toList :: (f:.: g) a -> [a]Source # null :: (f:.: g) a ->Bool Source # length :: (f:.: g) a ->Int Source # elem ::Eq a => a -> (f:.: g) a ->Bool Source # maximum ::Ord a => (f:.: g) a -> aSource # minimum ::Ord a => (f:.: g) a -> aSource # sum ::Num a => (f:.: g) a -> aSource # product ::Num a => (f:.: g) a -> aSource #
(Foldable f,Foldable g) =>Foldable (Compose f g)Source #	Since: 4.9.0.0
Instance details Defined inData.Functor.Compose Methods fold ::Monoid m =>Compose f g m -> mSource # foldMap ::Monoid m => (a -> m) ->Compose f g a -> mSource # foldr :: (a -> b -> b) -> b ->Compose f g a -> bSource # foldr' :: (a -> b -> b) -> b ->Compose f g a -> bSource # foldl :: (b -> a -> b) -> b ->Compose f g a -> bSource # foldl' :: (b -> a -> b) -> b ->Compose f g a -> bSource # foldr1 :: (a -> a -> a) ->Compose f g a -> aSource # foldl1 :: (a -> a -> a) ->Compose f g a -> aSource # toList ::Compose f g a -> [a]Source # null ::Compose f g a ->Bool Source # length ::Compose f g a ->Int Source # elem ::Eq a => a ->Compose f g a ->Bool Source # maximum ::Ord a =>Compose f g a -> aSource # minimum ::Ord a =>Compose f g a -> aSource # sum ::Num a =>Compose f g a -> aSource # product ::Num a =>Compose f g a -> aSource #

Special biased folds

foldrM :: (Foldable t,Monad m) => (a -> b -> m b) -> b -> t a -> m bSource #

Monadic fold over the elements of a structure, associating to the right, i.e. from right to left.

foldlM :: (Foldable t,Monad m) => (b -> a -> m b) -> b -> t a -> m bSource #

Monadic fold over the elements of a structure, associating to the left, i.e. from left to right.

Folding actions

Applicative actions

traverse_ :: (Foldable t,Applicative f) => (a -> f b) -> t a -> f ()Source #

Map each element of a structure to an action, evaluate these actions from left to right, and ignore the results. For a version that doesn't ignore the results seetraverse.

for_ :: (Foldable t,Applicative f) => t a -> (a -> f b) -> f ()Source #

for_ istraverse_ with its arguments flipped. For a version that doesn't ignore the results seefor.

>>>for_ [1..4] print1234

sequenceA_ :: (Foldable t,Applicative f) => t (f a) -> f ()Source #

Evaluate each action in the structure from left to right, and ignore the results. For a version that doesn't ignore the results seesequenceA.

asum :: (Foldable t,Alternative f) => t (f a) -> f aSource #

The sum of a collection of actions, generalizingconcat.

asum [JustHello, Nothing, JustWorld] JustHello

Monadic actions

mapM_ :: (Foldable t,Monad m) => (a -> m b) -> t a -> m ()Source #

Map each element of a structure to a monadic action, evaluate these actions from left to right, and ignore the results. For a version that doesn't ignore the results seemapM.

As of base 4.8.0.0,mapM_ is justtraverse_, specialized toMonad.

forM_ :: (Foldable t,Monad m) => t a -> (a -> m b) -> m ()Source #

forM_ ismapM_ with its arguments flipped. For a version that doesn't ignore the results seeforM.

As of base 4.8.0.0,forM_ is justfor_, specialized toMonad.

sequence_ :: (Foldable t,Monad m) => t (m a) -> m ()Source #

Evaluate each monadic action in the structure from left to right, and ignore the results. For a version that doesn't ignore the results seesequence.

As of base 4.8.0.0,sequence_ is justsequenceA_, specialized toMonad.

msum :: (Foldable t,MonadPlus m) => t (m a) -> m aSource #

The sum of a collection of actions, generalizingconcat. As of base 4.8.0.0,msum is justasum, specialized toMonadPlus.

Specialized folds

concat ::Foldable t => t [a] -> [a]Source #

The concatenation of all the elements of a container of lists.

concatMap ::Foldable t => (a -> [b]) -> t a -> [b]Source #

Map a function over all the elements of a container and concatenate the resulting lists.

and ::Foldable t => tBool ->Bool Source #

and returns the conjunction of a container of Bools. For the result to beTrue, the container must be finite;False, however, results from aFalse value finitely far from the left end.

or ::Foldable t => tBool ->Bool Source #

or returns the disjunction of a container of Bools. For the result to beFalse, the container must be finite;True, however, results from aTrue value finitely far from the left end.

any ::Foldable t => (a ->Bool) -> t a ->Bool Source #

Determines whether any element of the structure satisfies the predicate.

all ::Foldable t => (a ->Bool) -> t a ->Bool Source #

Determines whether all elements of the structure satisfy the predicate.

maximumBy ::Foldable t => (a -> a ->Ordering) -> t a -> aSource #

The largest element of a non-empty structure with respect to the given comparison function.

minimumBy ::Foldable t => (a -> a ->Ordering) -> t a -> aSource #

The least element of a non-empty structure with respect to the given comparison function.

Searches

notElem :: (Foldable t,Eq a) => a -> t a ->Boolinfix 4Source #

notElem is the negation ofelem.

find ::Foldable t => (a ->Bool) -> t a ->Maybe aSource #

Thefind function takes a predicate and a structure and returns the leftmost element of the structure matching the predicate, orNothing if there is no such element.

Movatterモバイル変換

Documentation

Special biased folds

Folding actions

Applicative actions

Monadic actions

Specialized folds

Searches