Safe Haskell | Safe |
---|---|
Language | Haskell2010 |
Synopsis
- class Foldable (t :: * -> *) where
- all :: Foldable t => (a -> Bool) -> t a -> Bool
- and :: Foldable t => t Bool -> Bool
- any :: Foldable t => (a -> Bool) -> t a -> Bool
- asum :: (Foldable t, Alternative f) => t (f a) -> f a
- concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
- find :: Foldable t => (a -> Bool) -> t a -> Maybe a
- foldBy :: Foldable t => (a -> a -> a) -> a -> t a -> a
- foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
- foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m ()
- foldMapBy :: Foldable t => (r -> r -> r) -> r -> (a -> r) -> t a -> r
- foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
- foldr1May :: Foldable t => (a -> a -> a) -> t a -> Maybe a
- foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b
- for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
- group :: (Foldable f, Eq a) => f a -> [NonEmpty a]
- groupAllWith :: Ord b => (a -> b) -> [a] -> [NonEmpty a]
- groupBy :: Foldable f => (a -> a -> Bool) -> f a -> [NonEmpty a]
- groupWith :: (Foldable f, Eq b) => (a -> b) -> f a -> [NonEmpty a]
- inits :: Foldable f => f a -> NonEmpty [a]
- insert :: (Foldable f, Ord a) => a -> f a -> NonEmpty a
- maximumByMay :: Foldable t => (a -> a -> Ordering) -> t a -> Maybe a
- maximumMay :: (Foldable t, Ord a) => t a -> Maybe a
- minimumByMay :: Foldable t => (a -> a -> Ordering) -> t a -> Maybe a
- minimumMay :: (Foldable t, Ord a) => t a -> Maybe a
- msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
- notElem :: (Foldable t, Eq a) => a -> t a -> Bool
- or :: Foldable t => t Bool -> Bool
- sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()
- tails :: Foldable f => f a -> NonEmpty [a]
- traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()
- class Foldable t => Foldable1 (t :: * -> *) where
- asum1 :: (Foldable1 t, Alt m) => t (m a) -> m a
- foldlM1 :: (Foldable1 t, Monad m) => (a -> a -> m a) -> t a -> m a
- foldrM1 :: (Foldable1 t, Monad m) => (a -> a -> m a) -> t a -> m a
- for1_ :: (Foldable1 t, Apply f) => t a -> (a -> f b) -> f ()
- intercalate1 :: (Foldable1 t, Semigroup m) => m -> t m -> m
- intercalateMap1 :: (Foldable1 t, Semigroup m) => m -> (a -> m) -> t a -> m
- sequenceA1_ :: (Foldable1 t, Apply f) => t (f a) -> f ()
- traverse1_ :: (Foldable1 t, Apply f) => (a -> f b) -> t a -> f ()
- class Bifoldable (p :: * -> * -> *) where
- bifoldr' :: Bifoldable t => (a -> c -> c) -> (b -> c -> c) -> c -> t a b -> c
- bifoldrM :: (Bifoldable t, Monad m) => (a -> c -> m c) -> (b -> c -> m c) -> c -> t a b -> m c
- bifoldl' :: Bifoldable t => (a -> b -> a) -> (a -> c -> a) -> a -> t b c -> a
- bifoldlM :: (Bifoldable t, Monad m) => (a -> b -> m a) -> (a -> c -> m a) -> a -> t b c -> m a
- bitraverse_ :: (Bifoldable t, Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f ()
- bifor_ :: (Bifoldable t, Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f ()
- bisequence_ :: (Bifoldable t, Applicative f) => t (f a) (f b) -> f ()
- biasum :: (Bifoldable t, Alternative f) => t (f a) (f a) -> f a
- biList :: Bifoldable t => t a a -> [a]
- binull :: Bifoldable t => t a b -> Bool
- bilength :: Bifoldable t => t a b -> Int
- bielem :: (Bifoldable t, Eq a) => a -> t a a -> Bool
- bisum :: (Bifoldable t, Num a) => t a a -> a
- biproduct :: (Bifoldable t, Num a) => t a a -> a
- biconcatMap :: Bifoldable t => (a -> [c]) -> (b -> [c]) -> t a b -> [c]
- biand :: Bifoldable t => t Bool Bool -> Bool
- bior :: Bifoldable t => t Bool Bool -> Bool
- biany :: Bifoldable t => (a -> Bool) -> (b -> Bool) -> t a b -> Bool
- biall :: Bifoldable t => (a -> Bool) -> (b -> Bool) -> t a b -> Bool
- binotElem :: (Bifoldable t, Eq a) => a -> t a a -> Bool
- bifind :: Bifoldable t => (a -> Bool) -> t a a -> Maybe a
- class Bifoldable t => Bifoldable1 (t :: * -> * -> *) where
- bitraverse1_ :: (Bifoldable1 t, Apply f) => (a -> f b) -> (c -> f d) -> t a c -> f ()
- bifor1_ :: (Bifoldable1 t, Apply f) => t a c -> (a -> f b) -> (c -> f d) -> f ()
- bisequenceA1_ :: (Bifoldable1 t, Apply f) => t (f a) (f b) -> f ()
Foldable
class Foldable (t :: * -> *) where #
Data structures that can be folded.
For example, given a data type
data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a)
a suitable instance would be
instance Foldable Tree where foldMap f Empty = mempty foldMap f (Leaf x) = f x foldMap f (Node l k r) = foldMap f l `mappend` f k `mappend` foldMap f r
This is suitable even for abstract types, as the monoid is assumed
to satisfy the monoid laws. Alternatively, one could define foldr
:
instance Foldable Tree where foldr f z Empty = z foldr f z (Leaf x) = f x z foldr f z (Node l k r) = foldr f (f k (foldr f z r)) l
Foldable
instances are expected to satisfy the following laws:
foldr f z t = appEndo (foldMap (Endo . f) t ) z
foldl f z t = appEndo (getDual (foldMap (Dual . Endo . flip f) t)) z
fold = foldMap id
length = getSum . foldMap (Sum . const 1)
sum
, product
, maximum
, and minimum
should all be essentially
equivalent to foldMap
forms, such as
sum = getSum . foldMap Sum
but may be less defined.
If the type is also a Functor
instance, it should satisfy
foldMap f = fold . fmap f
which implies that
foldMap f . fmap g = foldMap (f . g)
fold :: Monoid m => t m -> m #
Combine the elements of a structure using a monoid.
foldMap :: Monoid m => (a -> m) -> t a -> m #
Map each element of the structure to a monoid, and combine the results.
foldr :: (a -> b -> b) -> b -> t a -> b #
Right-associative fold of a structure.
In the case of lists, foldr
, when applied to a binary operator, a
starting value (typically the right-identity of the operator), and a
list, reduces the list using the binary operator, from right to left:
foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)
Note that, since the head of the resulting expression is produced by
an application of the operator to the first element of the list,
foldr
can produce a terminating expression from an infinite list.
For a general Foldable
structure this should be semantically identical
to,
foldr f z =foldr
f z .toList
foldr' :: (a -> b -> b) -> b -> t a -> b #
Right-associative fold of a structure, but with strict application of the operator.
foldl' :: (b -> a -> b) -> b -> t a -> b #
Left-associative fold of a structure but with strict application of the operator.
This ensures that each step of the fold is forced to weak head normal
form before being applied, avoiding the collection of thunks that would
otherwise occur. This is often what you want to strictly reduce a finite
list to a single, monolithic result (e.g. length
).
For a general Foldable
structure this should be semantically identical
to,
foldl f z =foldl'
f z .toList
List of elements of a structure, from left to right.
Test whether the structure is empty. The default implementation is optimized for structures that are similar to cons-lists, because there is no general way to do better.
Returns the size/length of a finite structure as an Int
. The
default implementation is optimized for structures that are similar to
cons-lists, because there is no general way to do better.
elem :: Eq a => a -> t a -> Bool infix 4 #
Does the element occur in the structure?
The sum
function computes the sum of the numbers of a structure.
product :: Num a => t a -> a #
The product
function computes the product of the numbers of a
structure.
Instances
Foldable [] | Since: base-2.1 |
Defined in Data.Foldable 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 # elem :: Eq a => a -> [a] -> Bool # maximum :: Ord a => [a] -> a # | |
Foldable Maybe | Since: base-2.1 |
Defined in Data.Foldable 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 # elem :: Eq a => a -> Maybe a -> Bool # maximum :: Ord a => Maybe a -> a # minimum :: Ord a => Maybe a -> a # | |
Foldable Par1 | |
Defined in Data.Foldable 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 # elem :: Eq a => a -> Par1 a -> Bool # maximum :: Ord a => Par1 a -> a # | |
Foldable IResult | |
Defined in Data.Aeson.Types.Internal fold :: Monoid m => IResult m -> m # foldMap :: Monoid m => (a -> m) -> IResult a -> m # foldr :: (a -> b -> b) -> b -> IResult a -> b # foldr' :: (a -> b -> b) -> b -> IResult a -> b # foldl :: (b -> a -> b) -> b -> IResult a -> b # foldl' :: (b -> a -> b) -> b -> IResult a -> b # foldr1 :: (a -> a -> a) -> IResult a -> a # foldl1 :: (a -> a -> a) -> IResult a -> a # elem :: Eq a => a -> IResult a -> Bool # maximum :: Ord a => IResult a -> a # minimum :: Ord a => IResult a -> a # | |
Foldable Result | |
Defined in Data.Aeson.Types.Internal fold :: Monoid m => Result m -> m # foldMap :: Monoid m => (a -> m) -> Result a -> m # foldr :: (a -> b -> b) -> b -> Result a -> b # foldr' :: (a -> b -> b) -> b -> Result a -> b # foldl :: (b -> a -> b) -> b -> Result a -> b # foldl' :: (b -> a -> b) -> b -> Result a -> b # foldr1 :: (a -> a -> a) -> Result a -> a # foldl1 :: (a -> a -> a) -> Result a -> a # elem :: Eq a => a -> Result a -> Bool # maximum :: Ord a => Result a -> a # minimum :: Ord a => Result a -> a # | |
Foldable Approximate | |
Defined in Data.Approximate.Type fold :: Monoid m => Approximate m -> m # foldMap :: Monoid m => (a -> m) -> Approximate a -> m # foldr :: (a -> b -> b) -> b -> Approximate a -> b # foldr' :: (a -> b -> b) -> b -> Approximate a -> b # foldl :: (b -> a -> b) -> b -> Approximate a -> b # foldl' :: (b -> a -> b) -> b -> Approximate a -> b # foldr1 :: (a -> a -> a) -> Approximate a -> a # foldl1 :: (a -> a -> a) -> Approximate a -> a # toList :: Approximate a -> [a] # null :: Approximate a -> Bool # length :: Approximate a -> Int # elem :: Eq a => a -> Approximate a -> Bool # maximum :: Ord a => Approximate a -> a # minimum :: Ord a => Approximate a -> a # sum :: Num a => Approximate a -> a # product :: Num a => Approximate a -> a # | |
Foldable Complex | |
Defined in Data.Complex 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 # elem :: Eq a => a -> Complex a -> Bool # maximum :: Ord a => Complex a -> a # minimum :: Ord a => Complex a -> a # | |
Foldable Min | Since: base-4.9.0.0 |
Defined in Data.Semigroup 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 # elem :: Eq a => a -> Min a -> Bool # maximum :: Ord a => Min a -> a # | |
Foldable Max | Since: base-4.9.0.0 |
Defined in Data.Semigroup 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 # elem :: Eq a => a -> Max a -> Bool # maximum :: Ord a => Max a -> a # | |
Foldable First | Since: base-4.9.0.0 |
Defined in Data.Semigroup 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 # elem :: Eq a => a -> First a -> Bool # maximum :: Ord a => First a -> a # minimum :: Ord a => First a -> a # | |
Foldable Last | Since: base-4.9.0.0 |
Defined in Data.Semigroup 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 # elem :: Eq a => a -> Last a -> Bool # maximum :: Ord a => Last a -> a # | |
Foldable Option | Since: base-4.9.0.0 |
Defined in Data.Semigroup 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 # elem :: Eq a => a -> Option a -> Bool # maximum :: Ord a => Option a -> a # minimum :: Ord a => Option a -> a # | |
Foldable ZipList | |
Defined in Control.Applicative 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 # elem :: Eq a => a -> ZipList a -> Bool # maximum :: Ord a => ZipList a -> a # minimum :: Ord a => ZipList a -> a # | |
Foldable Identity | Since: base-4.8.0.0 |
Defined in Data.Functor.Identity 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 # elem :: Eq a => a -> Identity a -> Bool # maximum :: Ord a => Identity a -> a # minimum :: Ord a => Identity a -> a # | |
Foldable First | Since: base-4.8.0.0 |
Defined in Data.Foldable 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 # elem :: Eq a => a -> First a -> Bool # maximum :: Ord a => First a -> a # minimum :: Ord a => First a -> a # | |
Foldable Last | Since: base-4.8.0.0 |
Defined in Data.Foldable 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 # elem :: Eq a => a -> Last a -> Bool # maximum :: Ord a => Last a -> a # | |
Foldable Dual | Since: base-4.8.0.0 |
Defined in Data.Foldable 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 # elem :: Eq a => a -> Dual a -> Bool # maximum :: Ord a => Dual a -> a # | |
Foldable Sum | Since: base-4.8.0.0 |
Defined in Data.Foldable 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 # elem :: Eq a => a -> Sum a -> Bool # maximum :: Ord a => Sum a -> a # | |
Foldable Product | Since: base-4.8.0.0 |
Defined in Data.Foldable 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 # elem :: Eq a => a -> Product a -> Bool # maximum :: Ord a => Product a -> a # minimum :: Ord a => Product a -> a # | |
Foldable NonEmpty | Since: base-4.9.0.0 |
Defined in Data.Foldable 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 # elem :: Eq a => a -> NonEmpty a -> Bool # maximum :: Ord a => NonEmpty a -> a # minimum :: Ord a => NonEmpty a -> a # | |
Foldable IntMap | |
Defined in Data.IntMap.Internal 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 # elem :: Eq a => a -> IntMap a -> Bool # maximum :: Ord a => IntMap a -> a # minimum :: Ord a => IntMap a -> a # | |
Foldable SCC | Since: containers-0.5.9 |
Defined in Data.Graph fold :: Monoid m => SCC m -> m # foldMap :: Monoid m => (a -> m) -> SCC a -> m # foldr :: (a -> b -> b) -> b -> SCC a -> b # foldr' :: (a -> b -> b) -> b -> SCC a -> b # foldl :: (b -> a -> b) -> b -> SCC a -> b # foldl' :: (b -> a -> b) -> b -> SCC a -> b # foldr1 :: (a -> a -> a) -> SCC a -> a # foldl1 :: (a -> a -> a) -> SCC a -> a # elem :: Eq a => a -> SCC a -> Bool # maximum :: Ord a => SCC a -> a # | |
Foldable Tree | |
Defined in Data.Tree 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 # elem :: Eq a => a -> Tree a -> Bool # maximum :: Ord a => Tree a -> a # | |
Foldable Seq | |
Defined in Data.Sequence.Internal 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 # elem :: Eq a => a -> Seq a -> Bool # maximum :: Ord a => Seq a -> a # | |
Foldable FingerTree | |
Defined in Data.Sequence.Internal 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 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 # elem :: Eq a => a -> Digit a -> Bool # maximum :: Ord a => Digit a -> a # minimum :: Ord a => Digit a -> a # | |
Foldable Node | |
Defined in Data.Sequence.Internal 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 # elem :: Eq a => a -> Node a -> Bool # maximum :: Ord a => Node a -> a # | |
Foldable Elem | |
Defined in Data.Sequence.Internal 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 # elem :: Eq a => a -> Elem a -> Bool # maximum :: Ord a => Elem a -> a # | |
Foldable ViewL | |
Defined in Data.Sequence.Internal 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 # elem :: Eq a => a -> ViewL a -> Bool # maximum :: Ord a => ViewL a -> a # minimum :: Ord a => ViewL a -> a # | |
Foldable ViewR | |
Defined in Data.Sequence.Internal 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 # elem :: Eq a => a -> ViewR a -> Bool # maximum :: Ord a => ViewR a -> a # minimum :: Ord a => ViewR a -> a # | |
Foldable Set | |
Defined in Data.Set.Internal 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 # elem :: Eq a => a -> Set a -> Bool # maximum :: Ord a => Set a -> a # | |
Foldable DList | |
Defined in Data.DList fold :: Monoid m => DList m -> m # foldMap :: Monoid m => (a -> m) -> DList a -> m # foldr :: (a -> b -> b) -> b -> DList a -> b # foldr' :: (a -> b -> b) -> b -> DList a -> b # foldl :: (b -> a -> b) -> b -> DList a -> b # foldl' :: (b -> a -> b) -> b -> DList a -> b # foldr1 :: (a -> a -> a) -> DList a -> a # foldl1 :: (a -> a -> a) -> DList a -> a # elem :: Eq a => a -> DList a -> Bool # maximum :: Ord a => DList a -> a # minimum :: Ord a => DList a -> a # | |
Foldable Hashed | |
Defined in Data.Hashable.Class 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 # elem :: Eq a => a -> Hashed a -> Bool # maximum :: Ord a => Hashed a -> a # minimum :: Ord a => Hashed a -> a # | |
Foldable ModuleName | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => ModuleName m -> m # foldMap :: Monoid m => (a -> m) -> ModuleName a -> m # foldr :: (a -> b -> b) -> b -> ModuleName a -> b # foldr' :: (a -> b -> b) -> b -> ModuleName a -> b # foldl :: (b -> a -> b) -> b -> ModuleName a -> b # foldl' :: (b -> a -> b) -> b -> ModuleName a -> b # foldr1 :: (a -> a -> a) -> ModuleName a -> a # foldl1 :: (a -> a -> a) -> ModuleName a -> a # toList :: ModuleName a -> [a] # null :: ModuleName a -> Bool # length :: ModuleName a -> Int # elem :: Eq a => a -> ModuleName a -> Bool # maximum :: Ord a => ModuleName a -> a # minimum :: Ord a => ModuleName a -> a # sum :: Num a => ModuleName a -> a # product :: Num a => ModuleName a -> a # | |
Foldable SpecialCon | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => SpecialCon m -> m # foldMap :: Monoid m => (a -> m) -> SpecialCon a -> m # foldr :: (a -> b -> b) -> b -> SpecialCon a -> b # foldr' :: (a -> b -> b) -> b -> SpecialCon a -> b # foldl :: (b -> a -> b) -> b -> SpecialCon a -> b # foldl' :: (b -> a -> b) -> b -> SpecialCon a -> b # foldr1 :: (a -> a -> a) -> SpecialCon a -> a # foldl1 :: (a -> a -> a) -> SpecialCon a -> a # toList :: SpecialCon a -> [a] # null :: SpecialCon a -> Bool # length :: SpecialCon a -> Int # elem :: Eq a => a -> SpecialCon a -> Bool # maximum :: Ord a => SpecialCon a -> a # minimum :: Ord a => SpecialCon a -> a # sum :: Num a => SpecialCon a -> a # product :: Num a => SpecialCon a -> a # | |
Foldable QName | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => QName m -> m # foldMap :: Monoid m => (a -> m) -> QName a -> m # foldr :: (a -> b -> b) -> b -> QName a -> b # foldr' :: (a -> b -> b) -> b -> QName a -> b # foldl :: (b -> a -> b) -> b -> QName a -> b # foldl' :: (b -> a -> b) -> b -> QName a -> b # foldr1 :: (a -> a -> a) -> QName a -> a # foldl1 :: (a -> a -> a) -> QName a -> a # elem :: Eq a => a -> QName a -> Bool # maximum :: Ord a => QName a -> a # minimum :: Ord a => QName a -> a # | |
Foldable Name | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Name m -> m # foldMap :: Monoid m => (a -> m) -> Name a -> m # foldr :: (a -> b -> b) -> b -> Name a -> b # foldr' :: (a -> b -> b) -> b -> Name a -> b # foldl :: (b -> a -> b) -> b -> Name a -> b # foldl' :: (b -> a -> b) -> b -> Name a -> b # foldr1 :: (a -> a -> a) -> Name a -> a # foldl1 :: (a -> a -> a) -> Name a -> a # elem :: Eq a => a -> Name a -> Bool # maximum :: Ord a => Name a -> a # | |
Foldable IPName | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => IPName m -> m # foldMap :: Monoid m => (a -> m) -> IPName a -> m # foldr :: (a -> b -> b) -> b -> IPName a -> b # foldr' :: (a -> b -> b) -> b -> IPName a -> b # foldl :: (b -> a -> b) -> b -> IPName a -> b # foldl' :: (b -> a -> b) -> b -> IPName a -> b # foldr1 :: (a -> a -> a) -> IPName a -> a # foldl1 :: (a -> a -> a) -> IPName a -> a # elem :: Eq a => a -> IPName a -> Bool # maximum :: Ord a => IPName a -> a # minimum :: Ord a => IPName a -> a # | |
Foldable QOp | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => QOp m -> m # foldMap :: Monoid m => (a -> m) -> QOp a -> m # foldr :: (a -> b -> b) -> b -> QOp a -> b # foldr' :: (a -> b -> b) -> b -> QOp a -> b # foldl :: (b -> a -> b) -> b -> QOp a -> b # foldl' :: (b -> a -> b) -> b -> QOp a -> b # foldr1 :: (a -> a -> a) -> QOp a -> a # foldl1 :: (a -> a -> a) -> QOp a -> a # elem :: Eq a => a -> QOp a -> Bool # maximum :: Ord a => QOp a -> a # | |
Foldable Op | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Op m -> m # foldMap :: Monoid m => (a -> m) -> Op a -> m # foldr :: (a -> b -> b) -> b -> Op a -> b # foldr' :: (a -> b -> b) -> b -> Op a -> b # foldl :: (b -> a -> b) -> b -> Op a -> b # foldl' :: (b -> a -> b) -> b -> Op a -> b # foldr1 :: (a -> a -> a) -> Op a -> a # foldl1 :: (a -> a -> a) -> Op a -> a # elem :: Eq a => a -> Op a -> Bool # maximum :: Ord a => Op a -> a # | |
Foldable CName | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => CName m -> m # foldMap :: Monoid m => (a -> m) -> CName a -> m # foldr :: (a -> b -> b) -> b -> CName a -> b # foldr' :: (a -> b -> b) -> b -> CName a -> b # foldl :: (b -> a -> b) -> b -> CName a -> b # foldl' :: (b -> a -> b) -> b -> CName a -> b # foldr1 :: (a -> a -> a) -> CName a -> a # foldl1 :: (a -> a -> a) -> CName a -> a # elem :: Eq a => a -> CName a -> Bool # maximum :: Ord a => CName a -> a # minimum :: Ord a => CName a -> a # | |
Foldable Module | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Module m -> m # foldMap :: Monoid m => (a -> m) -> Module a -> m # foldr :: (a -> b -> b) -> b -> Module a -> b # foldr' :: (a -> b -> b) -> b -> Module a -> b # foldl :: (b -> a -> b) -> b -> Module a -> b # foldl' :: (b -> a -> b) -> b -> Module a -> b # foldr1 :: (a -> a -> a) -> Module a -> a # foldl1 :: (a -> a -> a) -> Module a -> a # elem :: Eq a => a -> Module a -> Bool # maximum :: Ord a => Module a -> a # minimum :: Ord a => Module a -> a # | |
Foldable ModuleHead | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => ModuleHead m -> m # foldMap :: Monoid m => (a -> m) -> ModuleHead a -> m # foldr :: (a -> b -> b) -> b -> ModuleHead a -> b # foldr' :: (a -> b -> b) -> b -> ModuleHead a -> b # foldl :: (b -> a -> b) -> b -> ModuleHead a -> b # foldl' :: (b -> a -> b) -> b -> ModuleHead a -> b # foldr1 :: (a -> a -> a) -> ModuleHead a -> a # foldl1 :: (a -> a -> a) -> ModuleHead a -> a # toList :: ModuleHead a -> [a] # null :: ModuleHead a -> Bool # length :: ModuleHead a -> Int # elem :: Eq a => a -> ModuleHead a -> Bool # maximum :: Ord a => ModuleHead a -> a # minimum :: Ord a => ModuleHead a -> a # sum :: Num a => ModuleHead a -> a # product :: Num a => ModuleHead a -> a # | |
Foldable ExportSpecList | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => ExportSpecList m -> m # foldMap :: Monoid m => (a -> m) -> ExportSpecList a -> m # foldr :: (a -> b -> b) -> b -> ExportSpecList a -> b # foldr' :: (a -> b -> b) -> b -> ExportSpecList a -> b # foldl :: (b -> a -> b) -> b -> ExportSpecList a -> b # foldl' :: (b -> a -> b) -> b -> ExportSpecList a -> b # foldr1 :: (a -> a -> a) -> ExportSpecList a -> a # foldl1 :: (a -> a -> a) -> ExportSpecList a -> a # toList :: ExportSpecList a -> [a] # null :: ExportSpecList a -> Bool # length :: ExportSpecList a -> Int # elem :: Eq a => a -> ExportSpecList a -> Bool # maximum :: Ord a => ExportSpecList a -> a # minimum :: Ord a => ExportSpecList a -> a # sum :: Num a => ExportSpecList a -> a # product :: Num a => ExportSpecList a -> a # | |
Foldable ExportSpec | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => ExportSpec m -> m # foldMap :: Monoid m => (a -> m) -> ExportSpec a -> m # foldr :: (a -> b -> b) -> b -> ExportSpec a -> b # foldr' :: (a -> b -> b) -> b -> ExportSpec a -> b # foldl :: (b -> a -> b) -> b -> ExportSpec a -> b # foldl' :: (b -> a -> b) -> b -> ExportSpec a -> b # foldr1 :: (a -> a -> a) -> ExportSpec a -> a # foldl1 :: (a -> a -> a) -> ExportSpec a -> a # toList :: ExportSpec a -> [a] # null :: ExportSpec a -> Bool # length :: ExportSpec a -> Int # elem :: Eq a => a -> ExportSpec a -> Bool # maximum :: Ord a => ExportSpec a -> a # minimum :: Ord a => ExportSpec a -> a # sum :: Num a => ExportSpec a -> a # product :: Num a => ExportSpec a -> a # | |
Foldable EWildcard | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => EWildcard m -> m # foldMap :: Monoid m => (a -> m) -> EWildcard a -> m # foldr :: (a -> b -> b) -> b -> EWildcard a -> b # foldr' :: (a -> b -> b) -> b -> EWildcard a -> b # foldl :: (b -> a -> b) -> b -> EWildcard a -> b # foldl' :: (b -> a -> b) -> b -> EWildcard a -> b # foldr1 :: (a -> a -> a) -> EWildcard a -> a # foldl1 :: (a -> a -> a) -> EWildcard a -> a # toList :: EWildcard a -> [a] # length :: EWildcard a -> Int # elem :: Eq a => a -> EWildcard a -> Bool # maximum :: Ord a => EWildcard a -> a # minimum :: Ord a => EWildcard a -> a # | |
Foldable Namespace | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Namespace m -> m # foldMap :: Monoid m => (a -> m) -> Namespace a -> m # foldr :: (a -> b -> b) -> b -> Namespace a -> b # foldr' :: (a -> b -> b) -> b -> Namespace a -> b # foldl :: (b -> a -> b) -> b -> Namespace a -> b # foldl' :: (b -> a -> b) -> b -> Namespace a -> b # foldr1 :: (a -> a -> a) -> Namespace a -> a # foldl1 :: (a -> a -> a) -> Namespace a -> a # toList :: Namespace a -> [a] # length :: Namespace a -> Int # elem :: Eq a => a -> Namespace a -> Bool # maximum :: Ord a => Namespace a -> a # minimum :: Ord a => Namespace a -> a # | |
Foldable ImportDecl | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => ImportDecl m -> m # foldMap :: Monoid m => (a -> m) -> ImportDecl a -> m # foldr :: (a -> b -> b) -> b -> ImportDecl a -> b # foldr' :: (a -> b -> b) -> b -> ImportDecl a -> b # foldl :: (b -> a -> b) -> b -> ImportDecl a -> b # foldl' :: (b -> a -> b) -> b -> ImportDecl a -> b # foldr1 :: (a -> a -> a) -> ImportDecl a -> a # foldl1 :: (a -> a -> a) -> ImportDecl a -> a # toList :: ImportDecl a -> [a] # null :: ImportDecl a -> Bool # length :: ImportDecl a -> Int # elem :: Eq a => a -> ImportDecl a -> Bool # maximum :: Ord a => ImportDecl a -> a # minimum :: Ord a => ImportDecl a -> a # sum :: Num a => ImportDecl a -> a # product :: Num a => ImportDecl a -> a # | |
Foldable ImportSpecList | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => ImportSpecList m -> m # foldMap :: Monoid m => (a -> m) -> ImportSpecList a -> m # foldr :: (a -> b -> b) -> b -> ImportSpecList a -> b # foldr' :: (a -> b -> b) -> b -> ImportSpecList a -> b # foldl :: (b -> a -> b) -> b -> ImportSpecList a -> b # foldl' :: (b -> a -> b) -> b -> ImportSpecList a -> b # foldr1 :: (a -> a -> a) -> ImportSpecList a -> a # foldl1 :: (a -> a -> a) -> ImportSpecList a -> a # toList :: ImportSpecList a -> [a] # null :: ImportSpecList a -> Bool # length :: ImportSpecList a -> Int # elem :: Eq a => a -> ImportSpecList a -> Bool # maximum :: Ord a => ImportSpecList a -> a # minimum :: Ord a => ImportSpecList a -> a # sum :: Num a => ImportSpecList a -> a # product :: Num a => ImportSpecList a -> a # | |
Foldable ImportSpec | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => ImportSpec m -> m # foldMap :: Monoid m => (a -> m) -> ImportSpec a -> m # foldr :: (a -> b -> b) -> b -> ImportSpec a -> b # foldr' :: (a -> b -> b) -> b -> ImportSpec a -> b # foldl :: (b -> a -> b) -> b -> ImportSpec a -> b # foldl' :: (b -> a -> b) -> b -> ImportSpec a -> b # foldr1 :: (a -> a -> a) -> ImportSpec a -> a # foldl1 :: (a -> a -> a) -> ImportSpec a -> a # toList :: ImportSpec a -> [a] # null :: ImportSpec a -> Bool # length :: ImportSpec a -> Int # elem :: Eq a => a -> ImportSpec a -> Bool # maximum :: Ord a => ImportSpec a -> a # minimum :: Ord a => ImportSpec a -> a # sum :: Num a => ImportSpec a -> a # product :: Num a => ImportSpec a -> a # | |
Foldable Assoc | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Assoc m -> m # foldMap :: Monoid m => (a -> m) -> Assoc a -> m # foldr :: (a -> b -> b) -> b -> Assoc a -> b # foldr' :: (a -> b -> b) -> b -> Assoc a -> b # foldl :: (b -> a -> b) -> b -> Assoc a -> b # foldl' :: (b -> a -> b) -> b -> Assoc a -> b # foldr1 :: (a -> a -> a) -> Assoc a -> a # foldl1 :: (a -> a -> a) -> Assoc a -> a # elem :: Eq a => a -> Assoc a -> Bool # maximum :: Ord a => Assoc a -> a # minimum :: Ord a => Assoc a -> a # | |
Foldable Decl | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Decl m -> m # foldMap :: Monoid m => (a -> m) -> Decl a -> m # foldr :: (a -> b -> b) -> b -> Decl a -> b # foldr' :: (a -> b -> b) -> b -> Decl a -> b # foldl :: (b -> a -> b) -> b -> Decl a -> b # foldl' :: (b -> a -> b) -> b -> Decl a -> b # foldr1 :: (a -> a -> a) -> Decl a -> a # foldl1 :: (a -> a -> a) -> Decl a -> a # elem :: Eq a => a -> Decl a -> Bool # maximum :: Ord a => Decl a -> a # | |
Foldable PatternSynDirection | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => PatternSynDirection m -> m # foldMap :: Monoid m => (a -> m) -> PatternSynDirection a -> m # foldr :: (a -> b -> b) -> b -> PatternSynDirection a -> b # foldr' :: (a -> b -> b) -> b -> PatternSynDirection a -> b # foldl :: (b -> a -> b) -> b -> PatternSynDirection a -> b # foldl' :: (b -> a -> b) -> b -> PatternSynDirection a -> b # foldr1 :: (a -> a -> a) -> PatternSynDirection a -> a # foldl1 :: (a -> a -> a) -> PatternSynDirection a -> a # toList :: PatternSynDirection a -> [a] # null :: PatternSynDirection a -> Bool # length :: PatternSynDirection a -> Int # elem :: Eq a => a -> PatternSynDirection a -> Bool # maximum :: Ord a => PatternSynDirection a -> a # minimum :: Ord a => PatternSynDirection a -> a # sum :: Num a => PatternSynDirection a -> a # product :: Num a => PatternSynDirection a -> a # | |
Foldable TypeEqn | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => TypeEqn m -> m # foldMap :: Monoid m => (a -> m) -> TypeEqn a -> m # foldr :: (a -> b -> b) -> b -> TypeEqn a -> b # foldr' :: (a -> b -> b) -> b -> TypeEqn a -> b # foldl :: (b -> a -> b) -> b -> TypeEqn a -> b # foldl' :: (b -> a -> b) -> b -> TypeEqn a -> b # foldr1 :: (a -> a -> a) -> TypeEqn a -> a # foldl1 :: (a -> a -> a) -> TypeEqn a -> a # elem :: Eq a => a -> TypeEqn a -> Bool # maximum :: Ord a => TypeEqn a -> a # minimum :: Ord a => TypeEqn a -> a # | |
Foldable Annotation | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Annotation m -> m # foldMap :: Monoid m => (a -> m) -> Annotation a -> m # foldr :: (a -> b -> b) -> b -> Annotation a -> b # foldr' :: (a -> b -> b) -> b -> Annotation a -> b # foldl :: (b -> a -> b) -> b -> Annotation a -> b # foldl' :: (b -> a -> b) -> b -> Annotation a -> b # foldr1 :: (a -> a -> a) -> Annotation a -> a # foldl1 :: (a -> a -> a) -> Annotation a -> a # toList :: Annotation a -> [a] # null :: Annotation a -> Bool # length :: Annotation a -> Int # elem :: Eq a => a -> Annotation a -> Bool # maximum :: Ord a => Annotation a -> a # minimum :: Ord a => Annotation a -> a # sum :: Num a => Annotation a -> a # product :: Num a => Annotation a -> a # | |
Foldable BooleanFormula | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => BooleanFormula m -> m # foldMap :: Monoid m => (a -> m) -> BooleanFormula a -> m # foldr :: (a -> b -> b) -> b -> BooleanFormula a -> b # foldr' :: (a -> b -> b) -> b -> BooleanFormula a -> b # foldl :: (b -> a -> b) -> b -> BooleanFormula a -> b # foldl' :: (b -> a -> b) -> b -> BooleanFormula a -> b # foldr1 :: (a -> a -> a) -> BooleanFormula a -> a # foldl1 :: (a -> a -> a) -> BooleanFormula a -> a # toList :: BooleanFormula a -> [a] # null :: BooleanFormula a -> Bool # length :: BooleanFormula a -> Int # elem :: Eq a => a -> BooleanFormula a -> Bool # maximum :: Ord a => BooleanFormula a -> a # minimum :: Ord a => BooleanFormula a -> a # sum :: Num a => BooleanFormula a -> a # product :: Num a => BooleanFormula a -> a # | |
Foldable Role | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Role m -> m # foldMap :: Monoid m => (a -> m) -> Role a -> m # foldr :: (a -> b -> b) -> b -> Role a -> b # foldr' :: (a -> b -> b) -> b -> Role a -> b # foldl :: (b -> a -> b) -> b -> Role a -> b # foldl' :: (b -> a -> b) -> b -> Role a -> b # foldr1 :: (a -> a -> a) -> Role a -> a # foldl1 :: (a -> a -> a) -> Role a -> a # elem :: Eq a => a -> Role a -> Bool # maximum :: Ord a => Role a -> a # | |
Foldable DataOrNew | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => DataOrNew m -> m # foldMap :: Monoid m => (a -> m) -> DataOrNew a -> m # foldr :: (a -> b -> b) -> b -> DataOrNew a -> b # foldr' :: (a -> b -> b) -> b -> DataOrNew a -> b # foldl :: (b -> a -> b) -> b -> DataOrNew a -> b # foldl' :: (b -> a -> b) -> b -> DataOrNew a -> b # foldr1 :: (a -> a -> a) -> DataOrNew a -> a # foldl1 :: (a -> a -> a) -> DataOrNew a -> a # toList :: DataOrNew a -> [a] # length :: DataOrNew a -> Int # elem :: Eq a => a -> DataOrNew a -> Bool # maximum :: Ord a => DataOrNew a -> a # minimum :: Ord a => DataOrNew a -> a # | |
Foldable InjectivityInfo | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => InjectivityInfo m -> m # foldMap :: Monoid m => (a -> m) -> InjectivityInfo a -> m # foldr :: (a -> b -> b) -> b -> InjectivityInfo a -> b # foldr' :: (a -> b -> b) -> b -> InjectivityInfo a -> b # foldl :: (b -> a -> b) -> b -> InjectivityInfo a -> b # foldl' :: (b -> a -> b) -> b -> InjectivityInfo a -> b # foldr1 :: (a -> a -> a) -> InjectivityInfo a -> a # foldl1 :: (a -> a -> a) -> InjectivityInfo a -> a # toList :: InjectivityInfo a -> [a] # null :: InjectivityInfo a -> Bool # length :: InjectivityInfo a -> Int # elem :: Eq a => a -> InjectivityInfo a -> Bool # maximum :: Ord a => InjectivityInfo a -> a # minimum :: Ord a => InjectivityInfo a -> a # sum :: Num a => InjectivityInfo a -> a # product :: Num a => InjectivityInfo a -> a # | |
Foldable ResultSig | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => ResultSig m -> m # foldMap :: Monoid m => (a -> m) -> ResultSig a -> m # foldr :: (a -> b -> b) -> b -> ResultSig a -> b # foldr' :: (a -> b -> b) -> b -> ResultSig a -> b # foldl :: (b -> a -> b) -> b -> ResultSig a -> b # foldl' :: (b -> a -> b) -> b -> ResultSig a -> b # foldr1 :: (a -> a -> a) -> ResultSig a -> a # foldl1 :: (a -> a -> a) -> ResultSig a -> a # toList :: ResultSig a -> [a] # length :: ResultSig a -> Int # elem :: Eq a => a -> ResultSig a -> Bool # maximum :: Ord a => ResultSig a -> a # minimum :: Ord a => ResultSig a -> a # | |
Foldable DeclHead | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => DeclHead m -> m # foldMap :: Monoid m => (a -> m) -> DeclHead a -> m # foldr :: (a -> b -> b) -> b -> DeclHead a -> b # foldr' :: (a -> b -> b) -> b -> DeclHead a -> b # foldl :: (b -> a -> b) -> b -> DeclHead a -> b # foldl' :: (b -> a -> b) -> b -> DeclHead a -> b # foldr1 :: (a -> a -> a) -> DeclHead a -> a # foldl1 :: (a -> a -> a) -> DeclHead a -> a # elem :: Eq a => a -> DeclHead a -> Bool # maximum :: Ord a => DeclHead a -> a # minimum :: Ord a => DeclHead a -> a # | |
Foldable InstRule | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => InstRule m -> m # foldMap :: Monoid m => (a -> m) -> InstRule a -> m # foldr :: (a -> b -> b) -> b -> InstRule a -> b # foldr' :: (a -> b -> b) -> b -> InstRule a -> b # foldl :: (b -> a -> b) -> b -> InstRule a -> b # foldl' :: (b -> a -> b) -> b -> InstRule a -> b # foldr1 :: (a -> a -> a) -> InstRule a -> a # foldl1 :: (a -> a -> a) -> InstRule a -> a # elem :: Eq a => a -> InstRule a -> Bool # maximum :: Ord a => InstRule a -> a # minimum :: Ord a => InstRule a -> a # | |
Foldable InstHead | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => InstHead m -> m # foldMap :: Monoid m => (a -> m) -> InstHead a -> m # foldr :: (a -> b -> b) -> b -> InstHead a -> b # foldr' :: (a -> b -> b) -> b -> InstHead a -> b # foldl :: (b -> a -> b) -> b -> InstHead a -> b # foldl' :: (b -> a -> b) -> b -> InstHead a -> b # foldr1 :: (a -> a -> a) -> InstHead a -> a # foldl1 :: (a -> a -> a) -> InstHead a -> a # elem :: Eq a => a -> InstHead a -> Bool # maximum :: Ord a => InstHead a -> a # minimum :: Ord a => InstHead a -> a # | |
Foldable Deriving | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Deriving m -> m # foldMap :: Monoid m => (a -> m) -> Deriving a -> m # foldr :: (a -> b -> b) -> b -> Deriving a -> b # foldr' :: (a -> b -> b) -> b -> Deriving a -> b # foldl :: (b -> a -> b) -> b -> Deriving a -> b # foldl' :: (b -> a -> b) -> b -> Deriving a -> b # foldr1 :: (a -> a -> a) -> Deriving a -> a # foldl1 :: (a -> a -> a) -> Deriving a -> a # elem :: Eq a => a -> Deriving a -> Bool # maximum :: Ord a => Deriving a -> a # minimum :: Ord a => Deriving a -> a # | |
Foldable DerivStrategy | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => DerivStrategy m -> m # foldMap :: Monoid m => (a -> m) -> DerivStrategy a -> m # foldr :: (a -> b -> b) -> b -> DerivStrategy a -> b # foldr' :: (a -> b -> b) -> b -> DerivStrategy a -> b # foldl :: (b -> a -> b) -> b -> DerivStrategy a -> b # foldl' :: (b -> a -> b) -> b -> DerivStrategy a -> b # foldr1 :: (a -> a -> a) -> DerivStrategy a -> a # foldl1 :: (a -> a -> a) -> DerivStrategy a -> a # toList :: DerivStrategy a -> [a] # null :: DerivStrategy a -> Bool # length :: DerivStrategy a -> Int # elem :: Eq a => a -> DerivStrategy a -> Bool # maximum :: Ord a => DerivStrategy a -> a # minimum :: Ord a => DerivStrategy a -> a # sum :: Num a => DerivStrategy a -> a # product :: Num a => DerivStrategy a -> a # | |
Foldable Binds | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Binds m -> m # foldMap :: Monoid m => (a -> m) -> Binds a -> m # foldr :: (a -> b -> b) -> b -> Binds a -> b # foldr' :: (a -> b -> b) -> b -> Binds a -> b # foldl :: (b -> a -> b) -> b -> Binds a -> b # foldl' :: (b -> a -> b) -> b -> Binds a -> b # foldr1 :: (a -> a -> a) -> Binds a -> a # foldl1 :: (a -> a -> a) -> Binds a -> a # elem :: Eq a => a -> Binds a -> Bool # maximum :: Ord a => Binds a -> a # minimum :: Ord a => Binds a -> a # | |
Foldable IPBind | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => IPBind m -> m # foldMap :: Monoid m => (a -> m) -> IPBind a -> m # foldr :: (a -> b -> b) -> b -> IPBind a -> b # foldr' :: (a -> b -> b) -> b -> IPBind a -> b # foldl :: (b -> a -> b) -> b -> IPBind a -> b # foldl' :: (b -> a -> b) -> b -> IPBind a -> b # foldr1 :: (a -> a -> a) -> IPBind a -> a # foldl1 :: (a -> a -> a) -> IPBind a -> a # elem :: Eq a => a -> IPBind a -> Bool # maximum :: Ord a => IPBind a -> a # minimum :: Ord a => IPBind a -> a # | |
Foldable Match | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Match m -> m # foldMap :: Monoid m => (a -> m) -> Match a -> m # foldr :: (a -> b -> b) -> b -> Match a -> b # foldr' :: (a -> b -> b) -> b -> Match a -> b # foldl :: (b -> a -> b) -> b -> Match a -> b # foldl' :: (b -> a -> b) -> b -> Match a -> b # foldr1 :: (a -> a -> a) -> Match a -> a # foldl1 :: (a -> a -> a) -> Match a -> a # elem :: Eq a => a -> Match a -> Bool # maximum :: Ord a => Match a -> a # minimum :: Ord a => Match a -> a # | |
Foldable QualConDecl | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => QualConDecl m -> m # foldMap :: Monoid m => (a -> m) -> QualConDecl a -> m # foldr :: (a -> b -> b) -> b -> QualConDecl a -> b # foldr' :: (a -> b -> b) -> b -> QualConDecl a -> b # foldl :: (b -> a -> b) -> b -> QualConDecl a -> b # foldl' :: (b -> a -> b) -> b -> QualConDecl a -> b # foldr1 :: (a -> a -> a) -> QualConDecl a -> a # foldl1 :: (a -> a -> a) -> QualConDecl a -> a # toList :: QualConDecl a -> [a] # null :: QualConDecl a -> Bool # length :: QualConDecl a -> Int # elem :: Eq a => a -> QualConDecl a -> Bool # maximum :: Ord a => QualConDecl a -> a # minimum :: Ord a => QualConDecl a -> a # sum :: Num a => QualConDecl a -> a # product :: Num a => QualConDecl a -> a # | |
Foldable ConDecl | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => ConDecl m -> m # foldMap :: Monoid m => (a -> m) -> ConDecl a -> m # foldr :: (a -> b -> b) -> b -> ConDecl a -> b # foldr' :: (a -> b -> b) -> b -> ConDecl a -> b # foldl :: (b -> a -> b) -> b -> ConDecl a -> b # foldl' :: (b -> a -> b) -> b -> ConDecl a -> b # foldr1 :: (a -> a -> a) -> ConDecl a -> a # foldl1 :: (a -> a -> a) -> ConDecl a -> a # elem :: Eq a => a -> ConDecl a -> Bool # maximum :: Ord a => ConDecl a -> a # minimum :: Ord a => ConDecl a -> a # | |
Foldable FieldDecl | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => FieldDecl m -> m # foldMap :: Monoid m => (a -> m) -> FieldDecl a -> m # foldr :: (a -> b -> b) -> b -> FieldDecl a -> b # foldr' :: (a -> b -> b) -> b -> FieldDecl a -> b # foldl :: (b -> a -> b) -> b -> FieldDecl a -> b # foldl' :: (b -> a -> b) -> b -> FieldDecl a -> b # foldr1 :: (a -> a -> a) -> FieldDecl a -> a # foldl1 :: (a -> a -> a) -> FieldDecl a -> a # toList :: FieldDecl a -> [a] # length :: FieldDecl a -> Int # elem :: Eq a => a -> FieldDecl a -> Bool # maximum :: Ord a => FieldDecl a -> a # minimum :: Ord a => FieldDecl a -> a # | |
Foldable GadtDecl | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => GadtDecl m -> m # foldMap :: Monoid m => (a -> m) -> GadtDecl a -> m # foldr :: (a -> b -> b) -> b -> GadtDecl a -> b # foldr' :: (a -> b -> b) -> b -> GadtDecl a -> b # foldl :: (b -> a -> b) -> b -> GadtDecl a -> b # foldl' :: (b -> a -> b) -> b -> GadtDecl a -> b # foldr1 :: (a -> a -> a) -> GadtDecl a -> a # foldl1 :: (a -> a -> a) -> GadtDecl a -> a # elem :: Eq a => a -> GadtDecl a -> Bool # maximum :: Ord a => GadtDecl a -> a # minimum :: Ord a => GadtDecl a -> a # | |
Foldable ClassDecl | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => ClassDecl m -> m # foldMap :: Monoid m => (a -> m) -> ClassDecl a -> m # foldr :: (a -> b -> b) -> b -> ClassDecl a -> b # foldr' :: (a -> b -> b) -> b -> ClassDecl a -> b # foldl :: (b -> a -> b) -> b -> ClassDecl a -> b # foldl' :: (b -> a -> b) -> b -> ClassDecl a -> b # foldr1 :: (a -> a -> a) -> ClassDecl a -> a # foldl1 :: (a -> a -> a) -> ClassDecl a -> a # toList :: ClassDecl a -> [a] # length :: ClassDecl a -> Int # elem :: Eq a => a -> ClassDecl a -> Bool # maximum :: Ord a => ClassDecl a -> a # minimum :: Ord a => ClassDecl a -> a # | |
Foldable InstDecl | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => InstDecl m -> m # foldMap :: Monoid m => (a -> m) -> InstDecl a -> m # foldr :: (a -> b -> b) -> b -> InstDecl a -> b # foldr' :: (a -> b -> b) -> b -> InstDecl a -> b # foldl :: (b -> a -> b) -> b -> InstDecl a -> b # foldl' :: (b -> a -> b) -> b -> InstDecl a -> b # foldr1 :: (a -> a -> a) -> InstDecl a -> a # foldl1 :: (a -> a -> a) -> InstDecl a -> a # elem :: Eq a => a -> InstDecl a -> Bool # maximum :: Ord a => InstDecl a -> a # minimum :: Ord a => InstDecl a -> a # | |
Foldable BangType | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => BangType m -> m # foldMap :: Monoid m => (a -> m) -> BangType a -> m # foldr :: (a -> b -> b) -> b -> BangType a -> b # foldr' :: (a -> b -> b) -> b -> BangType a -> b # foldl :: (b -> a -> b) -> b -> BangType a -> b # foldl' :: (b -> a -> b) -> b -> BangType a -> b # foldr1 :: (a -> a -> a) -> BangType a -> a # foldl1 :: (a -> a -> a) -> BangType a -> a # elem :: Eq a => a -> BangType a -> Bool # maximum :: Ord a => BangType a -> a # minimum :: Ord a => BangType a -> a # | |
Foldable Unpackedness | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Unpackedness m -> m # foldMap :: Monoid m => (a -> m) -> Unpackedness a -> m # foldr :: (a -> b -> b) -> b -> Unpackedness a -> b # foldr' :: (a -> b -> b) -> b -> Unpackedness a -> b # foldl :: (b -> a -> b) -> b -> Unpackedness a -> b # foldl' :: (b -> a -> b) -> b -> Unpackedness a -> b # foldr1 :: (a -> a -> a) -> Unpackedness a -> a # foldl1 :: (a -> a -> a) -> Unpackedness a -> a # toList :: Unpackedness a -> [a] # null :: Unpackedness a -> Bool # length :: Unpackedness a -> Int # elem :: Eq a => a -> Unpackedness a -> Bool # maximum :: Ord a => Unpackedness a -> a # minimum :: Ord a => Unpackedness a -> a # sum :: Num a => Unpackedness a -> a # product :: Num a => Unpackedness a -> a # | |
Foldable Rhs | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Rhs m -> m # foldMap :: Monoid m => (a -> m) -> Rhs a -> m # foldr :: (a -> b -> b) -> b -> Rhs a -> b # foldr' :: (a -> b -> b) -> b -> Rhs a -> b # foldl :: (b -> a -> b) -> b -> Rhs a -> b # foldl' :: (b -> a -> b) -> b -> Rhs a -> b # foldr1 :: (a -> a -> a) -> Rhs a -> a # foldl1 :: (a -> a -> a) -> Rhs a -> a # elem :: Eq a => a -> Rhs a -> Bool # maximum :: Ord a => Rhs a -> a # | |
Foldable GuardedRhs | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => GuardedRhs m -> m # foldMap :: Monoid m => (a -> m) -> GuardedRhs a -> m # foldr :: (a -> b -> b) -> b -> GuardedRhs a -> b # foldr' :: (a -> b -> b) -> b -> GuardedRhs a -> b # foldl :: (b -> a -> b) -> b -> GuardedRhs a -> b # foldl' :: (b -> a -> b) -> b -> GuardedRhs a -> b # foldr1 :: (a -> a -> a) -> GuardedRhs a -> a # foldl1 :: (a -> a -> a) -> GuardedRhs a -> a # toList :: GuardedRhs a -> [a] # null :: GuardedRhs a -> Bool # length :: GuardedRhs a -> Int # elem :: Eq a => a -> GuardedRhs a -> Bool # maximum :: Ord a => GuardedRhs a -> a # minimum :: Ord a => GuardedRhs a -> a # sum :: Num a => GuardedRhs a -> a # product :: Num a => GuardedRhs a -> a # | |
Foldable Type | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Type m -> m # foldMap :: Monoid m => (a -> m) -> Type a -> m # foldr :: (a -> b -> b) -> b -> Type a -> b # foldr' :: (a -> b -> b) -> b -> Type a -> b # foldl :: (b -> a -> b) -> b -> Type a -> b # foldl' :: (b -> a -> b) -> b -> Type a -> b # foldr1 :: (a -> a -> a) -> Type a -> a # foldl1 :: (a -> a -> a) -> Type a -> a # elem :: Eq a => a -> Type a -> Bool # maximum :: Ord a => Type a -> a # | |
Foldable MaybePromotedName | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => MaybePromotedName m -> m # foldMap :: Monoid m => (a -> m) -> MaybePromotedName a -> m # foldr :: (a -> b -> b) -> b -> MaybePromotedName a -> b # foldr' :: (a -> b -> b) -> b -> MaybePromotedName a -> b # foldl :: (b -> a -> b) -> b -> MaybePromotedName a -> b # foldl' :: (b -> a -> b) -> b -> MaybePromotedName a -> b # foldr1 :: (a -> a -> a) -> MaybePromotedName a -> a # foldl1 :: (a -> a -> a) -> MaybePromotedName a -> a # toList :: MaybePromotedName a -> [a] # null :: MaybePromotedName a -> Bool # length :: MaybePromotedName a -> Int # elem :: Eq a => a -> MaybePromotedName a -> Bool # maximum :: Ord a => MaybePromotedName a -> a # minimum :: Ord a => MaybePromotedName a -> a # sum :: Num a => MaybePromotedName a -> a # product :: Num a => MaybePromotedName a -> a # | |
Foldable Promoted | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Promoted m -> m # foldMap :: Monoid m => (a -> m) -> Promoted a -> m # foldr :: (a -> b -> b) -> b -> Promoted a -> b # foldr' :: (a -> b -> b) -> b -> Promoted a -> b # foldl :: (b -> a -> b) -> b -> Promoted a -> b # foldl' :: (b -> a -> b) -> b -> Promoted a -> b # foldr1 :: (a -> a -> a) -> Promoted a -> a # foldl1 :: (a -> a -> a) -> Promoted a -> a # elem :: Eq a => a -> Promoted a -> Bool # maximum :: Ord a => Promoted a -> a # minimum :: Ord a => Promoted a -> a # | |
Foldable TyVarBind | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => TyVarBind m -> m # foldMap :: Monoid m => (a -> m) -> TyVarBind a -> m # foldr :: (a -> b -> b) -> b -> TyVarBind a -> b # foldr' :: (a -> b -> b) -> b -> TyVarBind a -> b # foldl :: (b -> a -> b) -> b -> TyVarBind a -> b # foldl' :: (b -> a -> b) -> b -> TyVarBind a -> b # foldr1 :: (a -> a -> a) -> TyVarBind a -> a # foldl1 :: (a -> a -> a) -> TyVarBind a -> a # toList :: TyVarBind a -> [a] # length :: TyVarBind a -> Int # elem :: Eq a => a -> TyVarBind a -> Bool # maximum :: Ord a => TyVarBind a -> a # minimum :: Ord a => TyVarBind a -> a # | |
Foldable Kind | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Kind m -> m # foldMap :: Monoid m => (a -> m) -> Kind a -> m # foldr :: (a -> b -> b) -> b -> Kind a -> b # foldr' :: (a -> b -> b) -> b -> Kind a -> b # foldl :: (b -> a -> b) -> b -> Kind a -> b # foldl' :: (b -> a -> b) -> b -> Kind a -> b # foldr1 :: (a -> a -> a) -> Kind a -> a # foldl1 :: (a -> a -> a) -> Kind a -> a # elem :: Eq a => a -> Kind a -> Bool # maximum :: Ord a => Kind a -> a # | |
Foldable FunDep | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => FunDep m -> m # foldMap :: Monoid m => (a -> m) -> FunDep a -> m # foldr :: (a -> b -> b) -> b -> FunDep a -> b # foldr' :: (a -> b -> b) -> b -> FunDep a -> b # foldl :: (b -> a -> b) -> b -> FunDep a -> b # foldl' :: (b -> a -> b) -> b -> FunDep a -> b # foldr1 :: (a -> a -> a) -> FunDep a -> a # foldl1 :: (a -> a -> a) -> FunDep a -> a # elem :: Eq a => a -> FunDep a -> Bool # maximum :: Ord a => FunDep a -> a # minimum :: Ord a => FunDep a -> a # | |
Foldable Context | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Context m -> m # foldMap :: Monoid m => (a -> m) -> Context a -> m # foldr :: (a -> b -> b) -> b -> Context a -> b # foldr' :: (a -> b -> b) -> b -> Context a -> b # foldl :: (b -> a -> b) -> b -> Context a -> b # foldl' :: (b -> a -> b) -> b -> Context a -> b # foldr1 :: (a -> a -> a) -> Context a -> a # foldl1 :: (a -> a -> a) -> Context a -> a # elem :: Eq a => a -> Context a -> Bool # maximum :: Ord a => Context a -> a # minimum :: Ord a => Context a -> a # | |
Foldable Asst | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Asst m -> m # foldMap :: Monoid m => (a -> m) -> Asst a -> m # foldr :: (a -> b -> b) -> b -> Asst a -> b # foldr' :: (a -> b -> b) -> b -> Asst a -> b # foldl :: (b -> a -> b) -> b -> Asst a -> b # foldl' :: (b -> a -> b) -> b -> Asst a -> b # foldr1 :: (a -> a -> a) -> Asst a -> a # foldl1 :: (a -> a -> a) -> Asst a -> a # elem :: Eq a => a -> Asst a -> Bool # maximum :: Ord a => Asst a -> a # | |
Foldable Literal | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Literal m -> m # foldMap :: Monoid m => (a -> m) -> Literal a -> m # foldr :: (a -> b -> b) -> b -> Literal a -> b # foldr' :: (a -> b -> b) -> b -> Literal a -> b # foldl :: (b -> a -> b) -> b -> Literal a -> b # foldl' :: (b -> a -> b) -> b -> Literal a -> b # foldr1 :: (a -> a -> a) -> Literal a -> a # foldl1 :: (a -> a -> a) -> Literal a -> a # elem :: Eq a => a -> Literal a -> Bool # maximum :: Ord a => Literal a -> a # minimum :: Ord a => Literal a -> a # | |
Foldable Sign | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Sign m -> m # foldMap :: Monoid m => (a -> m) -> Sign a -> m # foldr :: (a -> b -> b) -> b -> Sign a -> b # foldr' :: (a -> b -> b) -> b -> Sign a -> b # foldl :: (b -> a -> b) -> b -> Sign a -> b # foldl' :: (b -> a -> b) -> b -> Sign a -> b # foldr1 :: (a -> a -> a) -> Sign a -> a # foldl1 :: (a -> a -> a) -> Sign a -> a # elem :: Eq a => a -> Sign a -> Bool # maximum :: Ord a => Sign a -> a # | |
Foldable Exp | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Exp m -> m # foldMap :: Monoid m => (a -> m) -> Exp a -> m # foldr :: (a -> b -> b) -> b -> Exp a -> b # foldr' :: (a -> b -> b) -> b -> Exp a -> b # foldl :: (b -> a -> b) -> b -> Exp a -> b # foldl' :: (b -> a -> b) -> b -> Exp a -> b # foldr1 :: (a -> a -> a) -> Exp a -> a # foldl1 :: (a -> a -> a) -> Exp a -> a # elem :: Eq a => a -> Exp a -> Bool # maximum :: Ord a => Exp a -> a # | |
Foldable XName | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => XName m -> m # foldMap :: Monoid m => (a -> m) -> XName a -> m # foldr :: (a -> b -> b) -> b -> XName a -> b # foldr' :: (a -> b -> b) -> b -> XName a -> b # foldl :: (b -> a -> b) -> b -> XName a -> b # foldl' :: (b -> a -> b) -> b -> XName a -> b # foldr1 :: (a -> a -> a) -> XName a -> a # foldl1 :: (a -> a -> a) -> XName a -> a # elem :: Eq a => a -> XName a -> Bool # maximum :: Ord a => XName a -> a # minimum :: Ord a => XName a -> a # | |
Foldable XAttr | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => XAttr m -> m # foldMap :: Monoid m => (a -> m) -> XAttr a -> m # foldr :: (a -> b -> b) -> b -> XAttr a -> b # foldr' :: (a -> b -> b) -> b -> XAttr a -> b # foldl :: (b -> a -> b) -> b -> XAttr a -> b # foldl' :: (b -> a -> b) -> b -> XAttr a -> b # foldr1 :: (a -> a -> a) -> XAttr a -> a # foldl1 :: (a -> a -> a) -> XAttr a -> a # elem :: Eq a => a -> XAttr a -> Bool # maximum :: Ord a => XAttr a -> a # minimum :: Ord a => XAttr a -> a # | |
Foldable Bracket | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Bracket m -> m # foldMap :: Monoid m => (a -> m) -> Bracket a -> m # foldr :: (a -> b -> b) -> b -> Bracket a -> b # foldr' :: (a -> b -> b) -> b -> Bracket a -> b # foldl :: (b -> a -> b) -> b -> Bracket a -> b # foldl' :: (b -> a -> b) -> b -> Bracket a -> b # foldr1 :: (a -> a -> a) -> Bracket a -> a # foldl1 :: (a -> a -> a) -> Bracket a -> a # elem :: Eq a => a -> Bracket a -> Bool # maximum :: Ord a => Bracket a -> a # minimum :: Ord a => Bracket a -> a # | |
Foldable Splice | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Splice m -> m # foldMap :: Monoid m => (a -> m) -> Splice a -> m # foldr :: (a -> b -> b) -> b -> Splice a -> b # foldr' :: (a -> b -> b) -> b -> Splice a -> b # foldl :: (b -> a -> b) -> b -> Splice a -> b # foldl' :: (b -> a -> b) -> b -> Splice a -> b # foldr1 :: (a -> a -> a) -> Splice a -> a # foldl1 :: (a -> a -> a) -> Splice a -> a # elem :: Eq a => a -> Splice a -> Bool # maximum :: Ord a => Splice a -> a # minimum :: Ord a => Splice a -> a # | |
Foldable Safety | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Safety m -> m # foldMap :: Monoid m => (a -> m) -> Safety a -> m # foldr :: (a -> b -> b) -> b -> Safety a -> b # foldr' :: (a -> b -> b) -> b -> Safety a -> b # foldl :: (b -> a -> b) -> b -> Safety a -> b # foldl' :: (b -> a -> b) -> b -> Safety a -> b # foldr1 :: (a -> a -> a) -> Safety a -> a # foldl1 :: (a -> a -> a) -> Safety a -> a # elem :: Eq a => a -> Safety a -> Bool # maximum :: Ord a => Safety a -> a # minimum :: Ord a => Safety a -> a # | |
Foldable CallConv | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => CallConv m -> m # foldMap :: Monoid m => (a -> m) -> CallConv a -> m # foldr :: (a -> b -> b) -> b -> CallConv a -> b # foldr' :: (a -> b -> b) -> b -> CallConv a -> b # foldl :: (b -> a -> b) -> b -> CallConv a -> b # foldl' :: (b -> a -> b) -> b -> CallConv a -> b # foldr1 :: (a -> a -> a) -> CallConv a -> a # foldl1 :: (a -> a -> a) -> CallConv a -> a # elem :: Eq a => a -> CallConv a -> Bool # maximum :: Ord a => CallConv a -> a # minimum :: Ord a => CallConv a -> a # | |
Foldable ModulePragma | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => ModulePragma m -> m # foldMap :: Monoid m => (a -> m) -> ModulePragma a -> m # foldr :: (a -> b -> b) -> b -> ModulePragma a -> b # foldr' :: (a -> b -> b) -> b -> ModulePragma a -> b # foldl :: (b -> a -> b) -> b -> ModulePragma a -> b # foldl' :: (b -> a -> b) -> b -> ModulePragma a -> b # foldr1 :: (a -> a -> a) -> ModulePragma a -> a # foldl1 :: (a -> a -> a) -> ModulePragma a -> a # toList :: ModulePragma a -> [a] # null :: ModulePragma a -> Bool # length :: ModulePragma a -> Int # elem :: Eq a => a -> ModulePragma a -> Bool # maximum :: Ord a => ModulePragma a -> a # minimum :: Ord a => ModulePragma a -> a # sum :: Num a => ModulePragma a -> a # product :: Num a => ModulePragma a -> a # | |
Foldable Overlap | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Overlap m -> m # foldMap :: Monoid m => (a -> m) -> Overlap a -> m # foldr :: (a -> b -> b) -> b -> Overlap a -> b # foldr' :: (a -> b -> b) -> b -> Overlap a -> b # foldl :: (b -> a -> b) -> b -> Overlap a -> b # foldl' :: (b -> a -> b) -> b -> Overlap a -> b # foldr1 :: (a -> a -> a) -> Overlap a -> a # foldl1 :: (a -> a -> a) -> Overlap a -> a # elem :: Eq a => a -> Overlap a -> Bool # maximum :: Ord a => Overlap a -> a # minimum :: Ord a => Overlap a -> a # | |
Foldable Activation | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Activation m -> m # foldMap :: Monoid m => (a -> m) -> Activation a -> m # foldr :: (a -> b -> b) -> b -> Activation a -> b # foldr' :: (a -> b -> b) -> b -> Activation a -> b # foldl :: (b -> a -> b) -> b -> Activation a -> b # foldl' :: (b -> a -> b) -> b -> Activation a -> b # foldr1 :: (a -> a -> a) -> Activation a -> a # foldl1 :: (a -> a -> a) -> Activation a -> a # toList :: Activation a -> [a] # null :: Activation a -> Bool # length :: Activation a -> Int # elem :: Eq a => a -> Activation a -> Bool # maximum :: Ord a => Activation a -> a # minimum :: Ord a => Activation a -> a # sum :: Num a => Activation a -> a # product :: Num a => Activation a -> a # | |
Foldable Rule | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Rule m -> m # foldMap :: Monoid m => (a -> m) -> Rule a -> m # foldr :: (a -> b -> b) -> b -> Rule a -> b # foldr' :: (a -> b -> b) -> b -> Rule a -> b # foldl :: (b -> a -> b) -> b -> Rule a -> b # foldl' :: (b -> a -> b) -> b -> Rule a -> b # foldr1 :: (a -> a -> a) -> Rule a -> a # foldl1 :: (a -> a -> a) -> Rule a -> a # elem :: Eq a => a -> Rule a -> Bool # maximum :: Ord a => Rule a -> a # | |
Foldable RuleVar | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => RuleVar m -> m # foldMap :: Monoid m => (a -> m) -> RuleVar a -> m # foldr :: (a -> b -> b) -> b -> RuleVar a -> b # foldr' :: (a -> b -> b) -> b -> RuleVar a -> b # foldl :: (b -> a -> b) -> b -> RuleVar a -> b # foldl' :: (b -> a -> b) -> b -> RuleVar a -> b # foldr1 :: (a -> a -> a) -> RuleVar a -> a # foldl1 :: (a -> a -> a) -> RuleVar a -> a # elem :: Eq a => a -> RuleVar a -> Bool # maximum :: Ord a => RuleVar a -> a # minimum :: Ord a => RuleVar a -> a # | |
Foldable WarningText | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => WarningText m -> m # foldMap :: Monoid m => (a -> m) -> WarningText a -> m # foldr :: (a -> b -> b) -> b -> WarningText a -> b # foldr' :: (a -> b -> b) -> b -> WarningText a -> b # foldl :: (b -> a -> b) -> b -> WarningText a -> b # foldl' :: (b -> a -> b) -> b -> WarningText a -> b # foldr1 :: (a -> a -> a) -> WarningText a -> a # foldl1 :: (a -> a -> a) -> WarningText a -> a # toList :: WarningText a -> [a] # null :: WarningText a -> Bool # length :: WarningText a -> Int # elem :: Eq a => a -> WarningText a -> Bool # maximum :: Ord a => WarningText a -> a # minimum :: Ord a => WarningText a -> a # sum :: Num a => WarningText a -> a # product :: Num a => WarningText a -> a # | |
Foldable Pat | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Pat m -> m # foldMap :: Monoid m => (a -> m) -> Pat a -> m # foldr :: (a -> b -> b) -> b -> Pat a -> b # foldr' :: (a -> b -> b) -> b -> Pat a -> b # foldl :: (b -> a -> b) -> b -> Pat a -> b # foldl' :: (b -> a -> b) -> b -> Pat a -> b # foldr1 :: (a -> a -> a) -> Pat a -> a # foldl1 :: (a -> a -> a) -> Pat a -> a # elem :: Eq a => a -> Pat a -> Bool # maximum :: Ord a => Pat a -> a # | |
Foldable PXAttr | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => PXAttr m -> m # foldMap :: Monoid m => (a -> m) -> PXAttr a -> m # foldr :: (a -> b -> b) -> b -> PXAttr a -> b # foldr' :: (a -> b -> b) -> b -> PXAttr a -> b # foldl :: (b -> a -> b) -> b -> PXAttr a -> b # foldl' :: (b -> a -> b) -> b -> PXAttr a -> b # foldr1 :: (a -> a -> a) -> PXAttr a -> a # foldl1 :: (a -> a -> a) -> PXAttr a -> a # elem :: Eq a => a -> PXAttr a -> Bool # maximum :: Ord a => PXAttr a -> a # minimum :: Ord a => PXAttr a -> a # | |
Foldable RPatOp | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => RPatOp m -> m # foldMap :: Monoid m => (a -> m) -> RPatOp a -> m # foldr :: (a -> b -> b) -> b -> RPatOp a -> b # foldr' :: (a -> b -> b) -> b -> RPatOp a -> b # foldl :: (b -> a -> b) -> b -> RPatOp a -> b # foldl' :: (b -> a -> b) -> b -> RPatOp a -> b # foldr1 :: (a -> a -> a) -> RPatOp a -> a # foldl1 :: (a -> a -> a) -> RPatOp a -> a # elem :: Eq a => a -> RPatOp a -> Bool # maximum :: Ord a => RPatOp a -> a # minimum :: Ord a => RPatOp a -> a # | |
Foldable RPat | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => RPat m -> m # foldMap :: Monoid m => (a -> m) -> RPat a -> m # foldr :: (a -> b -> b) -> b -> RPat a -> b # foldr' :: (a -> b -> b) -> b -> RPat a -> b # foldl :: (b -> a -> b) -> b -> RPat a -> b # foldl' :: (b -> a -> b) -> b -> RPat a -> b # foldr1 :: (a -> a -> a) -> RPat a -> a # foldl1 :: (a -> a -> a) -> RPat a -> a # elem :: Eq a => a -> RPat a -> Bool # maximum :: Ord a => RPat a -> a # | |
Foldable PatField | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => PatField m -> m # foldMap :: Monoid m => (a -> m) -> PatField a -> m # foldr :: (a -> b -> b) -> b -> PatField a -> b # foldr' :: (a -> b -> b) -> b -> PatField a -> b # foldl :: (b -> a -> b) -> b -> PatField a -> b # foldl' :: (b -> a -> b) -> b -> PatField a -> b # foldr1 :: (a -> a -> a) -> PatField a -> a # foldl1 :: (a -> a -> a) -> PatField a -> a # elem :: Eq a => a -> PatField a -> Bool # maximum :: Ord a => PatField a -> a # minimum :: Ord a => PatField a -> a # | |
Foldable Stmt | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Stmt m -> m # foldMap :: Monoid m => (a -> m) -> Stmt a -> m # foldr :: (a -> b -> b) -> b -> Stmt a -> b # foldr' :: (a -> b -> b) -> b -> Stmt a -> b # foldl :: (b -> a -> b) -> b -> Stmt a -> b # foldl' :: (b -> a -> b) -> b -> Stmt a -> b # foldr1 :: (a -> a -> a) -> Stmt a -> a # foldl1 :: (a -> a -> a) -> Stmt a -> a # elem :: Eq a => a -> Stmt a -> Bool # maximum :: Ord a => Stmt a -> a # | |
Foldable QualStmt | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => QualStmt m -> m # foldMap :: Monoid m => (a -> m) -> QualStmt a -> m # foldr :: (a -> b -> b) -> b -> QualStmt a -> b # foldr' :: (a -> b -> b) -> b -> QualStmt a -> b # foldl :: (b -> a -> b) -> b -> QualStmt a -> b # foldl' :: (b -> a -> b) -> b -> QualStmt a -> b # foldr1 :: (a -> a -> a) -> QualStmt a -> a # foldl1 :: (a -> a -> a) -> QualStmt a -> a # elem :: Eq a => a -> QualStmt a -> Bool # maximum :: Ord a => QualStmt a -> a # minimum :: Ord a => QualStmt a -> a # | |
Foldable FieldUpdate | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => FieldUpdate m -> m # foldMap :: Monoid m => (a -> m) -> FieldUpdate a -> m # foldr :: (a -> b -> b) -> b -> FieldUpdate a -> b # foldr' :: (a -> b -> b) -> b -> FieldUpdate a -> b # foldl :: (b -> a -> b) -> b -> FieldUpdate a -> b # foldl' :: (b -> a -> b) -> b -> FieldUpdate a -> b # foldr1 :: (a -> a -> a) -> FieldUpdate a -> a # foldl1 :: (a -> a -> a) -> FieldUpdate a -> a # toList :: FieldUpdate a -> [a] # null :: FieldUpdate a -> Bool # length :: FieldUpdate a -> Int # elem :: Eq a => a -> FieldUpdate a -> Bool # maximum :: Ord a => FieldUpdate a -> a # minimum :: Ord a => FieldUpdate a -> a # sum :: Num a => FieldUpdate a -> a # product :: Num a => FieldUpdate a -> a # | |
Foldable Alt | |
Defined in Language.Haskell.Exts.Syntax fold :: Monoid m => Alt m -> m # foldMap :: Monoid m => (a -> m) -> Alt a -> m # foldr :: (a -> b -> b) -> b -> Alt a -> b # foldr' :: (a -> b -> b) -> b -> Alt a -> b # foldl :: (b -> a -> b) -> b -> Alt a -> b # foldl' :: (b -> a -> b) -> b -> Alt a -> b # foldr1 :: (a -> a -> a) -> Alt a -> a # foldl1 :: (a -> a -> a) -> Alt a -> a # elem :: Eq a => a -> Alt a -> Bool # maximum :: Ord a => Alt a -> a # | |
Foldable Heap | |
Defined in Data.Heap fold :: Monoid m => Heap m -> m # foldMap :: Monoid m => (a -> m) -> Heap a -> m # foldr :: (a -> b -> b) -> b -> Heap a -> b # foldr' :: (a -> b -> b) -> b -> Heap a -> b # foldl :: (b -> a -> b) -> b -> Heap a -> b # foldl' :: (b -> a -> b) -> b -> Heap a -> b # foldr1 :: (a -> a -> a) -> Heap a -> a # foldl1 :: (a -> a -> a) -> Heap a -> a # elem :: Eq a => a -> Heap a -> Bool # maximum :: Ord a => Heap a -> a # | |
Foldable HashSet | |
Defined in Data.HashSet 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 # elem :: Eq a => a -> HashSet a -> Bool # maximum :: Ord a => HashSet a -> a # minimum :: Ord a => HashSet a -> a # | |
Foldable Vector | |
Defined in Data.Vector fold :: Monoid m => Vector m -> m # foldMap :: Monoid m => (a -> m) -> Vector a -> m # foldr :: (a -> b -> b) -> b -> Vector a -> b # foldr' :: (a -> b -> b) -> b -> Vector a -> b # foldl :: (b -> a -> b) -> b -> Vector a -> b # foldl' :: (b -> a -> b) -> b -> Vector a -> b # foldr1 :: (a -> a -> a) -> Vector a -> a # foldl1 :: (a -> a -> a) -> Vector a -> a # elem :: Eq a => a -> Vector a -> Bool # maximum :: Ord a => Vector a -> a # minimum :: Ord a => Vector a -> a # | |
Foldable Log | |
Defined in Numeric.Log fold :: Monoid m => Log m -> m # foldMap :: Monoid m => (a -> m) -> Log a -> m # foldr :: (a -> b -> b) -> b -> Log a -> b # foldr' :: (a -> b -> b) -> b -> Log a -> b # foldl :: (b -> a -> b) -> b -> Log a -> b # foldl' :: (b -> a -> b) -> b -> Log a -> b # foldr1 :: (a -> a -> a) -> Log a -> a # foldl1 :: (a -> a -> a) -> Log a -> a # elem :: Eq a => a -> Log a -> Bool # maximum :: Ord a => Log a -> a # | |
Foldable MultiSet | |
Defined in Data.MultiSet fold :: Monoid m => MultiSet m -> m # foldMap :: Monoid m => (a -> m) -> MultiSet a -> m # foldr :: (a -> b -> b) -> b -> MultiSet a -> b # foldr' :: (a -> b -> b) -> b -> MultiSet a -> b # foldl :: (b -> a -> b) -> b -> MultiSet a -> b # foldl' :: (b -> a -> b) -> b -> MultiSet a -> b # foldr1 :: (a -> a -> a) -> MultiSet a -> a # foldl1 :: (a -> a -> a) -> MultiSet a -> a # elem :: Eq a => a -> MultiSet a -> Bool # maximum :: Ord a => MultiSet a -> a # minimum :: Ord a => MultiSet a -> a # | |
Foldable SimpleDocStream | Collect all annotations from a document. |
Defined in Data.Text.Prettyprint.Doc.Internal fold :: Monoid m => SimpleDocStream m -> m # foldMap :: Monoid m => (a -> m) -> SimpleDocStream a -> m # foldr :: (a -> b -> b) -> b -> SimpleDocStream a -> b # foldr' :: (a -> b -> b) -> b -> SimpleDocStream a -> b # foldl :: (b -> a -> b) -> b -> SimpleDocStream a -> b # foldl' :: (b -> a -> b) -> b -> SimpleDocStream a -> b # foldr1 :: (a -> a -> a) -> SimpleDocStream a -> a # foldl1 :: (a -> a -> a) -> SimpleDocStream a -> a # toList :: SimpleDocStream a -> [a] # null :: SimpleDocStream a -> Bool # length :: SimpleDocStream a -> Int # elem :: Eq a => a -> SimpleDocStream a -> Bool # maximum :: Ord a => SimpleDocStream a -> a # minimum :: Ord a => SimpleDocStream a -> a # sum :: Num a => SimpleDocStream a -> a # product :: Num a => SimpleDocStream a -> a # | |
Foldable SmallArray | |
Defined in Data.Primitive.SmallArray 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 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 # elem :: Eq a => a -> Array a -> Bool # maximum :: Ord a => Array a -> a # minimum :: Ord a => Array a -> a # | |
Foldable Bound | |
Defined in Data.Semilattice.Bound fold :: Monoid m => Bound m -> m # foldMap :: Monoid m => (a -> m) -> Bound a -> m # foldr :: (a -> b -> b) -> b -> Bound a -> b # foldr' :: (a -> b -> b) -> b -> Bound a -> b # foldl :: (b -> a -> b) -> b -> Bound a -> b # foldl' :: (b -> a -> b) -> b -> Bound a -> b # foldr1 :: (a -> a -> a) -> Bound a -> a # foldl1 :: (a -> a -> a) -> Bound a -> a # elem :: Eq a => a -> Bound a -> Bool # maximum :: Ord a => Bound a -> a # minimum :: Ord a => Bound a -> a # | |
Foldable Order | |
Defined in Data.Semilattice.Order fold :: Monoid m => Order m -> m # foldMap :: Monoid m => (a -> m) -> Order a -> m # foldr :: (a -> b -> b) -> b -> Order a -> b # foldr' :: (a -> b -> b) -> b -> Order a -> b # foldl :: (b -> a -> b) -> b -> Order a -> b # foldl' :: (b -> a -> b) -> b -> Order a -> b # foldr1 :: (a -> a -> a) -> Order a -> a # foldl1 :: (a -> a -> a) -> Order a -> a # elem :: Eq a => a -> Order a -> Bool # maximum :: Ord a => Order a -> a # minimum :: Ord a => Order a -> a # | |
Foldable Meeting | |
Defined in Data.Semilattice.Meet fold :: Monoid m => Meeting m -> m # foldMap :: Monoid m => (a -> m) -> Meeting a -> m # foldr :: (a -> b -> b) -> b -> Meeting a -> b # foldr' :: (a -> b -> b) -> b -> Meeting a -> b # foldl :: (b -> a -> b) -> b -> Meeting a -> b # foldl' :: (b -> a -> b) -> b -> Meeting a -> b # foldr1 :: (a -> a -> a) -> Meeting a -> a # foldl1 :: (a -> a -> a) -> Meeting a -> a # elem :: Eq a => a -> Meeting a -> Bool # maximum :: Ord a => Meeting a -> a # minimum :: Ord a => Meeting a -> a # | |
Foldable GreaterThan | |
Defined in Data.Semilattice.Meet fold :: Monoid m => GreaterThan m -> m # foldMap :: Monoid m => (a -> m) -> GreaterThan a -> m # foldr :: (a -> b -> b) -> b -> GreaterThan a -> b # foldr' :: (a -> b -> b) -> b -> GreaterThan a -> b # foldl :: (b -> a -> b) -> b -> GreaterThan a -> b # foldl' :: (b -> a -> b) -> b -> GreaterThan a -> b # foldr1 :: (a -> a -> a) -> GreaterThan a -> a # foldl1 :: (a -> a -> a) -> GreaterThan a -> a # toList :: GreaterThan a -> [a] # null :: GreaterThan a -> Bool # length :: GreaterThan a -> Int # elem :: Eq a => a -> GreaterThan a -> Bool # maximum :: Ord a => GreaterThan a -> a # minimum :: Ord a => GreaterThan a -> a # sum :: Num a => GreaterThan a -> a # product :: Num a => GreaterThan a -> a # | |
Foldable Joining | |
Defined in Data.Semilattice.Join fold :: Monoid m => Joining m -> m # foldMap :: Monoid m => (a -> m) -> Joining a -> m # foldr :: (a -> b -> b) -> b -> Joining a -> b # foldr' :: (a -> b -> b) -> b -> Joining a -> b # foldl :: (b -> a -> b) -> b -> Joining a -> b # foldl' :: (b -> a -> b) -> b -> Joining a -> b # foldr1 :: (a -> a -> a) -> Joining a -> a # foldl1 :: (a -> a -> a) -> Joining a -> a # elem :: Eq a => a -> Joining a -> Bool # maximum :: Ord a => Joining a -> a # minimum :: Ord a => Joining a -> a # | |
Foldable LessThan | |
Defined in Data.Semilattice.Join fold :: Monoid m => LessThan m -> m # foldMap :: Monoid m => (a -> m) -> LessThan a -> m # foldr :: (a -> b -> b) -> b -> LessThan a -> b # foldr' :: (a -> b -> b) -> b -> LessThan a -> b # foldl :: (b -> a -> b) -> b -> LessThan a -> b # foldl' :: (b -> a -> b) -> b -> LessThan a -> b # foldr1 :: (a -> a -> a) -> LessThan a -> a # foldl1 :: (a -> a -> a) -> LessThan a -> a # elem :: Eq a => a -> LessThan a -> Bool # maximum :: Ord a => LessThan a -> a # minimum :: Ord a => LessThan a -> a # | |
Foldable Forest | |
Defined in Data.Heap fold :: Monoid m => Forest m -> m # foldMap :: Monoid m => (a -> m) -> Forest a -> m # foldr :: (a -> b -> b) -> b -> Forest a -> b # foldr' :: (a -> b -> b) -> b -> Forest a -> b # foldl :: (b -> a -> b) -> b -> Forest a -> b # foldl' :: (b -> a -> b) -> b -> Forest a -> b # foldr1 :: (a -> a -> a) -> Forest a -> a # foldl1 :: (a -> a -> a) -> Forest a -> a # elem :: Eq a => a -> Forest a -> Bool # maximum :: Ord a => Forest a -> a # minimum :: Ord a => Forest a -> a # | |
Foldable Tree | |
Defined in Data.Heap 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 # elem :: Eq a => a -> Tree a -> Bool # maximum :: Ord a => Tree a -> a # | |
Foldable P | |
Defined in Data.HashMap.Strict.InsOrd fold :: Monoid m => P m -> m # foldMap :: Monoid m => (a -> m) -> P a -> m # foldr :: (a -> b -> b) -> b -> P a -> b # foldr' :: (a -> b -> b) -> b -> P a -> b # foldl :: (b -> a -> b) -> b -> P a -> b # foldl' :: (b -> a -> b) -> b -> P a -> b # foldr1 :: (a -> a -> a) -> P a -> a # foldl1 :: (a -> a -> a) -> P a -> a # elem :: Eq a => a -> P a -> Bool # maximum :: Ord a => P a -> a # | |
Foldable (Either a) | Since: base-4.7.0.0 |
Defined in Data.Foldable 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] # 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 # | |
Foldable (V1 :: * -> *) | |
Defined in Data.Foldable 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 # elem :: Eq a => a -> V1 a -> Bool # maximum :: Ord a => V1 a -> a # | |
Foldable (U1 :: * -> *) | Since: base-4.9.0.0 |
Defined in Data.Foldable 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 # elem :: Eq a => a -> U1 a -> Bool # maximum :: Ord a => U1 a -> a # | |
Foldable ((,) a) | Since: base-4.7.0.0 |
Defined in Data.Foldable 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 # elem :: Eq a0 => a0 -> (a, a0) -> Bool # maximum :: Ord a0 => (a, a0) -> a0 # minimum :: Ord a0 => (a, a0) -> a0 # | |
Foldable (HashMap k) | |
Defined in Data.HashMap.Base 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] # 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 # | |
Foldable (Map k) | |
Defined in Data.Map.Internal 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 # elem :: Eq a => a -> Map k a -> Bool # maximum :: Ord a => Map k a -> a # minimum :: Ord a => Map k a -> a # | |
Foldable (Array i) | Since: base-4.8.0.0 |
Defined in Data.Foldable 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 # elem :: Eq a => a -> Array i a -> Bool # maximum :: Ord a => Array i a -> a # minimum :: Ord a => Array i a -> a # | |
Foldable (Arg a) | Since: base-4.9.0.0 |
Defined in Data.Semigroup 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 # elem :: Eq a0 => a0 -> Arg a a0 -> Bool # maximum :: Ord a0 => Arg a a0 -> a0 # minimum :: Ord a0 => Arg a a0 -> a0 # | |
Foldable (Proxy :: * -> *) | Since: base-4.7.0.0 |
Defined in Data.Foldable 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 # elem :: Eq a => a -> Proxy a -> Bool # maximum :: Ord a => Proxy a -> a # minimum :: Ord a => Proxy a -> a # | |
Foldable f => Foldable (MaybeT f) | |
Defined in Control.Monad.Trans.Maybe 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 # elem :: Eq a => a -> MaybeT f a -> Bool # maximum :: Ord a => MaybeT f a -> a # minimum :: Ord a => MaybeT f a -> a # | |
Foldable f => Foldable (Cofree f) | |
Defined in Control.Comonad.Cofree fold :: Monoid m => Cofree f m -> m # foldMap :: Monoid m => (a -> m) -> Cofree f a -> m # foldr :: (a -> b -> b) -> b -> Cofree f a -> b # foldr' :: (a -> b -> b) -> b -> Cofree f a -> b # foldl :: (b -> a -> b) -> b -> Cofree f a -> b # foldl' :: (b -> a -> b) -> b -> Cofree f a -> b # foldr1 :: (a -> a -> a) -> Cofree f a -> a # foldl1 :: (a -> a -> a) -> Cofree f a -> a # elem :: Eq a => a -> Cofree f a -> Bool # maximum :: Ord a => Cofree f a -> a # minimum :: Ord a => Cofree f a -> a # | |
Foldable f => Foldable (Free f) | |
Defined in Control.Monad.Free fold :: Monoid m => Free f m -> m # foldMap :: Monoid m => (a -> m) -> Free f a -> m # foldr :: (a -> b -> b) -> b -> Free f a -> b # foldr' :: (a -> b -> b) -> b -> Free f a -> b # foldl :: (b -> a -> b) -> b -> Free f a -> b # foldl' :: (b -> a -> b) -> b -> Free f a -> b # foldr1 :: (a -> a -> a) -> Free f a -> a # foldl1 :: (a -> a -> a) -> Free f a -> a # elem :: Eq a => a -> Free f a -> Bool # maximum :: Ord a => Free f a -> a # minimum :: Ord a => Free f a -> a # | |
Foldable (Entry p) | |
Defined in Data.Heap fold :: Monoid m => Entry p m -> m # foldMap :: Monoid m => (a -> m) -> Entry p a -> m # foldr :: (a -> b -> b) -> b -> Entry p a -> b # foldr' :: (a -> b -> b) -> b -> Entry p a -> b # foldl :: (b -> a -> b) -> b -> Entry p a -> b # foldl' :: (b -> a -> b) -> b -> Entry p a -> b # foldr1 :: (a -> a -> a) -> Entry p a -> a # foldl1 :: (a -> a -> a) -> Entry p a -> a # elem :: Eq a => a -> Entry p a -> Bool # maximum :: Ord a => Entry p a -> a # minimum :: Ord a => Entry p a -> a # | |
Foldable (InsOrdHashMap k) | |
Defined in Data.HashMap.Strict.InsOrd fold :: Monoid m => InsOrdHashMap k m -> m # foldMap :: Monoid m => (a -> m) -> InsOrdHashMap k a -> m # foldr :: (a -> b -> b) -> b -> InsOrdHashMap k a -> b # foldr' :: (a -> b -> b) -> b -> InsOrdHashMap k a -> b # foldl :: (b -> a -> b) -> b -> InsOrdHashMap k a -> b # foldl' :: (b -> a -> b) -> b -> InsOrdHashMap k a -> b # foldr1 :: (a -> a -> a) -> InsOrdHashMap k a -> a # foldl1 :: (a -> a -> a) -> InsOrdHashMap k a -> a # toList :: InsOrdHashMap k a -> [a] # null :: InsOrdHashMap k a -> Bool # length :: InsOrdHashMap k a -> Int # elem :: Eq a => a -> InsOrdHashMap k a -> Bool # maximum :: Ord a => InsOrdHashMap k a -> a # minimum :: Ord a => InsOrdHashMap k a -> a # sum :: Num a => InsOrdHashMap k a -> a # product :: Num a => InsOrdHashMap k a -> a # | |
Foldable f => Foldable (Yoneda f) | |
Defined in Data.Functor.Yoneda fold :: Monoid m => Yoneda f m -> m # foldMap :: Monoid m => (a -> m) -> Yoneda f a -> m # foldr :: (a -> b -> b) -> b -> Yoneda f a -> b # foldr' :: (a -> b -> b) -> b -> Yoneda f a -> b # foldl :: (b -> a -> b) -> b -> Yoneda f a -> b # foldl' :: (b -> a -> b) -> b -> Yoneda f a -> b # foldr1 :: (a -> a -> a) -> Yoneda f a -> a # foldl1 :: (a -> a -> a) -> Yoneda f a -> a # elem :: Eq a => a -> Yoneda f a -> Bool # maximum :: Ord a => Yoneda f a -> a # minimum :: Ord a => Yoneda f a -> a # | |
Foldable m => Foldable (ListT m) | |
Defined in List.Transformer fold :: Monoid m0 => ListT m m0 -> m0 # foldMap :: Monoid m0 => (a -> m0) -> ListT m a -> m0 # foldr :: (a -> b -> b) -> b -> ListT m a -> b # foldr' :: (a -> b -> b) -> b -> ListT m a -> b # foldl :: (b -> a -> b) -> b -> ListT m a -> b # foldl' :: (b -> a -> b) -> b -> ListT m a -> b # foldr1 :: (a -> a -> a) -> ListT m a -> a # foldl1 :: (a -> a -> a) -> ListT m a -> a # elem :: Eq a => a -> ListT m a -> Bool # maximum :: Ord a => ListT m a -> a # minimum :: Ord a => ListT m a -> a # | |
Foldable m => Foldable (Step m) | |
Defined in List.Transformer fold :: Monoid m0 => Step m m0 -> m0 # foldMap :: Monoid m0 => (a -> m0) -> Step m a -> m0 # foldr :: (a -> b -> b) -> b -> Step m a -> b # foldr' :: (a -> b -> b) -> b -> Step m a -> b # foldl :: (b -> a -> b) -> b -> Step m a -> b # foldl' :: (b -> a -> b) -> b -> Step m a -> b # foldr1 :: (a -> a -> a) -> Step m a -> a # foldl1 :: (a -> a -> a) -> Step m a -> a # elem :: Eq a => a -> Step m a -> Bool # maximum :: Ord a => Step m a -> a # minimum :: Ord a => Step m a -> a # | |
(Monad m, Foldable m) => Foldable (LogicT m) | |
Defined in Control.Monad.Logic fold :: Monoid m0 => LogicT m m0 -> m0 # foldMap :: Monoid m0 => (a -> m0) -> LogicT m a -> m0 # foldr :: (a -> b -> b) -> b -> LogicT m a -> b # foldr' :: (a -> b -> b) -> b -> LogicT m a -> b # foldl :: (b -> a -> b) -> b -> LogicT m a -> b # foldl' :: (b -> a -> b) -> b -> LogicT m a -> b # foldr1 :: (a -> a -> a) -> LogicT m a -> a # foldl1 :: (a -> a -> a) -> LogicT m a -> a # elem :: Eq a => a -> LogicT m a -> Bool # maximum :: Ord a => LogicT m a -> a # minimum :: Ord a => LogicT m a -> a # | |
Foldable (IntPSQ p) | |
Defined in Data.IntPSQ.Internal fold :: Monoid m => IntPSQ p m -> m # foldMap :: Monoid m => (a -> m) -> IntPSQ p a -> m # foldr :: (a -> b -> b) -> b -> IntPSQ p a -> b # foldr' :: (a -> b -> b) -> b -> IntPSQ p a -> b # foldl :: (b -> a -> b) -> b -> IntPSQ p a -> b # foldl' :: (b -> a -> b) -> b -> IntPSQ p a -> b # foldr1 :: (a -> a -> a) -> IntPSQ p a -> a # foldl1 :: (a -> a -> a) -> IntPSQ p a -> a # elem :: Eq a => a -> IntPSQ p a -> Bool # maximum :: Ord a => IntPSQ p a -> a # minimum :: Ord a => IntPSQ p a -> a # | |
Foldable f => Foldable (Rec1 f) | |
Defined in Data.Foldable 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 # elem :: Eq a => a -> Rec1 f a -> Bool # maximum :: Ord a => Rec1 f a -> a # minimum :: Ord a => Rec1 f a -> a # | |
Foldable (URec Char :: * -> *) | |
Defined in Data.Foldable 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] # 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 # | |
Foldable (URec Double :: * -> *) | |
Defined in Data.Foldable 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 # | |
Foldable (URec Float :: * -> *) | |
Defined in Data.Foldable 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 # | |
Foldable (URec Int :: * -> *) | |
Defined in Data.Foldable 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 # elem :: Eq a => a -> URec Int a -> Bool # maximum :: Ord a => URec Int a -> a # minimum :: Ord a => URec Int a -> a # | |
Foldable (URec Word :: * -> *) | |
Defined in Data.Foldable 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] # 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 # | |
Foldable (URec (Ptr ()) :: * -> *) | |
Defined in Data.Foldable 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 # | |
Foldable (Const m :: * -> *) | Since: base-4.7.0.0 |
Defined in Data.Functor.Const 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 # elem :: Eq a => a -> Const m a -> Bool # maximum :: Ord a => Const m a -> a # minimum :: Ord a => Const m a -> a # | |
Bifoldable p => Foldable (Join p) | |
Defined in Data.Bifunctor.Join 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 # elem :: Eq a => a -> Join p a -> Bool # maximum :: Ord a => Join p a -> a # minimum :: Ord a => Join p a -> a # | |
Bifoldable p => Foldable (Fix p) | |
Defined in Data.Bifunctor.Fix fold :: Monoid m => Fix p m -> m # foldMap :: Monoid m => (a -> m) -> Fix p a -> m # foldr :: (a -> b -> b) -> b -> Fix p a -> b # foldr' :: (a -> b -> b) -> b -> Fix p a -> b # foldl :: (b -> a -> b) -> b -> Fix p a -> b # foldl' :: (b -> a -> b) -> b -> Fix p a -> b # foldr1 :: (a -> a -> a) -> Fix p a -> a # foldl1 :: (a -> a -> a) -> Fix p a -> a # elem :: Eq a => a -> Fix p a -> Bool # maximum :: Ord a => Fix p a -> a # minimum :: Ord a => Fix p a -> a # | |
Foldable f => Foldable (IdentityT f) | |
Defined in Control.Monad.Trans.Identity 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 # | |
Foldable f => Foldable (ExceptT e f) | |
Defined in Control.Monad.Trans.Except 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 # | |
Foldable f => Foldable (FreeF f a) | |
Defined in Control.Monad.Trans.Free fold :: Monoid m => FreeF f a m -> m # foldMap :: Monoid m => (a0 -> m) -> FreeF f a a0 -> m # foldr :: (a0 -> b -> b) -> b -> FreeF f a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> FreeF f a a0 -> b # foldl :: (b -> a0 -> b) -> b -> FreeF f a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> FreeF f a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> FreeF f a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> FreeF f a a0 -> a0 # toList :: FreeF f a a0 -> [a0] # null :: FreeF f a a0 -> Bool # length :: FreeF f a a0 -> Int # elem :: Eq a0 => a0 -> FreeF f a a0 -> Bool # maximum :: Ord a0 => FreeF f a a0 -> a0 # minimum :: Ord a0 => FreeF f a a0 -> a0 # | |
(Foldable m, Foldable f) => Foldable (FreeT f m) | |
Defined in Control.Monad.Trans.Free fold :: Monoid m0 => FreeT f m m0 -> m0 # foldMap :: Monoid m0 => (a -> m0) -> FreeT f m a -> m0 # foldr :: (a -> b -> b) -> b -> FreeT f m a -> b # foldr' :: (a -> b -> b) -> b -> FreeT f m a -> b # foldl :: (b -> a -> b) -> b -> FreeT f m a -> b # foldl' :: (b -> a -> b) -> b -> FreeT f m a -> b # foldr1 :: (a -> a -> a) -> FreeT f m a -> a # foldl1 :: (a -> a -> a) -> FreeT f m a -> a # toList :: FreeT f m a -> [a] # length :: FreeT f m a -> Int # elem :: Eq a => a -> FreeT f m a -> Bool # maximum :: Ord a => FreeT f m a -> a # minimum :: Ord a => FreeT f m a -> a # | |
Foldable f => Foldable (CofreeF f a) | |
Defined in Control.Comonad.Trans.Cofree fold :: Monoid m => CofreeF f a m -> m # foldMap :: Monoid m => (a0 -> m) -> CofreeF f a a0 -> m # foldr :: (a0 -> b -> b) -> b -> CofreeF f a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> CofreeF f a a0 -> b # foldl :: (b -> a0 -> b) -> b -> CofreeF f a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> CofreeF f a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> CofreeF f a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> CofreeF f a a0 -> a0 # toList :: CofreeF f a a0 -> [a0] # null :: CofreeF f a a0 -> Bool # length :: CofreeF f a a0 -> Int # elem :: Eq a0 => a0 -> CofreeF f a a0 -> Bool # maximum :: Ord a0 => CofreeF f a a0 -> a0 # minimum :: Ord a0 => CofreeF f a a0 -> a0 # | |
(Foldable f, Foldable w) => Foldable (CofreeT f w) | |
Defined in Control.Comonad.Trans.Cofree fold :: Monoid m => CofreeT f w m -> m # foldMap :: Monoid m => (a -> m) -> CofreeT f w a -> m # foldr :: (a -> b -> b) -> b -> CofreeT f w a -> b # foldr' :: (a -> b -> b) -> b -> CofreeT f w a -> b # foldl :: (b -> a -> b) -> b -> CofreeT f w a -> b # foldl' :: (b -> a -> b) -> b -> CofreeT f w a -> b # foldr1 :: (a -> a -> a) -> CofreeT f w a -> a # foldl1 :: (a -> a -> a) -> CofreeT f w a -> a # toList :: CofreeT f w a -> [a] # null :: CofreeT f w a -> Bool # length :: CofreeT f w a -> Int # elem :: Eq a => a -> CofreeT f w a -> Bool # maximum :: Ord a => CofreeT f w a -> a # minimum :: Ord a => CofreeT f w a -> a # | |
Foldable f => Foldable (ErrorT e f) | |
Defined in Control.Monad.Trans.Error 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 # | |
Foldable f => Foldable (Backwards f) | Derived instance. |
Defined in Control.Applicative.Backwards 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 # | |
Foldable (Forget r a) | |
Defined in Data.Profunctor.Types 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 # | |
Foldable (Bucket k p) | |
Defined in Data.HashPSQ.Internal fold :: Monoid m => Bucket k p m -> m # foldMap :: Monoid m => (a -> m) -> Bucket k p a -> m # foldr :: (a -> b -> b) -> b -> Bucket k p a -> b # foldr' :: (a -> b -> b) -> b -> Bucket k p a -> b # foldl :: (b -> a -> b) -> b -> Bucket k p a -> b # foldl' :: (b -> a -> b) -> b -> Bucket k p a -> b # foldr1 :: (a -> a -> a) -> Bucket k p a -> a # foldl1 :: (a -> a -> a) -> Bucket k p a -> a # toList :: Bucket k p a -> [a] # null :: Bucket k p a -> Bool # length :: Bucket k p a -> Int # elem :: Eq a => a -> Bucket k p a -> Bool # maximum :: Ord a => Bucket k p a -> a # minimum :: Ord a => Bucket k p a -> a # | |
Foldable (LTree k p) | |
Defined in Data.OrdPSQ.Internal fold :: Monoid m => LTree k p m -> m # foldMap :: Monoid m => (a -> m) -> LTree k p a -> m # foldr :: (a -> b -> b) -> b -> LTree k p a -> b # foldr' :: (a -> b -> b) -> b -> LTree k p a -> b # foldl :: (b -> a -> b) -> b -> LTree k p a -> b # foldl' :: (b -> a -> b) -> b -> LTree k p a -> b # foldr1 :: (a -> a -> a) -> LTree k p a -> a # foldl1 :: (a -> a -> a) -> LTree k p a -> a # toList :: LTree k p a -> [a] # length :: LTree k p a -> Int # elem :: Eq a => a -> LTree k p a -> Bool # maximum :: Ord a => LTree k p a -> a # minimum :: Ord a => LTree k p a -> a # | |
Foldable (Elem k p) | |
Defined in Data.OrdPSQ.Internal fold :: Monoid m => Elem k p m -> m # foldMap :: Monoid m => (a -> m) -> Elem k p a -> m # foldr :: (a -> b -> b) -> b -> Elem k p a -> b # foldr' :: (a -> b -> b) -> b -> Elem k p a -> b # foldl :: (b -> a -> b) -> b -> Elem k p a -> b # foldl' :: (b -> a -> b) -> b -> Elem k p a -> b # foldr1 :: (a -> a -> a) -> Elem k p a -> a # foldl1 :: (a -> a -> a) -> Elem k p a -> a # elem :: Eq a => a -> Elem k p a -> Bool # maximum :: Ord a => Elem k p a -> a # minimum :: Ord a => Elem k p a -> a # | |
Foldable (HashPSQ k p) | |
Defined in Data.HashPSQ.Internal fold :: Monoid m => HashPSQ k p m -> m # foldMap :: Monoid m => (a -> m) -> HashPSQ k p a -> m # foldr :: (a -> b -> b) -> b -> HashPSQ k p a -> b # foldr' :: (a -> b -> b) -> b -> HashPSQ k p a -> b # foldl :: (b -> a -> b) -> b -> HashPSQ k p a -> b # foldl' :: (b -> a -> b) -> b -> HashPSQ k p a -> b # foldr1 :: (a -> a -> a) -> HashPSQ k p a -> a # foldl1 :: (a -> a -> a) -> HashPSQ k p a -> a # toList :: HashPSQ k p a -> [a] # null :: HashPSQ k p a -> Bool # length :: HashPSQ k p a -> Int # elem :: Eq a => a -> HashPSQ k p a -> Bool # maximum :: Ord a => HashPSQ k p a -> a # minimum :: Ord a => HashPSQ k p a -> a # | |
Foldable (OrdPSQ k p) | |
Defined in Data.OrdPSQ.Internal fold :: Monoid m => OrdPSQ k p m -> m # foldMap :: Monoid m => (a -> m) -> OrdPSQ k p a -> m # foldr :: (a -> b -> b) -> b -> OrdPSQ k p a -> b # foldr' :: (a -> b -> b) -> b -> OrdPSQ k p a -> b # foldl :: (b -> a -> b) -> b -> OrdPSQ k p a -> b # foldl' :: (b -> a -> b) -> b -> OrdPSQ k p a -> b # foldr1 :: (a -> a -> a) -> OrdPSQ k p a -> a # foldl1 :: (a -> a -> a) -> OrdPSQ k p a -> a # toList :: OrdPSQ k p a -> [a] # null :: OrdPSQ k p a -> Bool # length :: OrdPSQ k p a -> Int # elem :: Eq a => a -> OrdPSQ k p a -> Bool # maximum :: Ord a => OrdPSQ k p a -> a # minimum :: Ord a => OrdPSQ k p a -> a # | |
Foldable (Tagged s) | |
Defined in Data.Tagged 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 # elem :: Eq a => a -> Tagged s a -> Bool # maximum :: Ord a => Tagged s a -> a # minimum :: Ord a => Tagged s a -> a # | |
Foldable (K1 i c :: * -> *) | |
Defined in Data.Foldable 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 # 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 # | |
(Foldable f, Foldable g) => Foldable (f :+: g) | |
Defined in Data.Foldable 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] # 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 # | |
(Foldable f, Foldable g) => Foldable (f :*: g) | |
Defined in Data.Foldable 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] # 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 # | |
(Foldable f, Foldable g) => Foldable (Product f g) | Since: base-4.9.0.0 |
Defined in Data.Functor.Product 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 # | |
(Foldable f, Foldable g) => Foldable (Sum f g) | Since: base-4.9.0.0 |
Defined in Data.Functor.Sum 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 # 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 # | |
Foldable (Magma i t b) | |
Defined in Control.Lens.Internal.Magma fold :: Monoid m => Magma i t b m -> m # foldMap :: Monoid m => (a -> m) -> Magma i t b a -> m # foldr :: (a -> b0 -> b0) -> b0 -> Magma i t b a -> b0 # foldr' :: (a -> b0 -> b0) -> b0 -> Magma i t b a -> b0 # foldl :: (b0 -> a -> b0) -> b0 -> Magma i t b a -> b0 # foldl' :: (b0 -> a -> b0) -> b0 -> Magma i t b a -> b0 # foldr1 :: (a -> a -> a) -> Magma i t b a -> a # foldl1 :: (a -> a -> a) -> Magma i t b a -> a # toList :: Magma i t b a -> [a] # null :: Magma i t b a -> Bool # length :: Magma i t b a -> Int # elem :: Eq a => a -> Magma i t b a -> Bool # maximum :: Ord a => Magma i t b a -> a # minimum :: Ord a => Magma i t b a -> a # | |
Foldable f => Foldable (M1 i c f) | |
Defined in Data.Foldable 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 # 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 # | |
(Foldable f, Foldable g) => Foldable (f :.: g) | |
Defined in Data.Foldable 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] # 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 # | |
(Foldable f, Foldable g) => Foldable (Compose f g) | Since: base-4.9.0.0 |
Defined in Data.Functor.Compose 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 # | |
Bifoldable p => Foldable (WrappedBifunctor p a) | |
Defined in Data.Bifunctor.Wrapped 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 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 # | |
Bifoldable p => Foldable (Flip p a) | |
Defined in Data.Bifunctor.Flip 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] # 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 # | |
Foldable (Clown f a :: * -> *) | |
Defined in Data.Bifunctor.Clown 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 # | |
(Foldable f, Bifoldable p) => Foldable (Tannen f p a) | |
Defined in Data.Bifunctor.Tannen 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 # | |
(Bifoldable p, Foldable g) => Foldable (Biff p f g a) | |
Defined in Data.Bifunctor.Biff 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 # |
all :: Foldable t => (a -> Bool) -> t a -> Bool #
Determines whether all elements of the structure satisfy the predicate.
any :: Foldable t => (a -> Bool) -> t a -> Bool #
Determines whether any element of the structure satisfies the predicate.
asum :: (Foldable t, Alternative f) => t (f a) -> f a #
concatMap :: Foldable t => (a -> [b]) -> t a -> [b] #
Map a function over all the elements of a container and concatenate the resulting lists.
foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b #
The foldM
function is analogous to foldl
, except that its result is
encapsulated in a monad. Note that foldM
works from left-to-right over
the list arguments. This could be an issue where (
and the `folded
function' are not commutative.>>
)
foldM f a1 [x1, x2, ..., xm] == do a2 <- f a1 x1 a3 <- f a2 x2 ... f am xm
If right-to-left evaluation is required, the input list should be reversed.
foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m () #
Like foldM
, but discards the result.
foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b #
Monadic fold over the elements of a structure, associating to the left, i.e. from left to right.
foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b #
Monadic fold over the elements of a structure, associating to the right, i.e. from right to left.
for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f () #
group :: (Foldable f, Eq a) => f a -> [NonEmpty a] #
The group
function takes a stream and returns a list of
streams such that flattening the resulting list is equal to the
argument. Moreover, each stream in the resulting list
contains only equal elements. For example, in list notation:
'group' $ 'cycle' "Mississippi" = "M" : "i" : "ss" : "i" : "ss" : "i" : "pp" : "i" : "M" : "i" : ...
groupAllWith :: Ord b => (a -> b) -> [a] -> [NonEmpty a] #
groupAllWith
operates like groupWith
, but sorts the list
first so that each equivalence class has, at most, one list in the
output
inits :: Foldable f => f a -> NonEmpty [a] #
The inits
function takes a stream xs
and returns all the
finite prefixes of xs
.
insert :: (Foldable f, Ord a) => a -> f a -> NonEmpty a #
inserts insert
x xsx
into the last position in xs
where it
is still less than or equal to the next element. In particular, if the
list is sorted beforehand, the result will also be sorted.
maximumByMay :: Foldable t => (a -> a -> Ordering) -> t a -> Maybe a #
maximumMay :: (Foldable t, Ord a) => t a -> Maybe a #
minimumByMay :: Foldable t => (a -> a -> Ordering) -> t a -> Maybe a #
minimumMay :: (Foldable t, Ord a) => t a -> Maybe a #
sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f () #
Evaluate each action in the structure from left to right, and
ignore the results. For a version that doesn't ignore the results
see sequenceA
.
tails :: Foldable f => f a -> NonEmpty [a] #
The tails
function takes a stream xs
and returns all the
suffixes of xs
.
traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f () #
Map each element of a structure to an action, evaluate these
actions from left to right, and ignore the results. For a version
that doesn't ignore the results see traverse
.
Foldable1
class Foldable t => Foldable1 (t :: * -> *) where #
fold1 :: Semigroup m => t m -> m #
foldMap1 :: Semigroup m => (a -> m) -> t a -> m #
toNonEmpty :: t a -> NonEmpty a #
Instances
foldlM1 :: (Foldable1 t, Monad m) => (a -> a -> m a) -> t a -> m a #
Monadic fold over the elements of a non-empty structure, associating to the left, i.e. from left to right.
let g = flip $ (=<<) . f in foldlM1 f (x1 :| [x2, ..., xn]) == (...((x1 `f` x2) `g` x2) `g`...) `g` xn
foldrM1 :: (Foldable1 t, Monad m) => (a -> a -> m a) -> t a -> m a #
Monadic fold over the elements of a non-empty structure, associating to the right, i.e. from right to left.
let g = (=<<) . f in foldrM1 f (x1 :| [x2, ..., xn]) == x1 `g` (x2 `g` ... (xn-1 `f` xn)...)
intercalate1 :: (Foldable1 t, Semigroup m) => m -> t m -> m #
Insert an m
between each pair of 't m'. Equivalent to
intercalateMap1
with id
as the second argument.
>>>
intercalate1 ", " $ "hello" :| ["how", "are", "you"]
"hello, how, are, you"
>>>
intercalate1 ", " $ "hello" :| []
"hello"
>>>
intercalate1 mempty $ "I" :| ["Am", "Fine", "You?"]
"IAmFineYou?"
intercalateMap1 :: (Foldable1 t, Semigroup m) => m -> (a -> m) -> t a -> m #
Insert m
between each pair of m
derived from a
.
>>>
intercalateMap1 " " show $ True :| [False, True]
"True False True"
>>>
intercalateMap1 " " show $ True :| []
"True"
sequenceA1_ :: (Foldable1 t, Apply f) => t (f a) -> f () #
traverse1_ :: (Foldable1 t, Apply f) => (a -> f b) -> t a -> f () #
Bifoldable
class Bifoldable (p :: * -> * -> *) where #
Bifoldable
identifies foldable structures with two different varieties
of elements (as opposed to Foldable
, which has one variety of element).
Common examples are Either
and '(,)':
instance Bifoldable Either where bifoldMap f _ (Left a) = f a bifoldMap _ g (Right b) = g b instance Bifoldable (,) where bifoldr f g z (a, b) = f a (g b z)
A minimal Bifoldable
definition consists of either bifoldMap
or
bifoldr
. When defining more than this minimal set, one should ensure
that the following identities hold:
bifold
≡bifoldMap
id
id
bifoldMap
f g ≡bifoldr
(mappend
. f) (mappend
. g)mempty
bifoldr
f g z t ≡appEndo
(bifoldMap
(Endo . f) (Endo . g) t) z
If the type is also a Bifunctor
instance, it should satisfy:
'bifoldMap' f g ≡ 'bifold' . 'bimap' f g
which implies that
'bifoldMap' f g . 'bimap' h i ≡ 'bifoldMap' (f . h) (g . i)
Since: base-4.10.0.0
bifold :: Monoid m => p m m -> m #
bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> p a b -> m #
Combines the elements of a structure, given ways of mapping them to a common monoid.
bifoldMap
f g ≡bifoldr
(mappend
. f) (mappend
. g)mempty
Since: base-4.10.0.0
bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c #
Instances
Bifoldable Either | Since: base-4.10.0.0 |
Bifoldable (,) | Since: base-4.10.0.0 |
Bifoldable Arg | Since: base-4.10.0.0 |
Bifoldable ((,,) x) | Since: base-4.10.0.0 |
Bifoldable (Const :: * -> * -> *) | Since: base-4.10.0.0 |
Foldable f => Bifoldable (FreeF f) | |
Foldable f => Bifoldable (CofreeF f) | |
Bifoldable (Tagged :: * -> * -> *) | |
Bifoldable (K1 i :: * -> * -> *) | Since: base-4.10.0.0 |
Bifoldable ((,,,) x y) | Since: base-4.10.0.0 |
Bifoldable ((,,,,) x y z) | Since: base-4.10.0.0 |
Defined in Data.Bifoldable |