Foldable

Foldable

class Foldable (t :: * -> *) 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 but with strict application of the operator.

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

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

foldl f z = foldl' f z . toList

toList :: t a -> [a]

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

null :: t a -> Bool

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

length :: t a -> Int

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

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

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 IResult

Defined in Data.Aeson.Types.Internal

Methods

fold :: Monoid m => IResult m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> IResult a -> a

foldl1 :: (a -> a -> a) -> IResult a -> a

toList :: IResult a -> [a]

null :: IResult a -> Bool

length :: IResult a -> Int

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

maximum :: Ord a => IResult a -> a

minimum :: Ord a => IResult a -> a

sum :: Num a => IResult a -> a

product :: Num a => IResult a -> a

Foldable Result

Defined in Data.Aeson.Types.Internal

Methods

fold :: Monoid m => Result m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Result a -> a

foldl1 :: (a -> a -> a) -> Result a -> a

toList :: Result a -> [a]

null :: Result a -> Bool

length :: Result a -> Int

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

maximum :: Ord a => Result a -> a

minimum :: Ord a => Result a -> a

sum :: Num a => Result a -> a

product :: Num a => Result a -> a

Foldable Approximate

Defined in Data.Approximate.Type

Methods

fold :: Monoid m => Approximate m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Approximate a -> a

foldl1 :: (a -> a -> a) -> Approximate a -> a

toList :: Approximate a -> [a]

null :: Approximate a -> Bool

length :: Approximate a -> Int

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

maximum :: Ord a => Approximate a -> a

minimum :: Ord a => Approximate a -> a

sum :: Num a => Approximate a -> a

product :: Num a => Approximate a -> a

Foldable Complex

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

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

Since: containers-0.5.9

Defined in Data.Graph

Methods

fold :: Monoid m => SCC m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> SCC a -> a

foldl1 :: (a -> a -> a) -> SCC a -> a

toList :: SCC a -> [a]

null :: SCC a -> Bool

length :: SCC a -> Int

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

maximum :: Ord a => SCC a -> a

minimum :: Ord a => SCC a -> a

sum :: Num a => SCC a -> a

product :: Num a => SCC 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 ModuleName

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ModuleName m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> ModuleName a -> a

foldl1 :: (a -> a -> a) -> ModuleName a -> a

toList :: ModuleName a -> [a]

null :: ModuleName a -> Bool

length :: ModuleName a -> Int

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

maximum :: Ord a => ModuleName a -> a

minimum :: Ord a => ModuleName a -> a

sum :: Num a => ModuleName a -> a

product :: Num a => ModuleName a -> a

Foldable SpecialCon

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => SpecialCon m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> SpecialCon a -> a

foldl1 :: (a -> a -> a) -> SpecialCon a -> a

toList :: SpecialCon a -> [a]

null :: SpecialCon a -> Bool

length :: SpecialCon a -> Int

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

maximum :: Ord a => SpecialCon a -> a

minimum :: Ord a => SpecialCon a -> a

sum :: Num a => SpecialCon a -> a

product :: Num a => SpecialCon a -> a

Foldable QName

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => QName m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> QName a -> a

foldl1 :: (a -> a -> a) -> QName a -> a

toList :: QName a -> [a]

null :: QName a -> Bool

length :: QName a -> Int

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

maximum :: Ord a => QName a -> a

minimum :: Ord a => QName a -> a

sum :: Num a => QName a -> a

product :: Num a => QName a -> a

Foldable Name

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Name m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Name a -> a

foldl1 :: (a -> a -> a) -> Name a -> a

toList :: Name a -> [a]

null :: Name a -> Bool

length :: Name a -> Int

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

maximum :: Ord a => Name a -> a

minimum :: Ord a => Name a -> a

sum :: Num a => Name a -> a

product :: Num a => Name a -> a

Foldable IPName

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => IPName m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> IPName a -> a

foldl1 :: (a -> a -> a) -> IPName a -> a

toList :: IPName a -> [a]

null :: IPName a -> Bool

length :: IPName a -> Int

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

maximum :: Ord a => IPName a -> a

minimum :: Ord a => IPName a -> a

sum :: Num a => IPName a -> a

product :: Num a => IPName a -> a

Foldable QOp

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => QOp m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> QOp a -> a

foldl1 :: (a -> a -> a) -> QOp a -> a

toList :: QOp a -> [a]

null :: QOp a -> Bool

length :: QOp a -> Int

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

maximum :: Ord a => QOp a -> a

minimum :: Ord a => QOp a -> a

sum :: Num a => QOp a -> a

product :: Num a => QOp a -> a

Foldable Op

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Op m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Op a -> a

foldl1 :: (a -> a -> a) -> Op a -> a

toList :: Op a -> [a]

null :: Op a -> Bool

length :: Op a -> Int

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

maximum :: Ord a => Op a -> a

minimum :: Ord a => Op a -> a

sum :: Num a => Op a -> a

product :: Num a => Op a -> a

Foldable CName

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => CName m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> CName a -> a

foldl1 :: (a -> a -> a) -> CName a -> a

toList :: CName a -> [a]

null :: CName a -> Bool

length :: CName a -> Int

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

maximum :: Ord a => CName a -> a

minimum :: Ord a => CName a -> a

sum :: Num a => CName a -> a

product :: Num a => CName a -> a

Foldable Module

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Module m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Module a -> a

foldl1 :: (a -> a -> a) -> Module a -> a

toList :: Module a -> [a]

null :: Module a -> Bool

length :: Module a -> Int

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

maximum :: Ord a => Module a -> a

minimum :: Ord a => Module a -> a

sum :: Num a => Module a -> a

product :: Num a => Module a -> a

Foldable ModuleHead

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ModuleHead m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> ModuleHead a -> a

foldl1 :: (a -> a -> a) -> ModuleHead a -> a

toList :: ModuleHead a -> [a]

null :: ModuleHead a -> Bool

length :: ModuleHead a -> Int

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

maximum :: Ord a => ModuleHead a -> a

minimum :: Ord a => ModuleHead a -> a

sum :: Num a => ModuleHead a -> a

product :: Num a => ModuleHead a -> a

Foldable ExportSpecList

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ExportSpecList m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> ExportSpecList a -> a

foldl1 :: (a -> a -> a) -> ExportSpecList a -> a

toList :: ExportSpecList a -> [a]

null :: ExportSpecList a -> Bool

length :: ExportSpecList a -> Int

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

maximum :: Ord a => ExportSpecList a -> a

minimum :: Ord a => ExportSpecList a -> a

sum :: Num a => ExportSpecList a -> a

product :: Num a => ExportSpecList a -> a

Foldable ExportSpec

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ExportSpec m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> ExportSpec a -> a

foldl1 :: (a -> a -> a) -> ExportSpec a -> a

toList :: ExportSpec a -> [a]

null :: ExportSpec a -> Bool

length :: ExportSpec a -> Int

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

maximum :: Ord a => ExportSpec a -> a

minimum :: Ord a => ExportSpec a -> a

sum :: Num a => ExportSpec a -> a

product :: Num a => ExportSpec a -> a

Foldable EWildcard

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => EWildcard m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> EWildcard a -> a

foldl1 :: (a -> a -> a) -> EWildcard a -> a

toList :: EWildcard a -> [a]

null :: EWildcard a -> Bool

length :: EWildcard a -> Int

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

maximum :: Ord a => EWildcard a -> a

minimum :: Ord a => EWildcard a -> a

sum :: Num a => EWildcard a -> a

product :: Num a => EWildcard a -> a

Foldable Namespace

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Namespace m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Namespace a -> a

foldl1 :: (a -> a -> a) -> Namespace a -> a

toList :: Namespace a -> [a]

null :: Namespace a -> Bool

length :: Namespace a -> Int

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

maximum :: Ord a => Namespace a -> a

minimum :: Ord a => Namespace a -> a

sum :: Num a => Namespace a -> a

product :: Num a => Namespace a -> a

Foldable ImportDecl

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ImportDecl m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> ImportDecl a -> a

foldl1 :: (a -> a -> a) -> ImportDecl a -> a

toList :: ImportDecl a -> [a]

null :: ImportDecl a -> Bool

length :: ImportDecl a -> Int

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

maximum :: Ord a => ImportDecl a -> a

minimum :: Ord a => ImportDecl a -> a

sum :: Num a => ImportDecl a -> a

product :: Num a => ImportDecl a -> a

Foldable ImportSpecList

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ImportSpecList m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> ImportSpecList a -> a

foldl1 :: (a -> a -> a) -> ImportSpecList a -> a

toList :: ImportSpecList a -> [a]

null :: ImportSpecList a -> Bool

length :: ImportSpecList a -> Int

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

maximum :: Ord a => ImportSpecList a -> a

minimum :: Ord a => ImportSpecList a -> a

sum :: Num a => ImportSpecList a -> a

product :: Num a => ImportSpecList a -> a

Foldable ImportSpec

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ImportSpec m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> ImportSpec a -> a

foldl1 :: (a -> a -> a) -> ImportSpec a -> a

toList :: ImportSpec a -> [a]

null :: ImportSpec a -> Bool

length :: ImportSpec a -> Int

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

maximum :: Ord a => ImportSpec a -> a

minimum :: Ord a => ImportSpec a -> a

sum :: Num a => ImportSpec a -> a

product :: Num a => ImportSpec a -> a

Foldable Assoc

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Assoc m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Assoc a -> a

foldl1 :: (a -> a -> a) -> Assoc a -> a

toList :: Assoc a -> [a]

null :: Assoc a -> Bool

length :: Assoc a -> Int

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

maximum :: Ord a => Assoc a -> a

minimum :: Ord a => Assoc a -> a

sum :: Num a => Assoc a -> a

product :: Num a => Assoc a -> a

Foldable Decl

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Decl m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Decl a -> a

foldl1 :: (a -> a -> a) -> Decl a -> a

toList :: Decl a -> [a]

null :: Decl a -> Bool

length :: Decl a -> Int

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

maximum :: Ord a => Decl a -> a

minimum :: Ord a => Decl a -> a

sum :: Num a => Decl a -> a

product :: Num a => Decl a -> a

Foldable PatternSynDirection

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => PatternSynDirection m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> PatternSynDirection a -> a

foldl1 :: (a -> a -> a) -> PatternSynDirection a -> a

toList :: PatternSynDirection a -> [a]

null :: PatternSynDirection a -> Bool

length :: PatternSynDirection a -> Int

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

maximum :: Ord a => PatternSynDirection a -> a

minimum :: Ord a => PatternSynDirection a -> a

sum :: Num a => PatternSynDirection a -> a

product :: Num a => PatternSynDirection a -> a

Foldable TypeEqn

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => TypeEqn m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> TypeEqn a -> a

foldl1 :: (a -> a -> a) -> TypeEqn a -> a

toList :: TypeEqn a -> [a]

null :: TypeEqn a -> Bool

length :: TypeEqn a -> Int

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

maximum :: Ord a => TypeEqn a -> a

minimum :: Ord a => TypeEqn a -> a

sum :: Num a => TypeEqn a -> a

product :: Num a => TypeEqn a -> a

Foldable Annotation

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Annotation m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Annotation a -> a

foldl1 :: (a -> a -> a) -> Annotation a -> a

toList :: Annotation a -> [a]

null :: Annotation a -> Bool

length :: Annotation a -> Int

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

maximum :: Ord a => Annotation a -> a

minimum :: Ord a => Annotation a -> a

sum :: Num a => Annotation a -> a

product :: Num a => Annotation a -> a

Foldable BooleanFormula

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => BooleanFormula m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> BooleanFormula a -> a

foldl1 :: (a -> a -> a) -> BooleanFormula a -> a

toList :: BooleanFormula a -> [a]

null :: BooleanFormula a -> Bool

length :: BooleanFormula a -> Int

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

maximum :: Ord a => BooleanFormula a -> a

minimum :: Ord a => BooleanFormula a -> a

sum :: Num a => BooleanFormula a -> a

product :: Num a => BooleanFormula a -> a

Foldable Role

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Role m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Role a -> a

foldl1 :: (a -> a -> a) -> Role a -> a

toList :: Role a -> [a]

null :: Role a -> Bool

length :: Role a -> Int

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

maximum :: Ord a => Role a -> a

minimum :: Ord a => Role a -> a

sum :: Num a => Role a -> a

product :: Num a => Role a -> a

Foldable DataOrNew

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => DataOrNew m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> DataOrNew a -> a

foldl1 :: (a -> a -> a) -> DataOrNew a -> a

toList :: DataOrNew a -> [a]

null :: DataOrNew a -> Bool

length :: DataOrNew a -> Int

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

maximum :: Ord a => DataOrNew a -> a

minimum :: Ord a => DataOrNew a -> a

sum :: Num a => DataOrNew a -> a

product :: Num a => DataOrNew a -> a

Foldable InjectivityInfo

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => InjectivityInfo m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> InjectivityInfo a -> a

foldl1 :: (a -> a -> a) -> InjectivityInfo a -> a

toList :: InjectivityInfo a -> [a]

null :: InjectivityInfo a -> Bool

length :: InjectivityInfo a -> Int

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

maximum :: Ord a => InjectivityInfo a -> a

minimum :: Ord a => InjectivityInfo a -> a

sum :: Num a => InjectivityInfo a -> a

product :: Num a => InjectivityInfo a -> a

Foldable ResultSig

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ResultSig m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> ResultSig a -> a

foldl1 :: (a -> a -> a) -> ResultSig a -> a

toList :: ResultSig a -> [a]

null :: ResultSig a -> Bool

length :: ResultSig a -> Int

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

maximum :: Ord a => ResultSig a -> a

minimum :: Ord a => ResultSig a -> a

sum :: Num a => ResultSig a -> a

product :: Num a => ResultSig a -> a

Foldable DeclHead

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => DeclHead m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> DeclHead a -> a

foldl1 :: (a -> a -> a) -> DeclHead a -> a

toList :: DeclHead a -> [a]

null :: DeclHead a -> Bool

length :: DeclHead a -> Int

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

maximum :: Ord a => DeclHead a -> a

minimum :: Ord a => DeclHead a -> a

sum :: Num a => DeclHead a -> a

product :: Num a => DeclHead a -> a

Foldable InstRule

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => InstRule m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> InstRule a -> a

foldl1 :: (a -> a -> a) -> InstRule a -> a

toList :: InstRule a -> [a]

null :: InstRule a -> Bool

length :: InstRule a -> Int

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

maximum :: Ord a => InstRule a -> a

minimum :: Ord a => InstRule a -> a

sum :: Num a => InstRule a -> a

product :: Num a => InstRule a -> a

Foldable InstHead

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => InstHead m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> InstHead a -> a

foldl1 :: (a -> a -> a) -> InstHead a -> a

toList :: InstHead a -> [a]

null :: InstHead a -> Bool

length :: InstHead a -> Int

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

maximum :: Ord a => InstHead a -> a

minimum :: Ord a => InstHead a -> a

sum :: Num a => InstHead a -> a

product :: Num a => InstHead a -> a

Foldable Deriving

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Deriving m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Deriving a -> a

foldl1 :: (a -> a -> a) -> Deriving a -> a

toList :: Deriving a -> [a]

null :: Deriving a -> Bool

length :: Deriving a -> Int

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

maximum :: Ord a => Deriving a -> a

minimum :: Ord a => Deriving a -> a

sum :: Num a => Deriving a -> a

product :: Num a => Deriving a -> a

Foldable DerivStrategy

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => DerivStrategy m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> DerivStrategy a -> a

foldl1 :: (a -> a -> a) -> DerivStrategy a -> a

toList :: DerivStrategy a -> [a]

null :: DerivStrategy a -> Bool

length :: DerivStrategy a -> Int

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

maximum :: Ord a => DerivStrategy a -> a

minimum :: Ord a => DerivStrategy a -> a

sum :: Num a => DerivStrategy a -> a

product :: Num a => DerivStrategy a -> a

Foldable Binds

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Binds m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Binds a -> a

foldl1 :: (a -> a -> a) -> Binds a -> a

toList :: Binds a -> [a]

null :: Binds a -> Bool

length :: Binds a -> Int

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

maximum :: Ord a => Binds a -> a

minimum :: Ord a => Binds a -> a

sum :: Num a => Binds a -> a

product :: Num a => Binds a -> a

Foldable IPBind

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => IPBind m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> IPBind a -> a

foldl1 :: (a -> a -> a) -> IPBind a -> a

toList :: IPBind a -> [a]

null :: IPBind a -> Bool

length :: IPBind a -> Int

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

maximum :: Ord a => IPBind a -> a

minimum :: Ord a => IPBind a -> a

sum :: Num a => IPBind a -> a

product :: Num a => IPBind a -> a

Foldable Match

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Match m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Match a -> a

foldl1 :: (a -> a -> a) -> Match a -> a

toList :: Match a -> [a]

null :: Match a -> Bool

length :: Match a -> Int

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

maximum :: Ord a => Match a -> a

minimum :: Ord a => Match a -> a

sum :: Num a => Match a -> a

product :: Num a => Match a -> a

Foldable QualConDecl

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => QualConDecl m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> QualConDecl a -> a

foldl1 :: (a -> a -> a) -> QualConDecl a -> a

toList :: QualConDecl a -> [a]

null :: QualConDecl a -> Bool

length :: QualConDecl a -> Int

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

maximum :: Ord a => QualConDecl a -> a

minimum :: Ord a => QualConDecl a -> a

sum :: Num a => QualConDecl a -> a

product :: Num a => QualConDecl a -> a

Foldable ConDecl

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ConDecl m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> ConDecl a -> a

foldl1 :: (a -> a -> a) -> ConDecl a -> a

toList :: ConDecl a -> [a]

null :: ConDecl a -> Bool

length :: ConDecl a -> Int

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

maximum :: Ord a => ConDecl a -> a

minimum :: Ord a => ConDecl a -> a

sum :: Num a => ConDecl a -> a

product :: Num a => ConDecl a -> a

Foldable FieldDecl

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => FieldDecl m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> FieldDecl a -> a

foldl1 :: (a -> a -> a) -> FieldDecl a -> a

toList :: FieldDecl a -> [a]

null :: FieldDecl a -> Bool

length :: FieldDecl a -> Int

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

maximum :: Ord a => FieldDecl a -> a

minimum :: Ord a => FieldDecl a -> a

sum :: Num a => FieldDecl a -> a

product :: Num a => FieldDecl a -> a

Foldable GadtDecl

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => GadtDecl m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> GadtDecl a -> a

foldl1 :: (a -> a -> a) -> GadtDecl a -> a

toList :: GadtDecl a -> [a]

null :: GadtDecl a -> Bool

length :: GadtDecl a -> Int

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

maximum :: Ord a => GadtDecl a -> a

minimum :: Ord a => GadtDecl a -> a

sum :: Num a => GadtDecl a -> a

product :: Num a => GadtDecl a -> a

Foldable ClassDecl

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ClassDecl m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> ClassDecl a -> a

foldl1 :: (a -> a -> a) -> ClassDecl a -> a

toList :: ClassDecl a -> [a]

null :: ClassDecl a -> Bool

length :: ClassDecl a -> Int

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

maximum :: Ord a => ClassDecl a -> a

minimum :: Ord a => ClassDecl a -> a

sum :: Num a => ClassDecl a -> a

product :: Num a => ClassDecl a -> a

Foldable InstDecl

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => InstDecl m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> InstDecl a -> a

foldl1 :: (a -> a -> a) -> InstDecl a -> a

toList :: InstDecl a -> [a]

null :: InstDecl a -> Bool

length :: InstDecl a -> Int

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

maximum :: Ord a => InstDecl a -> a

minimum :: Ord a => InstDecl a -> a

sum :: Num a => InstDecl a -> a

product :: Num a => InstDecl a -> a

Foldable BangType

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => BangType m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> BangType a -> a

foldl1 :: (a -> a -> a) -> BangType a -> a

toList :: BangType a -> [a]

null :: BangType a -> Bool

length :: BangType a -> Int

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

maximum :: Ord a => BangType a -> a

minimum :: Ord a => BangType a -> a

sum :: Num a => BangType a -> a

product :: Num a => BangType a -> a

Foldable Unpackedness

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Unpackedness m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Unpackedness a -> a

foldl1 :: (a -> a -> a) -> Unpackedness a -> a

toList :: Unpackedness a -> [a]

null :: Unpackedness a -> Bool

length :: Unpackedness a -> Int

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

maximum :: Ord a => Unpackedness a -> a

minimum :: Ord a => Unpackedness a -> a

sum :: Num a => Unpackedness a -> a

product :: Num a => Unpackedness a -> a

Foldable Rhs

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Rhs m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Rhs a -> a

foldl1 :: (a -> a -> a) -> Rhs a -> a

toList :: Rhs a -> [a]

null :: Rhs a -> Bool

length :: Rhs a -> Int

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

maximum :: Ord a => Rhs a -> a

minimum :: Ord a => Rhs a -> a

sum :: Num a => Rhs a -> a

product :: Num a => Rhs a -> a

Foldable GuardedRhs

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => GuardedRhs m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> GuardedRhs a -> a

foldl1 :: (a -> a -> a) -> GuardedRhs a -> a

toList :: GuardedRhs a -> [a]

null :: GuardedRhs a -> Bool

length :: GuardedRhs a -> Int

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

maximum :: Ord a => GuardedRhs a -> a

minimum :: Ord a => GuardedRhs a -> a

sum :: Num a => GuardedRhs a -> a

product :: Num a => GuardedRhs a -> a

Foldable Type

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Type m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Type a -> a

foldl1 :: (a -> a -> a) -> Type a -> a

toList :: Type a -> [a]

null :: Type a -> Bool

length :: Type a -> Int

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

maximum :: Ord a => Type a -> a

minimum :: Ord a => Type a -> a

sum :: Num a => Type a -> a

product :: Num a => Type a -> a

Foldable MaybePromotedName

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => MaybePromotedName m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> MaybePromotedName a -> a

foldl1 :: (a -> a -> a) -> MaybePromotedName a -> a

toList :: MaybePromotedName a -> [a]

null :: MaybePromotedName a -> Bool

length :: MaybePromotedName a -> Int

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

maximum :: Ord a => MaybePromotedName a -> a

minimum :: Ord a => MaybePromotedName a -> a

sum :: Num a => MaybePromotedName a -> a

product :: Num a => MaybePromotedName a -> a

Foldable Promoted

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Promoted m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Promoted a -> a

foldl1 :: (a -> a -> a) -> Promoted a -> a

toList :: Promoted a -> [a]

null :: Promoted a -> Bool

length :: Promoted a -> Int

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

maximum :: Ord a => Promoted a -> a

minimum :: Ord a => Promoted a -> a

sum :: Num a => Promoted a -> a

product :: Num a => Promoted a -> a

Foldable TyVarBind

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => TyVarBind m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> TyVarBind a -> a

foldl1 :: (a -> a -> a) -> TyVarBind a -> a

toList :: TyVarBind a -> [a]

null :: TyVarBind a -> Bool

length :: TyVarBind a -> Int

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

maximum :: Ord a => TyVarBind a -> a

minimum :: Ord a => TyVarBind a -> a

sum :: Num a => TyVarBind a -> a

product :: Num a => TyVarBind a -> a

Foldable Kind

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Kind m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Kind a -> a

foldl1 :: (a -> a -> a) -> Kind a -> a

toList :: Kind a -> [a]

null :: Kind a -> Bool

length :: Kind a -> Int

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

maximum :: Ord a => Kind a -> a

minimum :: Ord a => Kind a -> a

sum :: Num a => Kind a -> a

product :: Num a => Kind a -> a

Foldable FunDep

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => FunDep m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> FunDep a -> a

foldl1 :: (a -> a -> a) -> FunDep a -> a

toList :: FunDep a -> [a]

null :: FunDep a -> Bool

length :: FunDep a -> Int

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

maximum :: Ord a => FunDep a -> a

minimum :: Ord a => FunDep a -> a

sum :: Num a => FunDep a -> a

product :: Num a => FunDep a -> a

Foldable Context

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Context m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Context a -> a

foldl1 :: (a -> a -> a) -> Context a -> a

toList :: Context a -> [a]

null :: Context a -> Bool

length :: Context a -> Int

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

maximum :: Ord a => Context a -> a

minimum :: Ord a => Context a -> a

sum :: Num a => Context a -> a

product :: Num a => Context a -> a

Foldable Asst

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Asst m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Asst a -> a

foldl1 :: (a -> a -> a) -> Asst a -> a

toList :: Asst a -> [a]

null :: Asst a -> Bool

length :: Asst a -> Int

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

maximum :: Ord a => Asst a -> a

minimum :: Ord a => Asst a -> a

sum :: Num a => Asst a -> a

product :: Num a => Asst a -> a

Foldable Literal

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Literal m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Literal a -> a

foldl1 :: (a -> a -> a) -> Literal a -> a

toList :: Literal a -> [a]

null :: Literal a -> Bool

length :: Literal a -> Int

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

maximum :: Ord a => Literal a -> a

minimum :: Ord a => Literal a -> a

sum :: Num a => Literal a -> a

product :: Num a => Literal a -> a

Foldable Sign

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Sign m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Sign a -> a

foldl1 :: (a -> a -> a) -> Sign a -> a

toList :: Sign a -> [a]

null :: Sign a -> Bool

length :: Sign a -> Int

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

maximum :: Ord a => Sign a -> a

minimum :: Ord a => Sign a -> a

sum :: Num a => Sign a -> a

product :: Num a => Sign a -> a

Foldable Exp

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Exp m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Exp a -> a

foldl1 :: (a -> a -> a) -> Exp a -> a

toList :: Exp a -> [a]

null :: Exp a -> Bool

length :: Exp a -> Int

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

maximum :: Ord a => Exp a -> a

minimum :: Ord a => Exp a -> a

sum :: Num a => Exp a -> a

product :: Num a => Exp a -> a

Foldable XName

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => XName m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> XName a -> a

foldl1 :: (a -> a -> a) -> XName a -> a

toList :: XName a -> [a]

null :: XName a -> Bool

length :: XName a -> Int

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

maximum :: Ord a => XName a -> a

minimum :: Ord a => XName a -> a

sum :: Num a => XName a -> a

product :: Num a => XName a -> a

Foldable XAttr

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => XAttr m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> XAttr a -> a

foldl1 :: (a -> a -> a) -> XAttr a -> a

toList :: XAttr a -> [a]

null :: XAttr a -> Bool

length :: XAttr a -> Int

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

maximum :: Ord a => XAttr a -> a

minimum :: Ord a => XAttr a -> a

sum :: Num a => XAttr a -> a

product :: Num a => XAttr a -> a

Foldable Bracket

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Bracket m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Bracket a -> a

foldl1 :: (a -> a -> a) -> Bracket a -> a

toList :: Bracket a -> [a]

null :: Bracket a -> Bool

length :: Bracket a -> Int

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

maximum :: Ord a => Bracket a -> a

minimum :: Ord a => Bracket a -> a

sum :: Num a => Bracket a -> a

product :: Num a => Bracket a -> a

Foldable Splice

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Splice m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Splice a -> a

foldl1 :: (a -> a -> a) -> Splice a -> a

toList :: Splice a -> [a]

null :: Splice a -> Bool

length :: Splice a -> Int

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

maximum :: Ord a => Splice a -> a

minimum :: Ord a => Splice a -> a

sum :: Num a => Splice a -> a

product :: Num a => Splice a -> a

Foldable Safety

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Safety m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Safety a -> a

foldl1 :: (a -> a -> a) -> Safety a -> a

toList :: Safety a -> [a]

null :: Safety a -> Bool

length :: Safety a -> Int

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

maximum :: Ord a => Safety a -> a

minimum :: Ord a => Safety a -> a

sum :: Num a => Safety a -> a

product :: Num a => Safety a -> a

Foldable CallConv

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => CallConv m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> CallConv a -> a

foldl1 :: (a -> a -> a) -> CallConv a -> a

toList :: CallConv a -> [a]

null :: CallConv a -> Bool

length :: CallConv a -> Int

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

maximum :: Ord a => CallConv a -> a

minimum :: Ord a => CallConv a -> a

sum :: Num a => CallConv a -> a

product :: Num a => CallConv a -> a

Foldable ModulePragma

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ModulePragma m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> ModulePragma a -> a

foldl1 :: (a -> a -> a) -> ModulePragma a -> a

toList :: ModulePragma a -> [a]

null :: ModulePragma a -> Bool

length :: ModulePragma a -> Int

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

maximum :: Ord a => ModulePragma a -> a

minimum :: Ord a => ModulePragma a -> a

sum :: Num a => ModulePragma a -> a

product :: Num a => ModulePragma a -> a

Foldable Overlap

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Overlap m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Overlap a -> a

foldl1 :: (a -> a -> a) -> Overlap a -> a

toList :: Overlap a -> [a]

null :: Overlap a -> Bool

length :: Overlap a -> Int

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

maximum :: Ord a => Overlap a -> a

minimum :: Ord a => Overlap a -> a

sum :: Num a => Overlap a -> a

product :: Num a => Overlap a -> a

Foldable Activation

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Activation m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Activation a -> a

foldl1 :: (a -> a -> a) -> Activation a -> a

toList :: Activation a -> [a]

null :: Activation a -> Bool

length :: Activation a -> Int

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

maximum :: Ord a => Activation a -> a

minimum :: Ord a => Activation a -> a

sum :: Num a => Activation a -> a

product :: Num a => Activation a -> a

Foldable Rule

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Rule m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Rule a -> a

foldl1 :: (a -> a -> a) -> Rule a -> a

toList :: Rule a -> [a]

null :: Rule a -> Bool

length :: Rule a -> Int

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

maximum :: Ord a => Rule a -> a

minimum :: Ord a => Rule a -> a

sum :: Num a => Rule a -> a

product :: Num a => Rule a -> a

Foldable RuleVar

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => RuleVar m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> RuleVar a -> a

foldl1 :: (a -> a -> a) -> RuleVar a -> a

toList :: RuleVar a -> [a]

null :: RuleVar a -> Bool

length :: RuleVar a -> Int

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

maximum :: Ord a => RuleVar a -> a

minimum :: Ord a => RuleVar a -> a

sum :: Num a => RuleVar a -> a

product :: Num a => RuleVar a -> a

Foldable WarningText

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => WarningText m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> WarningText a -> a

foldl1 :: (a -> a -> a) -> WarningText a -> a

toList :: WarningText a -> [a]

null :: WarningText a -> Bool

length :: WarningText a -> Int

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

maximum :: Ord a => WarningText a -> a

minimum :: Ord a => WarningText a -> a

sum :: Num a => WarningText a -> a

product :: Num a => WarningText a -> a

Foldable Pat

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Pat m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Pat a -> a

foldl1 :: (a -> a -> a) -> Pat a -> a

toList :: Pat a -> [a]

null :: Pat a -> Bool

length :: Pat a -> Int

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

maximum :: Ord a => Pat a -> a

minimum :: Ord a => Pat a -> a

sum :: Num a => Pat a -> a

product :: Num a => Pat a -> a

Foldable PXAttr

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => PXAttr m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> PXAttr a -> a

foldl1 :: (a -> a -> a) -> PXAttr a -> a

toList :: PXAttr a -> [a]

null :: PXAttr a -> Bool

length :: PXAttr a -> Int

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

maximum :: Ord a => PXAttr a -> a

minimum :: Ord a => PXAttr a -> a

sum :: Num a => PXAttr a -> a

product :: Num a => PXAttr a -> a

Foldable RPatOp

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => RPatOp m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> RPatOp a -> a

foldl1 :: (a -> a -> a) -> RPatOp a -> a

toList :: RPatOp a -> [a]

null :: RPatOp a -> Bool

length :: RPatOp a -> Int

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

maximum :: Ord a => RPatOp a -> a

minimum :: Ord a => RPatOp a -> a

sum :: Num a => RPatOp a -> a

product :: Num a => RPatOp a -> a

Foldable RPat

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => RPat m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> RPat a -> a

foldl1 :: (a -> a -> a) -> RPat a -> a

toList :: RPat a -> [a]

null :: RPat a -> Bool

length :: RPat a -> Int

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

maximum :: Ord a => RPat a -> a

minimum :: Ord a => RPat a -> a

sum :: Num a => RPat a -> a

product :: Num a => RPat a -> a

Foldable PatField

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => PatField m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> PatField a -> a

foldl1 :: (a -> a -> a) -> PatField a -> a

toList :: PatField a -> [a]

null :: PatField a -> Bool

length :: PatField a -> Int

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

maximum :: Ord a => PatField a -> a

minimum :: Ord a => PatField a -> a

sum :: Num a => PatField a -> a

product :: Num a => PatField a -> a

Foldable Stmt

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Stmt m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Stmt a -> a

foldl1 :: (a -> a -> a) -> Stmt a -> a

toList :: Stmt a -> [a]

null :: Stmt a -> Bool

length :: Stmt a -> Int

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

maximum :: Ord a => Stmt a -> a

minimum :: Ord a => Stmt a -> a

sum :: Num a => Stmt a -> a

product :: Num a => Stmt a -> a

Foldable QualStmt

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => QualStmt m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> QualStmt a -> a

foldl1 :: (a -> a -> a) -> QualStmt a -> a

toList :: QualStmt a -> [a]

null :: QualStmt a -> Bool

length :: QualStmt a -> Int

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

maximum :: Ord a => QualStmt a -> a

minimum :: Ord a => QualStmt a -> a

sum :: Num a => QualStmt a -> a

product :: Num a => QualStmt a -> a

Foldable FieldUpdate

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => FieldUpdate m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> FieldUpdate a -> a

foldl1 :: (a -> a -> a) -> FieldUpdate a -> a

toList :: FieldUpdate a -> [a]

null :: FieldUpdate a -> Bool

length :: FieldUpdate a -> Int

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

maximum :: Ord a => FieldUpdate a -> a

minimum :: Ord a => FieldUpdate a -> a

sum :: Num a => FieldUpdate a -> a

product :: Num a => FieldUpdate a -> a

Foldable Alt

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Alt m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Alt a -> a

foldl1 :: (a -> a -> a) -> Alt a -> a

toList :: Alt a -> [a]

null :: Alt a -> Bool

length :: Alt a -> Int

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

maximum :: Ord a => Alt a -> a

minimum :: Ord a => Alt a -> a

sum :: Num a => Alt a -> a

product :: Num a => Alt a -> a

Foldable Heap

Defined in Data.Heap

Methods

fold :: Monoid m => Heap m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Heap a -> a

foldl1 :: (a -> a -> a) -> Heap a -> a

toList :: Heap a -> [a]

null :: Heap a -> Bool

length :: Heap a -> Int

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

maximum :: Ord a => Heap a -> a

minimum :: Ord a => Heap a -> a

sum :: Num a => Heap a -> a

product :: Num a => Heap a -> a

Foldable Concrete

Defined in Hedgehog.Internal.State

Methods

fold :: Monoid m => Concrete m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Concrete a -> a

foldl1 :: (a -> a -> a) -> Concrete a -> a

toList :: Concrete a -> [a]

null :: Concrete a -> Bool

length :: Concrete a -> Int

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

maximum :: Ord a => Concrete a -> a

minimum :: Ord a => Concrete a -> a

sum :: Num a => Concrete a -> a

product :: Num a => Concrete 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 Log

Defined in Numeric.Log

Methods

fold :: Monoid m => Log m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Log a -> a

foldl1 :: (a -> a -> a) -> Log a -> a

toList :: Log a -> [a]

null :: Log a -> Bool

length :: Log a -> Int

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

maximum :: Ord a => Log a -> a

minimum :: Ord a => Log a -> a

sum :: Num a => Log a -> a

product :: Num a => Log a -> a

Foldable MultiSet

Defined in Data.MultiSet

Methods

fold :: Monoid m => MultiSet m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> MultiSet a -> a

foldl1 :: (a -> a -> a) -> MultiSet a -> a

toList :: MultiSet a -> [a]

null :: MultiSet a -> Bool

length :: MultiSet a -> Int

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

maximum :: Ord a => MultiSet a -> a

minimum :: Ord a => MultiSet a -> a

sum :: Num a => MultiSet a -> a

product :: Num a => MultiSet a -> a

Foldable SimpleDocStream

Collect all annotations from a document.

Defined in Data.Text.Prettyprint.Doc.Internal

Methods

fold :: Monoid m => SimpleDocStream m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> SimpleDocStream a -> a

foldl1 :: (a -> a -> a) -> SimpleDocStream a -> a

toList :: SimpleDocStream a -> [a]

null :: SimpleDocStream a -> Bool

length :: SimpleDocStream a -> Int

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

maximum :: Ord a => SimpleDocStream a -> a

minimum :: Ord a => SimpleDocStream a -> a

sum :: Num a => SimpleDocStream a -> a

product :: Num a => SimpleDocStream 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 Bound

Defined in Data.Semilattice.Bound

Methods

fold :: Monoid m => Bound m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Bound a -> a

foldl1 :: (a -> a -> a) -> Bound a -> a

toList :: Bound a -> [a]

null :: Bound a -> Bool

length :: Bound a -> Int

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

maximum :: Ord a => Bound a -> a

minimum :: Ord a => Bound a -> a

sum :: Num a => Bound a -> a

product :: Num a => Bound a -> a

Foldable Order

Defined in Data.Semilattice.Order

Methods

fold :: Monoid m => Order m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Order a -> a

foldl1 :: (a -> a -> a) -> Order a -> a

toList :: Order a -> [a]

null :: Order a -> Bool

length :: Order a -> Int

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

maximum :: Ord a => Order a -> a

minimum :: Ord a => Order a -> a

sum :: Num a => Order a -> a

product :: Num a => Order a -> a

Foldable Meeting

Defined in Data.Semilattice.Meet

Methods

fold :: Monoid m => Meeting m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Meeting a -> a

foldl1 :: (a -> a -> a) -> Meeting a -> a

toList :: Meeting a -> [a]

null :: Meeting a -> Bool

length :: Meeting a -> Int

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

maximum :: Ord a => Meeting a -> a

minimum :: Ord a => Meeting a -> a

sum :: Num a => Meeting a -> a

product :: Num a => Meeting a -> a

Foldable GreaterThan

Defined in Data.Semilattice.Meet

Methods

fold :: Monoid m => GreaterThan m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> GreaterThan a -> a

foldl1 :: (a -> a -> a) -> GreaterThan a -> a

toList :: GreaterThan a -> [a]

null :: GreaterThan a -> Bool

length :: GreaterThan a -> Int

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

maximum :: Ord a => GreaterThan a -> a

minimum :: Ord a => GreaterThan a -> a

sum :: Num a => GreaterThan a -> a

product :: Num a => GreaterThan a -> a

Foldable Joining

Defined in Data.Semilattice.Join

Methods

fold :: Monoid m => Joining m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Joining a -> a

foldl1 :: (a -> a -> a) -> Joining a -> a

toList :: Joining a -> [a]

null :: Joining a -> Bool

length :: Joining a -> Int

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

maximum :: Ord a => Joining a -> a

minimum :: Ord a => Joining a -> a

sum :: Num a => Joining a -> a

product :: Num a => Joining a -> a

Foldable LessThan

Defined in Data.Semilattice.Join

Methods

fold :: Monoid m => LessThan m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> LessThan a -> a

foldl1 :: (a -> a -> a) -> LessThan a -> a

toList :: LessThan a -> [a]

null :: LessThan a -> Bool

length :: LessThan a -> Int

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

maximum :: Ord a => LessThan a -> a

minimum :: Ord a => LessThan a -> a

sum :: Num a => LessThan a -> a

product :: Num a => LessThan a -> a

Foldable Grouped

Defined in Weigh

Methods

fold :: Monoid m => Grouped m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Grouped a -> a

foldl1 :: (a -> a -> a) -> Grouped a -> a

toList :: Grouped a -> [a]

null :: Grouped a -> Bool

length :: Grouped a -> Int

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

maximum :: Ord a => Grouped a -> a

minimum :: Ord a => Grouped a -> a

sum :: Num a => Grouped a -> a

product :: Num a => Grouped a -> a

Foldable Forest

Defined in Data.Heap

Methods

fold :: Monoid m => Forest m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Forest a -> a

foldl1 :: (a -> a -> a) -> Forest a -> a

toList :: Forest a -> [a]

null :: Forest a -> Bool

length :: Forest a -> Int

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

maximum :: Ord a => Forest a -> a

minimum :: Ord a => Forest a -> a

sum :: Num a => Forest a -> a

product :: Num a => Forest a -> a

Foldable Tree

Defined in Data.Heap

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 (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 :: * -> *)

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 :: * -> *)

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 :: * -> *)

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 (Entry p)

Defined in Data.Heap

Methods

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

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

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

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

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

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

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

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

toList :: Entry p a -> [a]

null :: Entry p a -> Bool

length :: Entry p a -> Int

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

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

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

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

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

Foldable (Vec n)

Defined in Hedgehog.Internal.Gen

Methods

fold :: Monoid m => Vec n m -> m

foldMap :: Monoid m => (a -> m) -> Vec n a -> m

foldr :: (a -> b -> b) -> b -> Vec n a -> b

foldr' :: (a -> b -> b) -> b -> Vec n a -> b

foldl :: (b -> a -> b) -> b -> Vec n a -> b

foldl' :: (b -> a -> b) -> b -> Vec n a -> b

foldr1 :: (a -> a -> a) -> Vec n a -> a

foldl1 :: (a -> a -> a) -> Vec n a -> a

toList :: Vec n a -> [a]

null :: Vec n a -> Bool

length :: Vec n a -> Int

elem :: Eq a => a -> Vec n a -> Bool

maximum :: Ord a => Vec n a -> a

minimum :: Ord a => Vec n a -> a

sum :: Num a => Vec n a -> a

product :: Num a => Vec n 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 m => Foldable (ListT m)

Defined in List.Transformer

Methods

fold :: Monoid m0 => ListT m m0 -> m0

foldMap :: Monoid m0 => (a -> m0) -> ListT m a -> m0

foldr :: (a -> b -> b) -> b -> ListT m a -> b

foldr' :: (a -> b -> b) -> b -> ListT m a -> b

foldl :: (b -> a -> b) -> b -> ListT m a -> b

foldl' :: (b -> a -> b) -> b -> ListT m a -> b

foldr1 :: (a -> a -> a) -> ListT m a -> a

foldl1 :: (a -> a -> a) -> ListT m a -> a

toList :: ListT m a -> [a]

null :: ListT m a -> Bool

length :: ListT m a -> Int

elem :: Eq a => a -> ListT m a -> Bool

maximum :: Ord a => ListT m a -> a

minimum :: Ord a => ListT m a -> a

sum :: Num a => ListT m a -> a

product :: Num a => ListT m a -> a

Foldable m => Foldable (Step m)

Defined in List.Transformer

Methods

fold :: Monoid m0 => Step m m0 -> m0

foldMap :: Monoid m0 => (a -> m0) -> Step m a -> m0

foldr :: (a -> b -> b) -> b -> Step m a -> b

foldr' :: (a -> b -> b) -> b -> Step m a -> b

foldl :: (b -> a -> b) -> b -> Step m a -> b

foldl' :: (b -> a -> b) -> b -> Step m a -> b

foldr1 :: (a -> a -> a) -> Step m a -> a

foldl1 :: (a -> a -> a) -> Step m a -> a

toList :: Step m a -> [a]

null :: Step m a -> Bool

length :: Step m a -> Int

elem :: Eq a => a -> Step m a -> Bool

maximum :: Ord a => Step m a -> a

minimum :: Ord a => Step m a -> a

sum :: Num a => Step m a -> a

product :: Num a => Step m a -> a

(Monad m, Foldable m) => Foldable (LogicT m)

Defined in Control.Monad.Logic

Methods

fold :: Monoid m0 => LogicT m m0 -> m0

foldMap :: Monoid m0 => (a -> m0) -> LogicT m a -> m0

foldr :: (a -> b -> b) -> b -> LogicT m a -> b

foldr' :: (a -> b -> b) -> b -> LogicT m a -> b

foldl :: (b -> a -> b) -> b -> LogicT m a -> b

foldl' :: (b -> a -> b) -> b -> LogicT m a -> b

foldr1 :: (a -> a -> a) -> LogicT m a -> a

foldl1 :: (a -> a -> a) -> LogicT m a -> a

toList :: LogicT m a -> [a]

null :: LogicT m a -> Bool

length :: LogicT m a -> Int

elem :: Eq a => a -> LogicT m a -> Bool

maximum :: Ord a => LogicT m a -> a

minimum :: Ord a => LogicT m a -> a

sum :: Num a => LogicT m a -> a

product :: Num a => LogicT m a -> a

Foldable (IntPSQ p)

Defined in Data.IntPSQ.Internal

Methods

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

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

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

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

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

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

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

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

toList :: IntPSQ p a -> [a]

null :: IntPSQ p a -> Bool

length :: IntPSQ p a -> Int

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

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

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

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

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

Foldable (Subterms n)

Defined in Hedgehog.Internal.Gen

Methods

fold :: Monoid m => Subterms n m -> m

foldMap :: Monoid m => (a -> m) -> Subterms n a -> m

foldr :: (a -> b -> b) -> b -> Subterms n a -> b

foldr' :: (a -> b -> b) -> b -> Subterms n a -> b

foldl :: (b -> a -> b) -> b -> Subterms n a -> b

foldl' :: (b -> a -> b) -> b -> Subterms n a -> b

foldr1 :: (a -> a -> a) -> Subterms n a -> a

foldl1 :: (a -> a -> a) -> Subterms n a -> a

toList :: Subterms n a -> [a]

null :: Subterms n a -> Bool

length :: Subterms n a -> Int

elem :: Eq a => a -> Subterms n a -> Bool

maximum :: Ord a => Subterms n a -> a

minimum :: Ord a => Subterms n a -> a

sum :: Num a => Subterms n a -> a

product :: Num a => Subterms n a -> a

Foldable f => Foldable (Rec1 f)

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 :: * -> *)

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 :: * -> *)

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 :: * -> *)

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 :: * -> *)

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 :: * -> *)

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 ()) :: * -> *)

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 :: * -> *)

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

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 f => Foldable (Backwards f)

Derived instance.

Defined in Control.Applicative.Backwards

Methods

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

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

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

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

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

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

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

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

toList :: Backwards f a -> [a]

null :: Backwards f a -> Bool

length :: Backwards f a -> Int

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

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

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

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

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

Foldable (Forget r a)

Defined in Data.Profunctor.Types

Methods

fold :: Monoid m => Forget r a m -> m

foldMap :: Monoid m => (a0 -> m) -> Forget r a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Forget r a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Forget r a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Forget r a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Forget r a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Forget r a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Forget r a a0 -> a0

toList :: Forget r a a0 -> [a0]

null :: Forget r a a0 -> Bool

length :: Forget r a a0 -> Int

elem :: Eq a0 => a0 -> Forget r a a0 -> Bool

maximum :: Ord a0 => Forget r a a0 -> a0

minimum :: Ord a0 => Forget r a a0 -> a0

sum :: Num a0 => Forget r a a0 -> a0

product :: Num a0 => Forget r a a0 -> a0

Foldable (Bucket k p)

Defined in Data.HashPSQ.Internal

Methods

fold :: Monoid m => Bucket k p m -> m

foldMap :: Monoid m => (a -> m) -> Bucket k p a -> m

foldr :: (a -> b -> b) -> b -> Bucket k p a -> b

foldr' :: (a -> b -> b) -> b -> Bucket k p a -> b

foldl :: (b -> a -> b) -> b -> Bucket k p a -> b

foldl' :: (b -> a -> b) -> b -> Bucket k p a -> b

foldr1 :: (a -> a -> a) -> Bucket k p a -> a

foldl1 :: (a -> a -> a) -> Bucket k p a -> a

toList :: Bucket k p a -> [a]

null :: Bucket k p a -> Bool

length :: Bucket k p a -> Int

elem :: Eq a => a -> Bucket k p a -> Bool

maximum :: Ord a => Bucket k p a -> a

minimum :: Ord a => Bucket k p a -> a

sum :: Num a => Bucket k p a -> a

product :: Num a => Bucket k p a -> a

Foldable (LTree k p)

Defined in Data.OrdPSQ.Internal

Methods

fold :: Monoid m => LTree k p m -> m

foldMap :: Monoid m => (a -> m) -> LTree k p a -> m

foldr :: (a -> b -> b) -> b -> LTree k p a -> b

foldr' :: (a -> b -> b) -> b -> LTree k p a -> b

foldl :: (b -> a -> b) -> b -> LTree k p a -> b

foldl' :: (b -> a -> b) -> b -> LTree k p a -> b

foldr1 :: (a -> a -> a) -> LTree k p a -> a

foldl1 :: (a -> a -> a) -> LTree k p a -> a

toList :: LTree k p a -> [a]

null :: LTree k p a -> Bool

length :: LTree k p a -> Int

elem :: Eq a => a -> LTree k p a -> Bool

maximum :: Ord a => LTree k p a -> a

minimum :: Ord a => LTree k p a -> a

sum :: Num a => LTree k p a -> a

product :: Num a => LTree k p a -> a

Foldable (Elem k p)

Defined in Data.OrdPSQ.Internal

Methods

fold :: Monoid m => Elem k p m -> m

foldMap :: Monoid m => (a -> m) -> Elem k p a -> m

foldr :: (a -> b -> b) -> b -> Elem k p a -> b

foldr' :: (a -> b -> b) -> b -> Elem k p a -> b

foldl :: (b -> a -> b) -> b -> Elem k p a -> b

foldl' :: (b -> a -> b) -> b -> Elem k p a -> b

foldr1 :: (a -> a -> a) -> Elem k p a -> a

foldl1 :: (a -> a -> a) -> Elem k p a -> a

toList :: Elem k p a -> [a]

null :: Elem k p a -> Bool

length :: Elem k p a -> Int

elem :: Eq a => a -> Elem k p a -> Bool

maximum :: Ord a => Elem k p a -> a

minimum :: Ord a => Elem k p a -> a

sum :: Num a => Elem k p a -> a

product :: Num a => Elem k p a -> a

Foldable (HashPSQ k p)

Defined in Data.HashPSQ.Internal

Methods

fold :: Monoid m => HashPSQ k p m -> m

foldMap :: Monoid m => (a -> m) -> HashPSQ k p a -> m

foldr :: (a -> b -> b) -> b -> HashPSQ k p a -> b

foldr' :: (a -> b -> b) -> b -> HashPSQ k p a -> b

foldl :: (b -> a -> b) -> b -> HashPSQ k p a -> b

foldl' :: (b -> a -> b) -> b -> HashPSQ k p a -> b

foldr1 :: (a -> a -> a) -> HashPSQ k p a -> a

foldl1 :: (a -> a -> a) -> HashPSQ k p a -> a

toList :: HashPSQ k p a -> [a]

null :: HashPSQ k p a -> Bool

length :: HashPSQ k p a -> Int

elem :: Eq a => a -> HashPSQ k p a -> Bool

maximum :: Ord a => HashPSQ k p a -> a

minimum :: Ord a => HashPSQ k p a -> a

sum :: Num a => HashPSQ k p a -> a

product :: Num a => HashPSQ k p a -> a

Foldable (OrdPSQ k p)

Defined in Data.OrdPSQ.Internal

Methods

fold :: Monoid m => OrdPSQ k p m -> m

foldMap :: Monoid m => (a -> m) -> OrdPSQ k p a -> m

foldr :: (a -> b -> b) -> b -> OrdPSQ k p a -> b

foldr' :: (a -> b -> b) -> b -> OrdPSQ k p a -> b

foldl :: (b -> a -> b) -> b -> OrdPSQ k p a -> b

foldl' :: (b -> a -> b) -> b -> OrdPSQ k p a -> b

foldr1 :: (a -> a -> a) -> OrdPSQ k p a -> a

foldl1 :: (a -> a -> a) -> OrdPSQ k p a -> a

toList :: OrdPSQ k p a -> [a]

null :: OrdPSQ k p a -> Bool

length :: OrdPSQ k p a -> Int

elem :: Eq a => a -> OrdPSQ k p a -> Bool

maximum :: Ord a => OrdPSQ k p a -> a

minimum :: Ord a => OrdPSQ k p a -> a

sum :: Num a => OrdPSQ k p a -> a

product :: Num a => OrdPSQ k p 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 :: * -> *)

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)

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)

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 (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)

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)

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 :: * -> *)

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

(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

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.

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.

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.

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

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

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

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

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

The sum of a collection of actions, generalizing concat. As of base 4.8.0.0, msum is just asum, specialized to MonadPlus.

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

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

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.

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.

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

Determines whether all elements of the structure satisfy the predicate.

notElem :: (Foldable t, Eq a) => a -> t a -> Bool infix 4

notElem is the negation of elem.

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

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

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

The foldM function is analogous to foldl, except that its result is encapsulated in a monad. Note that foldM works from left-to-right over the list arguments. This could be an issue where (>>) and the `folded function' are not commutative.

foldM f a1 [x1, x2, ..., xm]

==

do
  a2 <- f a1 x1
  a3 <- f a2 x2
  ...
  f am xm

If right-to-left evaluation is required, the input list should be reversed.

Note: foldM is the same as foldlM

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

Like foldM, but discards the result.

foldMapBy :: Foldable t => (r -> r -> r) -> r -> (a -> r) -> t a -> r

Fold a value using its Foldable instance using explicitly provided Monoid operations. This is like foldMap where the Monoid instance can be manually specified.

foldMapBy mappend mempty ≡ foldMap

>>> foldMapBy (+) 0 length ["hello","world"]
10

foldBy :: Foldable t => (a -> a -> a) -> a -> t a -> a

Fold a value using its Foldable instance using explicitly provided Monoid operations. This is like fold where the Monoid instance can be manually specified.

foldBy mappend mempty ≡ fold

>>> foldBy (++) [] ["hello","world"]
"helloworld"

inits :: Foldable f => f a -> NonEmpty [a]

The inits function takes a stream xs and returns all the finite prefixes of xs.

tails :: Foldable f => f a -> NonEmpty [a]

The tails function takes a stream xs and returns all the suffixes of xs.

insert :: (Foldable f, Ord a) => a -> f a -> NonEmpty a

insert x xs inserts x into the last position in xs where it is still less than or equal to the next element. In particular, if the list is sorted beforehand, the result will also be sorted.

group :: (Foldable f, Eq a) => f a -> [NonEmpty a]

The group function takes a stream and returns a list of streams such that flattening the resulting list is equal to the argument. Moreover, each stream in the resulting list contains only equal elements. For example, in list notation:

'group' $ 'cycle' "Mississippi"
  = "M" : "i" : "ss" : "i" : "ss" : "i" : "pp" : "i" : "M" : "i" : ...

groupBy :: Foldable f => (a -> a -> Bool) -> f a -> [NonEmpty a]

groupBy operates like group, but uses the provided equality predicate instead of ==.

groupWith :: (Foldable f, Eq b) => (a -> b) -> f a -> [NonEmpty a]

groupWith operates like group, but uses the provided projection when comparing for equality

groupAllWith :: Ord b => (a -> b) -> [a] -> [NonEmpty a]

groupAllWith operates like groupWith, but sorts the list first so that each equivalence class has, at most, one list in the output

Foldable1

class Foldable t => Foldable1 (t :: * -> *) where

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 Log

Defined in Numeric.Log

Methods

fold1 :: Semigroup m => Log m -> m

foldMap1 :: Semigroup m => (a -> m) -> Log a -> m

toNonEmpty :: Log a -> NonEmpty a

Foldable1 (V1 :: * -> *)

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

asum1 :: (Foldable1 t, Alt m) => t (m a) -> m a

foldlM1 :: (Foldable1 t, Monad m) => (a -> a -> m a) -> t a -> m a

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

let g = flip $ (=<<) . f
in foldlM1 f (x1 :| [x2, ..., xn]) == (...((x1 `f` x2) `g` x2) `g`...) `g` xn

foldrM1 :: (Foldable1 t, Monad m) => (a -> a -> m a) -> t a -> m a

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

let g = (=<<) . f
in foldrM1 f (x1 :| [x2, ..., xn]) == x1 `g` (x2 `g` ... (xn-1 `f` xn)...)

for1_ :: (Foldable1 t, Apply f) => t a -> (a -> f b) -> f ()

intercalate1 :: (Foldable1 t, Semigroup m) => m -> t m -> m

Insert an m between each pair of 't m'. Equivalent to intercalateMap1 with id as the second argument.

>>> intercalate1 ", " $ "hello" :| ["how", "are", "you"]
"hello, how, are, you"

>>> intercalate1 ", " $ "hello" :| []
"hello"

>>> intercalate1 mempty $ "I" :| ["Am", "Fine", "You?"]
"IAmFineYou?"

intercalateMap1 :: (Foldable1 t, Semigroup m) => m -> (a -> m) -> t a -> m

Insert m between each pair of m derived from a.

>>> intercalateMap1 " " show $ True :| [False, True]
"True False True"

>>> intercalateMap1 " " show $ True :| []
"True"

sequenceA1_ :: (Foldable1 t, Apply f) => t (f a) -> f ()

traverse1_ :: (Foldable1 t, Apply f) => (a -> f b) -> t a -> f ()