Prologue.Data.Foldable

Documentation

type family Foldables (lst :: [Type -> Type]) :: Constraint where ...

Equations

Foldables '[] = ()

Foldables (t ': ts) = (Foldable t, Foldables ts)

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

bisequence_ :: (Bifoldable t, Applicative f) => t (f a) (f b) -> f ()

traverse2_ :: (Applicative m, Foldables '[t1, t2]) => (a -> m b) -> t1 (t2 a) -> m ()

traverse3_ :: (Applicative m, Foldables '[t1, t2, t3]) => (a -> m b) -> t1 (t2 (t3 a)) -> m ()

traverse4_ :: (Applicative m, Foldables '[t1, t2, t3, t4]) => (a -> m b) -> t1 (t2 (t3 (t4 a))) -> m ()

traverse5_ :: (Applicative m, Foldables '[t1, t2, t3, t4, t5]) => (a -> m b) -> t1 (t2 (t3 (t4 (t5 a)))) -> m ()

unsafeMinimum :: Ord a => [a] -> a

unsafeMaximum :: Ord a => [a] -> a

minimum :: MonadPlus m => Ord a => [a] -> m a

maximum :: MonadPlus m => Ord a => [a] -> m a

minimumDef :: Ord a => a -> [a] -> a

maximumDef :: Ord a => a -> [a] -> a

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

bimapM_ :: (Bifoldable t, Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f ()

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

Deprecated: Use for_ instead

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

foldMap | foldr

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

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

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

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

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 that foldl' will diverge if given an infinite list.

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

For a general Foldable structure this should be semantically identical to,

foldl f z = foldl 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

elem :: Eq a => a -> t a -> Bool infix 4

Does the element occur in the structure?

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

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

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

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

Instances

Foldable []

Since: base-2.1

Defined in Data.Foldable

Methods

fold :: Monoid m => [m] -> m

foldMap :: Monoid m => (a -> m) -> [a] -> m

foldr :: (a -> b -> b) -> b -> [a] -> b

foldr' :: (a -> b -> b) -> b -> [a] -> b

foldl :: (b -> a -> b) -> b -> [a] -> b

foldl' :: (b -> a -> b) -> b -> [a] -> b

foldr1 :: (a -> a -> a) -> [a] -> a

foldl1 :: (a -> a -> a) -> [a] -> a

toList :: [a] -> [a]

null :: [a] -> Bool

length :: [a] -> Int

elem :: Eq a => a -> [a] -> Bool

maximum :: Ord a => [a] -> a

minimum :: Ord a => [a] -> a

sum :: Num a => [a] -> a

product :: Num a => [a] -> a

Foldable Maybe

Since: base-2.1

Defined in Data.Foldable

Methods

fold :: Monoid m => Maybe m -> m

foldMap :: Monoid m => (a -> m) -> Maybe a -> m

foldr :: (a -> b -> b) -> b -> Maybe a -> b

foldr' :: (a -> b -> b) -> b -> Maybe a -> b

foldl :: (b -> a -> b) -> b -> Maybe a -> b

foldl' :: (b -> a -> b) -> b -> Maybe a -> b

foldr1 :: (a -> a -> a) -> Maybe a -> a

foldl1 :: (a -> a -> a) -> Maybe a -> a

toList :: Maybe a -> [a]

null :: Maybe a -> Bool

length :: Maybe a -> Int

elem :: Eq a => a -> Maybe a -> Bool

maximum :: Ord a => Maybe a -> a

minimum :: Ord a => Maybe a -> a

sum :: Num a => Maybe a -> a

product :: Num a => Maybe a -> a

Foldable Par1

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => Par1 m -> m

foldMap :: Monoid m => (a -> m) -> Par1 a -> m

foldr :: (a -> b -> b) -> b -> Par1 a -> b

foldr' :: (a -> b -> b) -> b -> Par1 a -> b

foldl :: (b -> a -> b) -> b -> Par1 a -> b

foldl' :: (b -> a -> b) -> b -> Par1 a -> b

foldr1 :: (a -> a -> a) -> Par1 a -> a

foldl1 :: (a -> a -> a) -> Par1 a -> a

toList :: Par1 a -> [a]

null :: Par1 a -> Bool

length :: Par1 a -> Int

elem :: Eq a => a -> Par1 a -> Bool

maximum :: Ord a => Par1 a -> a

minimum :: Ord a => Par1 a -> a

sum :: Num a => Par1 a -> a

product :: Num a => Par1 a -> a

Foldable Complex

Since: base-4.9.0.0

Defined in Data.Complex

Methods

fold :: 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

Foldable Min

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fold :: 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

Foldable Max

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fold :: 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

Foldable First

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fold :: Monoid m => First m -> m

foldMap :: Monoid m => (a -> m) -> First a -> m

foldr :: (a -> b -> b) -> b -> First a -> b

foldr' :: (a -> b -> b) -> b -> First a -> b

foldl :: (b -> a -> b) -> b -> First a -> b

foldl' :: (b -> a -> b) -> b -> First a -> b

foldr1 :: (a -> a -> a) -> First a -> a

foldl1 :: (a -> a -> a) -> First a -> a

toList :: First a -> [a]

null :: First a -> Bool

length :: First a -> Int

elem :: Eq a => a -> First a -> Bool

maximum :: Ord a => First a -> a

minimum :: Ord a => First a -> a

sum :: Num a => First a -> a

product :: Num a => First a -> a

Foldable Last

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fold :: Monoid m => Last m -> m

foldMap :: Monoid m => (a -> m) -> Last a -> m

foldr :: (a -> b -> b) -> b -> Last a -> b

foldr' :: (a -> b -> b) -> b -> Last a -> b

foldl :: (b -> a -> b) -> b -> Last a -> b

foldl' :: (b -> a -> b) -> b -> Last a -> b

foldr1 :: (a -> a -> a) -> Last a -> a

foldl1 :: (a -> a -> a) -> Last a -> a

toList :: Last a -> [a]

null :: Last a -> Bool

length :: Last a -> Int

elem :: Eq a => a -> Last a -> Bool

maximum :: Ord a => Last a -> a

minimum :: Ord a => Last a -> a

sum :: Num a => Last a -> a

product :: Num a => Last a -> a

Foldable Option

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fold :: 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

Foldable ZipList

Since: base-4.9.0.0

Defined in Control.Applicative

Methods

fold :: Monoid m => ZipList m -> m

foldMap :: Monoid m => (a -> m) -> ZipList a -> m

foldr :: (a -> b -> b) -> b -> ZipList a -> b

foldr' :: (a -> b -> b) -> b -> ZipList a -> b

foldl :: (b -> a -> b) -> b -> ZipList a -> b

foldl' :: (b -> a -> b) -> b -> ZipList a -> b

foldr1 :: (a -> a -> a) -> ZipList a -> a

foldl1 :: (a -> a -> a) -> ZipList a -> a

toList :: ZipList a -> [a]

null :: ZipList a -> Bool

length :: ZipList a -> Int

elem :: Eq a => a -> ZipList a -> Bool

maximum :: Ord a => ZipList a -> a

minimum :: Ord a => ZipList a -> a

sum :: Num a => ZipList a -> a

product :: Num a => ZipList a -> a

Foldable Identity

Since: base-4.8.0.0

Defined in Data.Functor.Identity

Methods

fold :: 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

Foldable First

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => First m -> m

foldMap :: Monoid m => (a -> m) -> First a -> m

foldr :: (a -> b -> b) -> b -> First a -> b

foldr' :: (a -> b -> b) -> b -> First a -> b

foldl :: (b -> a -> b) -> b -> First a -> b

foldl' :: (b -> a -> b) -> b -> First a -> b

foldr1 :: (a -> a -> a) -> First a -> a

foldl1 :: (a -> a -> a) -> First a -> a

toList :: First a -> [a]

null :: First a -> Bool

length :: First a -> Int

elem :: Eq a => a -> First a -> Bool

maximum :: Ord a => First a -> a

minimum :: Ord a => First a -> a

sum :: Num a => First a -> a

product :: Num a => First a -> a

Foldable Last

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => Last m -> m

foldMap :: Monoid m => (a -> m) -> Last a -> m

foldr :: (a -> b -> b) -> b -> Last a -> b

foldr' :: (a -> b -> b) -> b -> Last a -> b

foldl :: (b -> a -> b) -> b -> Last a -> b

foldl' :: (b -> a -> b) -> b -> Last a -> b

foldr1 :: (a -> a -> a) -> Last a -> a

foldl1 :: (a -> a -> a) -> Last a -> a

toList :: Last a -> [a]

null :: Last a -> Bool

length :: Last a -> Int

elem :: Eq a => a -> Last a -> Bool

maximum :: Ord a => Last a -> a

minimum :: Ord a => Last a -> a

sum :: Num a => Last a -> a

product :: Num a => Last a -> a

Foldable Dual

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => Dual m -> m

foldMap :: Monoid m => (a -> m) -> Dual a -> m

foldr :: (a -> b -> b) -> b -> Dual a -> b

foldr' :: (a -> b -> b) -> b -> Dual a -> b

foldl :: (b -> a -> b) -> b -> Dual a -> b

foldl' :: (b -> a -> b) -> b -> Dual a -> b

foldr1 :: (a -> a -> a) -> Dual a -> a

foldl1 :: (a -> a -> a) -> Dual a -> a

toList :: Dual a -> [a]

null :: Dual a -> Bool

length :: Dual a -> Int

elem :: Eq a => a -> Dual a -> Bool

maximum :: Ord a => Dual a -> a

minimum :: Ord a => Dual a -> a

sum :: Num a => Dual a -> a

product :: Num a => Dual a -> a

Foldable Sum

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => Sum m -> m

foldMap :: Monoid m => (a -> m) -> Sum a -> m

foldr :: (a -> b -> b) -> b -> Sum a -> b

foldr' :: (a -> b -> b) -> b -> Sum a -> b

foldl :: (b -> a -> b) -> b -> Sum a -> b

foldl' :: (b -> a -> b) -> b -> Sum a -> b

foldr1 :: (a -> a -> a) -> Sum a -> a

foldl1 :: (a -> a -> a) -> Sum a -> a

toList :: Sum a -> [a]

null :: Sum a -> Bool

length :: Sum a -> Int

elem :: Eq a => a -> Sum a -> Bool

maximum :: Ord a => Sum a -> a

minimum :: Ord a => Sum a -> a

sum :: Num a => Sum a -> a

product :: Num a => Sum a -> a

Foldable Product

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => Product m -> m

foldMap :: Monoid m => (a -> m) -> Product a -> m

foldr :: (a -> b -> b) -> b -> Product a -> b

foldr' :: (a -> b -> b) -> b -> Product a -> b

foldl :: (b -> a -> b) -> b -> Product a -> b

foldl' :: (b -> a -> b) -> b -> Product a -> b

foldr1 :: (a -> a -> a) -> Product a -> a

foldl1 :: (a -> a -> a) -> Product a -> a

toList :: Product a -> [a]

null :: Product a -> Bool

length :: Product a -> Int

elem :: Eq a => a -> Product a -> Bool

maximum :: Ord a => Product a -> a

minimum :: Ord a => Product a -> a

sum :: Num a => Product a -> a

product :: Num a => Product a -> a

Foldable Down

Since: base-4.12.0.0

Defined in Data.Foldable

Methods

fold :: 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

Foldable NonEmpty

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: 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

Foldable IntMap

Defined in Data.IntMap.Internal

Methods

fold :: 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

Foldable Tree

Defined in Data.Tree

Methods

fold :: 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

Foldable Seq

Defined in Data.Sequence.Internal

Methods

fold :: 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

Foldable FingerTree

Defined in Data.Sequence.Internal

Methods

fold :: 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

Foldable Digit

Defined in Data.Sequence.Internal

Methods

fold :: 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

Foldable Node

Defined in Data.Sequence.Internal

Methods

fold :: 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

Foldable Elem

Defined in Data.Sequence.Internal

Methods

fold :: 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

Foldable ViewL

Defined in Data.Sequence.Internal

Methods

fold :: 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

Foldable ViewR

Defined in Data.Sequence.Internal

Methods

fold :: 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

Foldable Set

Defined in Data.Set.Internal

Methods

fold :: 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

Foldable DList

Defined in Data.DList

Methods

fold :: Monoid m => DList m -> m

foldMap :: Monoid m => (a -> m) -> DList a -> m

foldr :: (a -> b -> b) -> b -> DList a -> b

foldr' :: (a -> b -> b) -> b -> DList a -> b

foldl :: (b -> a -> b) -> b -> DList a -> b

foldl' :: (b -> a -> b) -> b -> DList a -> b

foldr1 :: (a -> a -> a) -> DList a -> a

foldl1 :: (a -> a -> a) -> DList a -> a

toList :: DList a -> [a]

null :: DList a -> Bool

length :: DList a -> Int

elem :: Eq a => a -> DList a -> Bool

maximum :: Ord a => DList a -> a

minimum :: Ord a => DList a -> a

sum :: Num a => DList a -> a

product :: Num a => DList a -> a

Foldable Hashed

Defined in Data.Hashable.Class

Methods

fold :: 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

Foldable HashSet

Defined in Data.HashSet

Methods

fold :: 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

Foldable Vector

Defined in Data.Vector

Methods

fold :: Monoid m => Vector m -> m

foldMap :: Monoid m => (a -> m) -> Vector a -> m

foldr :: (a -> b -> b) -> b -> Vector a -> b

foldr' :: (a -> b -> b) -> b -> Vector a -> b

foldl :: (b -> a -> b) -> b -> Vector a -> b

foldl' :: (b -> a -> b) -> b -> Vector a -> b

foldr1 :: (a -> a -> a) -> Vector a -> a

foldl1 :: (a -> a -> a) -> Vector a -> a

toList :: Vector a -> [a]

null :: Vector a -> Bool

length :: Vector a -> Int

elem :: Eq a => a -> Vector a -> Bool

maximum :: Ord a => Vector a -> a

minimum :: Ord a => Vector a -> a

sum :: Num a => Vector a -> a

product :: Num a => Vector a -> a

Foldable SmallArray

Defined in Data.Primitive.SmallArray

Methods

fold :: Monoid m => SmallArray m -> m

foldMap :: Monoid m => (a -> m) -> SmallArray a -> m

foldr :: (a -> b -> b) -> b -> SmallArray a -> b

foldr' :: (a -> b -> b) -> b -> SmallArray a -> b

foldl :: (b -> a -> b) -> b -> SmallArray a -> b

foldl' :: (b -> a -> b) -> b -> SmallArray a -> b

foldr1 :: (a -> a -> a) -> SmallArray a -> a

foldl1 :: (a -> a -> a) -> SmallArray a -> a

toList :: SmallArray a -> [a]

null :: SmallArray a -> Bool

length :: SmallArray a -> Int

elem :: Eq a => a -> SmallArray a -> Bool

maximum :: Ord a => SmallArray a -> a

minimum :: Ord a => SmallArray a -> a

sum :: Num a => SmallArray a -> a

product :: Num a => SmallArray a -> a

Foldable Array

Defined in Data.Primitive.Array

Methods

fold :: Monoid m => Array m -> m

foldMap :: Monoid m => (a -> m) -> Array a -> m

foldr :: (a -> b -> b) -> b -> Array a -> b

foldr' :: (a -> b -> b) -> b -> Array a -> b

foldl :: (b -> a -> b) -> b -> Array a -> b

foldl' :: (b -> a -> b) -> b -> Array a -> b

foldr1 :: (a -> a -> a) -> Array a -> a

foldl1 :: (a -> a -> a) -> Array a -> a

toList :: Array a -> [a]

null :: Array a -> Bool

length :: Array a -> Int

elem :: Eq a => a -> Array a -> Bool

maximum :: Ord a => Array a -> a

minimum :: Ord a => Array a -> a

sum :: Num a => Array a -> a

product :: Num a => Array a -> a

Foldable OneTuple

Defined in Prologue.Data.OneTuple

Methods

fold :: Monoid m => OneTuple m -> m

foldMap :: Monoid m => (a -> m) -> OneTuple a -> m

foldr :: (a -> b -> b) -> b -> OneTuple a -> b

foldr' :: (a -> b -> b) -> b -> OneTuple a -> b

foldl :: (b -> a -> b) -> b -> OneTuple a -> b

foldl' :: (b -> a -> b) -> b -> OneTuple a -> b

foldr1 :: (a -> a -> a) -> OneTuple a -> a

foldl1 :: (a -> a -> a) -> OneTuple a -> a

toList :: OneTuple a -> [a]

null :: OneTuple a -> Bool

length :: OneTuple a -> Int

elem :: Eq a => a -> OneTuple a -> Bool

maximum :: Ord a => OneTuple a -> a

minimum :: Ord a => OneTuple a -> a

sum :: Num a => OneTuple a -> a

product :: Num a => OneTuple a -> a

Foldable (Either a)

Since: base-4.7.0.0

Defined in Data.Foldable

Methods

fold :: 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

Defined in Data.Foldable

Methods

fold :: Monoid m => V1 m -> m

foldMap :: Monoid m => (a -> m) -> V1 a -> m

foldr :: (a -> b -> b) -> b -> V1 a -> b

foldr' :: (a -> b -> b) -> b -> V1 a -> b

foldl :: (b -> a -> b) -> b -> V1 a -> b

foldl' :: (b -> a -> b) -> b -> V1 a -> b

foldr1 :: (a -> a -> a) -> V1 a -> a

foldl1 :: (a -> a -> a) -> V1 a -> a

toList :: V1 a -> [a]

null :: V1 a -> Bool

length :: V1 a -> Int

elem :: Eq a => a -> V1 a -> Bool

maximum :: Ord a => V1 a -> a

minimum :: Ord a => V1 a -> a

sum :: Num a => V1 a -> a

product :: Num a => V1 a -> a

Foldable (U1 :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => U1 m -> m

foldMap :: Monoid m => (a -> m) -> U1 a -> m

foldr :: (a -> b -> b) -> b -> U1 a -> b

foldr' :: (a -> b -> b) -> b -> U1 a -> b

foldl :: (b -> a -> b) -> b -> U1 a -> b

foldl' :: (b -> a -> b) -> b -> U1 a -> b

foldr1 :: (a -> a -> a) -> U1 a -> a

foldl1 :: (a -> a -> a) -> U1 a -> a

toList :: U1 a -> [a]

null :: U1 a -> Bool

length :: U1 a -> Int

elem :: Eq a => a -> U1 a -> Bool

maximum :: Ord a => U1 a -> a

minimum :: Ord a => U1 a -> a

sum :: Num a => U1 a -> a

product :: Num a => U1 a -> a

Foldable ((,) a)

Since: base-4.7.0.0

Defined in Data.Foldable

Methods

fold :: 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

Foldable (HashMap k)

Defined in Data.HashMap.Base

Methods

fold :: 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

Foldable (Map k)

Defined in Data.Map.Internal

Methods

fold :: 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 (Array i)

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => Array i m -> m

foldMap :: Monoid m => (a -> m) -> Array i a -> m

foldr :: (a -> b -> b) -> b -> Array i a -> b

foldr' :: (a -> b -> b) -> b -> Array i a -> b

foldl :: (b -> a -> b) -> b -> Array i a -> b

foldl' :: (b -> a -> b) -> b -> Array i a -> b

foldr1 :: (a -> a -> a) -> Array i a -> a

foldl1 :: (a -> a -> a) -> Array i a -> a

toList :: Array i a -> [a]

null :: Array i a -> Bool

length :: Array i a -> Int

elem :: Eq a => a -> Array i a -> Bool

maximum :: Ord a => Array i a -> a

minimum :: Ord a => Array i a -> a

sum :: Num a => Array i a -> a

product :: Num a => Array i a -> a

Foldable (Arg a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fold :: 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

Defined in Data.Foldable

Methods

fold :: Monoid m => Proxy m -> m

foldMap :: Monoid m => (a -> m) -> Proxy a -> m

foldr :: (a -> b -> b) -> b -> Proxy a -> b

foldr' :: (a -> b -> b) -> b -> Proxy a -> b

foldl :: (b -> a -> b) -> b -> Proxy a -> b

foldl' :: (b -> a -> b) -> b -> Proxy a -> b

foldr1 :: (a -> a -> a) -> Proxy a -> a

foldl1 :: (a -> a -> a) -> Proxy a -> a

toList :: Proxy a -> [a]

null :: Proxy a -> Bool

length :: Proxy a -> Int

elem :: Eq a => a -> Proxy a -> Bool

maximum :: Ord a => Proxy a -> a

minimum :: Ord a => Proxy a -> a

sum :: Num a => Proxy a -> a

product :: Num a => Proxy a -> a

Foldable f => Foldable (MaybeT f)

Defined in Control.Monad.Trans.Maybe

Methods

fold :: 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

Foldable f => Foldable (Cofree f)

Defined in Control.Comonad.Cofree

Methods

fold :: Monoid m => Cofree f m -> m

foldMap :: Monoid m => (a -> m) -> Cofree f a -> m

foldr :: (a -> b -> b) -> b -> Cofree f a -> b

foldr' :: (a -> b -> b) -> b -> Cofree f a -> b

foldl :: (b -> a -> b) -> b -> Cofree f a -> b

foldl' :: (b -> a -> b) -> b -> Cofree f a -> b

foldr1 :: (a -> a -> a) -> Cofree f a -> a

foldl1 :: (a -> a -> a) -> Cofree f a -> a

toList :: Cofree f a -> [a]

null :: Cofree f a -> Bool

length :: Cofree f a -> Int

elem :: Eq a => a -> Cofree f a -> Bool

maximum :: Ord a => Cofree f a -> a

minimum :: Ord a => Cofree f a -> a

sum :: Num a => Cofree f a -> a

product :: Num a => Cofree f a -> a

Foldable f => Foldable (Free f)

Defined in Control.Monad.Free

Methods

fold :: Monoid m => Free f m -> m

foldMap :: Monoid m => (a -> m) -> Free f a -> m

foldr :: (a -> b -> b) -> b -> Free f a -> b

foldr' :: (a -> b -> b) -> b -> Free f a -> b

foldl :: (b -> a -> b) -> b -> Free f a -> b

foldl' :: (b -> a -> b) -> b -> Free f a -> b

foldr1 :: (a -> a -> a) -> Free f a -> a

foldl1 :: (a -> a -> a) -> Free f a -> a

toList :: Free f a -> [a]

null :: Free f a -> Bool

length :: Free f a -> Int

elem :: Eq a => a -> Free f a -> Bool

maximum :: Ord a => Free f a -> a

minimum :: Ord a => Free f a -> a

sum :: Num a => Free f a -> a

product :: Num a => Free f a -> a

Foldable (ImpossibleM1 :: Type -> Type)

Defined in Data.Impossible

Methods

fold :: Monoid m => ImpossibleM1 m -> m

foldMap :: Monoid m => (a -> m) -> ImpossibleM1 a -> m

foldr :: (a -> b -> b) -> b -> ImpossibleM1 a -> b

foldr' :: (a -> b -> b) -> b -> ImpossibleM1 a -> b

foldl :: (b -> a -> b) -> b -> ImpossibleM1 a -> b

foldl' :: (b -> a -> b) -> b -> ImpossibleM1 a -> b

foldr1 :: (a -> a -> a) -> ImpossibleM1 a -> a

foldl1 :: (a -> a -> a) -> ImpossibleM1 a -> a

toList :: ImpossibleM1 a -> [a]

null :: ImpossibleM1 a -> Bool

length :: ImpossibleM1 a -> Int

elem :: Eq a => a -> ImpossibleM1 a -> Bool

maximum :: Ord a => ImpossibleM1 a -> a

minimum :: Ord a => ImpossibleM1 a -> a

sum :: Num a => ImpossibleM1 a -> a

product :: Num a => ImpossibleM1 a -> a

Foldable f => Foldable (Yoneda f)

Defined in Data.Functor.Yoneda

Methods

fold :: Monoid m => Yoneda f m -> m

foldMap :: Monoid m => (a -> m) -> Yoneda f a -> m

foldr :: (a -> b -> b) -> b -> Yoneda f a -> b

foldr' :: (a -> b -> b) -> b -> Yoneda f a -> b

foldl :: (b -> a -> b) -> b -> Yoneda f a -> b

foldl' :: (b -> a -> b) -> b -> Yoneda f a -> b

foldr1 :: (a -> a -> a) -> Yoneda f a -> a

foldl1 :: (a -> a -> a) -> Yoneda f a -> a

toList :: Yoneda f a -> [a]

null :: Yoneda f a -> Bool

length :: Yoneda f a -> Int

elem :: Eq a => a -> Yoneda f a -> Bool

maximum :: Ord a => Yoneda f a -> a

minimum :: Ord a => Yoneda f a -> a

sum :: Num a => Yoneda f a -> a

product :: Num a => Yoneda f a -> a

Foldable (Level i)

Defined in Control.Lens.Internal.Level

Methods

fold :: Monoid m => Level i m -> m

foldMap :: Monoid m => (a -> m) -> Level i a -> m

foldr :: (a -> b -> b) -> b -> Level i a -> b

foldr' :: (a -> b -> b) -> b -> Level i a -> b

foldl :: (b -> a -> b) -> b -> Level i a -> b

foldl' :: (b -> a -> b) -> b -> Level i a -> b

foldr1 :: (a -> a -> a) -> Level i a -> a

foldl1 :: (a -> a -> a) -> Level i a -> a

toList :: Level i a -> [a]

null :: Level i a -> Bool

length :: Level i a -> Int

elem :: Eq a => a -> Level i a -> Bool

maximum :: Ord a => Level i a -> a

minimum :: Ord a => Level i a -> a

sum :: Num a => Level i a -> a

product :: Num a => Level i a -> a

Foldable (ListF a)

Defined in Data.Functor.Foldable

Methods

fold :: Monoid m => ListF a m -> m

foldMap :: Monoid m => (a0 -> m) -> ListF a a0 -> m

foldr :: (a0 -> b -> b) -> b -> ListF a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> ListF a a0 -> b

foldl :: (b -> a0 -> b) -> b -> ListF a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> ListF a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> ListF a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> ListF a a0 -> a0

toList :: ListF a a0 -> [a0]

null :: ListF a a0 -> Bool

length :: ListF a a0 -> Int

elem :: Eq a0 => a0 -> ListF a a0 -> Bool

maximum :: Ord a0 => ListF a a0 -> a0

minimum :: Ord a0 => ListF a a0 -> a0

sum :: Num a0 => ListF a a0 -> a0

product :: Num a0 => ListF a a0 -> a0

Foldable (NonEmptyF a)

Defined in Data.Functor.Base

Methods

fold :: Monoid m => NonEmptyF a m -> m

foldMap :: Monoid m => (a0 -> m) -> NonEmptyF a a0 -> m

foldr :: (a0 -> b -> b) -> b -> NonEmptyF a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> NonEmptyF a a0 -> b

foldl :: (b -> a0 -> b) -> b -> NonEmptyF a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> NonEmptyF a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> NonEmptyF a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> NonEmptyF a a0 -> a0

toList :: NonEmptyF a a0 -> [a0]

null :: NonEmptyF a a0 -> Bool

length :: NonEmptyF a a0 -> Int

elem :: Eq a0 => a0 -> NonEmptyF a a0 -> Bool

maximum :: Ord a0 => NonEmptyF a a0 -> a0

minimum :: Ord a0 => NonEmptyF a a0 -> a0

sum :: Num a0 => NonEmptyF a a0 -> a0

product :: Num a0 => NonEmptyF a a0 -> a0

Foldable f => Foldable (Rec1 f)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => Rec1 f m -> m

foldMap :: Monoid m => (a -> m) -> Rec1 f a -> m

foldr :: (a -> b -> b) -> b -> Rec1 f a -> b

foldr' :: (a -> b -> b) -> b -> Rec1 f a -> b

foldl :: (b -> a -> b) -> b -> Rec1 f a -> b

foldl' :: (b -> a -> b) -> b -> Rec1 f a -> b

foldr1 :: (a -> a -> a) -> Rec1 f a -> a

foldl1 :: (a -> a -> a) -> Rec1 f a -> a

toList :: Rec1 f a -> [a]

null :: Rec1 f a -> Bool

length :: Rec1 f a -> Int

elem :: Eq a => a -> Rec1 f a -> Bool

maximum :: Ord a => Rec1 f a -> a

minimum :: Ord a => Rec1 f a -> a

sum :: Num a => Rec1 f a -> a

product :: Num a => Rec1 f a -> a

Foldable (URec Char :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => URec Char m -> m

foldMap :: Monoid m => (a -> m) -> URec Char a -> m

foldr :: (a -> b -> b) -> b -> URec Char a -> b

foldr' :: (a -> b -> b) -> b -> URec Char a -> b

foldl :: (b -> a -> b) -> b -> URec Char a -> b

foldl' :: (b -> a -> b) -> b -> URec Char a -> b

foldr1 :: (a -> a -> a) -> URec Char a -> a

foldl1 :: (a -> a -> a) -> URec Char a -> a

toList :: URec Char a -> [a]

null :: URec Char a -> Bool

length :: URec Char a -> Int

elem :: Eq a => a -> URec Char a -> Bool

maximum :: Ord a => URec Char a -> a

minimum :: Ord a => URec Char a -> a

sum :: Num a => URec Char a -> a

product :: Num a => URec Char a -> a

Foldable (URec Double :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => URec Double m -> m

foldMap :: Monoid m => (a -> m) -> URec Double a -> m

foldr :: (a -> b -> b) -> b -> URec Double a -> b

foldr' :: (a -> b -> b) -> b -> URec Double a -> b

foldl :: (b -> a -> b) -> b -> URec Double a -> b

foldl' :: (b -> a -> b) -> b -> URec Double a -> b

foldr1 :: (a -> a -> a) -> URec Double a -> a

foldl1 :: (a -> a -> a) -> URec Double a -> a

toList :: URec Double a -> [a]

null :: URec Double a -> Bool

length :: URec Double a -> Int

elem :: Eq a => a -> URec Double a -> Bool

maximum :: Ord a => URec Double a -> a

minimum :: Ord a => URec Double a -> a

sum :: Num a => URec Double a -> a

product :: Num a => URec Double a -> a

Foldable (URec Float :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => URec Float m -> m

foldMap :: Monoid m => (a -> m) -> URec Float a -> m

foldr :: (a -> b -> b) -> b -> URec Float a -> b

foldr' :: (a -> b -> b) -> b -> URec Float a -> b

foldl :: (b -> a -> b) -> b -> URec Float a -> b

foldl' :: (b -> a -> b) -> b -> URec Float a -> b

foldr1 :: (a -> a -> a) -> URec Float a -> a

foldl1 :: (a -> a -> a) -> URec Float a -> a

toList :: URec Float a -> [a]

null :: URec Float a -> Bool

length :: URec Float a -> Int

elem :: Eq a => a -> URec Float a -> Bool

maximum :: Ord a => URec Float a -> a

minimum :: Ord a => URec Float a -> a

sum :: Num a => URec Float a -> a

product :: Num a => URec Float a -> a

Foldable (URec Int :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => URec Int m -> m

foldMap :: Monoid m => (a -> m) -> URec Int a -> m

foldr :: (a -> b -> b) -> b -> URec Int a -> b

foldr' :: (a -> b -> b) -> b -> URec Int a -> b

foldl :: (b -> a -> b) -> b -> URec Int a -> b

foldl' :: (b -> a -> b) -> b -> URec Int a -> b

foldr1 :: (a -> a -> a) -> URec Int a -> a

foldl1 :: (a -> a -> a) -> URec Int a -> a

toList :: URec Int a -> [a]

null :: URec Int a -> Bool

length :: URec Int a -> Int

elem :: Eq a => a -> URec Int a -> Bool

maximum :: Ord a => URec Int a -> a

minimum :: Ord a => URec Int a -> a

sum :: Num a => URec Int a -> a

product :: Num a => URec Int a -> a

Foldable (URec Word :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => URec Word m -> m

foldMap :: Monoid m => (a -> m) -> URec Word a -> m

foldr :: (a -> b -> b) -> b -> URec Word a -> b

foldr' :: (a -> b -> b) -> b -> URec Word a -> b

foldl :: (b -> a -> b) -> b -> URec Word a -> b

foldl' :: (b -> a -> b) -> b -> URec Word a -> b

foldr1 :: (a -> a -> a) -> URec Word a -> a

foldl1 :: (a -> a -> a) -> URec Word a -> a

toList :: URec Word a -> [a]

null :: URec Word a -> Bool

length :: URec Word a -> Int

elem :: Eq a => a -> URec Word a -> Bool

maximum :: Ord a => URec Word a -> a

minimum :: Ord a => URec Word a -> a

sum :: Num a => URec Word a -> a

product :: Num a => URec Word a -> a

Foldable (URec (Ptr ()) :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => URec (Ptr ()) m -> m

foldMap :: Monoid m => (a -> m) -> URec (Ptr ()) a -> m

foldr :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b

foldr' :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b

foldl :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b

foldl' :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b

foldr1 :: (a -> a -> a) -> URec (Ptr ()) a -> a

foldl1 :: (a -> a -> a) -> URec (Ptr ()) a -> a

toList :: URec (Ptr ()) a -> [a]

null :: URec (Ptr ()) a -> Bool

length :: URec (Ptr ()) a -> Int

elem :: Eq a => a -> URec (Ptr ()) a -> Bool

maximum :: Ord a => URec (Ptr ()) a -> a

minimum :: Ord a => URec (Ptr ()) a -> a

sum :: Num a => URec (Ptr ()) a -> a

product :: Num a => URec (Ptr ()) a -> a

Foldable (Const m :: Type -> Type)

Since: base-4.7.0.0

Defined in Data.Functor.Const

Methods

fold :: 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

Defined in Data.Foldable

Methods

fold :: 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

Defined in Data.Foldable

Methods

fold :: 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

Bifoldable p => Foldable (Join p)

Defined in Data.Bifunctor.Join

Methods

fold :: Monoid m => Join p m -> m

foldMap :: Monoid m => (a -> m) -> Join p a -> m

foldr :: (a -> b -> b) -> b -> Join p a -> b

foldr' :: (a -> b -> b) -> b -> Join p a -> b

foldl :: (b -> a -> b) -> b -> Join p a -> b

foldl' :: (b -> a -> b) -> b -> Join p a -> b

foldr1 :: (a -> a -> a) -> Join p a -> a

foldl1 :: (a -> a -> a) -> Join p a -> a

toList :: Join p a -> [a]

null :: Join p a -> Bool

length :: Join p a -> Int

elem :: Eq a => a -> Join p a -> Bool

maximum :: Ord a => Join p a -> a

minimum :: Ord a => Join p a -> a

sum :: Num a => Join p a -> a

product :: Num a => Join p a -> a

Bifoldable p => Foldable (Fix p)

Defined in Data.Bifunctor.Fix

Methods

fold :: Monoid m => Fix p m -> m

foldMap :: Monoid m => (a -> m) -> Fix p a -> m

foldr :: (a -> b -> b) -> b -> Fix p a -> b

foldr' :: (a -> b -> b) -> b -> Fix p a -> b

foldl :: (b -> a -> b) -> b -> Fix p a -> b

foldl' :: (b -> a -> b) -> b -> Fix p a -> b

foldr1 :: (a -> a -> a) -> Fix p a -> a

foldl1 :: (a -> a -> a) -> Fix p a -> a

toList :: Fix p a -> [a]

null :: Fix p a -> Bool

length :: Fix p a -> Int

elem :: Eq a => a -> Fix p a -> Bool

maximum :: Ord a => Fix p a -> a

minimum :: Ord a => Fix p a -> a

sum :: Num a => Fix p a -> a

product :: Num a => Fix p a -> a

Foldable f => Foldable (IdentityT f)

Defined in Control.Monad.Trans.Identity

Methods

fold :: 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 (ExceptT e f)

Defined in Control.Monad.Trans.Except

Methods

fold :: 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 f => Foldable (FreeF f a)

Defined in Control.Monad.Trans.Free

Methods

fold :: Monoid m => FreeF f a m -> m

foldMap :: Monoid m => (a0 -> m) -> FreeF f a a0 -> m

foldr :: (a0 -> b -> b) -> b -> FreeF f a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> FreeF f a a0 -> b

foldl :: (b -> a0 -> b) -> b -> FreeF f a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> FreeF f a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> FreeF f a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> FreeF f a a0 -> a0

toList :: FreeF f a a0 -> [a0]

null :: FreeF f a a0 -> Bool

length :: FreeF f a a0 -> Int

elem :: Eq a0 => a0 -> FreeF f a a0 -> Bool

maximum :: Ord a0 => FreeF f a a0 -> a0

minimum :: Ord a0 => FreeF f a a0 -> a0

sum :: Num a0 => FreeF f a a0 -> a0

product :: Num a0 => FreeF f a a0 -> a0

(Foldable m, Foldable f) => Foldable (FreeT f m)

Defined in Control.Monad.Trans.Free

Methods

fold :: Monoid m0 => FreeT f m m0 -> m0

foldMap :: Monoid m0 => (a -> m0) -> FreeT f m a -> m0

foldr :: (a -> b -> b) -> b -> FreeT f m a -> b

foldr' :: (a -> b -> b) -> b -> FreeT f m a -> b

foldl :: (b -> a -> b) -> b -> FreeT f m a -> b

foldl' :: (b -> a -> b) -> b -> FreeT f m a -> b

foldr1 :: (a -> a -> a) -> FreeT f m a -> a

foldl1 :: (a -> a -> a) -> FreeT f m a -> a

toList :: FreeT f m a -> [a]

null :: FreeT f m a -> Bool

length :: FreeT f m a -> Int

elem :: Eq a => a -> FreeT f m a -> Bool

maximum :: Ord a => FreeT f m a -> a

minimum :: Ord a => FreeT f m a -> a

sum :: Num a => FreeT f m a -> a

product :: Num a => FreeT f m a -> a

Foldable f => Foldable (CofreeF f a)

Defined in Control.Comonad.Trans.Cofree

Methods

fold :: Monoid m => CofreeF f a m -> m

foldMap :: Monoid m => (a0 -> m) -> CofreeF f a a0 -> m

foldr :: (a0 -> b -> b) -> b -> CofreeF f a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> CofreeF f a a0 -> b

foldl :: (b -> a0 -> b) -> b -> CofreeF f a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> CofreeF f a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> CofreeF f a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> CofreeF f a a0 -> a0

toList :: CofreeF f a a0 -> [a0]

null :: CofreeF f a a0 -> Bool

length :: CofreeF f a a0 -> Int

elem :: Eq a0 => a0 -> CofreeF f a a0 -> Bool

maximum :: Ord a0 => CofreeF f a a0 -> a0

minimum :: Ord a0 => CofreeF f a a0 -> a0

sum :: Num a0 => CofreeF f a a0 -> a0

product :: Num a0 => CofreeF f a a0 -> a0

(Foldable f, Foldable w) => Foldable (CofreeT f w)

Defined in Control.Comonad.Trans.Cofree

Methods

fold :: Monoid m => CofreeT f w m -> m

foldMap :: Monoid m => (a -> m) -> CofreeT f w a -> m

foldr :: (a -> b -> b) -> b -> CofreeT f w a -> b

foldr' :: (a -> b -> b) -> b -> CofreeT f w a -> b

foldl :: (b -> a -> b) -> b -> CofreeT f w a -> b

foldl' :: (b -> a -> b) -> b -> CofreeT f w a -> b

foldr1 :: (a -> a -> a) -> CofreeT f w a -> a

foldl1 :: (a -> a -> a) -> CofreeT f w a -> a

toList :: CofreeT f w a -> [a]

null :: CofreeT f w a -> Bool

length :: CofreeT f w a -> Int

elem :: Eq a => a -> CofreeT f w a -> Bool

maximum :: Ord a => CofreeT f w a -> a

minimum :: Ord a => CofreeT f w a -> a

sum :: Num a => CofreeT f w a -> a

product :: Num a => CofreeT f w a -> a

Foldable f => Foldable (ErrorT e f)

Defined in Control.Monad.Trans.Error

Methods

fold :: 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 (Tagged s)

Defined in Data.Tagged

Methods

fold :: Monoid m => Tagged s m -> m

foldMap :: Monoid m => (a -> m) -> Tagged s a -> m

foldr :: (a -> b -> b) -> b -> Tagged s a -> b

foldr' :: (a -> b -> b) -> b -> Tagged s a -> b

foldl :: (b -> a -> b) -> b -> Tagged s a -> b

foldl' :: (b -> a -> b) -> b -> Tagged s a -> b

foldr1 :: (a -> a -> a) -> Tagged s a -> a

foldl1 :: (a -> a -> a) -> Tagged s a -> a

toList :: Tagged s a -> [a]

null :: Tagged s a -> Bool

length :: Tagged s a -> Int

elem :: Eq a => a -> Tagged s a -> Bool

maximum :: Ord a => Tagged s a -> a

minimum :: Ord a => Tagged s a -> a

sum :: Num a => Tagged s a -> a

product :: Num a => Tagged s a -> a

Foldable (K1 i c :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => K1 i c m -> m

foldMap :: Monoid m => (a -> m) -> K1 i c a -> m

foldr :: (a -> b -> b) -> b -> K1 i c a -> b

foldr' :: (a -> b -> b) -> b -> K1 i c a -> b

foldl :: (b -> a -> b) -> b -> K1 i c a -> b

foldl' :: (b -> a -> b) -> b -> K1 i c a -> b

foldr1 :: (a -> a -> a) -> K1 i c a -> a

foldl1 :: (a -> a -> a) -> K1 i c a -> a

toList :: K1 i c a -> [a]

null :: K1 i c a -> Bool

length :: K1 i c a -> Int

elem :: Eq a => a -> K1 i c a -> Bool

maximum :: Ord a => K1 i c a -> a

minimum :: Ord a => K1 i c a -> a

sum :: Num a => K1 i c a -> a

product :: Num a => K1 i c a -> a

(Foldable f, Foldable g) => Foldable (f :+: g)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => (f :+: g) m -> m

foldMap :: Monoid m => (a -> m) -> (f :+: g) a -> m

foldr :: (a -> b -> b) -> b -> (f :+: g) a -> b

foldr' :: (a -> b -> b) -> b -> (f :+: g) a -> b

foldl :: (b -> a -> b) -> b -> (f :+: g) a -> b

foldl' :: (b -> a -> b) -> b -> (f :+: g) a -> b

foldr1 :: (a -> a -> a) -> (f :+: g) a -> a

foldl1 :: (a -> a -> a) -> (f :+: g) a -> a

toList :: (f :+: g) a -> [a]

null :: (f :+: g) a -> Bool

length :: (f :+: g) a -> Int

elem :: Eq a => a -> (f :+: g) a -> Bool

maximum :: Ord a => (f :+: g) a -> a

minimum :: Ord a => (f :+: g) a -> a

sum :: Num a => (f :+: g) a -> a

product :: Num a => (f :+: g) a -> a

(Foldable f, Foldable g) => Foldable (f :*: g)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => (f :*: g) m -> m

foldMap :: Monoid m => (a -> m) -> (f :*: g) a -> m

foldr :: (a -> b -> b) -> b -> (f :*: g) a -> b

foldr' :: (a -> b -> b) -> b -> (f :*: g) a -> b

foldl :: (b -> a -> b) -> b -> (f :*: g) a -> b

foldl' :: (b -> a -> b) -> b -> (f :*: g) a -> b

foldr1 :: (a -> a -> a) -> (f :*: g) a -> a

foldl1 :: (a -> a -> a) -> (f :*: g) a -> a

toList :: (f :*: g) a -> [a]

null :: (f :*: g) a -> Bool

length :: (f :*: g) a -> Int

elem :: Eq a => a -> (f :*: g) a -> Bool

maximum :: Ord a => (f :*: g) a -> a

minimum :: Ord a => (f :*: g) a -> a

sum :: Num a => (f :*: g) a -> a

product :: Num a => (f :*: g) a -> a

(Foldable f, Foldable g) => Foldable (Product f g)

Since: base-4.9.0.0

Defined in Data.Functor.Product

Methods

fold :: 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

Defined in Data.Functor.Sum

Methods

fold :: 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 (ImpossibleM2 t1 :: Type -> Type)

Defined in Data.Impossible

Methods

fold :: Monoid m => ImpossibleM2 t1 m -> m

foldMap :: Monoid m => (a -> m) -> ImpossibleM2 t1 a -> m

foldr :: (a -> b -> b) -> b -> ImpossibleM2 t1 a -> b

foldr' :: (a -> b -> b) -> b -> ImpossibleM2 t1 a -> b

foldl :: (b -> a -> b) -> b -> ImpossibleM2 t1 a -> b

foldl' :: (b -> a -> b) -> b -> ImpossibleM2 t1 a -> b

foldr1 :: (a -> a -> a) -> ImpossibleM2 t1 a -> a

foldl1 :: (a -> a -> a) -> ImpossibleM2 t1 a -> a

toList :: ImpossibleM2 t1 a -> [a]

null :: ImpossibleM2 t1 a -> Bool

length :: ImpossibleM2 t1 a -> Int

elem :: Eq a => a -> ImpossibleM2 t1 a -> Bool

maximum :: Ord a => ImpossibleM2 t1 a -> a

minimum :: Ord a => ImpossibleM2 t1 a -> a

sum :: Num a => ImpossibleM2 t1 a -> a

product :: Num a => ImpossibleM2 t1 a -> a

Foldable (Magma i t b)

Defined in Control.Lens.Internal.Magma

Methods

fold :: Monoid m => Magma i t b m -> m

foldMap :: Monoid m => (a -> m) -> Magma i t b a -> m

foldr :: (a -> b0 -> b0) -> b0 -> Magma i t b a -> b0

foldr' :: (a -> b0 -> b0) -> b0 -> Magma i t b a -> b0

foldl :: (b0 -> a -> b0) -> b0 -> Magma i t b a -> b0

foldl' :: (b0 -> a -> b0) -> b0 -> Magma i t b a -> b0

foldr1 :: (a -> a -> a) -> Magma i t b a -> a

foldl1 :: (a -> a -> a) -> Magma i t b a -> a

toList :: Magma i t b a -> [a]

null :: Magma i t b a -> Bool

length :: Magma i t b a -> Int

elem :: Eq a => a -> Magma i t b a -> Bool

maximum :: Ord a => Magma i t b a -> a

minimum :: Ord a => Magma i t b a -> a

sum :: Num a => Magma i t b a -> a

product :: Num a => Magma i t b a -> a

Foldable f => Foldable (M1 i c f)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => M1 i c f m -> m

foldMap :: Monoid m => (a -> m) -> M1 i c f a -> m

foldr :: (a -> b -> b) -> b -> M1 i c f a -> b

foldr' :: (a -> b -> b) -> b -> M1 i c f a -> b

foldl :: (b -> a -> b) -> b -> M1 i c f a -> b

foldl' :: (b -> a -> b) -> b -> M1 i c f a -> b

foldr1 :: (a -> a -> a) -> M1 i c f a -> a

foldl1 :: (a -> a -> a) -> M1 i c f a -> a

toList :: M1 i c f a -> [a]

null :: M1 i c f a -> Bool

length :: M1 i c f a -> Int

elem :: Eq a => a -> M1 i c f a -> Bool

maximum :: Ord a => M1 i c f a -> a

minimum :: Ord a => M1 i c f a -> a

sum :: Num a => M1 i c f a -> a

product :: Num a => M1 i c f a -> a

(Foldable f, Foldable g) => Foldable (f :.: g)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => (f :.: g) m -> m

foldMap :: Monoid m => (a -> m) -> (f :.: g) a -> m

foldr :: (a -> b -> b) -> b -> (f :.: g) a -> b

foldr' :: (a -> b -> b) -> b -> (f :.: g) a -> b

foldl :: (b -> a -> b) -> b -> (f :.: g) a -> b

foldl' :: (b -> a -> b) -> b -> (f :.: g) a -> b

foldr1 :: (a -> a -> a) -> (f :.: g) a -> a

foldl1 :: (a -> a -> a) -> (f :.: g) a -> a

toList :: (f :.: g) a -> [a]

null :: (f :.: g) a -> Bool

length :: (f :.: g) a -> Int

elem :: Eq a => a -> (f :.: g) a -> Bool

maximum :: Ord a => (f :.: g) a -> a

minimum :: Ord a => (f :.: g) a -> a

sum :: Num a => (f :.: g) a -> a

product :: Num a => (f :.: g) a -> a

(Foldable f, Foldable g) => Foldable (Compose f g)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

fold :: 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

Bifoldable p => Foldable (WrappedBifunctor p a)

Defined in Data.Bifunctor.Wrapped

Methods

fold :: Monoid m => WrappedBifunctor p a m -> m

foldMap :: Monoid m => (a0 -> m) -> WrappedBifunctor p a a0 -> m

foldr :: (a0 -> b -> b) -> b -> WrappedBifunctor p a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> WrappedBifunctor p a a0 -> b

foldl :: (b -> a0 -> b) -> b -> WrappedBifunctor p a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> WrappedBifunctor p a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> WrappedBifunctor p a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> WrappedBifunctor p a a0 -> a0

toList :: WrappedBifunctor p a a0 -> [a0]

null :: WrappedBifunctor p a a0 -> Bool

length :: WrappedBifunctor p a a0 -> Int

elem :: Eq a0 => a0 -> WrappedBifunctor p a a0 -> Bool

maximum :: Ord a0 => WrappedBifunctor p a a0 -> a0

minimum :: Ord a0 => WrappedBifunctor p a a0 -> a0

sum :: Num a0 => WrappedBifunctor p a a0 -> a0

product :: Num a0 => WrappedBifunctor p a a0 -> a0

Foldable g => Foldable (Joker g a)

Defined in Data.Bifunctor.Joker

Methods

fold :: Monoid m => Joker g a m -> m

foldMap :: Monoid m => (a0 -> m) -> Joker g a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Joker g a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Joker g a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Joker g a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Joker g a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Joker g a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Joker g a a0 -> a0

toList :: Joker g a a0 -> [a0]

null :: Joker g a a0 -> Bool

length :: Joker g a a0 -> Int

elem :: Eq a0 => a0 -> Joker g a a0 -> Bool

maximum :: Ord a0 => Joker g a a0 -> a0

minimum :: Ord a0 => Joker g a a0 -> a0

sum :: Num a0 => Joker g a a0 -> a0

product :: Num a0 => Joker g a a0 -> a0

Bifoldable p => Foldable (Flip p a)

Defined in Data.Bifunctor.Flip

Methods

fold :: Monoid m => Flip p a m -> m

foldMap :: Monoid m => (a0 -> m) -> Flip p a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Flip p a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Flip p a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Flip p a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Flip p a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Flip p a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Flip p a a0 -> a0

toList :: Flip p a a0 -> [a0]

null :: Flip p a a0 -> Bool

length :: Flip p a a0 -> Int

elem :: Eq a0 => a0 -> Flip p a a0 -> Bool

maximum :: Ord a0 => Flip p a a0 -> a0

minimum :: Ord a0 => Flip p a a0 -> a0

sum :: Num a0 => Flip p a a0 -> a0

product :: Num a0 => Flip p a a0 -> a0

Foldable (Clown f a :: Type -> Type)

Defined in Data.Bifunctor.Clown

Methods

fold :: Monoid m => Clown f a m -> m

foldMap :: Monoid m => (a0 -> m) -> Clown f a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Clown f a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Clown f a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Clown f a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Clown f a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Clown f a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Clown f a a0 -> a0

toList :: Clown f a a0 -> [a0]

null :: Clown f a a0 -> Bool

length :: Clown f a a0 -> Int

elem :: Eq a0 => a0 -> Clown f a a0 -> Bool

maximum :: Ord a0 => Clown f a a0 -> a0

minimum :: Ord a0 => Clown f a a0 -> a0

sum :: Num a0 => Clown f a a0 -> a0

product :: Num a0 => Clown f a a0 -> a0

Foldable (ImpossibleM3 t1 t2 :: Type -> Type)

Defined in Data.Impossible

Methods

fold :: Monoid m => ImpossibleM3 t1 t2 m -> m

foldMap :: Monoid m => (a -> m) -> ImpossibleM3 t1 t2 a -> m

foldr :: (a -> b -> b) -> b -> ImpossibleM3 t1 t2 a -> b

foldr' :: (a -> b -> b) -> b -> ImpossibleM3 t1 t2 a -> b

foldl :: (b -> a -> b) -> b -> ImpossibleM3 t1 t2 a -> b

foldl' :: (b -> a -> b) -> b -> ImpossibleM3 t1 t2 a -> b

foldr1 :: (a -> a -> a) -> ImpossibleM3 t1 t2 a -> a

foldl1 :: (a -> a -> a) -> ImpossibleM3 t1 t2 a -> a

toList :: ImpossibleM3 t1 t2 a -> [a]

null :: ImpossibleM3 t1 t2 a -> Bool

length :: ImpossibleM3 t1 t2 a -> Int

elem :: Eq a => a -> ImpossibleM3 t1 t2 a -> Bool

maximum :: Ord a => ImpossibleM3 t1 t2 a -> a

minimum :: Ord a => ImpossibleM3 t1 t2 a -> a

sum :: Num a => ImpossibleM3 t1 t2 a -> a

product :: Num a => ImpossibleM3 t1 t2 a -> a

(Foldable f, Bifoldable p) => Foldable (Tannen f p a)

Defined in Data.Bifunctor.Tannen

Methods

fold :: Monoid m => Tannen f p a m -> m

foldMap :: Monoid m => (a0 -> m) -> Tannen f p a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Tannen f p a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Tannen f p a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Tannen f p a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Tannen f p a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Tannen f p a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Tannen f p a a0 -> a0

toList :: Tannen f p a a0 -> [a0]

null :: Tannen f p a a0 -> Bool

length :: Tannen f p a a0 -> Int

elem :: Eq a0 => a0 -> Tannen f p a a0 -> Bool

maximum :: Ord a0 => Tannen f p a a0 -> a0

minimum :: Ord a0 => Tannen f p a a0 -> a0

sum :: Num a0 => Tannen f p a a0 -> a0

product :: Num a0 => Tannen f p a a0 -> a0

Foldable (ImpossibleM4 t1 t2 t3 :: Type -> Type)

Defined in Data.Impossible

Methods

fold :: Monoid m => ImpossibleM4 t1 t2 t3 m -> m

foldMap :: Monoid m => (a -> m) -> ImpossibleM4 t1 t2 t3 a -> m

foldr :: (a -> b -> b) -> b -> ImpossibleM4 t1 t2 t3 a -> b

foldr' :: (a -> b -> b) -> b -> ImpossibleM4 t1 t2 t3 a -> b

foldl :: (b -> a -> b) -> b -> ImpossibleM4 t1 t2 t3 a -> b

foldl' :: (b -> a -> b) -> b -> ImpossibleM4 t1 t2 t3 a -> b

foldr1 :: (a -> a -> a) -> ImpossibleM4 t1 t2 t3 a -> a

foldl1 :: (a -> a -> a) -> ImpossibleM4 t1 t2 t3 a -> a

toList :: ImpossibleM4 t1 t2 t3 a -> [a]

null :: ImpossibleM4 t1 t2 t3 a -> Bool

length :: ImpossibleM4 t1 t2 t3 a -> Int

elem :: Eq a => a -> ImpossibleM4 t1 t2 t3 a -> Bool

maximum :: Ord a => ImpossibleM4 t1 t2 t3 a -> a

minimum :: Ord a => ImpossibleM4 t1 t2 t3 a -> a

sum :: Num a => ImpossibleM4 t1 t2 t3 a -> a

product :: Num a => ImpossibleM4 t1 t2 t3 a -> a

(Bifoldable p, Foldable g) => Foldable (Biff p f g a)

Defined in Data.Bifunctor.Biff

Methods

fold :: Monoid m => Biff p f g a m -> m

foldMap :: Monoid m => (a0 -> m) -> Biff p f g a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Biff p f g a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Biff p f g a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Biff p f g a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Biff p f g a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Biff p f g a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Biff p f g a a0 -> a0

toList :: Biff p f g a a0 -> [a0]

null :: Biff p f g a a0 -> Bool

length :: Biff p f g a a0 -> Int

elem :: Eq a0 => a0 -> Biff p f g a a0 -> Bool

maximum :: Ord a0 => Biff p f g a a0 -> a0

minimum :: Ord a0 => Biff p f g a a0 -> a0

sum :: Num a0 => Biff p f g a a0 -> a0

product :: Num a0 => Biff p f g a a0 -> a0

Foldable (ImpossibleM5 t1 t2 t3 t4 :: Type -> Type)

Defined in Data.Impossible

Methods

fold :: Monoid m => ImpossibleM5 t1 t2 t3 t4 m -> m

foldMap :: Monoid m => (a -> m) -> ImpossibleM5 t1 t2 t3 t4 a -> m

foldr :: (a -> b -> b) -> b -> ImpossibleM5 t1 t2 t3 t4 a -> b

foldr' :: (a -> b -> b) -> b -> ImpossibleM5 t1 t2 t3 t4 a -> b

foldl :: (b -> a -> b) -> b -> ImpossibleM5 t1 t2 t3 t4 a -> b

foldl' :: (b -> a -> b) -> b -> ImpossibleM5 t1 t2 t3 t4 a -> b

foldr1 :: (a -> a -> a) -> ImpossibleM5 t1 t2 t3 t4 a -> a

foldl1 :: (a -> a -> a) -> ImpossibleM5 t1 t2 t3 t4 a -> a

toList :: ImpossibleM5 t1 t2 t3 t4 a -> [a]

null :: ImpossibleM5 t1 t2 t3 t4 a -> Bool

length :: ImpossibleM5 t1 t2 t3 t4 a -> Int

elem :: Eq a => a -> ImpossibleM5 t1 t2 t3 t4 a -> Bool

maximum :: Ord a => ImpossibleM5 t1 t2 t3 t4 a -> a

minimum :: Ord a => ImpossibleM5 t1 t2 t3 t4 a -> a

sum :: Num a => ImpossibleM5 t1 t2 t3 t4 a -> a

product :: Num a => ImpossibleM5 t1 t2 t3 t4 a -> a

Foldable (ImpossibleM6 t1 t2 t3 t4 t5 :: Type -> Type)

Defined in Data.Impossible

Methods

fold :: Monoid m => ImpossibleM6 t1 t2 t3 t4 t5 m -> m

foldMap :: Monoid m => (a -> m) -> ImpossibleM6 t1 t2 t3 t4 t5 a -> m

foldr :: (a -> b -> b) -> b -> ImpossibleM6 t1 t2 t3 t4 t5 a -> b

foldr' :: (a -> b -> b) -> b -> ImpossibleM6 t1 t2 t3 t4 t5 a -> b

foldl :: (b -> a -> b) -> b -> ImpossibleM6 t1 t2 t3 t4 t5 a -> b

foldl' :: (b -> a -> b) -> b -> ImpossibleM6 t1 t2 t3 t4 t5 a -> b

foldr1 :: (a -> a -> a) -> ImpossibleM6 t1 t2 t3 t4 t5 a -> a

foldl1 :: (a -> a -> a) -> ImpossibleM6 t1 t2 t3 t4 t5 a -> a

toList :: ImpossibleM6 t1 t2 t3 t4 t5 a -> [a]

null :: ImpossibleM6 t1 t2 t3 t4 t5 a -> Bool

length :: ImpossibleM6 t1 t2 t3 t4 t5 a -> Int

elem :: Eq a => a -> ImpossibleM6 t1 t2 t3 t4 t5 a -> Bool

maximum :: Ord a => ImpossibleM6 t1 t2 t3 t4 t5 a -> a

minimum :: Ord a => ImpossibleM6 t1 t2 t3 t4 t5 a -> a

sum :: Num a => ImpossibleM6 t1 t2 t3 t4 t5 a -> a

product :: Num a => ImpossibleM6 t1 t2 t3 t4 t5 a -> a

Foldable (ImpossibleM7 t1 t2 t3 t4 t5 t6 :: Type -> Type)

Defined in Data.Impossible

Methods

fold :: Monoid m => ImpossibleM7 t1 t2 t3 t4 t5 t6 m -> m

foldMap :: Monoid m => (a -> m) -> ImpossibleM7 t1 t2 t3 t4 t5 t6 a -> m

foldr :: (a -> b -> b) -> b -> ImpossibleM7 t1 t2 t3 t4 t5 t6 a -> b

foldr' :: (a -> b -> b) -> b -> ImpossibleM7 t1 t2 t3 t4 t5 t6 a -> b

foldl :: (b -> a -> b) -> b -> ImpossibleM7 t1 t2 t3 t4 t5 t6 a -> b

foldl' :: (b -> a -> b) -> b -> ImpossibleM7 t1 t2 t3 t4 t5 t6 a -> b

foldr1 :: (a -> a -> a) -> ImpossibleM7 t1 t2 t3 t4 t5 t6 a -> a

foldl1 :: (a -> a -> a) -> ImpossibleM7 t1 t2 t3 t4 t5 t6 a -> a

toList :: ImpossibleM7 t1 t2 t3 t4 t5 t6 a -> [a]

null :: ImpossibleM7 t1 t2 t3 t4 t5 t6 a -> Bool

length :: ImpossibleM7 t1 t2 t3 t4 t5 t6 a -> Int

elem :: Eq a => a -> ImpossibleM7 t1 t2 t3 t4 t5 t6 a -> Bool

maximum :: Ord a => ImpossibleM7 t1 t2 t3 t4 t5 t6 a -> a

minimum :: Ord a => ImpossibleM7 t1 t2 t3 t4 t5 t6 a -> a

sum :: Num a => ImpossibleM7 t1 t2 t3 t4 t5 t6 a -> a

product :: Num a => ImpossibleM7 t1 t2 t3 t4 t5 t6 a -> a

Foldable (ImpossibleM8 t1 t2 t3 t4 t5 t6 t7 :: Type -> Type)

Defined in Data.Impossible

Methods

fold :: Monoid m => ImpossibleM8 t1 t2 t3 t4 t5 t6 t7 m -> m

foldMap :: Monoid m => (a -> m) -> ImpossibleM8 t1 t2 t3 t4 t5 t6 t7 a -> m

foldr :: (a -> b -> b) -> b -> ImpossibleM8 t1 t2 t3 t4 t5 t6 t7 a -> b

foldr' :: (a -> b -> b) -> b -> ImpossibleM8 t1 t2 t3 t4 t5 t6 t7 a -> b

foldl :: (b -> a -> b) -> b -> ImpossibleM8 t1 t2 t3 t4 t5 t6 t7 a -> b

foldl' :: (b -> a -> b) -> b -> ImpossibleM8 t1 t2 t3 t4 t5 t6 t7 a -> b

foldr1 :: (a -> a -> a) -> ImpossibleM8 t1 t2 t3 t4 t5 t6 t7 a -> a

foldl1 :: (a -> a -> a) -> ImpossibleM8 t1 t2 t3 t4 t5 t6 t7 a -> a

toList :: ImpossibleM8 t1 t2 t3 t4 t5 t6 t7 a -> [a]

null :: ImpossibleM8 t1 t2 t3 t4 t5 t6 t7 a -> Bool

length :: ImpossibleM8 t1 t2 t3 t4 t5 t6 t7 a -> Int

elem :: Eq a => a -> ImpossibleM8 t1 t2 t3 t4 t5 t6 t7 a -> Bool

maximum :: Ord a => ImpossibleM8 t1 t2 t3 t4 t5 t6 t7 a -> a

minimum :: Ord a => ImpossibleM8 t1 t2 t3 t4 t5 t6 t7 a -> a

sum :: Num a => ImpossibleM8 t1 t2 t3 t4 t5 t6 t7 a -> a

product :: Num a => ImpossibleM8 t1 t2 t3 t4 t5 t6 t7 a -> a

Foldable (ImpossibleM9 t1 t2 t3 t4 t5 t6 t7 t8 :: Type -> Type)

Defined in Data.Impossible

Methods

fold :: Monoid m => ImpossibleM9 t1 t2 t3 t4 t5 t6 t7 t8 m -> m

foldMap :: Monoid m => (a -> m) -> ImpossibleM9 t1 t2 t3 t4 t5 t6 t7 t8 a -> m

foldr :: (a -> b -> b) -> b -> ImpossibleM9 t1 t2 t3 t4 t5 t6 t7 t8 a -> b

foldr' :: (a -> b -> b) -> b -> ImpossibleM9 t1 t2 t3 t4 t5 t6 t7 t8 a -> b

foldl :: (b -> a -> b) -> b -> ImpossibleM9 t1 t2 t3 t4 t5 t6 t7 t8 a -> b

foldl' :: (b -> a -> b) -> b -> ImpossibleM9 t1 t2 t3 t4 t5 t6 t7 t8 a -> b

foldr1 :: (a -> a -> a) -> ImpossibleM9 t1 t2 t3 t4 t5 t6 t7 t8 a -> a

foldl1 :: (a -> a -> a) -> ImpossibleM9 t1 t2 t3 t4 t5 t6 t7 t8 a -> a

toList :: ImpossibleM9 t1 t2 t3 t4 t5 t6 t7 t8 a -> [a]

null :: ImpossibleM9 t1 t2 t3 t4 t5 t6 t7 t8 a -> Bool

length :: ImpossibleM9 t1 t2 t3 t4 t5 t6 t7 t8 a -> Int

elem :: Eq a => a -> ImpossibleM9 t1 t2 t3 t4 t5 t6 t7 t8 a -> Bool

maximum :: Ord a => ImpossibleM9 t1 t2 t3 t4 t5 t6 t7 t8 a -> a

minimum :: Ord a => ImpossibleM9 t1 t2 t3 t4 t5 t6 t7 t8 a -> a

sum :: Num a => ImpossibleM9 t1 t2 t3 t4 t5 t6 t7 t8 a -> a

product :: Num a => ImpossibleM9 t1 t2 t3 t4 t5 t6 t7 t8 a -> a

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

biconcatMap :: Bifoldable t => (a -> [c]) -> (b -> [c]) -> t a b -> [c]

Given a means of mapping the elements of a structure to lists, computes the concatenation of all such lists in order.

Since: base-4.10.0.0

biproduct :: (Bifoldable t, Num a) => t a a -> a

The biproduct function computes the product of the numbers of a structure.

Since: base-4.10.0.0

bisum :: (Bifoldable t, Num a) => t a a -> a

The bisum function computes the sum of the numbers of a structure.

Since: base-4.10.0.0

biconcat :: Bifoldable t => t [a] [a] -> [a]

Reduces a structure of lists to the concatenation of those lists.

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

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

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

bifoldr | bifoldMap

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

Bifoldable Either

Since: base-4.10.0.0

Defined in Data.Bifoldable

Methods

bifold :: 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

Bifoldable (,)

Since: base-4.10.0.0

Defined in Data.Bifoldable

Methods

bifold :: 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

Bifoldable Arg

Since: base-4.10.0.0

Defined in Data.Semigroup

Methods

bifold :: 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

Bifoldable ListF

Defined in Data.Functor.Foldable

Methods

bifold :: Monoid m => ListF m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> ListF a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> ListF a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> ListF a b -> c

Bifoldable NonEmptyF

Defined in Data.Functor.Base

Methods

bifold :: Monoid m => NonEmptyF m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> NonEmptyF a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> NonEmptyF a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> NonEmptyF a b -> c

Bifoldable ((,,) x)

Since: base-4.10.0.0

Defined in Data.Bifoldable

Methods

bifold :: 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

Defined in Data.Bifoldable

Methods

bifold :: 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

Foldable f => Bifoldable (FreeF f)

Defined in Control.Monad.Trans.Free

Methods

bifold :: Monoid m => FreeF f m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> FreeF f a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> FreeF f a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> FreeF f a b -> c

Foldable f => Bifoldable (CofreeF f)

Defined in Control.Comonad.Trans.Cofree

Methods

bifold :: Monoid m => CofreeF f m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> CofreeF f a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> CofreeF f a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> CofreeF f a b -> c

Bifoldable (Tagged :: Type -> Type -> Type)

Defined in Data.Tagged

Methods

bifold :: Monoid m => Tagged m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Tagged a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Tagged a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Tagged a b -> c

Bifoldable (K1 i :: Type -> Type -> Type)

Since: base-4.10.0.0

Defined in Data.Bifoldable

Methods

bifold :: 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

Defined in Data.Bifoldable

Methods

bifold :: 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

Defined in Data.Bifoldable

Methods

bifold :: 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 p => Bifoldable (WrappedBifunctor p)

Defined in Data.Bifunctor.Wrapped

Methods

bifold :: Monoid m => WrappedBifunctor p m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> WrappedBifunctor p a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> WrappedBifunctor p a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> WrappedBifunctor p a b -> c

Foldable g => Bifoldable (Joker g :: Type -> Type -> Type)

Defined in Data.Bifunctor.Joker

Methods

bifold :: Monoid m => Joker g m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Joker g a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Joker g a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Joker g a b -> c

Bifoldable p => Bifoldable (Flip p)

Defined in Data.Bifunctor.Flip

Methods

bifold :: Monoid m => Flip p m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Flip p a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Flip p a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Flip p a b -> c

Foldable f => Bifoldable (Clown f :: Type -> Type -> Type)

Defined in Data.Bifunctor.Clown

Methods

bifold :: Monoid m => Clown f m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Clown f a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Clown f a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Clown f a b -> c

Bifoldable ((,,,,,) x y z w)

Since: base-4.10.0.0

Defined in Data.Bifoldable

Methods

bifold :: 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 p, Bifoldable q) => Bifoldable (Sum p q)

Defined in Data.Bifunctor.Sum

Methods

bifold :: Monoid m => Sum p q m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Sum p q a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Sum p q a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Sum p q a b -> c

(Bifoldable f, Bifoldable g) => Bifoldable (Product f g)

Defined in Data.Bifunctor.Product

Methods

bifold :: Monoid m => Product f g m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Product f g a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Product f g a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Product f g a b -> c

Bifoldable ((,,,,,,) x y z w v)

Since: base-4.10.0.0

Defined in Data.Bifoldable

Methods

bifold :: 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

(Foldable f, Bifoldable p) => Bifoldable (Tannen f p)

Defined in Data.Bifunctor.Tannen

Methods

bifold :: Monoid m => Tannen f p m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Tannen f p a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Tannen f p a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Tannen f p a b -> c

(Bifoldable p, Foldable f, Foldable g) => Bifoldable (Biff p f g)

Defined in Data.Bifunctor.Biff

Methods

bifold :: Monoid m => Biff p f g m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Biff p f g a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Biff p f g a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Biff p f g a b -> c

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

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.

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

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

class Foldable t => Foldable1 (t :: Type -> Type) where

Minimal complete definition

Nothing

Methods

fold1 :: Semigroup m => t m -> m

foldMap1 :: Semigroup m => (a -> m) -> t a -> m

toNonEmpty :: t a -> NonEmpty a

Instances

Foldable1 Par1

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => Par1 m -> m

foldMap1 :: Semigroup m => (a -> m) -> Par1 a -> m

toNonEmpty :: Par1 a -> NonEmpty a

Foldable1 Complex

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => Complex m -> m

foldMap1 :: Semigroup m => (a -> m) -> Complex a -> m

toNonEmpty :: Complex a -> NonEmpty a

Foldable1 Min

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => Min m -> m

foldMap1 :: Semigroup m => (a -> m) -> Min a -> m

toNonEmpty :: Min a -> NonEmpty a

Foldable1 Max

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => Max m -> m

foldMap1 :: Semigroup m => (a -> m) -> Max a -> m

toNonEmpty :: Max a -> NonEmpty a

Foldable1 First

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => First m -> m

foldMap1 :: Semigroup m => (a -> m) -> First a -> m

toNonEmpty :: First a -> NonEmpty a

Foldable1 Last

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => Last m -> m

foldMap1 :: Semigroup m => (a -> m) -> Last a -> m

toNonEmpty :: Last a -> NonEmpty a

Foldable1 Identity

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => Identity m -> m

foldMap1 :: Semigroup m => (a -> m) -> Identity a -> m

toNonEmpty :: Identity a -> NonEmpty a

Foldable1 Dual

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => Dual m -> m

foldMap1 :: Semigroup m => (a -> m) -> Dual a -> m

toNonEmpty :: Dual a -> NonEmpty a

Foldable1 Sum

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => Sum m -> m

foldMap1 :: Semigroup m => (a -> m) -> Sum a -> m

toNonEmpty :: Sum a -> NonEmpty a

Foldable1 Product

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => Product m -> m

foldMap1 :: Semigroup m => (a -> m) -> Product a -> m

toNonEmpty :: Product a -> NonEmpty a

Foldable1 NonEmpty

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => NonEmpty m -> m

foldMap1 :: Semigroup m => (a -> m) -> NonEmpty a -> m

toNonEmpty :: NonEmpty a -> NonEmpty a

Foldable1 Tree

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => Tree m -> m

foldMap1 :: Semigroup m => (a -> m) -> Tree a -> m

toNonEmpty :: Tree a -> NonEmpty a

Foldable1 (V1 :: Type -> Type)

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => V1 m -> m

foldMap1 :: Semigroup m => (a -> m) -> V1 a -> m

toNonEmpty :: V1 a -> NonEmpty a

Foldable1 ((,) a)

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => (a, m) -> m

foldMap1 :: Semigroup m => (a0 -> m) -> (a, a0) -> m

toNonEmpty :: (a, a0) -> NonEmpty a0

Foldable1 f => Foldable1 (Cofree f)

Defined in Control.Comonad.Cofree

Methods

fold1 :: Semigroup m => Cofree f m -> m

foldMap1 :: Semigroup m => (a -> m) -> Cofree f a -> m

toNonEmpty :: Cofree f a -> NonEmpty a

Foldable1 f => Foldable1 (Free f)

Defined in Control.Monad.Free

Methods

fold1 :: Semigroup m => Free f m -> m

foldMap1 :: Semigroup m => (a -> m) -> Free f a -> m

toNonEmpty :: Free f a -> NonEmpty a

Foldable1 f => Foldable1 (Yoneda f)

Defined in Data.Functor.Yoneda

Methods

fold1 :: Semigroup m => Yoneda f m -> m

foldMap1 :: Semigroup m => (a -> m) -> Yoneda f a -> m

toNonEmpty :: Yoneda f a -> NonEmpty a

Foldable1 f => Foldable1 (Lift f)

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => Lift f m -> m

foldMap1 :: Semigroup m => (a -> m) -> Lift f a -> m

toNonEmpty :: Lift f a -> NonEmpty a

Foldable1 f => Foldable1 (Rec1 f)

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => Rec1 f m -> m

foldMap1 :: Semigroup m => (a -> m) -> Rec1 f a -> m

toNonEmpty :: Rec1 f a -> NonEmpty a

Foldable1 f => Foldable1 (Alt f)

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => Alt f m -> m

foldMap1 :: Semigroup m => (a -> m) -> Alt f a -> m

toNonEmpty :: Alt f a -> NonEmpty a

Bifoldable1 p => Foldable1 (Join p)

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => Join p m -> m

foldMap1 :: Semigroup m => (a -> m) -> Join p a -> m

toNonEmpty :: Join p a -> NonEmpty a

Foldable1 m => Foldable1 (IdentityT m)

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m0 => IdentityT m m0 -> m0

foldMap1 :: Semigroup m0 => (a -> m0) -> IdentityT m a -> m0

toNonEmpty :: IdentityT m a -> NonEmpty a

Foldable1 f => Foldable1 (Backwards f)

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => Backwards f m -> m

foldMap1 :: Semigroup m => (a -> m) -> Backwards f a -> m

toNonEmpty :: Backwards f a -> NonEmpty a

Foldable1 (Tagged a)

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => Tagged a m -> m

foldMap1 :: Semigroup m => (a0 -> m) -> Tagged a a0 -> m

toNonEmpty :: Tagged a a0 -> NonEmpty a0

Foldable1 f => Foldable1 (Reverse f)

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => Reverse f m -> m

foldMap1 :: Semigroup m => (a -> m) -> Reverse f a -> m

toNonEmpty :: Reverse f a -> NonEmpty a

(Foldable1 f, Foldable1 g) => Foldable1 (f :+: g)

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => (f :+: g) m -> m

foldMap1 :: Semigroup m => (a -> m) -> (f :+: g) a -> m

toNonEmpty :: (f :+: g) a -> NonEmpty a

(Foldable1 f, Foldable1 g) => Foldable1 (f :*: g)

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => (f :*: g) m -> m

foldMap1 :: Semigroup m => (a -> m) -> (f :*: g) a -> m

toNonEmpty :: (f :*: g) a -> NonEmpty a

(Foldable1 f, Foldable1 g) => Foldable1 (Product f g)

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => Product f g m -> m

foldMap1 :: Semigroup m => (a -> m) -> Product f g a -> m

toNonEmpty :: Product f g a -> NonEmpty a

(Foldable1 f, Foldable1 g) => Foldable1 (Sum f g)

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => Sum f g m -> m

foldMap1 :: Semigroup m => (a -> m) -> Sum f g a -> m

toNonEmpty :: Sum f g a -> NonEmpty a

Foldable1 f => Foldable1 (M1 i c f)

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => M1 i c f m -> m

foldMap1 :: Semigroup m => (a -> m) -> M1 i c f a -> m

toNonEmpty :: M1 i c f a -> NonEmpty a

(Foldable1 f, Foldable1 g) => Foldable1 (f :.: g)

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => (f :.: g) m -> m

foldMap1 :: Semigroup m => (a -> m) -> (f :.: g) a -> m

toNonEmpty :: (f :.: g) a -> NonEmpty a

(Foldable1 f, Foldable1 g) => Foldable1 (Compose f g)

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => Compose f g m -> m

foldMap1 :: Semigroup m => (a -> m) -> Compose f g a -> m

toNonEmpty :: Compose f g a -> NonEmpty a

Foldable1 g => Foldable1 (Joker g a)

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => Joker g a m -> m

foldMap1 :: Semigroup m => (a0 -> m) -> Joker g a a0 -> m

toNonEmpty :: Joker g a a0 -> NonEmpty a0