Control.Foldl.Text

Folds for text streams

Folding

fold :: Fold Text a -> Text -> a

Apply a strict left Fold to lazy text

foldM :: Monad m => FoldM m Text a -> Text -> m a

Apply a strict monadic left FoldM to lazy text

Folds

head :: Fold Text (Maybe Char)

Get the first character of a text stream or return Nothing if the stream is empty

last :: Fold Text (Maybe Char)

Get the last character of a text stream or return Nothing if the text stream is empty

null :: Fold Text Bool

Returns True if the text stream is empty, False otherwise

length :: Num n => Fold Text n

Return the length of the text stream in characters

any :: (Char -> Bool) -> Fold Text Bool

(any predicate) returns True if any character satisfies the predicate, False otherwise

all :: (Char -> Bool) -> Fold Text Bool

(all predicate) returns True if all characters satisfy the predicate, False otherwise

maximum :: Fold Text (Maybe Char)

Computes the maximum character

minimum :: Fold Text (Maybe Char)

Computes the minimum character

elem :: Char -> Fold Text Bool

(elem c) returns True if the text stream has a character equal to c, False otherwise

notElem :: Char -> Fold Text Bool

(notElem c) returns False if the text stream has a character equal to c, True otherwise

find :: (Char -> Bool) -> Fold Text (Maybe Char)

(find predicate) returns the first character that satisfies the predicate or Nothing if no character satisfies the predicate

index :: Integral n => n -> Fold Text (Maybe Char)

(index n) returns the nth character of the text stream, or Nothing if the stream has an insufficient number of characters

elemIndex :: Num n => Char -> Fold Text (Maybe n)

(elemIndex c) returns the index of the first character that equals c, or Nothing if no character matches

findIndex :: Num n => (Char -> Bool) -> Fold Text (Maybe n)

(findIndex predicate) returns the index of the first character that satisfies the predicate, or Nothing if no character satisfies the predicate

count :: Num n => Char -> Fold Text n

(count c) returns the number of times c appears

lazy :: Fold Text Text

Combine all the strict Text chunks to build a lazy Text

Re-exports

Control.Foldl re-exports the Fold type

Data.Text re-exports the Text type

class Foldable (t :: TYPE LiftedRep -> Type)

The Foldable class represents data structures that can be reduced to a summary value one element at a time. Strict left-associative folds are a good fit for space-efficient reduction, while lazy right-associative folds are a good fit for corecursive iteration, or for folds that short-circuit after processing an initial subsequence of the structure's elements.

Instances can be derived automatically by enabling the DeriveFoldable extension. For example, a derived instance for a binary tree might be:

{-# LANGUAGE DeriveFoldable #-}
data Tree a = Empty
            | Leaf a
            | Node (Tree a) a (Tree a)
    deriving Foldable

A more detailed description can be found in the Overview section of Data.Foldable.

For the class laws see the Laws section of Data.Foldable.

Minimal complete definition

foldMap | foldr

Instances

Foldable ZipList

Since: base-4.9.0.0

Defined in Control.Applicative

Methods

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

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

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 Complex

Since: base-4.9.0.0

Defined in Data.Complex

Methods

fold :: Monoid m => Complex m -> m

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

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 Identity

Since: base-4.8.0.0

Defined in Data.Functor.Identity

Methods

fold :: Monoid m => Identity m -> m

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

foldMap' :: Monoid m => (a -> m) -> Identity a -> m

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

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

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

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

foldr1 :: (a -> a -> a) -> Identity a -> a

foldl1 :: (a -> a -> a) -> Identity a -> a

toList :: Identity a -> [a]

null :: Identity a -> Bool

length :: Identity a -> Int

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

maximum :: Ord a => Identity a -> a

minimum :: Ord a => Identity a -> a

sum :: Num a => Identity a -> a

product :: Num a => Identity a -> a

Foldable First

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

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

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

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

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

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

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

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

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

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

toList :: First a -> [a]

null :: First a -> Bool

length :: First a -> Int

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

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

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

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

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

Foldable Last

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

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

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

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 Down

Since: base-4.12.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => Down m -> m

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

foldMap' :: Monoid m => (a -> m) -> Down a -> m

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

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

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

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

foldr1 :: (a -> a -> a) -> Down a -> a

foldl1 :: (a -> a -> a) -> Down a -> a

toList :: Down a -> [a]

null :: Down a -> Bool

length :: Down a -> Int

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

maximum :: Ord a => Down a -> a

minimum :: Ord a => Down a -> a

sum :: Num a => Down a -> a

product :: Num a => Down a -> a

Foldable First

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

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

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

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

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

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

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

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

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

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

toList :: First a -> [a]

null :: First a -> Bool

length :: First a -> Int

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

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

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

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

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

Foldable Last

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

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

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

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 Max

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fold :: Monoid m => Max m -> m

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

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 Min

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fold :: Monoid m => Min m -> m

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

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 Dual

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

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

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

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 Product

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

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

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

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 Sum

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

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

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

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 Par1

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

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

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

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 IntMap

Folds in order of increasing key.

Defined in Data.IntMap.Internal

Methods

fold :: Monoid m => IntMap m -> m

foldMap :: Monoid m => (a -> m) -> IntMap a -> 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 Digit

Defined in Data.Sequence.Internal

Methods

fold :: Monoid m => Digit m -> m

foldMap :: Monoid m => (a -> m) -> Digit a -> 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 Elem

Defined in Data.Sequence.Internal

Methods

fold :: Monoid m => Elem m -> m

foldMap :: Monoid m => (a -> m) -> Elem a -> 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 FingerTree

Defined in Data.Sequence.Internal

Methods

fold :: Monoid m => FingerTree m -> m

foldMap :: Monoid m => (a -> m) -> FingerTree a -> 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 Node

Defined in Data.Sequence.Internal

Methods

fold :: Monoid m => Node m -> m

foldMap :: Monoid m => (a -> m) -> Node a -> 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 Seq

Defined in Data.Sequence.Internal

Methods

fold :: Monoid m => Seq m -> m

foldMap :: Monoid m => (a -> m) -> Seq a -> 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 ViewL

Defined in Data.Sequence.Internal

Methods

fold :: Monoid m => ViewL m -> m

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

foldMap' :: Monoid m => (a -> m) -> ViewL a -> m

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

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

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

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

foldr1 :: (a -> a -> a) -> ViewL a -> a

foldl1 :: (a -> a -> a) -> ViewL a -> a

toList :: ViewL a -> [a]

null :: ViewL a -> Bool

length :: ViewL a -> Int

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

maximum :: Ord a => ViewL a -> a

minimum :: Ord a => ViewL a -> a

sum :: Num a => ViewL a -> a

product :: Num a => ViewL a -> a

Foldable ViewR

Defined in Data.Sequence.Internal

Methods

fold :: Monoid m => ViewR m -> m

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

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

Folds in order of increasing key.

Defined in Data.Set.Internal

Methods

fold :: Monoid m => Set m -> m

foldMap :: Monoid m => (a -> m) -> Set a -> 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 Tree

Defined in Data.Tree

Methods

fold :: Monoid m => Tree m -> m

foldMap :: Monoid m => (a -> m) -> Tree a -> 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 Hashed

Defined in Data.Hashable.Class

Methods

fold :: Monoid m => Hashed m -> m

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

foldMap' :: Monoid m => (a -> m) -> Hashed a -> m

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

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

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

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

foldr1 :: (a -> a -> a) -> Hashed a -> a

foldl1 :: (a -> a -> a) -> Hashed a -> a

toList :: Hashed a -> [a]

null :: Hashed a -> Bool

length :: Hashed a -> Int

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

maximum :: Ord a => Hashed a -> a

minimum :: Ord a => Hashed a -> a

sum :: Num a => Hashed a -> a

product :: Num a => Hashed a -> a

Foldable HashSet

Defined in Data.HashSet.Internal

Methods

fold :: Monoid m => HashSet m -> m

foldMap :: Monoid m => (a -> m) -> HashSet a -> 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 NonEmpty

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => NonEmpty m -> m

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

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 Maybe

Since: base-2.1

Defined in Data.Foldable

Methods

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

foldMap :: Monoid m => (a -> m) -> Maybe a -> 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 Solo

Since: base-4.15

Defined in Data.Foldable

Methods

fold :: Monoid m => Solo m -> m

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

foldMap' :: Monoid m => (a -> m) -> Solo a -> m

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

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

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

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

foldr1 :: (a -> a -> a) -> Solo a -> a

foldl1 :: (a -> a -> a) -> Solo a -> a

toList :: Solo a -> [a]

null :: Solo a -> Bool

length :: Solo a -> Int

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

maximum :: Ord a => Solo a -> a

minimum :: Ord a => Solo a -> a

sum :: Num a => Solo a -> a

product :: Num a => Solo a -> a

Foldable []

Since: base-2.1

Defined in Data.Foldable

Methods

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

foldMap :: Monoid m => (a -> m) -> [a] -> 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 (Either a)

Since: base-4.7.0.0

Defined in Data.Foldable

Methods

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

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

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 (Proxy :: TYPE LiftedRep -> Type)

Since: base-4.7.0.0

Defined in Data.Foldable

Methods

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

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

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 (Arg a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

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

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

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

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

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

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

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 (U1 :: TYPE LiftedRep -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

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

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

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 (UAddr :: TYPE LiftedRep -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => UAddr m -> m

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

foldMap' :: Monoid m => (a -> m) -> UAddr a -> m

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

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

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

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

foldr1 :: (a -> a -> a) -> UAddr a -> a

foldl1 :: (a -> a -> a) -> UAddr a -> a

toList :: UAddr a -> [a]

null :: UAddr a -> Bool

length :: UAddr a -> Int

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

maximum :: Ord a => UAddr a -> a

minimum :: Ord a => UAddr a -> a

sum :: Num a => UAddr a -> a

product :: Num a => UAddr a -> a

Foldable (UChar :: TYPE LiftedRep -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => UChar m -> m

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

foldMap' :: Monoid m => (a -> m) -> UChar a -> m

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

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

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

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

foldr1 :: (a -> a -> a) -> UChar a -> a

foldl1 :: (a -> a -> a) -> UChar a -> a

toList :: UChar a -> [a]

null :: UChar a -> Bool

length :: UChar a -> Int

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

maximum :: Ord a => UChar a -> a

minimum :: Ord a => UChar a -> a

sum :: Num a => UChar a -> a

product :: Num a => UChar a -> a

Foldable (UDouble :: TYPE LiftedRep -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => UDouble m -> m

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

foldMap' :: Monoid m => (a -> m) -> UDouble a -> m

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

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

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

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

foldr1 :: (a -> a -> a) -> UDouble a -> a

foldl1 :: (a -> a -> a) -> UDouble a -> a

toList :: UDouble a -> [a]

null :: UDouble a -> Bool

length :: UDouble a -> Int

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

maximum :: Ord a => UDouble a -> a

minimum :: Ord a => UDouble a -> a

sum :: Num a => UDouble a -> a

product :: Num a => UDouble a -> a

Foldable (UFloat :: TYPE LiftedRep -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => UFloat m -> m

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

foldMap' :: Monoid m => (a -> m) -> UFloat a -> m

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

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

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

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

foldr1 :: (a -> a -> a) -> UFloat a -> a

foldl1 :: (a -> a -> a) -> UFloat a -> a

toList :: UFloat a -> [a]

null :: UFloat a -> Bool

length :: UFloat a -> Int

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

maximum :: Ord a => UFloat a -> a

minimum :: Ord a => UFloat a -> a

sum :: Num a => UFloat a -> a

product :: Num a => UFloat a -> a

Foldable (UInt :: TYPE LiftedRep -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => UInt m -> m

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

foldMap' :: Monoid m => (a -> m) -> UInt a -> m

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

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

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

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

foldr1 :: (a -> a -> a) -> UInt a -> a

foldl1 :: (a -> a -> a) -> UInt a -> a

toList :: UInt a -> [a]

null :: UInt a -> Bool

length :: UInt a -> Int

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

maximum :: Ord a => UInt a -> a

minimum :: Ord a => UInt a -> a

sum :: Num a => UInt a -> a

product :: Num a => UInt a -> a

Foldable (UWord :: TYPE LiftedRep -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => UWord m -> m

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

foldMap' :: Monoid m => (a -> m) -> UWord a -> m

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

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

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

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

foldr1 :: (a -> a -> a) -> UWord a -> a

foldl1 :: (a -> a -> a) -> UWord a -> a

toList :: UWord a -> [a]

null :: UWord a -> Bool

length :: UWord a -> Int

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

maximum :: Ord a => UWord a -> a

minimum :: Ord a => UWord a -> a

sum :: Num a => UWord a -> a

product :: Num a => UWord a -> a

Foldable (V1 :: TYPE LiftedRep -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

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

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

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 (Map k)

Folds in order of increasing key.

Defined in Data.Map.Internal

Methods

fold :: Monoid m => Map k m -> m

foldMap :: Monoid m => (a -> m) -> Map k a -> m

foldMap' :: Monoid m => (a -> m) -> Map k a -> m

foldr :: (a -> b -> b) -> b -> Map k a -> b

foldr' :: (a -> b -> b) -> b -> Map k a -> b

foldl :: (b -> a -> b) -> b -> Map k a -> b

foldl' :: (b -> a -> b) -> b -> Map k a -> b

foldr1 :: (a -> a -> a) -> Map k a -> a

foldl1 :: (a -> a -> a) -> Map k a -> a

toList :: Map k a -> [a]

null :: Map k a -> Bool

length :: Map k a -> Int

elem :: Eq a => a -> Map k a -> Bool

maximum :: Ord a => Map k a -> a

minimum :: Ord a => Map k a -> a

sum :: Num a => Map k a -> a

product :: Num a => Map k a -> a

Foldable f => Foldable (ListT f)

Defined in Control.Monad.Trans.List

Methods

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

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

foldMap' :: Monoid m => (a -> m) -> ListT f a -> m

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

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

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

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

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

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

toList :: ListT f a -> [a]

null :: ListT f a -> Bool

length :: ListT f a -> Int

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

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

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

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

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

Foldable f => Foldable (MaybeT f)

Defined in Control.Monad.Trans.Maybe

Methods

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

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

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 (HashMap k)

Defined in Data.HashMap.Internal

Methods

fold :: Monoid m => HashMap k m -> m

foldMap :: Monoid m => (a -> m) -> HashMap k a -> 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 ((,) a)

Since: base-4.7.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => (a, m) -> m

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

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 (Const m :: TYPE LiftedRep -> Type)

Since: base-4.7.0.0

Defined in Data.Functor.Const

Methods

fold :: Monoid m0 => Const m m0 -> m0

foldMap :: Monoid m0 => (a -> m0) -> Const m a -> m0

foldMap' :: Monoid m0 => (a -> m0) -> Const m a -> m0

foldr :: (a -> b -> b) -> b -> Const m a -> b

foldr' :: (a -> b -> b) -> b -> Const m a -> b

foldl :: (b -> a -> b) -> b -> Const m a -> b

foldl' :: (b -> a -> b) -> b -> Const m a -> b

foldr1 :: (a -> a -> a) -> Const m a -> a

foldl1 :: (a -> a -> a) -> Const m a -> a

toList :: Const m a -> [a]

null :: Const m a -> Bool

length :: Const m a -> Int

elem :: Eq a => a -> Const m a -> Bool

maximum :: Ord a => Const m a -> a

minimum :: Ord a => Const m a -> a

sum :: Num a => Const m a -> a

product :: Num a => Const m a -> a

Foldable f => Foldable (Ap f)

Since: base-4.12.0.0

Defined in Data.Foldable

Methods

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

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

foldMap' :: Monoid m => (a -> m) -> Ap f a -> m

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

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

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

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

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

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

toList :: Ap f a -> [a]

null :: Ap f a -> Bool

length :: Ap f a -> Int

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

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

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

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

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

Foldable f => Foldable (Alt f)

Since: base-4.12.0.0

Defined in Data.Foldable

Methods

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

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

foldMap' :: Monoid m => (a -> m) -> Alt f a -> m

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

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

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

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

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

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

toList :: Alt f a -> [a]

null :: Alt f a -> Bool

length :: Alt f a -> Int

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

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

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

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

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

Foldable f => Foldable (Rec1 f)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

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

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

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

Bifoldable p => Foldable (Join p)

Defined in Data.Bifunctor.Join

Methods

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

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

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

Foldable (Tagged s)

Defined in Data.Tagged

Methods

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

foldMap :: Monoid m => (a -> m) -> Tagged s a -> 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 f => Foldable (ErrorT e f)

Defined in Control.Monad.Trans.Error

Methods

fold :: Monoid m => ErrorT e f m -> m

foldMap :: Monoid m => (a -> m) -> ErrorT e f a -> m

foldMap' :: Monoid m => (a -> m) -> ErrorT e f a -> m

foldr :: (a -> b -> b) -> b -> ErrorT e f a -> b

foldr' :: (a -> b -> b) -> b -> ErrorT e f a -> b

foldl :: (b -> a -> b) -> b -> ErrorT e f a -> b

foldl' :: (b -> a -> b) -> b -> ErrorT e f a -> b

foldr1 :: (a -> a -> a) -> ErrorT e f a -> a

foldl1 :: (a -> a -> a) -> ErrorT e f a -> a

toList :: ErrorT e f a -> [a]

null :: ErrorT e f a -> Bool

length :: ErrorT e f a -> Int

elem :: Eq a => a -> ErrorT e f a -> Bool

maximum :: Ord a => ErrorT e f a -> a

minimum :: Ord a => ErrorT e f a -> a

sum :: Num a => ErrorT e f a -> a

product :: Num a => ErrorT e f a -> a

Foldable f => Foldable (ExceptT e f)

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

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 (IdentityT f)

Defined in Control.Monad.Trans.Identity

Methods

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

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

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 (WriterT w f)

Defined in Control.Monad.Trans.Writer.Lazy

Methods

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

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

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

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

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

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

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

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

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

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

null :: WriterT w f a -> Bool

length :: WriterT w f a -> Int

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

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

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

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

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

Foldable f => Foldable (WriterT w f)

Defined in Control.Monad.Trans.Writer.Strict

Methods

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

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

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

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

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

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

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

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

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

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

null :: WriterT w f a -> Bool

length :: WriterT w f a -> Int

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

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

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

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

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

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

Since: base-4.9.0.0

Defined in Data.Functor.Product

Methods

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

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

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

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

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

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

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

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

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

toList :: Product f g a -> [a]

null :: Product f g a -> Bool

length :: Product f g a -> Int

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

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

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

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

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

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

Since: base-4.9.0.0

Defined in Data.Functor.Sum

Methods

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

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

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

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

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

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

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

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

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

toList :: Sum f g a -> [a]

null :: Sum f g a -> Bool

length :: Sum f g a -> Int

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

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

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

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

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

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

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

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

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

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 (K1 i c :: TYPE LiftedRep -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

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

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

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 (Forget r a :: TYPE LiftedRep -> TYPE LiftedRep)

Defined in Data.Profunctor.Types

Methods

fold :: Monoid m => Forget r a m -> m

foldMap :: Monoid m => (a0 -> m) -> Forget r a a0 -> 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 f, Foldable g) => Foldable (Compose f g)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

fold :: Monoid m => Compose f g m -> m

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

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

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

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

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

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

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 (M1 i c f)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

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

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

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 (Clown f a :: TYPE LiftedRep -> Type)

Defined in Data.Bifunctor.Clown

Methods

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

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

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

Bifoldable p => Foldable (Flip p a)

Defined in Data.Bifunctor.Flip

Methods

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

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

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 g => Foldable (Joker g a)

Defined in Data.Bifunctor.Joker

Methods

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

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

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 (WrappedBifunctor p a)

Defined in Data.Bifunctor.Wrapped

Methods

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

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

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 f, Bifoldable p) => Foldable (Tannen f p a)

Defined in Data.Bifunctor.Tannen

Methods

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

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

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

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

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

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

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

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

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

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

null :: Tannen f p a a0 -> Bool

length :: Tannen f p a a0 -> Int

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

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

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

sum :: Num a0 => Tannen f p a a0 -> a0

product :: Num a0 => Tannen f p a a0 -> a0

(Bifoldable p, Foldable g) => Foldable (Biff p f g a)

Defined in Data.Bifunctor.Biff

Methods

fold :: Monoid m => Biff p f g a m -> m

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

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

data FoldM m a b

Like Fold, but monadic.

A 'FoldM m a b' processes elements of type a and results in a monadic value of type m b.

Instances

Functor m => Profunctor (FoldM m)

Defined in Control.Foldl

Methods

dimap :: (a -> b) -> (c -> d) -> FoldM m b c -> FoldM m a d

lmap :: (a -> b) -> FoldM m b c -> FoldM m a c

rmap :: (b -> c) -> FoldM m a b -> FoldM m a c

(#.) :: forall a b c q. Coercible c b => q b c -> FoldM m a b -> FoldM m a c

(.#) :: forall a b c q. Coercible b a => FoldM m b c -> q a b -> FoldM m a c

Applicative m => Applicative (FoldM m a)

Defined in Control.Foldl

Methods

pure :: a0 -> FoldM m a a0

(<*>) :: FoldM m a (a0 -> b) -> FoldM m a a0 -> FoldM m a b

liftA2 :: (a0 -> b -> c) -> FoldM m a a0 -> FoldM m a b -> FoldM m a c

(*>) :: FoldM m a a0 -> FoldM m a b -> FoldM m a b

(<*) :: FoldM m a a0 -> FoldM m a b -> FoldM m a a0

Functor m => Functor (FoldM m a)

Defined in Control.Foldl

Methods

fmap :: (a0 -> b) -> FoldM m a a0 -> FoldM m a b

(<$) :: a0 -> FoldM m a b -> FoldM m a a0

Monad m => Extend (FoldM m a)

Defined in Control.Foldl

Methods

duplicated :: FoldM m a a0 -> FoldM m a (FoldM m a a0)

extended :: (FoldM m a a0 -> b) -> FoldM m a a0 -> FoldM m a b

(Monoid b, Monad m) => Monoid (FoldM m a b)

Defined in Control.Foldl

Methods

mempty :: FoldM m a b

mappend :: FoldM m a b -> FoldM m a b -> FoldM m a b

mconcat :: [FoldM m a b] -> FoldM m a b

(Semigroup b, Monad m) => Semigroup (FoldM m a b)

Defined in Control.Foldl

Methods

(<>) :: FoldM m a b -> FoldM m a b -> FoldM m a b

sconcat :: NonEmpty (FoldM m a b) -> FoldM m a b

stimes :: Integral b0 => b0 -> FoldM m a b -> FoldM m a b

(Monad m, Floating b) => Floating (FoldM m a b)

Defined in Control.Foldl

Methods

pi :: FoldM m a b

exp :: FoldM m a b -> FoldM m a b

log :: FoldM m a b -> FoldM m a b

sqrt :: FoldM m a b -> FoldM m a b

(**) :: FoldM m a b -> FoldM m a b -> FoldM m a b

logBase :: FoldM m a b -> FoldM m a b -> FoldM m a b

sin :: FoldM m a b -> FoldM m a b

cos :: FoldM m a b -> FoldM m a b

tan :: FoldM m a b -> FoldM m a b

asin :: FoldM m a b -> FoldM m a b

acos :: FoldM m a b -> FoldM m a b

atan :: FoldM m a b -> FoldM m a b

sinh :: FoldM m a b -> FoldM m a b

cosh :: FoldM m a b -> FoldM m a b

tanh :: FoldM m a b -> FoldM m a b

asinh :: FoldM m a b -> FoldM m a b

acosh :: FoldM m a b -> FoldM m a b

atanh :: FoldM m a b -> FoldM m a b

log1p :: FoldM m a b -> FoldM m a b

expm1 :: FoldM m a b -> FoldM m a b

log1pexp :: FoldM m a b -> FoldM m a b

log1mexp :: FoldM m a b -> FoldM m a b

(Monad m, Num b) => Num (FoldM m a b)

Defined in Control.Foldl

Methods

(+) :: FoldM m a b -> FoldM m a b -> FoldM m a b

(-) :: FoldM m a b -> FoldM m a b -> FoldM m a b

(*) :: FoldM m a b -> FoldM m a b -> FoldM m a b

negate :: FoldM m a b -> FoldM m a b

abs :: FoldM m a b -> FoldM m a b

signum :: FoldM m a b -> FoldM m a b

fromInteger :: Integer -> FoldM m a b

(Monad m, Fractional b) => Fractional (FoldM m a b)

Defined in Control.Foldl

Methods

(/) :: FoldM m a b -> FoldM m a b -> FoldM m a b

recip :: FoldM m a b -> FoldM m a b

fromRational :: Rational -> FoldM m a b

data Fold a b

Efficient representation of a left fold that preserves the fold's step function, initial accumulator, and extraction function

This allows the Applicative instance to assemble derived folds that traverse the container only once

A 'Fold a b' processes elements of type a and results in a value of type b.

Instances

Choice Fold

Defined in Control.Foldl

Methods

left' :: Fold a b -> Fold (Either a c) (Either b c)

right' :: Fold a b -> Fold (Either c a) (Either c b)

Profunctor Fold

Defined in Control.Foldl

Methods

dimap :: (a -> b) -> (c -> d) -> Fold b c -> Fold a d

lmap :: (a -> b) -> Fold b c -> Fold a c

rmap :: (b -> c) -> Fold a b -> Fold a c

(#.) :: forall a b c q. Coercible c b => q b c -> Fold a b -> Fold a c

(.#) :: forall a b c q. Coercible b a => Fold b c -> q a b -> Fold a c

Semigroupoid Fold

Defined in Control.Foldl

Methods

o :: forall (j :: k) (k1 :: k) (i :: k). Fold j k1 -> Fold i j -> Fold i k1

Applicative (Fold a)

Defined in Control.Foldl

Methods

pure :: a0 -> Fold a a0

(<*>) :: Fold a (a0 -> b) -> Fold a a0 -> Fold a b

liftA2 :: (a0 -> b -> c) -> Fold a a0 -> Fold a b -> Fold a c

(*>) :: Fold a a0 -> Fold a b -> Fold a b

(<*) :: Fold a a0 -> Fold a b -> Fold a a0

Functor (Fold a)

Defined in Control.Foldl

Methods

fmap :: (a0 -> b) -> Fold a a0 -> Fold a b

(<$) :: a0 -> Fold a b -> Fold a a0

Comonad (Fold a)

Defined in Control.Foldl

Methods

extract :: Fold a a0 -> a0

duplicate :: Fold a a0 -> Fold a (Fold a a0)

extend :: (Fold a a0 -> b) -> Fold a a0 -> Fold a b

Extend (Fold a)

Defined in Control.Foldl

Methods

duplicated :: Fold a a0 -> Fold a (Fold a a0)

extended :: (Fold a a0 -> b) -> Fold a a0 -> Fold a b

Monoid b => Monoid (Fold a b)

Defined in Control.Foldl

Methods

mempty :: Fold a b

mappend :: Fold a b -> Fold a b -> Fold a b

mconcat :: [Fold a b] -> Fold a b

Semigroup b => Semigroup (Fold a b)

Defined in Control.Foldl

Methods

(<>) :: Fold a b -> Fold a b -> Fold a b

sconcat :: NonEmpty (Fold a b) -> Fold a b

stimes :: Integral b0 => b0 -> Fold a b -> Fold a b

Floating b => Floating (Fold a b)

Defined in Control.Foldl

Methods

pi :: Fold a b

exp :: Fold a b -> Fold a b

log :: Fold a b -> Fold a b

sqrt :: Fold a b -> Fold a b

(**) :: Fold a b -> Fold a b -> Fold a b

logBase :: Fold a b -> Fold a b -> Fold a b

sin :: Fold a b -> Fold a b

cos :: Fold a b -> Fold a b

tan :: Fold a b -> Fold a b

asin :: Fold a b -> Fold a b

acos :: Fold a b -> Fold a b

atan :: Fold a b -> Fold a b

sinh :: Fold a b -> Fold a b

cosh :: Fold a b -> Fold a b

tanh :: Fold a b -> Fold a b

asinh :: Fold a b -> Fold a b

acosh :: Fold a b -> Fold a b

atanh :: Fold a b -> Fold a b

log1p :: Fold a b -> Fold a b

expm1 :: Fold a b -> Fold a b

log1pexp :: Fold a b -> Fold a b

log1mexp :: Fold a b -> Fold a b

Num b => Num (Fold a b)

Defined in Control.Foldl

Methods

(+) :: Fold a b -> Fold a b -> Fold a b

(-) :: Fold a b -> Fold a b -> Fold a b

(*) :: Fold a b -> Fold a b -> Fold a b

negate :: Fold a b -> Fold a b

abs :: Fold a b -> Fold a b

signum :: Fold a b -> Fold a b

fromInteger :: Integer -> Fold a b

Fractional b => Fractional (Fold a b)

Defined in Control.Foldl

Methods

(/) :: Fold a b -> Fold a b -> Fold a b

recip :: Fold a b -> Fold a b

fromRational :: Rational -> Fold a b

data Text

A space efficient, packed, unboxed Unicode text type.

Instances

Hashable Text

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Text -> Int

hash :: Text -> Int

type Item Text

Defined in Data.Text

type Item Text = Char