planet-mitchell-0.1.0: Planet Mitchell

Safe HaskellSafe
LanguageHaskell2010

Foldable

Contents

Synopsis

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

Instance details

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

Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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

Instance details

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

Instance details

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

Instance details

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

Instance details

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

Instance details

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 
Instance details

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

Instance details

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

Instance details

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

Instance details

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

Instance details

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

Instance details

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

Instance details

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

Instance details

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 
Instance details

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

Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 HashSet 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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.

Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 Forest 
Instance details

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 
Instance details

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 P 
Instance details

Defined in Data.HashMap.Strict.InsOrd

Methods

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

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

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

foldr' :: (a -> b -> b) -> b -> P a -> b #

foldl :: (b -> a -> b) -> b -> P a -> b #

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

foldr1 :: (a -> a -> a) -> P a -> a #

foldl1 :: (a -> a -> a) -> P a -> a #

toList :: P a -> [a] #

null :: P a -> Bool #

length :: P a -> Int #

elem :: Eq a => a -> P a -> Bool #

maximum :: Ord a => P a -> a #

minimum :: Ord a => P a -> a #

sum :: Num a => P a -> a #

product :: Num a => P a -> a #

Foldable (Either a)

Since: base-4.7.0.0

Instance details

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 :: * -> *) 
Instance details

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

Instance details

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

Instance details

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) 
Instance details

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) 
Instance details

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

Instance details

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

Instance details

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

Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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 (InsOrdHashMap k) 
Instance details

Defined in Data.HashMap.Strict.InsOrd

Methods

fold :: Monoid m => InsOrdHashMap k m -> m #

foldMap :: Monoid m => (a -> m) -> InsOrdHashMap k a -> m #

foldr :: (a -> b -> b) -> b -> InsOrdHashMap k a -> b #

foldr' :: (a -> b -> b) -> b -> InsOrdHashMap k a -> b #

foldl :: (b -> a -> b) -> b -> InsOrdHashMap k a -> b #

foldl' :: (b -> a -> b) -> b -> InsOrdHashMap k a -> b #

foldr1 :: (a -> a -> a) -> InsOrdHashMap k a -> a #

foldl1 :: (a -> a -> a) -> InsOrdHashMap k a -> a #

toList :: InsOrdHashMap k a -> [a] #

null :: InsOrdHashMap k a -> Bool #

length :: InsOrdHashMap k a -> Int #

elem :: Eq a => a -> InsOrdHashMap k a -> Bool #

maximum :: Ord a => InsOrdHashMap k a -> a #

minimum :: Ord a => InsOrdHashMap k a -> a #

sum :: Num a => InsOrdHashMap k a -> a #

product :: Num a => InsOrdHashMap k a -> a #

Foldable f => Foldable (Yoneda f) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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 f => Foldable (Rec1 f) 
Instance details

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 :: * -> *) 
Instance details

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 :: * -> *) 
Instance details

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 :: * -> *) 
Instance details

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 :: * -> *) 
Instance details

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 :: * -> *) 
Instance details

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 ()) :: * -> *) 
Instance details

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

Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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.

Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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 :: * -> *) 
Instance details

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) 
Instance details

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) 
Instance details

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

Instance details

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

Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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

Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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 :: * -> *) 
Instance details

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) 
Instance details

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) 
Instance details

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 #

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

Determines whether all elements of the structure satisfy the predicate.

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.

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

Determines whether any element of the structure satisfies the predicate.

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

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

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

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.

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 memptyfold
>>> foldBy (++) [] ["hello","world"]
"helloworld"

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 memptyfoldMap
>>> foldMapBy (+) 0 length ["hello","world"]
10

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.

foldr1May :: Foldable t => (a -> a -> a) -> t a -> Maybe a #

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.

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

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" : ...

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

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

inits :: Foldable f => f a -> NonEmpty [a] #

The inits function takes a stream xs and returns all the finite prefixes 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.

maximumByMay :: Foldable t => (a -> a -> Ordering) -> t a -> Maybe a #

maximumMay :: (Foldable t, Ord a) => t a -> Maybe a #

minimumByMay :: Foldable t => (a -> a -> Ordering) -> t a -> Maybe a #

minimumMay :: (Foldable t, Ord a) => t a -> Maybe a #

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.

notElem :: (Foldable t, Eq a) => a -> t a -> Bool infix 4 #

notElem is the negation of elem.

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.

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.

tails :: Foldable f => f a -> NonEmpty [a] #

The tails function takes a stream xs and returns all the suffixes of xs.

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.

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 :: * -> *) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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 () #

Bifoldable

class Bifoldable (p :: * -> * -> *) where #

Bifoldable identifies foldable structures with two different varieties of elements (as opposed to Foldable, which has one variety of element). Common examples are Either and '(,)':

instance Bifoldable Either where
  bifoldMap f _ (Left  a) = f a
  bifoldMap _ g (Right b) = g b

instance Bifoldable (,) where
  bifoldr f g z (a, b) = f a (g b z)

A minimal Bifoldable definition consists of either bifoldMap or bifoldr. When defining more than this minimal set, one should ensure that the following identities hold:

bifoldbifoldMap id id
bifoldMap f g ≡ bifoldr (mappend . f) (mappend . g) mempty
bifoldr f g z t ≡ appEndo (bifoldMap (Endo . f) (Endo . g) t) z

If the type is also a Bifunctor instance, it should satisfy:

'bifoldMap' f g ≡ 'bifold' . 'bimap' f g

which implies that

'bifoldMap' f g . 'bimap' h i ≡ 'bifoldMap' (f . h) (g . i)

Since: base-4.10.0.0

Minimal complete definition

bifoldr | bifoldMap

Methods

bifold :: Monoid m => p m m -> m #

Combines the elements of a structure using a monoid.

bifoldbifoldMap id id

Since: base-4.10.0.0

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> p a b -> m #

Combines the elements of a structure, given ways of mapping them to a common monoid.

bifoldMap f g
     ≡ bifoldr (mappend . f) (mappend . g) mempty

Since: base-4.10.0.0

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c #

Combines the elements of a structure in a right associative manner. Given a hypothetical function toEitherList :: p a b -> [Either a b] yielding a list of all elements of a structure in order, the following would hold:

bifoldr f g z ≡ foldr (either f g) z . toEitherList

Since: base-4.10.0.0

Instances
Bifoldable Either

Since: base-4.10.0.0

Instance details

Defined in Data.Bifoldable

Methods

bifold :: Monoid m => Either m m -> m #

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Either a b -> m #

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Either a b -> c #

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Either a b -> c #

Bifoldable (,)

Since: base-4.10.0.0

Instance details

Defined in Data.Bifoldable

Methods

bifold :: Monoid m => (m, m) -> m #

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> (a, b) -> m #

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> (a, b) -> c #

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> (a, b) -> c #

Bifoldable Arg

Since: base-4.10.0.0

Instance details

Defined in Data.Semigroup

Methods

bifold :: Monoid m => Arg m m -> m #

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Arg a b -> m #

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Arg a b -> c #

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Arg a b -> c #

Bifoldable ((,,) x)

Since: base-4.10.0.0

Instance details

Defined in Data.Bifoldable

Methods

bifold :: Monoid m => (x, m, m) -> m #

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> (x, a, b) -> m #

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> (x, a, b) -> c #

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> (x, a, b) -> c #

Bifoldable (Const :: * -> * -> *)

Since: base-4.10.0.0

Instance details

Defined in Data.Bifoldable

Methods

bifold :: Monoid m => Const m m -> m #

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Const a b -> m #

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Const a b -> c #

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Const a b -> c #

Foldable f => Bifoldable (FreeF f) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

bifold :: Monoid m => FreeF f m m -> m #

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> FreeF f a b -> m #

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> FreeF f a b -> c #

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> FreeF f a b -> c #

Foldable f => Bifoldable (CofreeF f) 
Instance details

Defined in Control.Comonad.Trans.Cofree

Methods

bifold :: Monoid m => CofreeF f m m -> m #

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> CofreeF f a b -> m #

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> CofreeF f a b -> c #

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> CofreeF f a b -> c #

Bifoldable (Tagged :: * -> * -> *) 
Instance details

Defined in Data.Tagged

Methods

bifold :: Monoid m => Tagged m m -> m #

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Tagged a b -> m #

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Tagged a b -> c #

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Tagged a b -> c #

Bifoldable (K1 i :: * -> * -> *)

Since: base-4.10.0.0

Instance details

Defined in Data.Bifoldable

Methods

bifold :: Monoid m => K1 i m m -> m #

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> K1 i a b -> m #

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> K1 i a b -> c #

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> K1 i a b -> c #

Bifoldable ((,,,) x y)

Since: base-4.10.0.0

Instance details

Defined in Data.Bifoldable

Methods

bifold :: Monoid m => (x, y, m, m) -> m #

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> (x, y, a, b) -> m #

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> (x, y, a, b) -> c #

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> (x, y, a, b) -> c #

Bifoldable ((,,,,) x y z)

Since: base-4.10.0.0

Instance details

Defined in Data.Bifoldable

Methods

bifold :: Monoid m => (x, y, z, m, m) -> m #

bifoldMap