Control.Foldl.ByteString

Folds for byte streams

Folding

fold :: Fold ByteString a -> ByteString -> a

Apply a strict left Fold to a lazy bytestring

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

Apply a strict monadic left FoldM to a lazy bytestring

Folds

head :: Fold ByteString (Maybe Word8)

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

last :: Fold ByteString (Maybe Word8)

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

null :: Fold ByteString Bool

Returns True if the byte stream is empty, False otherwise

length :: Num n => Fold ByteString n

Return the length of the byte stream in bytes

any :: (Word8 -> Bool) -> Fold ByteString Bool

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

all :: (Word8 -> Bool) -> Fold ByteString Bool

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

maximum :: Fold ByteString (Maybe Word8)

Computes the maximum byte

minimum :: Fold ByteString (Maybe Word8)

Computes the minimum byte

elem :: Word8 -> Fold ByteString Bool

(elem w8) returns True if the byte stream has a byte equal to w8, False otherwise

notElem :: Word8 -> Fold ByteString Bool

(notElem w8) returns False if the byte stream has a byte equal to w8, True otherwise

find :: (Word8 -> Bool) -> Fold ByteString (Maybe Word8)

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

index :: Integral n => n -> Fold ByteString (Maybe Word8)

(index n) returns the nth byte of the byte stream, or Nothing if the stream has an insufficient number of bytes

elemIndex :: Num n => Word8 -> Fold ByteString (Maybe n)

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

findIndex :: Num n => (Word8 -> Bool) -> Fold ByteString (Maybe n)

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

count :: Num n => Word8 -> Fold ByteString n

count w8 returns the number of times w8 appears

lazy :: Fold ByteString ByteString

Combine all the strict ByteString chunks to build a lazy ByteString

Re-exports

Control.Foldl re-exports the Fold type

Data.ByteString re-exports the ByteString type

Data.Word re-exports the Word8 type

class Foldable (t :: * -> *)

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

Instances

Foldable []

Since: base-2.1

Defined in Data.Foldable

Methods

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

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

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

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

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

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

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

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

toList :: [a] -> [a]

null :: [a] -> Bool

length :: [a] -> Int

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

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

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

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

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

Foldable Maybe

Since: base-2.1

Defined in Data.Foldable

Methods

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

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

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

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

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

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

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

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

toList :: Maybe a -> [a]

null :: Maybe a -> Bool

length :: Maybe a -> Int

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

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

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

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

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

Foldable Par1

Defined in Data.Foldable

Methods

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

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

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

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

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

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

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

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

toList :: Par1 a -> [a]

null :: Par1 a -> Bool

length :: Par1 a -> Int

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

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

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

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

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

Foldable Complex

Defined in Data.Complex

Methods

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

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Complex a -> a

foldl1 :: (a -> a -> a) -> Complex a -> a

toList :: Complex a -> [a]

null :: Complex a -> Bool

length :: Complex a -> Int

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

maximum :: Ord a => Complex a -> a

minimum :: Ord a => Complex a -> a

sum :: Num a => Complex a -> a

product :: Num a => Complex a -> a

Foldable Min

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

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

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Min a -> a

foldl1 :: (a -> a -> a) -> Min a -> a

toList :: Min a -> [a]

null :: Min a -> Bool

length :: Min a -> Int

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

maximum :: Ord a => Min a -> a

minimum :: Ord a => Min a -> a

sum :: Num a => Min a -> a

product :: Num a => Min a -> a

Foldable Max

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

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

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Max a -> a

foldl1 :: (a -> a -> a) -> Max a -> a

toList :: Max a -> [a]

null :: Max a -> Bool

length :: Max a -> Int

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

maximum :: Ord a => Max a -> a

minimum :: Ord a => Max a -> a

sum :: Num a => Max a -> a

product :: Num a => Max a -> a

Foldable First

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

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

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

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

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

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

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

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

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

toList :: First a -> [a]

null :: First a -> Bool

length :: First a -> Int

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

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

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

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

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

Foldable Last

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

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

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

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

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

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

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

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

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

toList :: Last a -> [a]

null :: Last a -> Bool

length :: Last a -> Int

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

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

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

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

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

Foldable Option

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fold :: Monoid m => Option m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Option a -> a

foldl1 :: (a -> a -> a) -> Option a -> a

toList :: Option a -> [a]

null :: Option a -> Bool

length :: Option a -> Int

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

maximum :: Ord a => Option a -> a

minimum :: Ord a => Option a -> a

sum :: Num a => Option a -> a

product :: Num a => Option a -> a

Foldable ZipList

Defined in Control.Applicative

Methods

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

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

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

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

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

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

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

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

toList :: ZipList a -> [a]

null :: ZipList a -> Bool

length :: ZipList a -> Int

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

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

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

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

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

Foldable Identity

Since: base-4.8.0.0

Defined in Data.Functor.Identity

Methods

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

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

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

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

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

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

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

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

toList :: Identity a -> [a]

null :: Identity a -> Bool

length :: Identity a -> Int

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

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

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

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

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

Foldable First

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

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

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

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

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

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

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

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

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

toList :: First a -> [a]

null :: First a -> Bool

length :: First a -> Int

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

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

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

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

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

Foldable Last

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

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

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

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

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

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

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

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

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

toList :: Last a -> [a]

null :: Last a -> Bool

length :: Last a -> Int

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

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

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

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

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

Foldable Dual

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

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

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

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

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

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

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

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

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

toList :: Dual a -> [a]

null :: Dual a -> Bool

length :: Dual a -> Int

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

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

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

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

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

Foldable Sum

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

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

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

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

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

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

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

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

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

toList :: Sum a -> [a]

null :: Sum a -> Bool

length :: Sum a -> Int

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

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

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

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

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

Foldable Product

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

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

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

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

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

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

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

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

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

toList :: Product a -> [a]

null :: Product a -> Bool

length :: Product a -> Int

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

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

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

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

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

Foldable NonEmpty

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

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

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

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

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

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

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

foldr1 :: (a -> a -> a) -> NonEmpty a -> a

foldl1 :: (a -> a -> a) -> NonEmpty a -> a

toList :: NonEmpty a -> [a]

null :: NonEmpty a -> Bool

length :: NonEmpty a -> Int

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

maximum :: Ord a => NonEmpty a -> a

minimum :: Ord a => NonEmpty a -> a

sum :: Num a => NonEmpty a -> a

product :: Num a => NonEmpty a -> a

Foldable IntMap

Defined in Data.IntMap.Internal

Methods

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

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

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

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

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

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

foldr1 :: (a -> a -> a) -> IntMap a -> a

foldl1 :: (a -> a -> a) -> IntMap a -> a

toList :: IntMap a -> [a]

null :: IntMap a -> Bool

length :: IntMap a -> Int

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

maximum :: Ord a => IntMap a -> a

minimum :: Ord a => IntMap a -> a

sum :: Num a => IntMap a -> a

product :: Num a => IntMap a -> a

Foldable Tree

Defined in Data.Tree

Methods

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

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Tree a -> a

foldl1 :: (a -> a -> a) -> Tree a -> a

toList :: Tree a -> [a]

null :: Tree a -> Bool

length :: Tree a -> Int

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

maximum :: Ord a => Tree a -> a

minimum :: Ord a => Tree a -> a

sum :: Num a => Tree a -> a

product :: Num a => Tree a -> a

Foldable Seq

Defined in Data.Sequence.Internal

Methods

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

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Seq a -> a

foldl1 :: (a -> a -> a) -> Seq a -> a

toList :: Seq a -> [a]

null :: Seq a -> Bool

length :: Seq a -> Int

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

maximum :: Ord a => Seq a -> a

minimum :: Ord a => Seq a -> a

sum :: Num a => Seq a -> a

product :: Num a => Seq a -> a

Foldable FingerTree

Defined in Data.Sequence.Internal

Methods

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

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

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

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

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

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

foldr1 :: (a -> a -> a) -> FingerTree a -> a

foldl1 :: (a -> a -> a) -> FingerTree a -> a

toList :: FingerTree a -> [a]

null :: FingerTree a -> Bool

length :: FingerTree a -> Int

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

maximum :: Ord a => FingerTree a -> a

minimum :: Ord a => FingerTree a -> a

sum :: Num a => FingerTree a -> a

product :: Num a => FingerTree a -> a

Foldable Digit

Defined in Data.Sequence.Internal

Methods

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

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Digit a -> a

foldl1 :: (a -> a -> a) -> Digit a -> a

toList :: Digit a -> [a]

null :: Digit a -> Bool

length :: Digit a -> Int

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

maximum :: Ord a => Digit a -> a

minimum :: Ord a => Digit a -> a

sum :: Num a => Digit a -> a

product :: Num a => Digit a -> a

Foldable Node

Defined in Data.Sequence.Internal

Methods

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

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Node a -> a

foldl1 :: (a -> a -> a) -> Node a -> a

toList :: Node a -> [a]

null :: Node a -> Bool

length :: Node a -> Int

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

maximum :: Ord a => Node a -> a

minimum :: Ord a => Node a -> a

sum :: Num a => Node a -> a

product :: Num a => Node a -> a

Foldable Elem

Defined in Data.Sequence.Internal

Methods

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

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Elem a -> a

foldl1 :: (a -> a -> a) -> Elem a -> a

toList :: Elem a -> [a]

null :: Elem a -> Bool

length :: Elem a -> Int

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

maximum :: Ord a => Elem a -> a

minimum :: Ord a => Elem a -> a

sum :: Num a => Elem a -> a

product :: Num a => Elem a -> a

Foldable ViewL

Defined in Data.Sequence.Internal

Methods

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

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

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

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

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

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

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

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

toList :: ViewL a -> [a]

null :: ViewL a -> Bool

length :: ViewL a -> Int

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

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

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

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

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

Foldable ViewR

Defined in Data.Sequence.Internal

Methods

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

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

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

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

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

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

foldr1 :: (a -> a -> a) -> ViewR a -> a

foldl1 :: (a -> a -> a) -> ViewR a -> a

toList :: ViewR a -> [a]

null :: ViewR a -> Bool

length :: ViewR a -> Int

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

maximum :: Ord a => ViewR a -> a

minimum :: Ord a => ViewR a -> a

sum :: Num a => ViewR a -> a

product :: Num a => ViewR a -> a

Foldable Set

Defined in Data.Set.Internal

Methods

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

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Set a -> a

foldl1 :: (a -> a -> a) -> Set a -> a

toList :: Set a -> [a]

null :: Set a -> Bool

length :: Set a -> Int

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

maximum :: Ord a => Set a -> a

minimum :: Ord a => Set a -> a

sum :: Num a => Set a -> a

product :: Num a => Set a -> a

Foldable Hashed

Defined in Data.Hashable.Class

Methods

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

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

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

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

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

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

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

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

toList :: Hashed a -> [a]

null :: Hashed a -> Bool

length :: Hashed a -> Int

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

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

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

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

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

Foldable SmallArray

Defined in Data.Primitive.SmallArray

Methods

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

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

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

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

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

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

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

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

toList :: SmallArray a -> [a]

null :: SmallArray a -> Bool

length :: SmallArray a -> Int

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

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

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

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

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

Foldable Array

Defined in Data.Primitive.Array

Methods

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

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

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

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

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

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

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

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

toList :: Array a -> [a]

null :: Array a -> Bool

length :: Array a -> Int

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

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

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

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

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

Foldable HashSet

Defined in Data.HashSet

Methods

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

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

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

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

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

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

foldr1 :: (a -> a -> a) -> HashSet a -> a

foldl1 :: (a -> a -> a) -> HashSet a -> a

toList :: HashSet a -> [a]

null :: HashSet a -> Bool

length :: HashSet a -> Int

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

maximum :: Ord a => HashSet a -> a

minimum :: Ord a => HashSet a -> a

sum :: Num a => HashSet a -> a

product :: Num a => HashSet a -> a

Foldable (Either a)

Since: base-4.7.0.0

Defined in Data.Foldable

Methods

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

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

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

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

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

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

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

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

toList :: Either a a0 -> [a0]

null :: Either a a0 -> Bool

length :: Either a a0 -> Int

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

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

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

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

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

Foldable (V1 :: * -> *)

Defined in Data.Foldable

Methods

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

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

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

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

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

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

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

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

toList :: V1 a -> [a]

null :: V1 a -> Bool

length :: V1 a -> Int

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

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

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

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

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

Foldable (U1 :: * -> *)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

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

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

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

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

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

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

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

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

toList :: U1 a -> [a]

null :: U1 a -> Bool

length :: U1 a -> Int

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

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

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

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

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

Foldable ((,) a)

Since: base-4.7.0.0

Defined in Data.Foldable

Methods

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

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

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

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

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

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

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

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

toList :: (a, a0) -> [a0]

null :: (a, a0) -> Bool

length :: (a, a0) -> Int

elem :: Eq a0 => a0 -> (a, a0) -> Bool

maximum :: Ord a0 => (a, a0) -> a0

minimum :: Ord a0 => (a, a0) -> a0

sum :: Num a0 => (a, a0) -> a0

product :: Num a0 => (a, a0) -> a0

Foldable (Array i)

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

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

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

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

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

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

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

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

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

toList :: Array i a -> [a]

null :: Array i a -> Bool

length :: Array i a -> Int

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

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

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

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

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

Foldable (Arg a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

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

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

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

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

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

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

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

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

toList :: Arg a a0 -> [a0]

null :: Arg a a0 -> Bool

length :: Arg a a0 -> Int

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

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

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

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

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

Foldable (Proxy :: * -> *)

Since: base-4.7.0.0

Defined in Data.Foldable

Methods

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

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

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

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

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

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

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

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

toList :: Proxy a -> [a]

null :: Proxy a -> Bool

length :: Proxy a -> Int

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

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

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

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

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

Foldable (Map k)

Defined in Data.Map.Internal

Methods

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

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

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

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

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

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

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

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

toList :: Map k a -> [a]

null :: Map k a -> Bool

length :: Map k a -> Int

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

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

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

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

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

Foldable (HashMap k)

Defined in Data.HashMap.Base

Methods

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

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

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

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

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

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

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

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

toList :: HashMap k a -> [a]

null :: HashMap k a -> Bool

length :: HashMap k a -> Int

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

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

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

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

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

Foldable f => Foldable (MaybeT f)

Defined in Control.Monad.Trans.Maybe

Methods

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

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

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

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

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

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

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

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

toList :: MaybeT f a -> [a]

null :: MaybeT f a -> Bool

length :: MaybeT f a -> Int

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

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

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

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

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

Foldable f => Foldable (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

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

Defined in Data.Foldable

Methods

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

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

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

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

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

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

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

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

toList :: Rec1 f a -> [a]

null :: Rec1 f a -> Bool

length :: Rec1 f a -> Int

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

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

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

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

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

Foldable (URec Char :: * -> *)

Defined in Data.Foldable

Methods

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

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

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

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

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

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

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

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

toList :: URec Char a -> [a]

null :: URec Char a -> Bool

length :: URec Char a -> Int

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

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

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

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

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

Foldable (URec Double :: * -> *)

Defined in Data.Foldable

Methods

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

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

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

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

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

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

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

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

toList :: URec Double a -> [a]

null :: URec Double a -> Bool

length :: URec Double a -> Int

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

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

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

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

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

Foldable (URec Float :: * -> *)

Defined in Data.Foldable

Methods

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

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

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

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

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

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

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

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

toList :: URec Float a -> [a]

null :: URec Float a -> Bool

length :: URec Float a -> Int

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

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

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

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

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

Foldable (URec Int :: * -> *)

Defined in Data.Foldable

Methods

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

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

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

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

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

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

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

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

toList :: URec Int a -> [a]

null :: URec Int a -> Bool

length :: URec Int a -> Int

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

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

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

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

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

Foldable (URec Word :: * -> *)

Defined in Data.Foldable

Methods

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

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

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

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

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

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

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

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

toList :: URec Word a -> [a]

null :: URec Word a -> Bool

length :: URec Word a -> Int

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

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

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

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

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

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

Defined in Data.Foldable

Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Foldable (Const m :: * -> *)

Since: base-4.7.0.0

Defined in Data.Functor.Const

Methods

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

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

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

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

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

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

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

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

toList :: Const m a -> [a]

null :: Const m a -> Bool

length :: Const m a -> Int

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

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

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

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

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

Bifoldable p => Foldable (Join p)

Defined in Data.Bifunctor.Join

Methods

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

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

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

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

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

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

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

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

toList :: Join p a -> [a]

null :: Join p a -> Bool

length :: Join p a -> Int

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

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

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

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

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

Foldable f => Foldable (IdentityT f)

Defined in Control.Monad.Trans.Identity

Methods

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

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

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

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

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

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

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

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

toList :: IdentityT f a -> [a]

null :: IdentityT f a -> Bool

length :: IdentityT f a -> Int

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

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

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

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

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

Foldable (Forget r a)

Defined in Data.Profunctor.Types

Methods

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

foldMap :: Monoid m => (a0 -> m) -> Forget r a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Forget r a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Forget r a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Forget r a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Forget r a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Forget r a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Forget r a a0 -> a0

toList :: Forget r a a0 -> [a0]

null :: Forget r a a0 -> Bool

length :: Forget r a a0 -> Int

elem :: Eq a0 => a0 -> Forget r a a0 -> Bool

maximum :: Ord a0 => Forget r a a0 -> a0

minimum :: Ord a0 => Forget r a a0 -> a0

sum :: Num a0 => Forget r a a0 -> a0

product :: Num a0 => Forget r a a0 -> a0

Foldable f => Foldable (ErrorT e f)

Defined in Control.Monad.Trans.Error

Methods

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

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

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

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

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

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

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

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

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

null :: ErrorT e f a -> Bool

length :: ErrorT e f a -> Int

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

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

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

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

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

Foldable (Tagged s)

Defined in Data.Tagged

Methods

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

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

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

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

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

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

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

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

toList :: Tagged s a -> [a]

null :: Tagged s a -> Bool

length :: Tagged s a -> Int

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

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

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

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

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

Foldable f => Foldable (Reverse f)

Fold from right to left.

Defined in Data.Functor.Reverse

Methods

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

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

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

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

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

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

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

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

toList :: Reverse f a -> [a]

null :: Reverse f a -> Bool

length :: Reverse f a -> Int

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

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

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

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

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

Foldable (Constant a :: * -> *)

Defined in Data.Functor.Constant

Methods

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

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

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

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

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

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

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

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

toList :: Constant a a0 -> [a0]

null :: Constant a a0 -> Bool

length :: Constant a a0 -> Int

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

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

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

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

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

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

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.Lazy

Methods

fold :: Monoid m => WriterT w f m -> 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 (ExceptT e f)

Defined in Control.Monad.Trans.Except

Methods

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

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

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

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

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

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

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

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

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

null :: ExceptT e f a -> Bool

length :: ExceptT e f a -> Int

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

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

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

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

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

Foldable f => Foldable (Backwards f)

Derived instance.

Defined in Control.Applicative.Backwards

Methods

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

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

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

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

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

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

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

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

toList :: Backwards f a -> [a]

null :: Backwards f a -> Bool

length :: Backwards f a -> Int

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

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

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

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

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

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

Defined in Data.Foldable

Methods

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

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

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

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

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

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

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

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

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

null :: K1 i c a -> Bool

length :: K1 i c a -> Int

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

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

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

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

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

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

Defined in Data.Foldable

Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Defined in Data.Foldable

Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Since: base-4.9.0.0

Defined in Data.Functor.Product

Methods

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

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

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

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

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

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

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

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

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

null :: Product f g a -> Bool

length :: Product f g a -> Int

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

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

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

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

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

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

Since: base-4.9.0.0

Defined in Data.Functor.Sum

Methods

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

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

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

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

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

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

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

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

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

null :: Sum f g a -> Bool

length :: Sum f g a -> Int

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

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

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

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

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

Foldable f => Foldable (M1 i c f)

Defined in Data.Foldable

Methods

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

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

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

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

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

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

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

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

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

null :: M1 i c f a -> Bool

length :: M1 i c f a -> Int

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

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

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

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

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

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

Defined in Data.Foldable

Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

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

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

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

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

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

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

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

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

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

null :: Compose f g a -> Bool

length :: Compose f g a -> Int

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

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

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

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

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

Bifoldable p => Foldable (WrappedBifunctor p a)

Defined in Data.Bifunctor.Wrapped

Methods

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

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

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

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

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

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

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

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

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

null :: WrappedBifunctor p a a0 -> Bool

length :: WrappedBifunctor p a a0 -> Int

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

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

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

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

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

Foldable g => Foldable (Joker g a)

Defined in Data.Bifunctor.Joker

Methods

fold :: Monoid m => Joker g a m -> m

foldMap :: Monoid m => (a0 -> m) -> Joker g a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Joker g a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Joker g a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Joker g a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Joker g a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Joker g a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Joker g a a0 -> a0

toList :: Joker g a a0 -> [a0]

null :: Joker g a a0 -> Bool

length :: Joker g a a0 -> Int

elem :: Eq a0 => a0 -> Joker g a a0 -> Bool

maximum :: Ord a0 => Joker g a a0 -> a0

minimum :: Ord a0 => Joker g a a0 -> a0

sum :: Num a0 => Joker g a a0 -> a0

product :: Num a0 => Joker g a a0 -> a0

Bifoldable p => Foldable (Flip p a)

Defined in Data.Bifunctor.Flip

Methods

fold :: Monoid m => Flip p a m -> m

foldMap :: Monoid m => (a0 -> m) -> Flip p a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Flip p a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Flip p a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Flip p a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Flip p a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Flip p a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Flip p a a0 -> a0

toList :: Flip p a a0 -> [a0]

null :: Flip p a a0 -> Bool

length :: Flip p a a0 -> Int

elem :: Eq a0 => a0 -> Flip p a a0 -> Bool

maximum :: Ord a0 => Flip p a a0 -> a0

minimum :: Ord a0 => Flip p a a0 -> a0

sum :: Num a0 => Flip p a a0 -> a0

product :: Num a0 => Flip p a a0 -> a0

Foldable (Clown f a :: * -> *)

Defined in Data.Bifunctor.Clown

Methods

fold :: Monoid m => Clown f a m -> m

foldMap :: Monoid m => (a0 -> m) -> Clown f a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Clown f a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Clown f a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Clown f a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Clown f a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Clown f a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Clown f a a0 -> a0

toList :: Clown f a a0 -> [a0]

null :: Clown f a a0 -> Bool

length :: Clown f a a0 -> Int

elem :: Eq a0 => a0 -> Clown f a a0 -> Bool

maximum :: Ord a0 => Clown f a a0 -> a0

minimum :: Ord a0 => Clown f a a0 -> a0

sum :: Num a0 => Clown f a a0 -> a0

product :: Num a0 => Clown f a a0 -> a0

(Foldable f, Bifoldable p) => Foldable (Tannen f p a)

Defined in Data.Bifunctor.Tannen

Methods

fold :: Monoid m => Tannen f p a m -> m

foldMap :: Monoid m => (a0 -> m) -> Tannen f p a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Tannen f p a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Tannen f p a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Tannen f p a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Tannen f p a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Tannen f p a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Tannen f p a a0 -> a0

toList :: Tannen f p a a0 -> [a0]

null :: Tannen f p a a0 -> Bool

length :: Tannen f p a a0 -> Int

elem :: Eq a0 => a0 -> Tannen f p a a0 -> Bool

maximum :: Ord a0 => Tannen f p a a0 -> a0

minimum :: Ord a0 => Tannen f p a a0 -> a0

sum :: Num a0 => Tannen f p a a0 -> a0

product :: Num a0 => Tannen f p a a0 -> a0

(Bifoldable p, Foldable g) => Foldable (Biff p f g a)

Defined in Data.Bifunctor.Biff

Methods

fold :: Monoid m => Biff p f g a m -> m

foldMap :: Monoid m => (a0 -> m) -> Biff p f g a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Biff p f g a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Biff p f g a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Biff p f g a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Biff p f g a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Biff p f g a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Biff p f g a a0 -> a0

toList :: Biff p f g a a0 -> [a0]

null :: Biff p f g a a0 -> Bool

length :: Biff p f g a a0 -> Int

elem :: Eq a0 => a0 -> Biff p f g a a0 -> Bool

maximum :: Ord a0 => Biff p f g a a0 -> a0

minimum :: Ord a0 => Biff p f g a a0 -> a0

sum :: Num a0 => Biff p f g a a0 -> a0

product :: Num a0 => Biff p f g a a0 -> a0

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

(#.) :: Coercible c b => q b c -> FoldM m a b -> FoldM m a c

(.#) :: Coercible b a => FoldM m b c -> q a b -> FoldM m a c

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

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

(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, 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

(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

(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

(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

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

(#.) :: Coercible c b => q b c -> Fold a b -> Fold a c

(.#) :: Coercible b a => Fold b c -> q a b -> Fold a c

Functor (Fold a)

Defined in Control.Foldl

Methods

fmap :: (a0 -> b) -> Fold a a0 -> Fold a b

(<$) :: a0 -> Fold a b -> Fold a a0

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

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

Semigroupoid Fold

Defined in Control.Foldl

Methods

o :: Fold j k1 -> Fold i j -> Fold i k1

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

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

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

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

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

data ByteString

A space-efficient representation of a Word8 vector, supporting many efficient operations.

A ByteString contains 8-bit bytes, or by using the operations from Data.ByteString.Char8 it can be interpreted as containing 8-bit characters.

Instances

Eq ByteString

Defined in Data.ByteString.Internal

Methods

(==) :: ByteString -> ByteString -> Bool

(/=) :: ByteString -> ByteString -> Bool

Data ByteString

Defined in Data.ByteString.Internal

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ByteString -> c ByteString

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ByteString

toConstr :: ByteString -> Constr

dataTypeOf :: ByteString -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ByteString)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ByteString)

gmapT :: (forall b. Data b => b -> b) -> ByteString -> ByteString

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ByteString -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ByteString -> r

gmapQ :: (forall d. Data d => d -> u) -> ByteString -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ByteString -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ByteString -> m ByteString

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ByteString -> m ByteString

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ByteString -> m ByteString

Ord ByteString

Defined in Data.ByteString.Internal

Methods

compare :: ByteString -> ByteString -> Ordering

(<) :: ByteString -> ByteString -> Bool

(<=) :: ByteString -> ByteString -> Bool

(>) :: ByteString -> ByteString -> Bool

(>=) :: ByteString -> ByteString -> Bool

max :: ByteString -> ByteString -> ByteString

min :: ByteString -> ByteString -> ByteString

Read ByteString

Defined in Data.ByteString.Internal

Methods

readsPrec :: Int -> ReadS ByteString

readList :: ReadS [ByteString]

readPrec :: ReadPrec ByteString

readListPrec :: ReadPrec [ByteString]

Show ByteString

Defined in Data.ByteString.Internal

Methods

showsPrec :: Int -> ByteString -> ShowS

show :: ByteString -> String

showList :: [ByteString] -> ShowS

IsString ByteString

Defined in Data.ByteString.Internal

Methods

fromString :: String -> ByteString

Semigroup ByteString

Defined in Data.ByteString.Internal

Methods

(<>) :: ByteString -> ByteString -> ByteString

sconcat :: NonEmpty ByteString -> ByteString

stimes :: Integral b => b -> ByteString -> ByteString

Monoid ByteString

Defined in Data.ByteString.Internal

Methods

mempty :: ByteString

mappend :: ByteString -> ByteString -> ByteString

mconcat :: [ByteString] -> ByteString

NFData ByteString

Defined in Data.ByteString.Internal

Methods

rnf :: ByteString -> ()

Hashable ByteString

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> ByteString -> Int

hash :: ByteString -> Int

data Word8

8-bit unsigned integer type

Instances

Bounded Word8

Since: base-2.1

Defined in GHC.Word

Methods

minBound :: Word8

maxBound :: Word8

Enum Word8

Since: base-2.1

Defined in GHC.Word

Methods

succ :: Word8 -> Word8

pred :: Word8 -> Word8

toEnum :: Int -> Word8

fromEnum :: Word8 -> Int

enumFrom :: Word8 -> [Word8]

enumFromThen :: Word8 -> Word8 -> [Word8]

enumFromTo :: Word8 -> Word8 -> [Word8]

enumFromThenTo :: Word8 -> Word8 -> Word8 -> [Word8]

Eq Word8

Since: base-2.1

Defined in GHC.Word

Methods

(==) :: Word8 -> Word8 -> Bool

(/=) :: Word8 -> Word8 -> Bool

Integral Word8

Since: base-2.1

Defined in GHC.Word

Methods

quot :: Word8 -> Word8 -> Word8

rem :: Word8 -> Word8 -> Word8

div :: Word8 -> Word8 -> Word8

mod :: Word8 -> Word8 -> Word8

quotRem :: Word8 -> Word8 -> (Word8, Word8)

divMod :: Word8 -> Word8 -> (Word8, Word8)

toInteger :: Word8 -> Integer

Num Word8

Since: base-2.1

Defined in GHC.Word

Methods

(+) :: Word8 -> Word8 -> Word8

(-) :: Word8 -> Word8 -> Word8

(*) :: Word8 -> Word8 -> Word8

negate :: Word8 -> Word8

abs :: Word8 -> Word8

signum :: Word8 -> Word8

fromInteger :: Integer -> Word8

Ord Word8

Since: base-2.1

Defined in GHC.Word

Methods

compare :: Word8 -> Word8 -> Ordering

(<) :: Word8 -> Word8 -> Bool

(<=) :: Word8 -> Word8 -> Bool

(>) :: Word8 -> Word8 -> Bool

(>=) :: Word8 -> Word8 -> Bool

max :: Word8 -> Word8 -> Word8

min :: Word8 -> Word8 -> Word8

Read Word8

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Word8

readList :: ReadS [Word8]

readPrec :: ReadPrec Word8

readListPrec :: ReadPrec [Word8]

Real Word8

Since: base-2.1

Defined in GHC.Word

Methods

toRational :: Word8 -> Rational

Show Word8

Since: base-2.1

Defined in GHC.Word

Methods

showsPrec :: Int -> Word8 -> ShowS

show :: Word8 -> String

showList :: [Word8] -> ShowS

Ix Word8

Since: base-2.1

Defined in GHC.Word

Methods

range :: (Word8, Word8) -> [Word8]

index :: (Word8, Word8) -> Word8 -> Int

unsafeIndex :: (Word8, Word8) -> Word8 -> Int

inRange :: (Word8, Word8) -> Word8 -> Bool

rangeSize :: (Word8, Word8) -> Int

unsafeRangeSize :: (Word8, Word8) -> Int

Lift Word8

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Word8 -> Q Exp

Bits Word8

Since: base-2.1

Defined in GHC.Word

Methods

(.&.) :: Word8 -> Word8 -> Word8

(.|.) :: Word8 -> Word8 -> Word8

xor :: Word8 -> Word8 -> Word8

complement :: Word8 -> Word8

shift :: Word8 -> Int -> Word8

rotate :: Word8 -> Int -> Word8

zeroBits :: Word8

bit :: Int -> Word8

setBit :: Word8 -> Int -> Word8

clearBit :: Word8 -> Int -> Word8

complementBit :: Word8 -> Int -> Word8

testBit :: Word8 -> Int -> Bool

bitSizeMaybe :: Word8 -> Maybe Int

bitSize :: Word8 -> Int

isSigned :: Word8 -> Bool

shiftL :: Word8 -> Int -> Word8

unsafeShiftL :: Word8 -> Int -> Word8

shiftR :: Word8 -> Int -> Word8

unsafeShiftR :: Word8 -> Int -> Word8

rotateL :: Word8 -> Int -> Word8

rotateR :: Word8 -> Int -> Word8

popCount :: Word8 -> Int

FiniteBits Word8

Since: base-4.6.0.0

Defined in GHC.Word

Methods

finiteBitSize :: Word8 -> Int

countLeadingZeros :: Word8 -> Int

countTrailingZeros :: Word8 -> Int

Hashable Word8

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Word8 -> Int

hash :: Word8 -> Int

Variate Word8

Defined in System.Random.MWC

Methods

uniform :: PrimMonad m => Gen (PrimState m) -> m Word8

uniformR :: PrimMonad m => (Word8, Word8) -> Gen (PrimState m) -> m Word8

Prim Word8

Defined in Data.Primitive.Types

Methods

sizeOf# :: Word8 -> Int#

alignment# :: Word8 -> Int#

indexByteArray# :: ByteArray# -> Int# -> Word8

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Word8#)

writeByteArray# :: MutableByteArray# s -> Int# -> Word8 -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word8 -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Word8

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Word8#)

writeOffAddr# :: Addr# -> Int# -> Word8 -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Word8 -> State# s -> State# s

Unbox Word8

Defined in Data.Vector.Unboxed.Base

Vector Vector Word8

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word8 -> m (Vector Word8)

basicUnsafeThaw :: PrimMonad m => Vector Word8 -> m (Mutable Vector (PrimState m) Word8)

basicLength :: Vector Word8 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Word8 -> Vector Word8

basicUnsafeIndexM :: Monad m => Vector Word8 -> Int -> m Word8

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word8 -> Vector Word8 -> m ()

elemseq :: Vector Word8 -> Word8 -> b -> b

MVector MVector Word8

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Word8 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Word8 -> MVector s Word8

basicOverlaps :: MVector s Word8 -> MVector s Word8 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word8)

basicInitialize :: PrimMonad m => MVector (PrimState m) Word8 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Word8 -> m (MVector (PrimState m) Word8)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> m Word8

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> Word8 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Word8 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Word8 -> Word8 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word8 -> MVector (PrimState m) Word8 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word8 -> MVector (PrimState m) Word8 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> m (MVector (PrimState m) Word8)

data Vector Word8

Defined in Data.Vector.Unboxed.Base

data Vector Word8 = V_Word8 (Vector Word8)

type Unsigned Word8

Defined in System.Random.MWC

type Unsigned Word8 = Word8

data MVector s Word8

Defined in Data.Vector.Unboxed.Base

data MVector s Word8 = MV_Word8 (MVector s Word8)