relude-0.5.0: Custom prelude from Kowainik

Relude.Foldable.Reexport

Description

Synopsis

# Documentation

class Foldable (t :: Type -> Type) where #

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 define foldr:

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, and minimum should all be essentially equivalent to foldMap forms, such as

sum = getSum . foldMap Sum

but may be less defined.

If the type is also a Functor instance, it should satisfy

foldMap f = fold . fmap f

which implies that

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

Minimal complete definition

Methods

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

Combine the elements of a structure using a monoid.

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

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

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

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 general Foldable structure this should be semantically identical to,

foldr f z = foldr f z . toList

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

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 general Foldable structure this should be semantically identical to,

foldl f z = foldl' f z . toList

toList :: t a -> [a] #

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

null :: t a -> Bool #

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 #

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

Instances
 Foldable [] Since: base-2.1 Instance detailsDefined in Data.Foldable Methodsfold :: 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 # Since: base-2.1 Instance detailsDefined in Data.Foldable Methodsfold :: 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 # Since: base-4.9.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: 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 # Since: base-4.9.0.0 Instance detailsDefined in Data.Complex Methodsfold :: Monoid m => Complex m -> m #foldMap :: Monoid m => (a -> m) -> Complex a -> m #foldr :: (a -> b -> b) -> b -> Complex a -> b #foldr' :: (a -> b -> b) -> b -> Complex a -> b #foldl :: (b -> a -> b) -> b -> Complex a -> b #foldl' :: (b -> a -> b) -> b -> Complex a -> b #foldr1 :: (a -> a -> a) -> Complex a -> a #foldl1 :: (a -> a -> a) -> Complex a -> a #toList :: Complex a -> [a] #null :: Complex a -> Bool #length :: Complex a -> Int #elem :: Eq a => a -> Complex a -> Bool #maximum :: Ord a => Complex a -> a #minimum :: Ord a => Complex a -> a #sum :: Num a => Complex a -> a #product :: Num a => Complex a -> a # Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodsfold :: Monoid m => Min m -> m #foldMap :: Monoid m => (a -> m) -> Min a -> m #foldr :: (a -> b -> b) -> b -> Min a -> b #foldr' :: (a -> b -> b) -> b -> Min a -> b #foldl :: (b -> a -> b) -> b -> Min a -> b #foldl' :: (b -> a -> b) -> b -> Min a -> b #foldr1 :: (a -> a -> a) -> Min a -> a #foldl1 :: (a -> a -> a) -> Min a -> a #toList :: Min a -> [a] #null :: Min a -> Bool #length :: Min a -> Int #elem :: Eq a => a -> Min a -> Bool #maximum :: Ord a => Min a -> a #minimum :: Ord a => Min a -> a #sum :: Num a => Min a -> a #product :: Num a => Min a -> a # Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodsfold :: Monoid m => Max m -> m #foldMap :: Monoid m => (a -> m) -> Max a -> m #foldr :: (a -> b -> b) -> b -> Max a -> b #foldr' :: (a -> b -> b) -> b -> Max a -> b #foldl :: (b -> a -> b) -> b -> Max a -> b #foldl' :: (b -> a -> b) -> b -> Max a -> b #foldr1 :: (a -> a -> a) -> Max a -> a #foldl1 :: (a -> a -> a) -> Max a -> a #toList :: Max a -> [a] #null :: Max a -> Bool #length :: Max a -> Int #elem :: Eq a => a -> Max a -> Bool #maximum :: Ord a => Max a -> a #minimum :: Ord a => Max a -> a #sum :: Num a => Max a -> a #product :: Num a => Max a -> a # Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodsfold :: 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 # Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodsfold :: 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 # Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodsfold :: Monoid m => Option m -> m #foldMap :: Monoid m => (a -> m) -> Option a -> m #foldr :: (a -> b -> b) -> b -> Option a -> b #foldr' :: (a -> b -> b) -> b -> Option a -> b #foldl :: (b -> a -> b) -> b -> Option a -> b #foldl' :: (b -> a -> b) -> b -> Option a -> b #foldr1 :: (a -> a -> a) -> Option a -> a #foldl1 :: (a -> a -> a) -> Option a -> a #toList :: Option a -> [a] #null :: Option a -> Bool #length :: Option a -> Int #elem :: Eq a => a -> Option a -> Bool #maximum :: Ord a => Option a -> a #minimum :: Ord a => Option a -> a #sum :: Num a => Option a -> a #product :: Num a => Option a -> a # Since: base-4.9.0.0 Instance detailsDefined in Control.Applicative Methodsfold :: 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 # Since: base-4.8.0.0 Instance detailsDefined in Data.Functor.Identity Methodsfold :: Monoid m => Identity m -> m #foldMap :: Monoid m => (a -> m) -> Identity a -> m #foldr :: (a -> b -> b) -> b -> Identity a -> b #foldr' :: (a -> b -> b) -> b -> Identity a -> b #foldl :: (b -> a -> b) -> b -> Identity a -> b #foldl' :: (b -> a -> b) -> b -> Identity a -> b #foldr1 :: (a -> a -> a) -> Identity a -> a #foldl1 :: (a -> a -> a) -> Identity a -> a #toList :: Identity a -> [a] #null :: Identity a -> Bool #length :: Identity a -> Int #elem :: Eq a => a -> Identity a -> Bool #maximum :: Ord a => Identity a -> a #minimum :: Ord a => Identity a -> a #sum :: Num a => Identity a -> a #product :: Num a => Identity a -> a # Since: base-4.8.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: 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 # Since: base-4.8.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: 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 # Since: base-4.8.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: 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 # Since: base-4.8.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: 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 # Since: base-4.8.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: 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 # Since: base-4.12.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => Down m -> m #foldMap :: Monoid m => (a -> m) -> Down a -> m #foldr :: (a -> b -> b) -> b -> Down a -> b #foldr' :: (a -> b -> b) -> b -> Down a -> b #foldl :: (b -> a -> b) -> b -> Down a -> b #foldl' :: (b -> a -> b) -> b -> Down a -> b #foldr1 :: (a -> a -> a) -> Down a -> a #foldl1 :: (a -> a -> a) -> Down a -> a #toList :: Down a -> [a] #null :: Down a -> Bool #length :: Down a -> Int #elem :: Eq a => a -> Down a -> Bool #maximum :: Ord a => Down a -> a #minimum :: Ord a => Down a -> a #sum :: Num a => Down a -> a #product :: Num a => Down a -> a # Since: base-4.9.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => NonEmpty m -> m #foldMap :: Monoid m => (a -> m) -> NonEmpty a -> m #foldr :: (a -> b -> b) -> b -> NonEmpty a -> b #foldr' :: (a -> b -> b) -> b -> NonEmpty a -> b #foldl :: (b -> a -> b) -> b -> NonEmpty a -> b #foldl' :: (b -> a -> b) -> b -> NonEmpty a -> b #foldr1 :: (a -> a -> a) -> NonEmpty a -> a #foldl1 :: (a -> a -> a) -> NonEmpty a -> a #toList :: NonEmpty a -> [a] #null :: NonEmpty a -> Bool #length :: NonEmpty a -> Int #elem :: Eq a => a -> NonEmpty a -> Bool #maximum :: Ord a => NonEmpty a -> a #minimum :: Ord a => NonEmpty a -> a #sum :: Num a => NonEmpty a -> a #product :: Num a => NonEmpty a -> a # Instance detailsDefined in Data.IntMap.Internal Methodsfold :: Monoid m => IntMap m -> m #foldMap :: Monoid m => (a -> m) -> IntMap a -> m #foldr :: (a -> b -> b) -> b -> IntMap a -> b #foldr' :: (a -> b -> b) -> b -> IntMap a -> b #foldl :: (b -> a -> b) -> b -> IntMap a -> b #foldl' :: (b -> a -> b) -> b -> IntMap a -> b #foldr1 :: (a -> a -> a) -> IntMap a -> a #foldl1 :: (a -> a -> a) -> IntMap a -> a #toList :: IntMap a -> [a] #null :: IntMap a -> Bool #length :: IntMap a -> Int #elem :: Eq a => a -> IntMap a -> Bool #maximum :: Ord a => IntMap a -> a #minimum :: Ord a => IntMap a -> a #sum :: Num a => IntMap a -> a #product :: Num a => IntMap a -> a # Instance detailsDefined in Data.Tree Methodsfold :: Monoid m => Tree m -> m #foldMap :: Monoid m => (a -> m) -> Tree a -> m #foldr :: (a -> b -> b) -> b -> Tree a -> b #foldr' :: (a -> b -> b) -> b -> Tree a -> b #foldl :: (b -> a -> b) -> b -> Tree a -> b #foldl' :: (b -> a -> b) -> b -> Tree a -> b #foldr1 :: (a -> a -> a) -> Tree a -> a #foldl1 :: (a -> a -> a) -> Tree a -> a #toList :: Tree a -> [a] #null :: Tree a -> Bool #length :: Tree a -> Int #elem :: Eq a => a -> Tree a -> Bool #maximum :: Ord a => Tree a -> a #minimum :: Ord a => Tree a -> a #sum :: Num a => Tree a -> a #product :: Num a => Tree a -> a # Instance detailsDefined in Data.Sequence.Internal Methodsfold :: Monoid m => Seq m -> m #foldMap :: Monoid m => (a -> m) -> Seq a -> m #foldr :: (a -> b -> b) -> b -> Seq a -> b #foldr' :: (a -> b -> b) -> b -> Seq a -> b #foldl :: (b -> a -> b) -> b -> Seq a -> b #foldl' :: (b -> a -> b) -> b -> Seq a -> b #foldr1 :: (a -> a -> a) -> Seq a -> a #foldl1 :: (a -> a -> a) -> Seq a -> a #toList :: Seq a -> [a] #null :: Seq a -> Bool #length :: Seq a -> Int #elem :: Eq a => a -> Seq a -> Bool #maximum :: Ord a => Seq a -> a #minimum :: Ord a => Seq a -> a #sum :: Num a => Seq a -> a #product :: Num a => Seq a -> a # Instance detailsDefined in Data.Sequence.Internal Methodsfold :: Monoid m => FingerTree m -> m #foldMap :: Monoid m => (a -> m) -> FingerTree a -> m #foldr :: (a -> b -> b) -> b -> FingerTree a -> b #foldr' :: (a -> b -> b) -> b -> FingerTree a -> b #foldl :: (b -> a -> b) -> b -> FingerTree a -> b #foldl' :: (b -> a -> b) -> b -> FingerTree a -> b #foldr1 :: (a -> a -> a) -> FingerTree a -> a #foldl1 :: (a -> a -> a) -> FingerTree a -> a #toList :: FingerTree a -> [a] #null :: FingerTree a -> Bool #length :: FingerTree a -> Int #elem :: Eq a => a -> FingerTree a -> Bool #maximum :: Ord a => FingerTree a -> a #minimum :: Ord a => FingerTree a -> a #sum :: Num a => FingerTree a -> a #product :: Num a => FingerTree a -> a # Instance detailsDefined in Data.Sequence.Internal Methodsfold :: Monoid m => Digit m -> m #foldMap :: Monoid m => (a -> m) -> Digit a -> m #foldr :: (a -> b -> b) -> b -> Digit a -> b #foldr' :: (a -> b -> b) -> b -> Digit a -> b #foldl :: (b -> a -> b) -> b -> Digit a -> b #foldl' :: (b -> a -> b) -> b -> Digit a -> b #foldr1 :: (a -> a -> a) -> Digit a -> a #foldl1 :: (a -> a -> a) -> Digit a -> a #toList :: Digit a -> [a] #null :: Digit a -> Bool #length :: Digit a -> Int #elem :: Eq a => a -> Digit a -> Bool #maximum :: Ord a => Digit a -> a #minimum :: Ord a => Digit a -> a #sum :: Num a => Digit a -> a #product :: Num a => Digit a -> a # Instance detailsDefined in Data.Sequence.Internal Methodsfold :: Monoid m => Node m -> m #foldMap :: Monoid m => (a -> m) -> Node a -> m #foldr :: (a -> b -> b) -> b -> Node a -> b #foldr' :: (a -> b -> b) -> b -> Node a -> b #foldl :: (b -> a -> b) -> b -> Node a -> b #foldl' :: (b -> a -> b) -> b -> Node a -> b #foldr1 :: (a -> a -> a) -> Node a -> a #foldl1 :: (a -> a -> a) -> Node a -> a #toList :: Node a -> [a] #null :: Node a -> Bool #length :: Node a -> Int #elem :: Eq a => a -> Node a -> Bool #maximum :: Ord a => Node a -> a #minimum :: Ord a => Node a -> a #sum :: Num a => Node a -> a #product :: Num a => Node a -> a # Instance detailsDefined in Data.Sequence.Internal Methodsfold :: Monoid m => Elem m -> m #foldMap :: Monoid m => (a -> m) -> Elem a -> m #foldr :: (a -> b -> b) -> b -> Elem a -> b #foldr' :: (a -> b -> b) -> b -> Elem a -> b #foldl :: (b -> a -> b) -> b -> Elem a -> b #foldl' :: (b -> a -> b) -> b -> Elem a -> b #foldr1 :: (a -> a -> a) -> Elem a -> a #foldl1 :: (a -> a -> a) -> Elem a -> a #toList :: Elem a -> [a] #null :: Elem a -> Bool #length :: Elem a -> Int #elem :: Eq a => a -> Elem a -> Bool #maximum :: Ord a => Elem a -> a #minimum :: Ord a => Elem a -> a #sum :: Num a => Elem a -> a #product :: Num a => Elem a -> a # Instance detailsDefined in Data.Sequence.Internal Methodsfold :: Monoid m => ViewL m -> m #foldMap :: Monoid m => (a -> m) -> ViewL a -> m #foldr :: (a -> b -> b) -> b -> ViewL a -> b #foldr' :: (a -> b -> b) -> b -> ViewL a -> b #foldl :: (b -> a -> b) -> b -> ViewL a -> b #foldl' :: (b -> a -> b) -> b -> ViewL a -> b #foldr1 :: (a -> a -> a) -> ViewL a -> a #foldl1 :: (a -> a -> a) -> ViewL a -> a #toList :: ViewL a -> [a] #null :: ViewL a -> Bool #length :: ViewL a -> Int #elem :: Eq a => a -> ViewL a -> Bool #maximum :: Ord a => ViewL a -> a #minimum :: Ord a => ViewL a -> a #sum :: Num a => ViewL a -> a #product :: Num a => ViewL a -> a # Instance detailsDefined in Data.Sequence.Internal Methodsfold :: Monoid m => ViewR m -> m #foldMap :: Monoid m => (a -> m) -> ViewR a -> m #foldr :: (a -> b -> b) -> b -> ViewR a -> b #foldr' :: (a -> b -> b) -> b -> ViewR a -> b #foldl :: (b -> a -> b) -> b -> ViewR a -> b #foldl' :: (b -> a -> b) -> b -> ViewR a -> b #foldr1 :: (a -> a -> a) -> ViewR a -> a #foldl1 :: (a -> a -> a) -> ViewR a -> a #toList :: ViewR a -> [a] #null :: ViewR a -> Bool #length :: ViewR a -> Int #elem :: Eq a => a -> ViewR a -> Bool #maximum :: Ord a => ViewR a -> a #minimum :: Ord a => ViewR a -> a #sum :: Num a => ViewR a -> a #product :: Num a => ViewR a -> a # Instance detailsDefined in Data.Set.Internal Methodsfold :: Monoid m => Set m -> m #foldMap :: Monoid m => (a -> m) -> Set a -> m #foldr :: (a -> b -> b) -> b -> Set a -> b #foldr' :: (a -> b -> b) -> b -> Set a -> b #foldl :: (b -> a -> b) -> b -> Set a -> b #foldl' :: (b -> a -> b) -> b -> Set a -> b #foldr1 :: (a -> a -> a) -> Set a -> a #foldl1 :: (a -> a -> a) -> Set a -> a #toList :: Set a -> [a] #null :: Set a -> Bool #length :: Set a -> Int #elem :: Eq a => a -> Set a -> Bool #maximum :: Ord a => Set a -> a #minimum :: Ord a => Set a -> a #sum :: Num a => Set a -> a #product :: Num a => Set a -> a # Instance detailsDefined in Data.Hashable.Class Methodsfold :: Monoid m => Hashed m -> m #foldMap :: Monoid m => (a -> m) -> Hashed a -> m #foldr :: (a -> b -> b) -> b -> Hashed a -> b #foldr' :: (a -> b -> b) -> b -> Hashed a -> b #foldl :: (b -> a -> b) -> b -> Hashed a -> b #foldl' :: (b -> a -> b) -> b -> Hashed a -> b #foldr1 :: (a -> a -> a) -> Hashed a -> a #foldl1 :: (a -> a -> a) -> Hashed a -> a #toList :: Hashed a -> [a] #null :: Hashed a -> Bool #length :: Hashed a -> Int #elem :: Eq a => a -> Hashed a -> Bool #maximum :: Ord a => Hashed a -> a #minimum :: Ord a => Hashed a -> a #sum :: Num a => Hashed a -> a #product :: Num a => Hashed a -> a # Instance detailsDefined in Data.HashSet.Base Methodsfold :: Monoid m => HashSet m -> m #foldMap :: Monoid m => (a -> m) -> HashSet a -> m #foldr :: (a -> b -> b) -> b -> HashSet a -> b #foldr' :: (a -> b -> b) -> b -> HashSet a -> b #foldl :: (b -> a -> b) -> b -> HashSet a -> b #foldl' :: (b -> a -> b) -> b -> HashSet a -> b #foldr1 :: (a -> a -> a) -> HashSet a -> a #foldl1 :: (a -> a -> a) -> HashSet a -> a #toList :: HashSet a -> [a] #null :: HashSet a -> Bool #length :: HashSet a -> Int #elem :: Eq a => a -> HashSet a -> Bool #maximum :: Ord a => HashSet a -> a #minimum :: Ord a => HashSet a -> a #sum :: Num a => HashSet a -> a #product :: Num a => HashSet a -> a # Since: base-4.7.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => Either a m -> m #foldMap :: Monoid m => (a0 -> m) -> Either a a0 -> m #foldr :: (a0 -> b -> b) -> b -> Either a a0 -> b #foldr' :: (a0 -> b -> b) -> b -> Either a a0 -> b #foldl :: (b -> a0 -> b) -> b -> Either a a0 -> b #foldl' :: (b -> a0 -> b) -> b -> Either a a0 -> b #foldr1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 #foldl1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 #toList :: Either a a0 -> [a0] #null :: Either a a0 -> Bool #length :: Either a a0 -> Int #elem :: Eq a0 => a0 -> Either a a0 -> Bool #maximum :: Ord a0 => Either a a0 -> a0 #minimum :: Ord a0 => Either a a0 -> a0 #sum :: Num a0 => Either a a0 -> a0 #product :: Num a0 => Either a a0 -> a0 # Foldable (V1 :: Type -> Type) Since: base-4.9.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: 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 :: Type -> Type) Since: base-4.9.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: 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 ((,) a) Since: base-4.7.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => (a, m) -> m #foldMap :: Monoid m => (a0 -> m) -> (a, a0) -> m #foldr :: (a0 -> b -> b) -> b -> (a, a0) -> b #foldr' :: (a0 -> b -> b) -> b -> (a, a0) -> b #foldl :: (b -> a0 -> b) -> b -> (a, a0) -> b #foldl' :: (b -> a0 -> b) -> b -> (a, a0) -> b #foldr1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0 #foldl1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0 #toList :: (a, a0) -> [a0] #null :: (a, a0) -> Bool #length :: (a, a0) -> Int #elem :: Eq a0 => a0 -> (a, a0) -> Bool #maximum :: Ord a0 => (a, a0) -> a0 #minimum :: Ord a0 => (a, a0) -> a0 #sum :: Num a0 => (a, a0) -> a0 #product :: Num a0 => (a, a0) -> a0 # Since: base-4.8.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: 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 (Arg a) Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodsfold :: Monoid m => Arg a m -> m #foldMap :: Monoid m => (a0 -> m) -> Arg a a0 -> m #foldr :: (a0 -> b -> b) -> b -> Arg a a0 -> b #foldr' :: (a0 -> b -> b) -> b -> Arg a a0 -> b #foldl :: (b -> a0 -> b) -> b -> Arg a a0 -> b #foldl' :: (b -> a0 -> b) -> b -> Arg a a0 -> b #foldr1 :: (a0 -> a0 -> a0) -> Arg a a0 -> a0 #foldl1 :: (a0 -> a0 -> a0) -> Arg a a0 -> a0 #toList :: Arg a a0 -> [a0] #null :: Arg a a0 -> Bool #length :: Arg a a0 -> Int #elem :: Eq a0 => a0 -> Arg a a0 -> Bool #maximum :: Ord a0 => Arg a a0 -> a0 #minimum :: Ord a0 => Arg a a0 -> a0 #sum :: Num a0 => Arg a a0 -> a0 #product :: Num a0 => Arg a a0 -> a0 # Foldable (Proxy :: Type -> Type) Since: base-4.7.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: 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 (Map k) Instance detailsDefined in Data.Map.Internal Methodsfold :: Monoid m => Map k m -> m #foldMap :: Monoid m => (a -> m) -> Map k a -> m #foldr :: (a -> b -> b) -> b -> Map k a -> b #foldr' :: (a -> b -> b) -> b -> Map k a -> b #foldl :: (b -> a -> b) -> b -> Map k a -> b #foldl' :: (b -> a -> b) -> b -> Map k a -> b #foldr1 :: (a -> a -> a) -> Map k a -> a #foldl1 :: (a -> a -> a) -> Map k a -> a #toList :: Map k a -> [a] #null :: Map k a -> Bool #length :: Map k a -> Int #elem :: Eq a => a -> Map k a -> Bool #maximum :: Ord a => Map k a -> a #minimum :: Ord a => Map k a -> a #sum :: Num a => Map k a -> a #product :: Num a => Map k a -> a # Foldable f => Foldable (MaybeT f) Instance detailsDefined in Control.Monad.Trans.Maybe Methodsfold :: Monoid m => MaybeT f m -> m #foldMap :: Monoid m => (a -> m) -> MaybeT f a -> m #foldr :: (a -> b -> b) -> b -> MaybeT f a -> b #foldr' :: (a -> b -> b) -> b -> MaybeT f a -> b #foldl :: (b -> a -> b) -> b -> MaybeT f a -> b #foldl' :: (b -> a -> b) -> b -> MaybeT f a -> b #foldr1 :: (a -> a -> a) -> MaybeT f a -> a #foldl1 :: (a -> a -> a) -> MaybeT f a -> a #toList :: MaybeT f a -> [a] #null :: MaybeT f a -> Bool #length :: MaybeT f a -> Int #elem :: Eq a => a -> MaybeT f a -> Bool #maximum :: Ord a => MaybeT f a -> a #minimum :: Ord a => MaybeT f a -> a #sum :: Num a => MaybeT f a -> a #product :: Num a => MaybeT f a -> a # Instance detailsDefined in Data.HashMap.Base Methodsfold :: Monoid m => HashMap k m -> m #foldMap :: Monoid m => (a -> m) -> HashMap k a -> m #foldr :: (a -> b -> b) -> b -> HashMap k a -> b #foldr' :: (a -> b -> b) -> b -> HashMap k a -> b #foldl :: (b -> a -> b) -> b -> HashMap k a -> b #foldl' :: (b -> a -> b) -> b -> HashMap k a -> b #foldr1 :: (a -> a -> a) -> HashMap k a -> a #foldl1 :: (a -> a -> a) -> HashMap k a -> a #toList :: HashMap k a -> [a] #null :: HashMap k a -> Bool #length :: HashMap k a -> Int #elem :: Eq a => a -> HashMap k a -> Bool #maximum :: Ord a => HashMap k a -> a #minimum :: Ord a => HashMap k a -> a #sum :: Num a => HashMap k a -> a #product :: Num a => HashMap k a -> a # Source # Instance detailsDefined in Relude.Extra.Validation Methodsfold :: Monoid m => Validation e m -> m #foldMap :: Monoid m => (a -> m) -> Validation e a -> m #foldr :: (a -> b -> b) -> b -> Validation e a -> b #foldr' :: (a -> b -> b) -> b -> Validation e a -> b #foldl :: (b -> a -> b) -> b -> Validation e a -> b #foldl' :: (b -> a -> b) -> b -> Validation e a -> b #foldr1 :: (a -> a -> a) -> Validation e a -> a #foldl1 :: (a -> a -> a) -> Validation e a -> a #toList :: Validation e a -> [a] #null :: Validation e a -> Bool #length :: Validation e a -> Int #elem :: Eq a => a -> Validation e a -> Bool #maximum :: Ord a => Validation e a -> a #minimum :: Ord a => Validation e a -> a #sum :: Num a => Validation e a -> a #product :: Num a => Validation e a -> a # Foldable f => Foldable (Rec1 f) Since: base-4.9.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: 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 :: Type -> Type) Since: base-4.9.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: 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 # Since: base-4.9.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: 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 # Since: base-4.9.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: 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 :: Type -> Type) Since: base-4.9.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: 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 :: Type -> Type) Since: base-4.9.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: 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 ()) :: Type -> Type) Since: base-4.9.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: 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 (Const m :: Type -> Type) Since: base-4.7.0.0 Instance detailsDefined in Data.Functor.Const Methodsfold :: Monoid m0 => Const m m0 -> m0 #foldMap :: Monoid m0 => (a -> m0) -> Const m a -> m0 #foldr :: (a -> b -> b) -> b -> Const m a -> b #foldr' :: (a -> b -> b) -> b -> Const m a -> b #foldl :: (b -> a -> b) -> b -> Const m a -> b #foldl' :: (b -> a -> b) -> b -> Const m a -> b #foldr1 :: (a -> a -> a) -> Const m a -> a #foldl1 :: (a -> a -> a) -> Const m a -> a #toList :: Const m a -> [a] #null :: Const m a -> Bool #length :: Const m a -> Int #elem :: Eq a => a -> Const m a -> Bool #maximum :: Ord a => Const m a -> a #minimum :: Ord a => Const m a -> a #sum :: Num a => Const m a -> a #product :: Num a => Const m a -> a # Foldable f => Foldable (Ap f) Since: base-4.12.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => Ap f m -> m #foldMap :: Monoid m => (a -> m) -> Ap f a -> m #foldr :: (a -> b -> b) -> b -> Ap f a -> b #foldr' :: (a -> b -> b) -> b -> Ap f a -> b #foldl :: (b -> a -> b) -> b -> Ap f a -> b #foldl' :: (b -> a -> b) -> b -> Ap f a -> b #foldr1 :: (a -> a -> a) -> Ap f a -> a #foldl1 :: (a -> a -> a) -> Ap f a -> a #toList :: Ap f a -> [a] #null :: Ap f a -> Bool #length :: Ap f a -> Int #elem :: Eq a => a -> Ap f a -> Bool #maximum :: Ord a => Ap f a -> a #minimum :: Ord a => Ap f a -> a #sum :: Num a => Ap f a -> a #product :: Num a => Ap f a -> a # Foldable f => Foldable (Alt f) Since: base-4.12.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => Alt f m -> m #foldMap :: Monoid m => (a -> m) -> Alt f a -> m #foldr :: (a -> b -> b) -> b -> Alt f a -> b #foldr' :: (a -> b -> b) -> b -> Alt f a -> b #foldl :: (b -> a -> b) -> b -> Alt f a -> b #foldl' :: (b -> a -> b) -> b -> Alt f a -> b #foldr1 :: (a -> a -> a) -> Alt f a -> a #foldl1 :: (a -> a -> a) -> Alt f a -> a #toList :: Alt f a -> [a] #null :: Alt f a -> Bool #length :: Alt f a -> Int #elem :: Eq a => a -> Alt f a -> Bool #maximum :: Ord a => Alt f a -> a #minimum :: Ord a => Alt f a -> a #sum :: Num a => Alt f a -> a #product :: Num a => Alt f a -> a # Foldable f => Foldable (IdentityT f) Instance detailsDefined in Control.Monad.Trans.Identity Methodsfold :: Monoid m => IdentityT f m -> m #foldMap :: Monoid m => (a -> m) -> IdentityT f a -> m #foldr :: (a -> b -> b) -> b -> IdentityT f a -> b #foldr' :: (a -> b -> b) -> b -> IdentityT f a -> b #foldl :: (b -> a -> b) -> b -> IdentityT f a -> b #foldl' :: (b -> a -> b) -> b -> IdentityT f a -> b #foldr1 :: (a -> a -> a) -> IdentityT f a -> a #foldl1 :: (a -> a -> a) -> IdentityT f a -> a #toList :: IdentityT f a -> [a] #null :: IdentityT f a -> Bool #length :: IdentityT f a -> Int #elem :: Eq a => a -> IdentityT f a -> Bool #maximum :: Ord a => IdentityT f a -> a #minimum :: Ord a => IdentityT f a -> a #sum :: Num a => IdentityT f a -> a #product :: Num a => IdentityT f a -> a # Foldable f => Foldable (ErrorT e f) Instance detailsDefined in Control.Monad.Trans.Error Methodsfold :: Monoid m => ErrorT e f m -> m #foldMap :: Monoid m => (a -> m) -> ErrorT e f a -> m #foldr :: (a -> b -> b) -> b -> ErrorT e f a -> b #foldr' :: (a -> b -> b) -> b -> ErrorT e f a -> b #foldl :: (b -> a -> b) -> b -> ErrorT e f a -> b #foldl' :: (b -> a -> b) -> b -> ErrorT e f a -> b #foldr1 :: (a -> a -> a) -> ErrorT e f a -> a #foldl1 :: (a -> a -> a) -> ErrorT e f a -> a #toList :: ErrorT e f a -> [a] #null :: ErrorT e f a -> Bool #length :: ErrorT e f a -> Int #elem :: Eq a => a -> ErrorT e f a -> Bool #maximum :: Ord a => ErrorT e f a -> a #minimum :: Ord a => ErrorT e f a -> a #sum :: Num a => ErrorT e f a -> a #product :: Num a => ErrorT e f a -> a # Foldable f => Foldable (ExceptT e f) Instance detailsDefined in Control.Monad.Trans.Except Methodsfold :: Monoid m => ExceptT e f m -> m #foldMap :: Monoid m => (a -> m) -> ExceptT e f a -> m #foldr :: (a -> b -> b) -> b -> ExceptT e f a -> b #foldr' :: (a -> b -> b) -> b -> ExceptT e f a -> b #foldl :: (b -> a -> b) -> b -> ExceptT e f a -> b #foldl' :: (b -> a -> b) -> b -> ExceptT e f a -> b #foldr1 :: (a -> a -> a) -> ExceptT e f a -> a #foldl1 :: (a -> a -> a) -> ExceptT e f a -> a #toList :: ExceptT e f a -> [a] #null :: ExceptT e f a -> Bool #length :: ExceptT e f a -> Int #elem :: Eq a => a -> ExceptT e f a -> Bool #maximum :: Ord a => ExceptT e f a -> a #minimum :: Ord a => ExceptT e f a -> a #sum :: Num a => ExceptT e f a -> a #product :: Num a => ExceptT e f a -> a # Foldable (K1 i c :: Type -> Type) Since: base-4.9.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: 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) Since: base-4.9.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: 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) Since: base-4.9.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: 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 (Product f g) Since: base-4.9.0.0 Instance detailsDefined in Data.Functor.Product Methodsfold :: Monoid m => Product f g m -> m #foldMap :: Monoid m => (a -> m) -> Product f g a -> m #foldr :: (a -> b -> b) -> b -> Product f g a -> b #foldr' :: (a -> b -> b) -> b -> Product f g a -> b #foldl :: (b -> a -> b) -> b -> Product f g a -> b #foldl' :: (b -> a -> b) -> b -> Product f g a -> b #foldr1 :: (a -> a -> a) -> Product f g a -> a #foldl1 :: (a -> a -> a) -> Product f g a -> a #toList :: Product f g a -> [a] #null :: Product f g a -> Bool #length :: Product f g a -> Int #elem :: Eq a => a -> Product f g a -> Bool #maximum :: Ord a => Product f g a -> a #minimum :: Ord a => Product f g a -> a #sum :: Num a => Product f g a -> a #product :: Num a => Product f g a -> a # (Foldable f, Foldable g) => Foldable (Sum f g) Since: base-4.9.0.0 Instance detailsDefined in Data.Functor.Sum Methodsfold :: Monoid m => Sum f g m -> m #foldMap :: Monoid m => (a -> m) -> Sum f g a -> m #foldr :: (a -> b -> b) -> b -> Sum f g a -> b #foldr' :: (a -> b -> b) -> b -> Sum f g a -> b #foldl :: (b -> a -> b) -> b -> Sum f g a -> b #foldl' :: (b -> a -> b) -> b -> Sum f g a -> b #foldr1 :: (a -> a -> a) -> Sum f g a -> a #foldl1 :: (a -> a -> a) -> Sum f g a -> a #toList :: Sum f g a -> [a] #null :: Sum f g a -> Bool #length :: Sum f g a -> Int #elem :: Eq a => a -> Sum f g a -> Bool #maximum :: Ord a => Sum f g a -> a #minimum :: Ord a => Sum f g a -> a #sum :: Num a => Sum f g a -> a #product :: Num a => Sum f g a -> a # Foldable f => Foldable (M1 i c f) Since: base-4.9.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: 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 # (Foldable f, Foldable g) => Foldable (f :.: g) Since: base-4.9.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: 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 (Compose f g) Since: base-4.9.0.0 Instance detailsDefined in Data.Functor.Compose Methodsfold :: Monoid m => Compose f g m -> m #foldMap :: Monoid m => (a -> m) -> Compose f g a -> m #foldr :: (a -> b -> b) -> b -> Compose f g a -> b #foldr' :: (a -> b -> b) -> b -> Compose f g a -> b #foldl :: (b -> a -> b) -> b -> Compose f g a -> b #foldl' :: (b -> a -> b) -> b -> Compose f g a -> b #foldr1 :: (a -> a -> a) -> Compose f g a -> a #foldl1 :: (a -> a -> a) -> Compose f g a -> a #toList :: Compose f g a -> [a] #null :: Compose f g a -> Bool #length :: Compose f g a -> Int #elem :: Eq a => a -> Compose f g a -> Bool #maximum :: Ord a => Compose f g a -> a #minimum :: Ord a => Compose f g a -> a #sum :: Num a => Compose f g a -> a #product :: Num a => Compose f g a -> a #

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

The find function takes a predicate and a structure and returns the leftmost element of the structure matching the predicate, or Nothing if there is no such element.

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

Determines whether all elements of the structure satisfy the predicate.

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

Determines whether any element of the structure satisfies the predicate.

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

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

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

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

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

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

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

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

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

The sum of a collection of actions, generalizing concat.

asum [Just Hello, Nothing, Just World] Just Hello

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

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

As of base 4.8.0.0, sequence_ is just sequenceA_, specialized to Monad.

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

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

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

forM_ is mapM_ with its arguments flipped. For a version that doesn't ignore the results see forM.

As of base 4.8.0.0, forM_ is just for_, specialized to Monad.

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

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

As of base 4.8.0.0, mapM_ is just traverse_, specialized to Monad.

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

for_ is traverse_ with its arguments flipped. For a version that doesn't ignore the results see for.

>>> for_ [1..4] print
1
2
3
4


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

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

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

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

class (Functor t, Foldable t) => Traversable (t :: Type -> Type) where #

Functors representing data structures that can be traversed from left to right.

A definition of traverse must satisfy the following laws:

naturality
t . traverse f = traverse (t . f) for every applicative transformation t
identity
traverse Identity = Identity
composition
traverse (Compose . fmap g . f) = Compose . fmap (traverse g) . traverse f

A definition of sequenceA must satisfy the following laws:

naturality
t . sequenceA = sequenceA . fmap t for every applicative transformation t
identity
sequenceA . fmap Identity = Identity
composition
sequenceA . fmap Compose = Compose . fmap sequenceA . sequenceA

where an applicative transformation is a function

t :: (Applicative f, Applicative g) => f a -> g a

preserving the Applicative operations, i.e.

• t (pure x) = pure x
• t (x <*> y) = t x <*> t y

and the identity functor Identity and composition of functors Compose are defined as

  newtype Identity a = Identity a

instance Functor Identity where
fmap f (Identity x) = Identity (f x)

instance Applicative Identity where
pure x = Identity x
Identity f <*> Identity x = Identity (f x)

newtype Compose f g a = Compose (f (g a))

instance (Functor f, Functor g) => Functor (Compose f g) where
fmap f (Compose x) = Compose (fmap (fmap f) x)

instance (Applicative f, Applicative g) => Applicative (Compose f g) where
pure x = Compose (pure (pure x))
Compose f <*> Compose x = Compose ((<*>) <$> f <*> x) (The naturality law is implied by parametricity.) Instances are similar to Functor, e.g. given a data type data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a) a suitable instance would be instance Traversable Tree where traverse f Empty = pure Empty traverse f (Leaf x) = Leaf <$> f x
traverse f (Node l k r) = Node <$> traverse f l <*> f k <*> traverse f r This is suitable even for abstract types, as the laws for <*> imply a form of associativity. The superclass instances should satisfy the following: • In the Functor instance, fmap should be equivalent to traversal with the identity applicative functor (fmapDefault). • In the Foldable instance, foldMap should be equivalent to traversal with a constant applicative functor (foldMapDefault). Minimal complete definition Methods traverse :: Applicative f => (a -> f b) -> t a -> f (t b) # Map each element of a structure to an action, evaluate these actions from left to right, and collect the results. For a version that ignores the results see traverse_. sequenceA :: Applicative f => t (f a) -> f (t a) # Evaluate each action in the structure from left to right, and collect the results. For a version that ignores the results see sequenceA_. mapM :: Monad m => (a -> m b) -> t a -> m (t b) # Map each element of a structure to a monadic action, evaluate these actions from left to right, and collect the results. For a version that ignores the results see mapM_. sequence :: Monad m => t (m a) -> m (t a) # Evaluate each monadic action in the structure from left to right, and collect the results. For a version that ignores the results see sequence_. Instances  Since: base-2.1 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f => (a -> f b) -> [a] -> f [b] #sequenceA :: Applicative f => [f a] -> f [a] #mapM :: Monad m => (a -> m b) -> [a] -> m [b] #sequence :: Monad m => [m a] -> m [a] # Since: base-2.1 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f => (a -> f b) -> Maybe a -> f (Maybe b) #sequenceA :: Applicative f => Maybe (f a) -> f (Maybe a) #mapM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b) #sequence :: Monad m => Maybe (m a) -> m (Maybe a) # Since: base-4.9.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f => (a -> f b) -> Par1 a -> f (Par1 b) #sequenceA :: Applicative f => Par1 (f a) -> f (Par1 a) #mapM :: Monad m => (a -> m b) -> Par1 a -> m (Par1 b) #sequence :: Monad m => Par1 (m a) -> m (Par1 a) # Since: base-4.9.0.0 Instance detailsDefined in Data.Complex Methodstraverse :: Applicative f => (a -> f b) -> Complex a -> f (Complex b) #sequenceA :: Applicative f => Complex (f a) -> f (Complex a) #mapM :: Monad m => (a -> m b) -> Complex a -> m (Complex b) #sequence :: Monad m => Complex (m a) -> m (Complex a) # Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodstraverse :: Applicative f => (a -> f b) -> Min a -> f (Min b) #sequenceA :: Applicative f => Min (f a) -> f (Min a) #mapM :: Monad m => (a -> m b) -> Min a -> m (Min b) #sequence :: Monad m => Min (m a) -> m (Min a) # Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodstraverse :: Applicative f => (a -> f b) -> Max a -> f (Max b) #sequenceA :: Applicative f => Max (f a) -> f (Max a) #mapM :: Monad m => (a -> m b) -> Max a -> m (Max b) #sequence :: Monad m => Max (m a) -> m (Max a) # Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodstraverse :: Applicative f => (a -> f b) -> First a -> f (First b) #sequenceA :: Applicative f => First (f a) -> f (First a) #mapM :: Monad m => (a -> m b) -> First a -> m (First b) #sequence :: Monad m => First (m a) -> m (First a) # Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodstraverse :: Applicative f => (a -> f b) -> Last a -> f (Last b) #sequenceA :: Applicative f => Last (f a) -> f (Last a) #mapM :: Monad m => (a -> m b) -> Last a -> m (Last b) #sequence :: Monad m => Last (m a) -> m (Last a) # Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodstraverse :: Applicative f => (a -> f b) -> Option a -> f (Option b) #sequenceA :: Applicative f => Option (f a) -> f (Option a) #mapM :: Monad m => (a -> m b) -> Option a -> m (Option b) #sequence :: Monad m => Option (m a) -> m (Option a) # Since: base-4.9.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f => (a -> f b) -> ZipList a -> f (ZipList b) #sequenceA :: Applicative f => ZipList (f a) -> f (ZipList a) #mapM :: Monad m => (a -> m b) -> ZipList a -> m (ZipList b) #sequence :: Monad m => ZipList (m a) -> m (ZipList a) # Since: base-4.9.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f => (a -> f b) -> Identity a -> f (Identity b) #sequenceA :: Applicative f => Identity (f a) -> f (Identity a) #mapM :: Monad m => (a -> m b) -> Identity a -> m (Identity b) #sequence :: Monad m => Identity (m a) -> m (Identity a) # Since: base-4.8.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f => (a -> f b) -> First a -> f (First b) #sequenceA :: Applicative f => First (f a) -> f (First a) #mapM :: Monad m => (a -> m b) -> First a -> m (First b) #sequence :: Monad m => First (m a) -> m (First a) # Since: base-4.8.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f => (a -> f b) -> Last a -> f (Last b) #sequenceA :: Applicative f => Last (f a) -> f (Last a) #mapM :: Monad m => (a -> m b) -> Last a -> m (Last b) #sequence :: Monad m => Last (m a) -> m (Last a) # Since: base-4.8.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f => (a -> f b) -> Dual a -> f (Dual b) #sequenceA :: Applicative f => Dual (f a) -> f (Dual a) #mapM :: Monad m => (a -> m b) -> Dual a -> m (Dual b) #sequence :: Monad m => Dual (m a) -> m (Dual a) # Since: base-4.8.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f => (a -> f b) -> Sum a -> f (Sum b) #sequenceA :: Applicative f => Sum (f a) -> f (Sum a) #mapM :: Monad m => (a -> m b) -> Sum a -> m (Sum b) #sequence :: Monad m => Sum (m a) -> m (Sum a) # Since: base-4.8.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f => (a -> f b) -> Product a -> f (Product b) #sequenceA :: Applicative f => Product (f a) -> f (Product a) #mapM :: Monad m => (a -> m b) -> Product a -> m (Product b) #sequence :: Monad m => Product (m a) -> m (Product a) # Since: base-4.12.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f => (a -> f b) -> Down a -> f (Down b) #sequenceA :: Applicative f => Down (f a) -> f (Down a) #mapM :: Monad m => (a -> m b) -> Down a -> m (Down b) #sequence :: Monad m => Down (m a) -> m (Down a) # Since: base-4.9.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f => (a -> f b) -> NonEmpty a -> f (NonEmpty b) #sequenceA :: Applicative f => NonEmpty (f a) -> f (NonEmpty a) #mapM :: Monad m => (a -> m b) -> NonEmpty a -> m (NonEmpty b) #sequence :: Monad m => NonEmpty (m a) -> m (NonEmpty a) # Instance detailsDefined in Data.IntMap.Internal Methodstraverse :: Applicative f => (a -> f b) -> IntMap a -> f (IntMap b) #sequenceA :: Applicative f => IntMap (f a) -> f (IntMap a) #mapM :: Monad m => (a -> m b) -> IntMap a -> m (IntMap b) #sequence :: Monad m => IntMap (m a) -> m (IntMap a) # Instance detailsDefined in Data.Tree Methodstraverse :: Applicative f => (a -> f b) -> Tree a -> f (Tree b) #sequenceA :: Applicative f => Tree (f a) -> f (Tree a) #mapM :: Monad m => (a -> m b) -> Tree a -> m (Tree b) #sequence :: Monad m => Tree (m a) -> m (Tree a) # Instance detailsDefined in Data.Sequence.Internal Methodstraverse :: Applicative f => (a -> f b) -> Seq a -> f (Seq b) #sequenceA :: Applicative f => Seq (f a) -> f (Seq a) #mapM :: Monad m => (a -> m b) -> Seq a -> m (Seq b) #sequence :: Monad m => Seq (m a) -> m (Seq a) # Instance detailsDefined in Data.Sequence.Internal Methodstraverse :: Applicative f => (a -> f b) -> FingerTree a -> f (FingerTree b) #sequenceA :: Applicative f => FingerTree (f a) -> f (FingerTree a) #mapM :: Monad m => (a -> m b) -> FingerTree a -> m (FingerTree b) #sequence :: Monad m => FingerTree (m a) -> m (FingerTree a) # Instance detailsDefined in Data.Sequence.Internal Methodstraverse :: Applicative f => (a -> f b) -> Digit a -> f (Digit b) #sequenceA :: Applicative f => Digit (f a) -> f (Digit a) #mapM :: Monad m => (a -> m b) -> Digit a -> m (Digit b) #sequence :: Monad m => Digit (m a) -> m (Digit a) # Instance detailsDefined in Data.Sequence.Internal Methodstraverse :: Applicative f => (a -> f b) -> Node a -> f (Node b) #sequenceA :: Applicative f => Node (f a) -> f (Node a) #mapM :: Monad m => (a -> m b) -> Node a -> m (Node b) #sequence :: Monad m => Node (m a) -> m (Node a) # Instance detailsDefined in Data.Sequence.Internal Methodstraverse :: Applicative f => (a -> f b) -> Elem a -> f (Elem b) #sequenceA :: Applicative f => Elem (f a) -> f (Elem a) #mapM :: Monad m => (a -> m b) -> Elem a -> m (Elem b) #sequence :: Monad m => Elem (m a) -> m (Elem a) # Instance detailsDefined in Data.Sequence.Internal Methodstraverse :: Applicative f => (a -> f b) -> ViewL a -> f (ViewL b) #sequenceA :: Applicative f => ViewL (f a) -> f (ViewL a) #mapM :: Monad m => (a -> m b) -> ViewL a -> m (ViewL b) #sequence :: Monad m => ViewL (m a) -> m (ViewL a) # Instance detailsDefined in Data.Sequence.Internal Methodstraverse :: Applicative f => (a -> f b) -> ViewR a -> f (ViewR b) #sequenceA :: Applicative f => ViewR (f a) -> f (ViewR a) #mapM :: Monad m => (a -> m b) -> ViewR a -> m (ViewR b) #sequence :: Monad m => ViewR (m a) -> m (ViewR a) # Since: base-4.7.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f => (a0 -> f b) -> Either a a0 -> f (Either a b) #sequenceA :: Applicative f => Either a (f a0) -> f (Either a a0) #mapM :: Monad m => (a0 -> m b) -> Either a a0 -> m (Either a b) #sequence :: Monad m => Either a (m a0) -> m (Either a a0) # Traversable (V1 :: Type -> Type) Since: base-4.9.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f => (a -> f b) -> V1 a -> f (V1 b) #sequenceA :: Applicative f => V1 (f a) -> f (V1 a) #mapM :: Monad m => (a -> m b) -> V1 a -> m (V1 b) #sequence :: Monad m => V1 (m a) -> m (V1 a) # Traversable (U1 :: Type -> Type) Since: base-4.9.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f => (a -> f b) -> U1 a -> f (U1 b) #sequenceA :: Applicative f => U1 (f a) -> f (U1 a) #mapM :: Monad m => (a -> m b) -> U1 a -> m (U1 b) #sequence :: Monad m => U1 (m a) -> m (U1 a) # Since: base-4.7.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f => (a0 -> f b) -> (a, a0) -> f (a, b) #sequenceA :: Applicative f => (a, f a0) -> f (a, a0) #mapM :: Monad m => (a0 -> m b) -> (a, a0) -> m (a, b) #sequence :: Monad m => (a, m a0) -> m (a, a0) # Ix i => Traversable (Array i) Since: base-2.1 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f => (a -> f b) -> Array i a -> f (Array i b) #sequenceA :: Applicative f => Array i (f a) -> f (Array i a) #mapM :: Monad m => (a -> m b) -> Array i a -> m (Array i b) #sequence :: Monad m => Array i (m a) -> m (Array i a) # Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodstraverse :: Applicative f => (a0 -> f b) -> Arg a a0 -> f (Arg a b) #sequenceA :: Applicative f => Arg a (f a0) -> f (Arg a a0) #mapM :: Monad m => (a0 -> m b) -> Arg a a0 -> m (Arg a b) #sequence :: Monad m => Arg a (m a0) -> m (Arg a a0) # Traversable (Proxy :: Type -> Type) Since: base-4.7.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f => (a -> f b) -> Proxy a -> f (Proxy b) #sequenceA :: Applicative f => Proxy (f a) -> f (Proxy a) #mapM :: Monad m => (a -> m b) -> Proxy a -> m (Proxy b) #sequence :: Monad m => Proxy (m a) -> m (Proxy a) # Instance detailsDefined in Data.Map.Internal Methodstraverse :: Applicative f => (a -> f b) -> Map k a -> f (Map k b) #sequenceA :: Applicative f => Map k (f a) -> f (Map k a) #mapM :: Monad m => (a -> m b) -> Map k a -> m (Map k b) #sequence :: Monad m => Map k (m a) -> m (Map k a) # Traversable f => Traversable (MaybeT f) Instance detailsDefined in Control.Monad.Trans.Maybe Methodstraverse :: Applicative f0 => (a -> f0 b) -> MaybeT f a -> f0 (MaybeT f b) #sequenceA :: Applicative f0 => MaybeT f (f0 a) -> f0 (MaybeT f a) #mapM :: Monad m => (a -> m b) -> MaybeT f a -> m (MaybeT f b) #sequence :: Monad m => MaybeT f (m a) -> m (MaybeT f a) # Instance detailsDefined in Data.HashMap.Base Methodstraverse :: Applicative f => (a -> f b) -> HashMap k a -> f (HashMap k b) #sequenceA :: Applicative f => HashMap k (f a) -> f (HashMap k a) #mapM :: Monad m => (a -> m b) -> HashMap k a -> m (HashMap k b) #sequence :: Monad m => HashMap k (m a) -> m (HashMap k a) # Source # Instance detailsDefined in Relude.Extra.Validation Methodstraverse :: Applicative f => (a -> f b) -> Validation e a -> f (Validation e b) #sequenceA :: Applicative f => Validation e (f a) -> f (Validation e a) #mapM :: Monad m => (a -> m b) -> Validation e a -> m (Validation e b) #sequence :: Monad m => Validation e (m a) -> m (Validation e a) # Traversable f => Traversable (Rec1 f) Since: base-4.9.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f0 => (a -> f0 b) -> Rec1 f a -> f0 (Rec1 f b) #sequenceA :: Applicative f0 => Rec1 f (f0 a) -> f0 (Rec1 f a) #mapM :: Monad m => (a -> m b) -> Rec1 f a -> m (Rec1 f b) #sequence :: Monad m => Rec1 f (m a) -> m (Rec1 f a) # Since: base-4.9.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f => (a -> f b) -> URec Char a -> f (URec Char b) #sequenceA :: Applicative f => URec Char (f a) -> f (URec Char a) #mapM :: Monad m => (a -> m b) -> URec Char a -> m (URec Char b) #sequence :: Monad m => URec Char (m a) -> m (URec Char a) # Since: base-4.9.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f => (a -> f b) -> URec Double a -> f (URec Double b) #sequenceA :: Applicative f => URec Double (f a) -> f (URec Double a) #mapM :: Monad m => (a -> m b) -> URec Double a -> m (URec Double b) #sequence :: Monad m => URec Double (m a) -> m (URec Double a) # Since: base-4.9.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f => (a -> f b) -> URec Float a -> f (URec Float b) #sequenceA :: Applicative f => URec Float (f a) -> f (URec Float a) #mapM :: Monad m => (a -> m b) -> URec Float a -> m (URec Float b) #sequence :: Monad m => URec Float (m a) -> m (URec Float a) # Since: base-4.9.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f => (a -> f b) -> URec Int a -> f (URec Int b) #sequenceA :: Applicative f => URec Int (f a) -> f (URec Int a) #mapM :: Monad m => (a -> m b) -> URec Int a -> m (URec Int b) #sequence :: Monad m => URec Int (m a) -> m (URec Int a) # Since: base-4.9.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f => (a -> f b) -> URec Word a -> f (URec Word b) #sequenceA :: Applicative f => URec Word (f a) -> f (URec Word a) #mapM :: Monad m => (a -> m b) -> URec Word a -> m (URec Word b) #sequence :: Monad m => URec Word (m a) -> m (URec Word a) # Traversable (URec (Ptr ()) :: Type -> Type) Since: base-4.9.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f => (a -> f b) -> URec (Ptr ()) a -> f (URec (Ptr ()) b) #sequenceA :: Applicative f => URec (Ptr ()) (f a) -> f (URec (Ptr ()) a) #mapM :: Monad m => (a -> m b) -> URec (Ptr ()) a -> m (URec (Ptr ()) b) #sequence :: Monad m => URec (Ptr ()) (m a) -> m (URec (Ptr ()) a) # Traversable (Const m :: Type -> Type) Since: base-4.7.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f => (a -> f b) -> Const m a -> f (Const m b) #sequenceA :: Applicative f => Const m (f a) -> f (Const m a) #mapM :: Monad m0 => (a -> m0 b) -> Const m a -> m0 (Const m b) #sequence :: Monad m0 => Const m (m0 a) -> m0 (Const m a) # Traversable f => Traversable (Ap f) Since: base-4.12.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f0 => (a -> f0 b) -> Ap f a -> f0 (Ap f b) #sequenceA :: Applicative f0 => Ap f (f0 a) -> f0 (Ap f a) #mapM :: Monad m => (a -> m b) -> Ap f a -> m (Ap f b) #sequence :: Monad m => Ap f (m a) -> m (Ap f a) # Traversable f => Traversable (Alt f) Since: base-4.12.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f0 => (a -> f0 b) -> Alt f a -> f0 (Alt f b) #sequenceA :: Applicative f0 => Alt f (f0 a) -> f0 (Alt f a) #mapM :: Monad m => (a -> m b) -> Alt f a -> m (Alt f b) #sequence :: Monad m => Alt f (m a) -> m (Alt f a) # Instance detailsDefined in Control.Monad.Trans.Identity Methodstraverse :: Applicative f0 => (a -> f0 b) -> IdentityT f a -> f0 (IdentityT f b) #sequenceA :: Applicative f0 => IdentityT f (f0 a) -> f0 (IdentityT f a) #mapM :: Monad m => (a -> m b) -> IdentityT f a -> m (IdentityT f b) #sequence :: Monad m => IdentityT f (m a) -> m (IdentityT f a) # Traversable f => Traversable (ErrorT e f) Instance detailsDefined in Control.Monad.Trans.Error Methodstraverse :: Applicative f0 => (a -> f0 b) -> ErrorT e f a -> f0 (ErrorT e f b) #sequenceA :: Applicative f0 => ErrorT e f (f0 a) -> f0 (ErrorT e f a) #mapM :: Monad m => (a -> m b) -> ErrorT e f a -> m (ErrorT e f b) #sequence :: Monad m => ErrorT e f (m a) -> m (ErrorT e f a) # Traversable f => Traversable (ExceptT e f) Instance detailsDefined in Control.Monad.Trans.Except Methodstraverse :: Applicative f0 => (a -> f0 b) -> ExceptT e f a -> f0 (ExceptT e f b) #sequenceA :: Applicative f0 => ExceptT e f (f0 a) -> f0 (ExceptT e f a) #mapM :: Monad m => (a -> m b) -> ExceptT e f a -> m (ExceptT e f b) #sequence :: Monad m => ExceptT e f (m a) -> m (ExceptT e f a) # Traversable (K1 i c :: Type -> Type) Since: base-4.9.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f => (a -> f b) -> K1 i c a -> f (K1 i c b) #sequenceA :: Applicative f => K1 i c (f a) -> f (K1 i c a) #mapM :: Monad m => (a -> m b) -> K1 i c a -> m (K1 i c b) #sequence :: Monad m => K1 i c (m a) -> m (K1 i c a) # (Traversable f, Traversable g) => Traversable (f :+: g) Since: base-4.9.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f0 => (a -> f0 b) -> (f :+: g) a -> f0 ((f :+: g) b) #sequenceA :: Applicative f0 => (f :+: g) (f0 a) -> f0 ((f :+: g) a) #mapM :: Monad m => (a -> m b) -> (f :+: g) a -> m ((f :+: g) b) #sequence :: Monad m => (f :+: g) (m a) -> m ((f :+: g) a) # (Traversable f, Traversable g) => Traversable (f :*: g) Since: base-4.9.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f0 => (a -> f0 b) -> (f :*: g) a -> f0 ((f :*: g) b) #sequenceA :: Applicative f0 => (f :*: g) (f0 a) -> f0 ((f :*: g) a) #mapM :: Monad m => (a -> m b) -> (f :*: g) a -> m ((f :*: g) b) #sequence :: Monad m => (f :*: g) (m a) -> m ((f :*: g) a) # (Traversable f, Traversable g) => Traversable (Product f g) Since: base-4.9.0.0 Instance detailsDefined in Data.Functor.Product Methodstraverse :: Applicative f0 => (a -> f0 b) -> Product f g a -> f0 (Product f g b) #sequenceA :: Applicative f0 => Product f g (f0 a) -> f0 (Product f g a) #mapM :: Monad m => (a -> m b) -> Product f g a -> m (Product f g b) #sequence :: Monad m => Product f g (m a) -> m (Product f g a) # (Traversable f, Traversable g) => Traversable (Sum f g) Since: base-4.9.0.0 Instance detailsDefined in Data.Functor.Sum Methodstraverse :: Applicative f0 => (a -> f0 b) -> Sum f g a -> f0 (Sum f g b) #sequenceA :: Applicative f0 => Sum f g (f0 a) -> f0 (Sum f g a) #mapM :: Monad m => (a -> m b) -> Sum f g a -> m (Sum f g b) #sequence :: Monad m => Sum f g (m a) -> m (Sum f g a) # Traversable f => Traversable (M1 i c f) Since: base-4.9.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f0 => (a -> f0 b) -> M1 i c f a -> f0 (M1 i c f b) #sequenceA :: Applicative f0 => M1 i c f (f0 a) -> f0 (M1 i c f a) #mapM :: Monad m => (a -> m b) -> M1 i c f a -> m (M1 i c f b) #sequence :: Monad m => M1 i c f (m a) -> m (M1 i c f a) # (Traversable f, Traversable g) => Traversable (f :.: g) Since: base-4.9.0.0 Instance detailsDefined in Data.Traversable Methodstraverse :: Applicative f0 => (a -> f0 b) -> (f :.: g) a -> f0 ((f :.: g) b) #sequenceA :: Applicative f0 => (f :.: g) (f0 a) -> f0 ((f :.: g) a) #mapM :: Monad m => (a -> m b) -> (f :.: g) a -> m ((f :.: g) b) #sequence :: Monad m => (f :.: g) (m a) -> m ((f :.: g) a) # (Traversable f, Traversable g) => Traversable (Compose f g) Since: base-4.9.0.0 Instance detailsDefined in Data.Functor.Compose Methodstraverse :: Applicative f0 => (a -> f0 b) -> Compose f g a -> f0 (Compose f g b) #sequenceA :: Applicative f0 => Compose f g (f0 a) -> f0 (Compose f g a) #mapM :: Monad m => (a -> m b) -> Compose f g a -> m (Compose f g b) #sequence :: Monad m => Compose f g (m a) -> m (Compose f g a) # mapAccumR :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c) # The mapAccumR function behaves like a combination of fmap and foldr; it applies a function to each element of a structure, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new structure. mapAccumL :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c) # The mapAccumL function behaves like a combination of fmap and foldl; it applies a function to each element of a structure, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new structure. forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b) # forM is mapM with its arguments flipped. For a version that ignores the results see forM_. bifind :: Bifoldable t => (a -> Bool) -> t a a -> Maybe a # The bifind function takes a predicate and a structure and returns the leftmost element of the structure matching the predicate, or Nothing if there is no such element. Since: base-4.10.0.0 biall :: Bifoldable t => (a -> Bool) -> (b -> Bool) -> t a b -> Bool # Determines whether all elements of the structure satisfy their appropriate predicate argument. Since: base-4.10.0.0 biany :: Bifoldable t => (a -> Bool) -> (b -> Bool) -> t a b -> Bool # Determines whether any element of the structure satisfies its appropriate predicate argument. Since: base-4.10.0.0 bior :: Bifoldable t => t Bool Bool -> Bool # bior returns the disjunction of a container of Bools. For the result to be False, the container must be finite; True, however, results from a True value finitely far from the left end. Since: base-4.10.0.0 biand :: Bifoldable t => t Bool Bool -> Bool # biand returns the conjunction of a container of Bools. For the result to be True, the container must be finite; False, however, results from a False value finitely far from the left end. Since: base-4.10.0.0 bielem :: (Bifoldable t, Eq a) => a -> t a a -> Bool # Does the element occur in the structure? Since: base-4.10.0.0 bilength :: Bifoldable t => t a b -> Int # Returns the size/length of a finite structure as an Int. Since: base-4.10.0.0 binull :: Bifoldable t => t a b -> Bool # Test whether the structure is empty. Since: base-4.10.0.0 biList :: Bifoldable t => t a a -> [a] # Collects the list of elements of a structure, from left to right. Since: base-4.10.0.0 biasum :: (Bifoldable t, Alternative f) => t (f a) (f a) -> f a # The sum of a collection of actions, generalizing biconcat. Since: base-4.10.0.0 bisequence_ :: (Bifoldable t, Applicative f) => t (f a) (f b) -> f () # Evaluate each action in the structure from left to right, and ignore the results. For a version that doesn't ignore the results, see bisequence. Since: base-4.10.0.0 bifor_ :: (Bifoldable t, Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f () # As bitraverse_, but with the structure as the primary argument. For a version that doesn't ignore the results, see bifor. >>> > bifor_ ('a', "bc") print (print . reverse) 'a' "cb"  Since: base-4.10.0.0 bitraverse_ :: (Bifoldable t, Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f () # Map each element of a structure using one of two actions, evaluate these actions from left to right, and ignore the results. For a version that doesn't ignore the results, see bitraverse. Since: base-4.10.0.0 bifoldlM :: (Bifoldable t, Monad m) => (a -> b -> m a) -> (a -> c -> m a) -> a -> t b c -> m a # Left associative monadic bifold over a structure. Since: base-4.10.0.0 bifoldl' :: Bifoldable t => (a -> b -> a) -> (a -> c -> a) -> a -> t b c -> a # As bifoldl, but strict in the result of the reduction functions at each step. This ensures that each step of the bifold 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 structure to a single, monolithic result (e.g., bilength). Since: base-4.10.0.0 bifoldrM :: (Bifoldable t, Monad m) => (a -> c -> m c) -> (b -> c -> m c) -> c -> t a b -> m c # Right associative monadic bifold over a structure. Since: base-4.10.0.0 bifoldr' :: Bifoldable t => (a -> c -> c) -> (b -> c -> c) -> c -> t a b -> c # As bifoldr, but strict in the result of the reduction functions at each step. Since: base-4.10.0.0 class Bifoldable (p :: Type -> Type -> Type) where # Bifoldable identifies foldable structures with two different varieties of elements (as opposed to Foldable, which has one variety of element). Common examples are Either and '(,)': instance Bifoldable Either where bifoldMap f _ (Left a) = f a bifoldMap _ g (Right b) = g b instance Bifoldable (,) where bifoldr f g z (a, b) = f a (g b z) A minimal Bifoldable definition consists of either bifoldMap or bifoldr. When defining more than this minimal set, one should ensure that the following identities hold: bifold ≡ bifoldMap id id bifoldMap f g ≡ bifoldr (mappend . f) (mappend . g) mempty bifoldr f g z t ≡ appEndo (bifoldMap (Endo . f) (Endo . g) t) z  If the type is also a Bifunctor instance, it should satisfy: 'bifoldMap' f g ≡ 'bifold' . 'bimap' f g which implies that 'bifoldMap' f g . 'bimap' h i ≡ 'bifoldMap' (f . h) (g . i) Since: base-4.10.0.0 Minimal complete definition Methods bifold :: Monoid m => p m m -> m # Combines the elements of a structure using a monoid. bifold ≡ bifoldMap id id Since: base-4.10.0.0 bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> p a b -> m # Combines the elements of a structure, given ways of mapping them to a common monoid. bifoldMap f g ≡ bifoldr (mappend . f) (mappend . g) mempty Since: base-4.10.0.0 bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c # Combines the elements of a structure in a right associative manner. Given a hypothetical function toEitherList :: p a b -> [Either a b] yielding a list of all elements of a structure in order, the following would hold: bifoldr f g z ≡ foldr (either f g) z . toEitherList Since: base-4.10.0.0 bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> p a b -> c # Combines the elements of a structure in a left associative manner. Given a hypothetical function toEitherList :: p a b -> [Either a b] yielding a list of all elements of a structure in order, the following would hold: bifoldl f g z ≡ foldl (acc -> either (f acc) (g acc)) z . toEitherList Note that if you want an efficient left-fold, you probably want to use bifoldl' instead of bifoldl. The reason is that the latter does not force the "inner" results, resulting in a thunk chain which then must be evaluated from the outside-in. Since: base-4.10.0.0 Instances  Since: base-4.10.0.0 Instance detailsDefined in Data.Bifoldable Methodsbifold :: Monoid m => Either m m -> m #bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Either a b -> m #bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Either a b -> c #bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Either a b -> c # Since: base-4.10.0.0 Instance detailsDefined in Data.Bifoldable Methodsbifold :: Monoid m => (m, m) -> m #bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> (a, b) -> m #bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> (a, b) -> c #bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> (a, b) -> c # Since: base-4.10.0.0 Instance detailsDefined in Data.Semigroup Methodsbifold :: Monoid m => Arg m m -> m #bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Arg a b -> m #bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Arg a b -> c #bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Arg a b -> c # Source # Instance detailsDefined in Relude.Extra.Validation Methodsbifold :: Monoid m => Validation m m -> m #bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Validation a b -> m #bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Validation a b -> c #bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Validation a b -> c # Since: base-4.10.0.0 Instance detailsDefined in Data.Bifoldable Methodsbifold :: Monoid m => (x, m, m) -> m #bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> (x, a, b) -> m #bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> (x, a, b) -> c #bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> (x, a, b) -> c # Bifoldable (Const :: Type -> Type -> Type) Since: base-4.10.0.0 Instance detailsDefined in Data.Bifoldable Methodsbifold :: Monoid m => Const m m -> m #bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Const a b -> m #bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Const a b -> c #bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Const a b -> c # Bifoldable (K1 i :: Type -> Type -> Type) Since: base-4.10.0.0 Instance detailsDefined in Data.Bifoldable Methodsbifold :: Monoid m => K1 i m m -> m #bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> K1 i a b -> m #bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> K1 i a b -> c #bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> K1 i a b -> c # Bifoldable ((,,,) x y) Since: base-4.10.0.0 Instance detailsDefined in Data.Bifoldable Methodsbifold :: Monoid m => (x, y, m, m) -> m #bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> (x, y, a, b) -> m #bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> (x, y, a, b) -> c #bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> (x, y, a, b) -> c # Bifoldable ((,,,,) x y z) Since: base-4.10.0.0 Instance detailsDefined in Data.Bifoldable Methodsbifold :: Monoid m => (x, y, z, m, m) -> m #bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> (x, y, z, a, b) -> m #bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> (x, y, z, a, b) -> c #bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> (x, y, z, a, b) -> c # Bifoldable ((,,,,,) x y z w) Since: base-4.10.0.0 Instance detailsDefined in Data.Bifoldable Methodsbifold :: Monoid m => (x, y, z, w, m, m) -> m #bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> (x, y, z, w, a, b) -> m #bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> (x, y, z, w, a, b) -> c #bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> (x, y, z, w, a, b) -> c # Bifoldable ((,,,,,,) x y z w v) Since: base-4.10.0.0 Instance detailsDefined in Data.Bifoldable Methodsbifold :: Monoid m => (x, y, z, w, v, m, m) -> m #bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> (x, y, z, w, v, a, b) -> m #bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> (x, y, z, w, v, a, b) -> c #bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> (x, y, z, w, v, a, b) -> c # bifoldMapDefault :: (Bitraversable t, Monoid m) => (a -> m) -> (b -> m) -> t a b -> m # A default definition of bifoldMap in terms of the Bitraversable operations. bifoldMapDefault f g ≡ getConst . bitraverse (Const . f) (Const . g) Since: base-4.10.0.0 bimapDefault :: Bitraversable t => (a -> b) -> (c -> d) -> t a c -> t b d # A default definition of bimap in terms of the Bitraversable operations. bimapDefault f g ≡ runIdentity . bitraverse (Identity . f) (Identity . g) Since: base-4.10.0.0 bifor :: (Bitraversable t, Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f (t c d) # bifor is bitraverse with the structure as the first argument. For a version that ignores the results, see bifor_. Since: base-4.10.0.0 bisequence :: (Bitraversable t, Applicative f) => t (f a) (f b) -> f (t a b) # Sequences all the actions in a structure, building a new structure with the same shape using the results of the actions. For a version that ignores the results, see bisequence_. bisequence ≡ bitraverse id id Since: base-4.10.0.0 class (Bifunctor t, Bifoldable t) => Bitraversable (t :: Type -> Type -> Type) where # Bitraversable identifies bifunctorial data structures whose elements can be traversed in order, performing Applicative or Monad actions at each element, and collecting a result structure with the same shape. As opposed to Traversable data structures, which have one variety of element on which an action can be performed, Bitraversable data structures have two such varieties of elements. A definition of bitraverse must satisfy the following laws: naturality bitraverse (t . f) (t . g) ≡ t . bitraverse f g for every applicative transformation t identity bitraverse Identity Identity ≡ Identity composition Compose . fmap (bitraverse g1 g2) . bitraverse f1 f2 ≡ traverse (Compose . fmap g1 . f1) (Compose . fmap g2 . f2) where an applicative transformation is a function t :: (Applicative f, Applicative g) => f a -> g a preserving the Applicative operations: t (pure x) = pure x t (f <*> x) = t f <*> t x  and the identity functor Identity and composition functors Compose are defined as newtype Identity a = Identity { runIdentity :: a } instance Functor Identity where fmap f (Identity x) = Identity (f x) instance Applicative Identity where pure = Identity Identity f <*> Identity x = Identity (f x) newtype Compose f g a = Compose (f (g a)) instance (Functor f, Functor g) => Functor (Compose f g) where fmap f (Compose x) = Compose (fmap (fmap f) x) instance (Applicative f, Applicative g) => Applicative (Compose f g) where pure = Compose . pure . pure Compose f <*> Compose x = Compose ((<*>) <$> f <*> x)

Some simple examples are Either and '(,)':

instance Bitraversable Either where
bitraverse f _ (Left x) = Left <$> f x bitraverse _ g (Right y) = Right <$> g y

instance Bitraversable (,) where
bitraverse f g (x, y) = (,) <\$> f x <*> g y

Bitraversable relates to its superclasses in the following ways:

bimap f g ≡ runIdentity . bitraverse (Identity . f) (Identity . g)
bifoldMap f g = getConst . bitraverse (Const . f) (Const . g)


These are available as bimapDefault and bifoldMapDefault respectively.

Since: base-4.10.0.0

Minimal complete definition

Nothing

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> t a b -> f (t c d) #

Evaluates the relevant functions at each element in the structure, running the action, and builds a new structure with the same shape, using the results produced from sequencing the actions.

bitraverse f g ≡ bisequenceA . bimap f g

For a version that ignores the results, see bitraverse_.

Since: base-4.10.0.0

Instances
 Since: base-4.10.0.0 Instance detailsDefined in Data.Bitraversable Methodsbitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Either a b -> f (Either c d) # Since: base-4.10.0.0 Instance detailsDefined in Data.Bitraversable Methodsbitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> (a, b) -> f (c, d) # Since: base-4.10.0.0 Instance detailsDefined in Data.Semigroup Methodsbitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Arg a b -> f (Arg c d) # Source # Instance detailsDefined in Relude.Extra.Validation Methodsbitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Validation a b -> f (Validation c d) # Since: base-4.10.0.0 Instance detailsDefined in Data.Bitraversable Methodsbitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> (x, a, b) -> f (x, c, d) # Bitraversable (Const :: Type -> Type -> Type) Since: base-4.10.0.0 Instance detailsDefined in Data.Bitraversable Methodsbitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Const a b -> f (Const c d) # Bitraversable (K1 i :: Type -> Type -> Type) Since: base-4.10.0.0 Instance detailsDefined in Data.Bitraversable Methodsbitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> K1 i a b -> f (K1 i c d) # Bitraversable ((,,,) x y) Since: base-4.10.0.0 Instance detailsDefined in Data.Bitraversable Methodsbitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> (x, y, a, b) -> f (x, y, c, d) # Bitraversable ((,,,,) x y z) Since: base-4.10.0.0 Instance detailsDefined in Data.Bitraversable Methodsbitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> (x, y, z, a, b) -> f (x, y, z, c, d) # Bitraversable ((,,,,,) x y z w) Since: base-4.10.0.0 Instance detailsDefined in Data.Bitraversable Methodsbitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> (x, y, z, w, a, b) -> f (x, y, z, w, c, d) # Bitraversable ((,,,,,,) x y z w v) Since: base-4.10.0.0 Instance detailsDefined in Data.Bitraversable Methodsbitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> (x, y, z, w, v, a, b) -> f (x, y, z, w, v, c, d) #