Safe Haskell  Trustworthy 

Language  Haskell2010 
This module provides efficient and streaming left folds that you can combine
using Applicative
style.
Import this module qualified to avoid clashing with the Prelude:
>>>
import qualified Control.Foldl as L
Use fold
to apply a Fold
to a list:
>>>
L.fold L.sum [1..100]
5050
Fold
s are Applicative
s, so you can combine them using Applicative
combinators:
>>>
import Control.Applicative
>>>
let average = (/) <$> L.sum <*> L.genericLength
Taking the sum, the sum of squares, ..., upto the sum of x^5
>>>
import Data.Traversable
>>>
let powerSums = sequenceA [L.premap (^n) L.sum  n < [1..5]]
>>>
L.fold powerSums [1..10]
[55,385,3025,25333,220825]
These combined folds will still traverse the list only once, streaming efficiently over the list in constant space without space leaks:
>>>
L.fold average [1..10000000]
5000000.5>>>
L.fold ((,) <$> L.minimum <*> L.maximum) [1..10000000]
(Just 1,Just 10000000)
You might want to try enabling the flatedmdanal
flag when compiling
executables that use this library to further improve performance.
Synopsis
 data Fold a b = forall x. Fold (x > a > x) x (x > b)
 data FoldM m a b = forall x. FoldM (x > a > m x) (m x) (x > m b)
 fold :: Foldable f => Fold a b > f a > b
 foldM :: (Foldable f, Monad m) => FoldM m a b > f a > m b
 scan :: Fold a b > [a] > [b]
 prescan :: Traversable t => Fold a b > t a > t b
 postscan :: Traversable t => Fold a b > t a > t b
 mconcat :: Monoid a => Fold a a
 foldMap :: Monoid w => (a > w) > (w > b) > Fold a b
 head :: Fold a (Maybe a)
 last :: Fold a (Maybe a)
 lastDef :: a > Fold a a
 lastN :: Int > Fold a [a]
 null :: Fold a Bool
 length :: Fold a Int
 and :: Fold Bool Bool
 or :: Fold Bool Bool
 all :: (a > Bool) > Fold a Bool
 any :: (a > Bool) > Fold a Bool
 sum :: Num a => Fold a a
 product :: Num a => Fold a a
 mean :: Fractional a => Fold a a
 variance :: Fractional a => Fold a a
 std :: Floating a => Fold a a
 maximum :: Ord a => Fold a (Maybe a)
 maximumBy :: (a > a > Ordering) > Fold a (Maybe a)
 minimum :: Ord a => Fold a (Maybe a)
 minimumBy :: (a > a > Ordering) > Fold a (Maybe a)
 elem :: Eq a => a > Fold a Bool
 notElem :: Eq a => a > Fold a Bool
 find :: (a > Bool) > Fold a (Maybe a)
 index :: Int > Fold a (Maybe a)
 lookup :: Eq a => a > Fold (a, b) (Maybe b)
 elemIndex :: Eq a => a > Fold a (Maybe Int)
 findIndex :: (a > Bool) > Fold a (Maybe Int)
 random :: FoldM IO a (Maybe a)
 randomN :: Vector v a => Int > FoldM IO a (Maybe (v a))
 mapM_ :: Monad m => (a > m ()) > FoldM m a ()
 sink :: (Monoid w, Monad m) => (a > m w) > FoldM m a w
 genericLength :: Num b => Fold a b
 genericIndex :: Integral i => i > Fold a (Maybe a)
 list :: Fold a [a]
 revList :: Fold a [a]
 nub :: Ord a => Fold a [a]
 eqNub :: Eq a => Fold a [a]
 set :: Ord a => Fold a (Set a)
 hashSet :: (Eq a, Hashable a) => Fold a (HashSet a)
 map :: Ord a => Fold (a, b) (Map a b)
 foldByKeyMap :: forall k a b. Ord k => Fold a b > Fold (k, a) (Map k b)
 hashMap :: (Eq a, Hashable a) => Fold (a, b) (HashMap a b)
 foldByKeyHashMap :: forall k a b. (Hashable k, Eq k) => Fold a b > Fold (k, a) (HashMap k b)
 vector :: Vector v a => Fold a (v a)
 vectorM :: (PrimMonad m, Vector v a) => FoldM m a (v a)
 purely :: (forall x. (x > a > x) > x > (x > b) > r) > Fold a b > r
 purely_ :: (forall x. (x > a > x) > x > x) > Fold a b > b
 impurely :: (forall x. (x > a > m x) > m x > (x > m b) > r) > FoldM m a b > r
 impurely_ :: Monad m => (forall x. (x > a > m x) > m x > m x) > FoldM m a b > m b
 generalize :: Monad m => Fold a b > FoldM m a b
 simplify :: FoldM Identity a b > Fold a b
 hoists :: (forall x. m x > n x) > FoldM m a b > FoldM n a b
 duplicateM :: Applicative m => FoldM m a b > FoldM m a (FoldM m a b)
 _Fold1 :: (a > a > a) > Fold a (Maybe a)
 premap :: (a > b) > Fold b r > Fold a r
 premapM :: Monad m => (a > m b) > FoldM m b r > FoldM m a r
 prefilter :: (a > Bool) > Fold a r > Fold a r
 prefilterM :: Monad m => (a > m Bool) > FoldM m a r > FoldM m a r
 predropWhile :: (a > Bool) > Fold a r > Fold a r
 drop :: Natural > Fold a b > Fold a b
 dropM :: Monad m => Natural > FoldM m a b > FoldM m a b
 type Handler a b = forall x. (b > Const (Dual (Endo x)) b) > a > Const (Dual (Endo x)) a
 handles :: Handler a b > Fold b r > Fold a r
 foldOver :: Handler s a > Fold a b > s > b
 newtype EndoM m a = EndoM {
 appEndoM :: a > m a
 type HandlerM m a b = forall x. (b > Const (Dual (EndoM m x)) b) > a > Const (Dual (EndoM m x)) a
 handlesM :: HandlerM m a b > FoldM m b r > FoldM m a r
 foldOverM :: Monad m => HandlerM m s a > FoldM m a b > s > m b
 folded :: (Contravariant f, Applicative f, Foldable t) => (a > f a) > t a > f (t a)
 filtered :: Monoid m => (a > Bool) > (a > m) > a > m
 groupBy :: Ord g => (a > g) > Fold a r > Fold a (Map g r)
 either :: Fold a1 b1 > Fold a2 b2 > Fold (Either a1 a2) (b1, b2)
 eitherM :: Monad m => FoldM m a1 b1 > FoldM m a2 b2 > FoldM m (Either a1 a2) (b1, b2)
 nest :: Applicative f => Fold a b > Fold (f a) (f b)
 data RealWorld
 class Monad m => PrimMonad (m :: Type > Type)
 class Foldable (t :: Type > Type)
 type family Mutable (v :: Type > Type) = (mv :: Type > Type > Type)  mv > v
 class MVector (Mutable v) a => Vector (v :: Type > Type) a
Fold Types
Efficient representation of a left fold that preserves the fold's step function, initial accumulator, and extraction function
This allows the Applicative
instance to assemble derived folds that
traverse the container only once
A 'Fold
a b' processes elements of type a and results in a
value of type b.
forall x. Fold (x > a > x) x (x > b) 

Instances
Choice Fold Source #  
Profunctor Fold Source #  
Defined in Control.Foldl  
Functor (Fold a) Source #  
Applicative (Fold a) Source #  
Comonad (Fold a) Source #  
Semigroupoid Fold Source #  
Floating b => Floating (Fold a b) Source #  
Defined in Control.Foldl sqrt :: Fold a b > Fold a b # (**) :: Fold a b > Fold a b > Fold a b # logBase :: Fold a b > Fold a b > Fold a b # asin :: Fold a b > Fold a b # acos :: Fold a b > Fold a b # atan :: Fold a b > Fold a b # sinh :: Fold a b > Fold a b # cosh :: Fold a b > Fold a b # tanh :: Fold a b > Fold a b # asinh :: Fold a b > Fold a b # acosh :: Fold a b > Fold a b # atanh :: Fold a b > Fold a b # log1p :: Fold a b > Fold a b # expm1 :: Fold a b > Fold a b #  
Fractional b => Fractional (Fold a b) Source #  
Num b => Num (Fold a b) Source #  
Semigroup b => Semigroup (Fold a b) Source #  
Monoid b => Monoid (Fold a b) Source #  
Like Fold
, but monadic.
A 'FoldM
m a b' processes elements of type a and
results in a monadic value of type m b.
forall x. FoldM (x > a > m x) (m x) (x > m b) 

Instances
Functor m => Profunctor (FoldM m) Source #  
Defined in Control.Foldl dimap :: (a > b) > (c > d) > FoldM m b c > FoldM m a d # lmap :: (a > b) > FoldM m b c > FoldM m a c # rmap :: (b > c) > FoldM m a b > FoldM m a c # (#.) :: forall a b c q. Coercible c b => q b c > FoldM m a b > FoldM m a c # (.#) :: forall a b c q. Coercible b a => FoldM m b c > q a b > FoldM m a c #  
Functor m => Functor (FoldM m a) Source #  
Applicative m => Applicative (FoldM m a) Source #  
(Monad m, Floating b) => Floating (FoldM m a b) Source #  
Defined in Control.Foldl exp :: FoldM m a b > FoldM m a b # log :: FoldM m a b > FoldM m a b # sqrt :: FoldM m a b > FoldM m a b # (**) :: FoldM m a b > FoldM m a b > FoldM m a b # logBase :: FoldM m a b > FoldM m a b > FoldM m a b # sin :: FoldM m a b > FoldM m a b # cos :: FoldM m a b > FoldM m a b # tan :: FoldM m a b > FoldM m a b # asin :: FoldM m a b > FoldM m a b # acos :: FoldM m a b > FoldM m a b # atan :: FoldM m a b > FoldM m a b # sinh :: FoldM m a b > FoldM m a b # cosh :: FoldM m a b > FoldM m a b # tanh :: FoldM m a b > FoldM m a b # asinh :: FoldM m a b > FoldM m a b # acosh :: FoldM m a b > FoldM m a b # atanh :: FoldM m a b > FoldM m a b # log1p :: FoldM m a b > FoldM m a b # expm1 :: FoldM m a b > FoldM m a b #  
(Monad m, Fractional b) => Fractional (FoldM m a b) Source #  
(Monad m, Num b) => Num (FoldM m a b) Source #  
Defined in Control.Foldl (+) :: FoldM m a b > FoldM m a b > FoldM m a b # () :: FoldM m a b > FoldM m a b > FoldM m a b # (*) :: FoldM m a b > FoldM m a b > FoldM m a b # negate :: FoldM m a b > FoldM m a b # abs :: FoldM m a b > FoldM m a b # signum :: FoldM m a b > FoldM m a b # fromInteger :: Integer > FoldM m a b #  
(Semigroup b, Monad m) => Semigroup (FoldM m a b) Source #  
(Monoid b, Monad m) => Monoid (FoldM m a b) Source #  
Folding
scan :: Fold a b > [a] > [b] Source #
Convert a strict left Fold
into a scan
>>>
L.scan L.length [1..5]
[0,1,2,3,4,5]
prescan :: Traversable t => Fold a b > t a > t b Source #
Convert a Fold
into a prescan for any Traversable
type
"Prescan" means that the last element of the scan is not included
>>>
L.prescan L.length [1..5]
[0,1,2,3,4]
postscan :: Traversable t => Fold a b > t a > t b Source #
Convert a Fold
into a postscan for any Traversable
type
"Postscan" means that the first element of the scan is not included
>>>
L.postscan L.length [1..5]
[1,2,3,4,5]
Folds
head :: Fold a (Maybe a) Source #
Get the first element of a container or return Nothing
if the container is
empty
last :: Fold a (Maybe a) Source #
Get the last element of a container or return Nothing
if the container is
empty
lastDef :: a > Fold a a Source #
Get the last element of a container or return a default value if the container is empty
mean :: Fractional a => Fold a a Source #
Compute a numerically stable arithmetic mean of all elements
variance :: Fractional a => Fold a a Source #
Compute a numerically stable (population) variance over all elements
std :: Floating a => Fold a a Source #
Compute a numerically stable (population) standard deviation over all elements
maximumBy :: (a > a > Ordering) > Fold a (Maybe a) Source #
Computes the maximum element with respect to the given comparison function
minimumBy :: (a > a > Ordering) > Fold a (Maybe a) Source #
Computes the minimum element with respect to the given comparison function
find :: (a > Bool) > Fold a (Maybe a) Source #
(find predicate)
returns the first element that satisfies the predicate or
Nothing
if no element satisfies the predicate
index :: Int > Fold a (Maybe a) Source #
(index n)
returns the n
th element of the container, or Nothing
if the
container has an insufficient number of elements
lookup :: Eq a => a > Fold (a, b) (Maybe b) Source #
(lookup a)
returns the element paired with the first matching item, or
Nothing
if none matches
elemIndex :: Eq a => a > Fold a (Maybe Int) Source #
(elemIndex a)
returns the index of the first element that equals a
, or
Nothing
if no element matches
findIndex :: (a > Bool) > Fold a (Maybe Int) Source #
(findIndex predicate)
returns the index of the first element that
satisfies the predicate, or Nothing
if no element satisfies the predicate
randomN :: Vector v a => Int > FoldM IO a (Maybe (v a)) Source #
Pick several random elements, using reservoir sampling
mapM_ :: Monad m => (a > m ()) > FoldM m a () Source #
Converts an effectful function to a fold. Specialized version of sink
.
sink :: (Monoid w, Monad m) => (a > m w) > FoldM m a w Source #
Converts an effectful function to a fold
sink (f <> g) = sink f <> sink g  if `(<>)` is commutative sink mempty = mempty
Generic Folds
Container folds
nub :: Ord a => Fold a [a] Source #
O(n log n). Fold values into a list with duplicates removed, while preserving their first occurrences
eqNub :: Eq a => Fold a [a] Source #
O(n^2). Fold values into a list with duplicates removed, while preserving their first occurrences
foldByKeyHashMap :: forall k a b. (Hashable k, Eq k) => Fold a b > Fold (k, a) (HashMap k b) Source #
vectorM :: (PrimMonad m, Vector v a) => FoldM m a (v a) Source #
Fold all values into a vector
This is more efficient than vector
but is impure
Utilities
purely
and impurely
allow you to write folds compatible with the foldl
library without incurring a foldl
dependency. Write your fold to accept
three parameters corresponding to the step function, initial
accumulator, and extraction function and then users can upgrade your
function to accept a Fold
or FoldM
using the purely
or impurely
combinators.
For example, the pipes
library implements fold
and foldM
functions in
Pipes.Prelude
with the following type:
Pipes.Prelude.fold :: Monad m > (x > a > x) > x > (x > b) > Producer a m () > m b Pipes.Prelude.foldM :: Monad m => (x > a > m x) > m x > (x > m b) > Producer a m () > m b
Both fold
and foldM
is set up so that you can wrap them with either
purely
or impurely
to accept a Fold
or FoldM
, respectively:
purely Pipes.Prelude.fold :: Monad m => Fold a b > Producer a m () > m b impurely Pipes.Prelude.foldM :: Monad m => FoldM m a b > Producer a m () > m b
Other streaming libraries supporting purely
and impurely
include iostreams
and streaming
.
So for example we have:
purely System.IO.Streams.fold_ :: Fold a b > Streams.InputStream a > IO b impurely System.IO.Streams.foldM_ :: FoldM IO a b > Streams.InputStream a > IO b
The monotraversable
package makes it convenient to apply a
Fold
or FoldM
to pure containers that do not allow
a general Foldable
instance, like unboxed vectors:
purely ofoldlUnwrap :: MonoFoldable mono => Fold (Element mono) b > mono > b impurely ofoldMUnwrap :: MonoFoldable mono => FoldM m (Element mono) b > mono > m b
purely :: (forall x. (x > a > x) > x > (x > b) > r) > Fold a b > r Source #
Upgrade a fold to accept the Fold
type
purely_ :: (forall x. (x > a > x) > x > x) > Fold a b > b Source #
Upgrade a more traditional fold to accept the Fold
type
impurely :: (forall x. (x > a > m x) > m x > (x > m b) > r) > FoldM m a b > r Source #
Upgrade a monadic fold to accept the FoldM
type
impurely_ :: Monad m => (forall x. (x > a > m x) > m x > m x) > FoldM m a b > m b Source #
Upgrade a more traditional monadic fold to accept the FoldM
type
duplicateM :: Applicative m => FoldM m a b > FoldM m a (FoldM m a b) Source #
premap :: (a > b) > Fold b r > Fold a r Source #
(premap f folder)
returns a new Fold
where f is applied at each step
fold (premap f folder) list = fold folder (List.map f list)
>>>
fold (premap Sum L.mconcat) [1..10]
Sum {getSum = 55}
>>>
fold L.mconcat (List.map Sum [1..10])
Sum {getSum = 55}
premap id = id premap (f . g) = premap g . premap f
premap k (pure r) = pure r premap k (f <*> x) = premap k f <*> premap k x
premapM :: Monad m => (a > m b) > FoldM m b r > FoldM m a r Source #
(premapM f folder)
returns a new FoldM
where f is applied to each input
element
premapM return = id premapM (f <=< g) = premap g . premap f
premapM k (pure r) = pure r premapM k (f <*> x) = premapM k f <*> premapM k x
prefilter :: (a > Bool) > Fold a r > Fold a r Source #
(prefilter f folder)
returns a new Fold
where the folder's input is used
only when the input satisfies a predicate f
This can also be done with handles
(handles (filtered f)
) but prefilter
does not need you to depend on a lens library.
fold (prefilter p folder) list = fold folder (filter p list)
>>>
fold (prefilter (>5) Control.Foldl.sum) [1..10]
40
>>>
fold Control.Foldl.sum (filter (>5) [1..10])
40
prefilterM :: Monad m => (a > m Bool) > FoldM m a r > FoldM m a r Source #
(prefilterM f folder)
returns a new FoldM
where the folder's input is used
only when the input satisfies a monadic predicate f.
foldM (prefilterM p folder) list = foldM folder (filter p list)
predropWhile :: (a > Bool) > Fold a r > Fold a r Source #
Transforms a Fold
into one which ignores elements
until they stop satisfying a predicate
fold (predropWhile p folder) list = fold folder (dropWhile p list)
>>>
fold (predropWhile (>5) Control.Foldl.sum) [10,9,5,9]
14
drop :: Natural > Fold a b > Fold a b Source #
(drop n folder)
returns a new Fold
that ignores the first n
inputs but
otherwise behaves the same as the original fold.
fold (drop n folder) list = fold folder (Data.List.genericDrop n list)
>>>
L.fold (L.drop 3 L.sum) [10, 20, 30, 1, 2, 3]
6
>>>
L.fold (L.drop 10 L.sum) [10, 20, 30, 1, 2, 3]
0
dropM :: Monad m => Natural > FoldM m a b > FoldM m a b Source #
(dropM n folder)
returns a new FoldM
that ignores the first n
inputs but
otherwise behaves the same as the original fold.
foldM (dropM n folder) list = foldM folder (Data.List.genericDrop n list)
>>>
L.foldM (L.dropM 3 (L.generalize L.sum)) [10, 20, 30, 1, 2, 3]
6
>>>
L.foldM (L.dropM 10 (L.generalize L.sum)) [10, 20, 30, 1, 2, 3]
0
type Handler a b = forall x. (b > Const (Dual (Endo x)) b) > a > Const (Dual (Endo x)) a Source #
handles :: Handler a b > Fold b r > Fold a r Source #
(handles t folder)
transforms the input of a Fold
using a lens,
traversal, or prism:
handles _1 :: Fold a r > Fold (a, b) r handles _Left :: Fold a r > Fold (Either a b) r handles traverse :: Traversable t => Fold a r > Fold (t a) r handles folded :: Foldable t => Fold a r > Fold (t a) r
>>>
fold (handles traverse sum) [[1..5],[6..10]]
55
>>>
fold (handles (traverse.traverse) sum) [[Nothing, Just 2, Just 7],[Just 13, Nothing, Just 20]]
42
>>>
fold (handles (filtered even) sum) [1..10]
30
>>>
fold (handles _2 L.mconcat) [(1,"Hello "),(2,"World"),(3,"!")]
"Hello World!"
handles id = id handles (f . g) = handles f . handles g
handles t (pure r) = pure r handles t (f <*> x) = handles t f <*> handles t x
foldOver :: Handler s a > Fold a b > s > b Source #
(foldOver f folder xs)
folds all values from a Lens, Traversal, Prism or Fold with the given folder
>>>
foldOver (_Just . both) L.sum (Just (2, 3))
5
>>>
foldOver (_Just . both) L.sum Nothing
0
L.foldOver f folder xs == L.fold folder (xs^..f)
L.foldOver (folded.f) folder == L.fold (handles f folder)
L.foldOver folded == L.fold
instance Monad m => Monoid (EndoM m a) where mempty = EndoM return mappend (EndoM f) (EndoM g) = EndoM (f <=< g)
type HandlerM m a b = forall x. (b > Const (Dual (EndoM m x)) b) > a > Const (Dual (EndoM m x)) a Source #
handlesM :: HandlerM m a b > FoldM m b r > FoldM m a r Source #
(handlesM t folder)
transforms the input of a FoldM
using a lens,
traversal, or prism:
handlesM _1 :: FoldM m a r > FoldM (a, b) r handlesM _Left :: FoldM m a r > FoldM (Either a b) r handlesM traverse :: Traversable t => FoldM m a r > FoldM m (t a) r handlesM folded :: Foldable t => FoldM m a r > FoldM m (t a) r
handlesM
obeys these laws:
handlesM id = id handlesM (f . g) = handlesM f . handlesM g
handlesM t (pure r) = pure r handlesM t (f <*> x) = handlesM t f <*> handlesM t x
foldOverM :: Monad m => HandlerM m s a > FoldM m a b > s > m b Source #
(foldOverM f folder xs)
folds all values from a Lens, Traversal, Prism or Fold monadically with the given folder
L.foldOverM (folded.f) folder == L.foldM (handlesM f folder)
L.foldOverM folded == L.foldM
folded :: (Contravariant f, Applicative f, Foldable t) => (a > f a) > t a > f (t a) Source #
folded :: Foldable t => Fold (t a) a handles folded :: Foldable t => Fold a r > Fold (t a) r
filtered :: Monoid m => (a > Bool) > (a > m) > a > m Source #
>>>
fold (handles (filtered even) sum) [1..10]
30
>>>
foldM (handlesM (filtered even) (L.mapM_ print)) [1..10]
2 4 6 8 10
groupBy :: Ord g => (a > g) > Fold a r > Fold a (Map g r) Source #
Perform a Fold
while grouping the data according to a specified group
projection function. Returns the folded result grouped as a map keyed by the
group.
either :: Fold a1 b1 > Fold a2 b2 > Fold (Either a1 a2) (b1, b2) Source #
Combine two folds into a fold over inputs for either of them.
eitherM :: Monad m => FoldM m a1 b1 > FoldM m a2 b2 > FoldM m (Either a1 a2) (b1, b2) Source #
Combine two monadic folds into a fold over inputs for either of them.
Reexports
Control.Monad.Primitive
reexports the PrimMonad
type class
Data.Foldable
reexports the Foldable
type class
Data.Vector.Generic
reexports the Vector
type class
RealWorld
is deeply magical. It is primitive, but it is not
unlifted (hence ptrArg
). We never manipulate values of type
RealWorld
; it's only used in the type system, to parameterise State#
.
class Monad m => PrimMonad (m :: Type > Type) #
Class of monads which can perform primitive statetransformer actions
Instances
PrimMonad IO  
PrimMonad (ST s)  
PrimMonad (ST s)  
PrimMonad m => PrimMonad (ListT m)  
PrimMonad m => PrimMonad (MaybeT m)  
PrimMonad m => PrimMonad (IdentityT m)  
(Error e, PrimMonad m) => PrimMonad (ErrorT e m)  
PrimMonad m => PrimMonad (ExceptT e m)  
PrimMonad m => PrimMonad (ReaderT r m)  
PrimMonad m => PrimMonad (StateT s m)  
PrimMonad m => PrimMonad (StateT s m)  
(Monoid w, PrimMonad m) => PrimMonad (WriterT w m)  
(Monoid w, PrimMonad m) => PrimMonad (WriterT w m)  
(Monoid w, PrimMonad m) => PrimMonad (AccumT w m)  Since: primitive0.6.3.0 
(Monoid w, PrimMonad m) => PrimMonad (WriterT w m)  
PrimMonad m => PrimMonad (SelectT r m)  
PrimMonad m => PrimMonad (ContT r m)  Since: primitive0.6.3.0 
(Monoid w, PrimMonad m) => PrimMonad (RWST r w s m)  
(Monoid w, PrimMonad m) => PrimMonad (RWST r w s m)  
(Monoid w, PrimMonad m) => PrimMonad (RWST r w s m)  
class Foldable (t :: Type > Type) #
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)
Instances
Foldable []  Since: base2.1 
Defined in Data.Foldable fold :: Monoid m => [m] > m # foldMap :: Monoid m => (a > m) > [a] > m # foldMap' :: Monoid m => (a > m) > [a] > m # foldr :: (a > b > b) > b > [a] > b # foldr' :: (a > b > b) > b > [a] > b # foldl :: (b > a > b) > b > [a] > b # foldl' :: (b > a > b) > b > [a] > b # foldr1 :: (a > a > a) > [a] > a # foldl1 :: (a > a > a) > [a] > a # elem :: Eq a => a > [a] > Bool # maximum :: Ord a => [a] > a #  
Foldable Maybe  Since: base2.1 
Defined in Data.Foldable fold :: Monoid m => Maybe m > m # foldMap :: Monoid m => (a > m) > Maybe a > m # foldMap' :: Monoid m => (a > m) > Maybe a > m # foldr :: (a > b > b) > b > Maybe a > b # foldr' :: (a > b > b) > b > Maybe a > b # foldl :: (b > a > b) > b > Maybe a > b # foldl' :: (b > a > b) > b > Maybe a > b # foldr1 :: (a > a > a) > Maybe a > a # foldl1 :: (a > a > a) > Maybe a > a # elem :: Eq a => a > Maybe a > Bool # maximum :: Ord a => Maybe a > a # minimum :: Ord a => Maybe a > a #  
Foldable Par1  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => Par1 m > m # foldMap :: Monoid m => (a > m) > Par1 a > m # foldMap' :: Monoid m => (a > m) > Par1 a > m # foldr :: (a > b > b) > b > Par1 a > b # foldr' :: (a > b > b) > b > Par1 a > b # foldl :: (b > a > b) > b > Par1 a > b # foldl' :: (b > a > b) > b > Par1 a > b # foldr1 :: (a > a > a) > Par1 a > a # foldl1 :: (a > a > a) > Par1 a > a # elem :: Eq a => a > Par1 a > Bool # maximum :: Ord a => Par1 a > a #  
Foldable Complex  Since: base4.9.0.0 
Defined in Data.Complex fold :: Monoid m => Complex m > m # foldMap :: Monoid m => (a > m) > Complex a > m # foldMap' :: Monoid m => (a > m) > Complex a > m # foldr :: (a > b > b) > b > Complex a > b # foldr' :: (a > b > b) > b > Complex a > b # foldl :: (b > a > b) > b > Complex a > b # foldl' :: (b > a > b) > b > Complex a > b # foldr1 :: (a > a > a) > Complex a > a # foldl1 :: (a > a > a) > Complex a > a # elem :: Eq a => a > Complex a > Bool # maximum :: Ord a => Complex a > a # minimum :: Ord a => Complex a > a #  
Foldable Min  Since: base4.9.0.0 
Defined in Data.Semigroup fold :: Monoid m => Min m > m # foldMap :: Monoid m => (a > m) > Min a > m # foldMap' :: Monoid m => (a > m) > Min a > m # foldr :: (a > b > b) > b > Min a > b # foldr' :: (a > b > b) > b > Min a > b # foldl :: (b > a > b) > b > Min a > b # foldl' :: (b > a > b) > b > Min a > b # foldr1 :: (a > a > a) > Min a > a # foldl1 :: (a > a > a) > Min a > a # elem :: Eq a => a > Min a > Bool # maximum :: Ord a => Min a > a #  
Foldable Max  Since: base4.9.0.0 
Defined in Data.Semigroup fold :: Monoid m => Max m > m # foldMap :: Monoid m => (a > m) > Max a > m # foldMap' :: Monoid m => (a > m) > Max a > m # foldr :: (a > b > b) > b > Max a > b # foldr' :: (a > b > b) > b > Max a > b # foldl :: (b > a > b) > b > Max a > b # foldl' :: (b > a > b) > b > Max a > b # foldr1 :: (a > a > a) > Max a > a # foldl1 :: (a > a > a) > Max a > a # elem :: Eq a => a > Max a > Bool # maximum :: Ord a => Max a > a #  
Foldable First  Since: base4.9.0.0 
Defined in Data.Semigroup fold :: Monoid m => First m > m # foldMap :: Monoid m => (a > m) > First a > m # foldMap' :: Monoid m => (a > m) > First a > m # foldr :: (a > b > b) > b > First a > b # foldr' :: (a > b > b) > b > First a > b # foldl :: (b > a > b) > b > First a > b # foldl' :: (b > a > b) > b > First a > b # foldr1 :: (a > a > a) > First a > a # foldl1 :: (a > a > a) > First a > a # elem :: Eq a => a > First a > Bool # maximum :: Ord a => First a > a # minimum :: Ord a => First a > a #  
Foldable Last  Since: base4.9.0.0 
Defined in Data.Semigroup fold :: Monoid m => Last m > m # foldMap :: Monoid m => (a > m) > Last a > m # foldMap' :: Monoid m => (a > m) > Last a > m # foldr :: (a > b > b) > b > Last a > b # foldr' :: (a > b > b) > b > Last a > b # foldl :: (b > a > b) > b > Last a > b # foldl' :: (b > a > b) > b > Last a > b # foldr1 :: (a > a > a) > Last a > a # foldl1 :: (a > a > a) > Last a > a # elem :: Eq a => a > Last a > Bool # maximum :: Ord a => Last a > a #  
Foldable Option  Since: base4.9.0.0 
Defined in Data.Semigroup fold :: Monoid m => Option m > m # foldMap :: Monoid m => (a > m) > Option a > 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  Since: base4.9.0.0 
Defined in Control.Applicative fold :: Monoid m => ZipList m > m # foldMap :: Monoid m => (a > m) > ZipList a > m # foldMap' :: Monoid m => (a > m) > ZipList a > m # foldr :: (a > b > b) > b > ZipList a > b # foldr' :: (a > b > b) > b > ZipList a > b # foldl :: (b > a > b) > b > ZipList a > b # foldl' :: (b > a > b) > b > ZipList a > b # foldr1 :: (a > a > a) > ZipList a > a # foldl1 :: (a > a > a) > ZipList a > a # elem :: Eq a => a > ZipList a > Bool # maximum :: Ord a => ZipList a > a # minimum :: Ord a => ZipList a > a #  
Foldable Identity  Since: base4.8.0.0 
Defined in Data.Functor.Identity fold :: Monoid m => Identity m > m # foldMap :: Monoid m => (a > m) > Identity a > m # foldMap' :: Monoid m => (a > m) > Identity a > m # foldr :: (a > b > b) > b > Identity a > b # foldr' :: (a > b > b) > b > Identity a > b # foldl :: (b > a > b) > b > Identity a > b # foldl' :: (b > a > b) > b > Identity a > b # foldr1 :: (a > a > a) > Identity a > a # foldl1 :: (a > a > a) > Identity a > a # elem :: Eq a => a > Identity a > Bool # maximum :: Ord a => Identity a > a # minimum :: Ord a => Identity a > a #  
Foldable First  Since: base4.8.0.0 
Defined in Data.Foldable fold :: Monoid m => First m > m # foldMap :: Monoid m => (a > m) > First a > m # foldMap' :: Monoid m => (a > m) > First a > m # foldr :: (a > b > b) > b > First a > b # foldr' :: (a > b > b) > b > First a > b # foldl :: (b > a > b) > b > First a > b # foldl' :: (b > a > b) > b > First a > b # foldr1 :: (a > a > a) > First a > a # foldl1 :: (a > a > a) > First a > a # elem :: Eq a => a > First a > Bool # maximum :: Ord a => First a > a # minimum :: Ord a => First a > a #  
Foldable Last  Since: base4.8.0.0 
Defined in Data.Foldable fold :: Monoid m => Last m > m # foldMap :: Monoid m => (a > m) > Last a > m # foldMap' :: Monoid m => (a > m) > Last a > m # foldr :: (a > b > b) > b > Last a > b # foldr' :: (a > b > b) > b > Last a > b # foldl :: (b > a > b) > b > Last a > b # foldl' :: (b > a > b) > b > Last a > b # foldr1 :: (a > a > a) > Last a > a # foldl1 :: (a > a > a) > Last a > a # elem :: Eq a => a > Last a > Bool # maximum :: Ord a => Last a > a #  
Foldable Dual  Since: base4.8.0.0 
Defined in Data.Foldable fold :: Monoid m => Dual m > m # foldMap :: Monoid m => (a > m) > Dual a > m # foldMap' :: Monoid m => (a > m) > Dual a > m # foldr :: (a > b > b) > b > Dual a > b # foldr' :: (a > b > b) > b > Dual a > b # foldl :: (b > a > b) > b > Dual a > b # foldl' :: (b > a > b) > b > Dual a > b # foldr1 :: (a > a > a) > Dual a > a # foldl1 :: (a > a > a) > Dual a > a # elem :: Eq a => a > Dual a > Bool # maximum :: Ord a => Dual a > a #  
Foldable Sum  Since: base4.8.0.0 
Defined in Data.Foldable fold :: Monoid m => Sum m > m # foldMap :: Monoid m => (a > m) > Sum a > m # foldMap' :: Monoid m => (a > m) > Sum a > m # foldr :: (a > b > b) > b > Sum a > b # foldr' :: (a > b > b) > b > Sum a > b # foldl :: (b > a > b) > b > Sum a > b # foldl' :: (b > a > b) > b > Sum a > b # foldr1 :: (a > a > a) > Sum a > a # foldl1 :: (a > a > a) > Sum a > a # elem :: Eq a => a > Sum a > Bool # maximum :: Ord a => Sum a > a #  
Foldable Product  Since: base4.8.0.0 
Defined in Data.Foldable fold :: Monoid m => Product m > m # foldMap :: Monoid m => (a > m) > Product a > m # foldMap' :: Monoid m => (a > m) > Product a > m # foldr :: (a > b > b) > b > Product a > b # foldr' :: (a > b > b) > b > Product a > b # foldl :: (b > a > b) > b > Product a > b # foldl' :: (b > a > b) > b > Product a > b # foldr1 :: (a > a > a) > Product a > a # foldl1 :: (a > a > a) > Product a > a # elem :: Eq a => a > Product a > Bool # maximum :: Ord a => Product a > a # minimum :: Ord a => Product a > a #  
Foldable Down  Since: base4.12.0.0 
Defined in Data.Foldable fold :: Monoid m => Down m > m # foldMap :: Monoid m => (a > m) > Down a > m # foldMap' :: Monoid m => (a > m) > Down a > m # foldr :: (a > b > b) > b > Down a > b # foldr' :: (a > b > b) > b > Down a > b # foldl :: (b > a > b) > b > Down a > b # foldl' :: (b > a > b) > b > Down a > b # foldr1 :: (a > a > a) > Down a > a # foldl1 :: (a > a > a) > Down a > a # elem :: Eq a => a > Down a > Bool # maximum :: Ord a => Down a > a #  
Foldable NonEmpty  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => NonEmpty m > m # foldMap :: Monoid m => (a > m) > NonEmpty a > m # foldMap' :: Monoid m => (a > m) > NonEmpty a > m # foldr :: (a > b > b) > b > NonEmpty a > b # foldr' :: (a > b > b) > b > NonEmpty a > b # foldl :: (b > a > b) > b > NonEmpty a > b # foldl' :: (b > a > b) > b > NonEmpty a > b # foldr1 :: (a > a > a) > NonEmpty a > a # foldl1 :: (a > a > a) > NonEmpty a > a # elem :: Eq a => a > NonEmpty a > Bool # maximum :: Ord a => NonEmpty a > a # minimum :: Ord a => NonEmpty a > a #  
Foldable IntMap  Folds in order of increasing key. 
Defined in Data.IntMap.Internal fold :: Monoid m => IntMap m > m # foldMap :: Monoid m => (a > m) > IntMap a > m # foldMap' :: Monoid m => (a > m) > IntMap a > m # foldr :: (a > b > b) > b > IntMap a > b # foldr' :: (a > b > b) > b > IntMap a > b # foldl :: (b > a > b) > b > IntMap a > b # foldl' :: (b > a > b) > b > IntMap a > b # foldr1 :: (a > a > a) > IntMap a > a # foldl1 :: (a > a > a) > IntMap a > a # elem :: Eq a => a > IntMap a > Bool # maximum :: Ord a => IntMap a > a # minimum :: Ord a => IntMap a > a #  
Foldable Tree  
Defined in Data.Tree fold :: Monoid m => Tree m > m # foldMap :: Monoid m => (a > m) > Tree a > m # foldMap' :: Monoid m => (a > m) > Tree a > m # foldr :: (a > b > b) > b > Tree a > b # foldr' :: (a > b > b) > b > Tree a > b # foldl :: (b > a > b) > b > Tree a > b # foldl' :: (b > a > b) > b > Tree a > b # foldr1 :: (a > a > a) > Tree a > a # foldl1 :: (a > a > a) > Tree a > a # 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 # 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 # 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 # 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 # 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 # 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 # 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 # 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  Folds in order of increasing key. 
Defined in Data.Set.Internal fold :: Monoid m => Set m > m # foldMap :: Monoid m => (a > m) > Set a > m # foldMap' :: Monoid m => (a > m) > Set a > m # foldr :: (a > b > b) > b > Set a > b # foldr' :: (a > b > b) > b > Set a > b # foldl :: (b > a > b) > b > Set a > b # foldl' :: (b > a > b) > b > Set a > b # foldr1 :: (a > a > a) > Set a > a # foldl1 :: (a > a > a) > Set a > a # elem :: Eq a => a > Set a > Bool # maximum :: Ord a => Set a > a #  
Foldable Hashed  
Defined in Data.Hashable.Class fold :: Monoid m => Hashed m > m # foldMap :: Monoid m => (a > m) > Hashed a > m # foldMap' :: Monoid m => (a > m) > Hashed a > m # foldr :: (a > b > b) > b > Hashed a > b # foldr' :: (a > b > b) > b > Hashed a > b # foldl :: (b > a > b) > b > Hashed a > b # foldl' :: (b > a > b) > b > Hashed a > b # foldr1 :: (a > a > a) > Hashed a > a # foldl1 :: (a > a > a) > Hashed a > a # elem :: Eq a => a > Hashed a > Bool # maximum :: Ord a => Hashed a > a # minimum :: Ord a => Hashed a > a #  
Foldable SmallArray  
Defined in Data.Primitive.SmallArray fold :: Monoid m => SmallArray m > m # foldMap :: Monoid m => (a > m) > SmallArray a > 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 # 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 HashSet  
Defined in Data.HashSet.Internal fold :: Monoid m => HashSet m > m # foldMap :: Monoid m => (a > m) > HashSet a > m # foldMap' :: Monoid m => (a > m) > HashSet a > m # foldr :: (a > b > b) > b > HashSet a > b # foldr' :: (a > b > b) > b > HashSet a > b # foldl :: (b > a > b) > b > HashSet a > b # foldl' :: (b > a > b) > b > HashSet a > b # foldr1 :: (a > a > a) > HashSet a > a # foldl1 :: (a > a > a) > HashSet a > a # elem :: Eq a => a > HashSet a > Bool # maximum :: Ord a => HashSet a > a # minimum :: Ord a => HashSet a > a #  
Foldable (Either a)  Since: base4.7.0.0 
Defined in Data.Foldable fold :: Monoid m => Either a m > m # foldMap :: Monoid m => (a0 > m) > Either a a0 > m # foldMap' :: Monoid m => (a0 > m) > Either a a0 > m # foldr :: (a0 > b > b) > b > Either a a0 > b # foldr' :: (a0 > b > b) > b > Either a a0 > b # foldl :: (b > a0 > b) > b > Either a a0 > b # foldl' :: (b > a0 > b) > b > Either a a0 > b # foldr1 :: (a0 > a0 > a0) > Either a a0 > a0 # foldl1 :: (a0 > a0 > a0) > Either a a0 > a0 # toList :: Either a a0 > [a0] # 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 :: Type > Type)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => V1 m > m # foldMap :: Monoid m => (a > m) > V1 a > m # foldMap' :: Monoid m => (a > m) > V1 a > m # foldr :: (a > b > b) > b > V1 a > b # foldr' :: (a > b > b) > b > V1 a > b # foldl :: (b > a > b) > b > V1 a > b # foldl' :: (b > a > b) > b > V1 a > b # foldr1 :: (a > a > a) > V1 a > a # foldl1 :: (a > a > a) > V1 a > a # elem :: Eq a => a > V1 a > Bool # maximum :: Ord a => V1 a > a #  
Foldable (U1 :: Type > Type)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => U1 m > m # foldMap :: Monoid m => (a > m) > U1 a > m # foldMap' :: Monoid m => (a > m) > U1 a > m # foldr :: (a > b > b) > b > U1 a > b # foldr' :: (a > b > b) > b > U1 a > b # foldl :: (b > a > b) > b > U1 a > b # foldl' :: (b > a > b) > b > U1 a > b # foldr1 :: (a > a > a) > U1 a > a # foldl1 :: (a > a > a) > U1 a > a # elem :: Eq a => a > U1 a > Bool # maximum :: Ord a => U1 a > a #  
Foldable (UAddr :: Type > Type)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => UAddr m > m # foldMap :: Monoid m => (a > m) > UAddr a > m # foldMap' :: Monoid m => (a > m) > UAddr a > m # foldr :: (a > b > b) > b > UAddr a > b # foldr' :: (a > b > b) > b > UAddr a > b # foldl :: (b > a > b) > b > UAddr a > b # foldl' :: (b > a > b) > b > UAddr a > b # foldr1 :: (a > a > a) > UAddr a > a # foldl1 :: (a > a > a) > UAddr a > a # elem :: Eq a => a > UAddr a > Bool # maximum :: Ord a => UAddr a > a # minimum :: Ord a => UAddr a > a #  
Foldable (UChar :: Type > Type)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => UChar m > m # foldMap :: Monoid m => (a > m) > UChar a > m # foldMap' :: Monoid m => (a > m) > UChar a > m # foldr :: (a > b > b) > b > UChar a > b # foldr' :: (a > b > b) > b > UChar a > b # foldl :: (b > a > b) > b > UChar a > b # foldl' :: (b > a > b) > b > UChar a > b # foldr1 :: (a > a > a) > UChar a > a # foldl1 :: (a > a > a) > UChar a > a # elem :: Eq a => a > UChar a > Bool # maximum :: Ord a => UChar a > a # minimum :: Ord a => UChar a > a #  
Foldable (UDouble :: Type > Type)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => UDouble m > m # foldMap :: Monoid m => (a > m) > UDouble a > m # foldMap' :: Monoid m => (a > m) > UDouble a > m # foldr :: (a > b > b) > b > UDouble a > b # foldr' :: (a > b > b) > b > UDouble a > b # foldl :: (b > a > b) > b > UDouble a > b # foldl' :: (b > a > b) > b > UDouble a > b # foldr1 :: (a > a > a) > UDouble a > a # foldl1 :: (a > a > a) > UDouble a > a # elem :: Eq a => a > UDouble a > Bool # maximum :: Ord a => UDouble a > a # minimum :: Ord a => UDouble a > a #  
Foldable (UFloat :: Type > Type)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => UFloat m > m # foldMap :: Monoid m => (a > m) > UFloat a > m # foldMap' :: Monoid m => (a > m) > UFloat a > m # foldr :: (a > b > b) > b > UFloat a > b # foldr' :: (a > b > b) > b > UFloat a > b # foldl :: (b > a > b) > b > UFloat a > b # foldl' :: (b > a > b) > b > UFloat a > b # foldr1 :: (a > a > a) > UFloat a > a # foldl1 :: (a > a > a) > UFloat a > a # elem :: Eq a => a > UFloat a > Bool # maximum :: Ord a => UFloat a > a # minimum :: Ord a => UFloat a > a #  
Foldable (UInt :: Type > Type)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => UInt m > m # foldMap :: Monoid m => (a > m) > UInt a > m # foldMap' :: Monoid m => (a > m) > UInt a > m # foldr :: (a > b > b) > b > UInt a > b # foldr' :: (a > b > b) > b > UInt a > b # foldl :: (b > a > b) > b > UInt a > b # foldl' :: (b > a > b) > b > UInt a > b # foldr1 :: (a > a > a) > UInt a > a # foldl1 :: (a > a > a) > UInt a > a # elem :: Eq a => a > UInt a > Bool # maximum :: Ord a => UInt a > a #  
Foldable (UWord :: Type > Type)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => UWord m > m # foldMap :: Monoid m => (a > m) > UWord a > m # foldMap' :: Monoid m => (a > m) > UWord a > m # foldr :: (a > b > b) > b > UWord a > b # foldr' :: (a > b > b) > b > UWord a > b # foldl :: (b > a > b) > b > UWord a > b # foldl' :: (b > a > b) > b > UWord a > b # foldr1 :: (a > a > a) > UWord a > a # foldl1 :: (a > a > a) > UWord a > a # elem :: Eq a => a > UWord a > Bool # maximum :: Ord a => UWord a > a # minimum :: Ord a => UWord a > a #  
Foldable ((,) a)  Since: base4.7.0.0 
Defined in Data.Foldable fold :: Monoid m => (a, m) > m # foldMap :: Monoid m => (a0 > m) > (a, a0) > m # foldMap' :: Monoid m => (a0 > m) > (a, a0) > m # foldr :: (a0 > b > b) > b > (a, a0) > b # foldr' :: (a0 > b > b) > b > (a, a0) > b # foldl :: (b > a0 > b) > b > (a, a0) > b # foldl' :: (b > a0 > b) > b > (a, a0) > b # foldr1 :: (a0 > a0 > a0) > (a, a0) > a0 # foldl1 :: (a0 > a0 > a0) > (a, a0) > a0 # elem :: Eq a0 => a0 > (a, a0) > Bool # maximum :: Ord a0 => (a, a0) > a0 # minimum :: Ord a0 => (a, a0) > a0 #  
Foldable (Array i)  Since: base4.8.0.0 
Defined in Data.Foldable fold :: Monoid m => Array i m > m # foldMap :: Monoid m => (a > m) > Array i a > m # foldMap' :: Monoid m => (a > m) > Array i a > m # foldr :: (a > b > b) > b > Array i a > b # foldr' :: (a > b > b) > b > Array i a > b # foldl :: (b > a > b) > b > Array i a > b # foldl' :: (b > a > b) > b > Array i a > b # foldr1 :: (a > a > a) > Array i a > a # foldl1 :: (a > a > a) > Array i a > a # 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: base4.9.0.0 
Defined in Data.Semigroup fold :: Monoid m => Arg a m > m # foldMap :: Monoid m => (a0 > m) > Arg a a0 > m # foldMap' :: Monoid m => (a0 > m) > Arg a a0 > m # foldr :: (a0 > b > b) > b > Arg a a0 > b # foldr' :: (a0 > b > b) > b > Arg a a0 > b # foldl :: (b > a0 > b) > b > Arg a a0 > b # foldl' :: (b > a0 > b) > b > Arg a a0 > b # foldr1 :: (a0 > a0 > a0) > Arg a a0 > a0 # foldl1 :: (a0 > a0 > a0) > Arg a a0 > a0 # elem :: Eq a0 => a0 > Arg a a0 > Bool # maximum :: Ord a0 => Arg a a0 > a0 # minimum :: Ord a0 => Arg a a0 > a0 #  
Foldable (Proxy :: Type > Type)  Since: base4.7.0.0 
Defined in Data.Foldable fold :: Monoid m => Proxy m > m # foldMap :: Monoid m => (a > m) > Proxy a > m # foldMap' :: Monoid m => (a > m) > Proxy a > m # foldr :: (a > b > b) > b > Proxy a > b # foldr' :: (a > b > b) > b > Proxy a > b # foldl :: (b > a > b) > b > Proxy a > b # foldl' :: (b > a > b) > b > Proxy a > b # foldr1 :: (a > a > a) > Proxy a > a # foldl1 :: (a > a > a) > Proxy a > a # elem :: Eq a => a > Proxy a > Bool # maximum :: Ord a => Proxy a > a # minimum :: Ord a => Proxy a > a #  
Foldable (Map k)  Folds in order of increasing key. 
Defined in Data.Map.Internal fold :: Monoid m => Map k m > m # foldMap :: Monoid m => (a > m) > Map k a > m # foldMap' :: Monoid m => (a > m) > Map k a > m # foldr :: (a > b > b) > b > Map k a > b # foldr' :: (a > b > b) > b > Map k a > b # foldl :: (b > a > b) > b > Map k a > b # foldl' :: (b > a > b) > b > Map k a > b # foldr1 :: (a > a > a) > Map k a > a # foldl1 :: (a > a > a) > Map k a > a # elem :: Eq a => a > Map k a > Bool # maximum :: Ord a => Map k a > a # minimum :: Ord a => Map k a > a #  
Foldable f => Foldable (ListT f)  
Defined in Control.Monad.Trans.List fold :: Monoid m => ListT f m > m # foldMap :: Monoid m => (a > m) > ListT f a > m # foldMap' :: Monoid m => (a > m) > ListT f a > m # foldr :: (a > b > b) > b > ListT f a > b # foldr' :: (a > b > b) > b > ListT f a > b # foldl :: (b > a > b) > b > ListT f a > b # foldl' :: (b > a > b) > b > ListT f a > b # foldr1 :: (a > a > a) > ListT f a > a # foldl1 :: (a > a > a) > ListT f a > a # elem :: Eq a => a > ListT f a > Bool # maximum :: Ord a => ListT f a > a # minimum :: Ord a => ListT f 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 # 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 (HashMap k)  
Defined in Data.HashMap.Internal fold :: Monoid m => HashMap k m > m # foldMap :: Monoid m => (a > m) > HashMap k a > m # foldMap' :: Monoid m => (a > m) > HashMap k a > m # foldr :: (a > b > b) > b > HashMap k a > b # foldr' :: (a > b > b) > b > HashMap k a > b # foldl :: (b > a > b) > b > HashMap k a > b # foldl' :: (b > a > b) > b > HashMap k a > b # foldr1 :: (a > a > a) > HashMap k a > a # foldl1 :: (a > a > a) > HashMap k a > a # toList :: HashMap k a > [a] # 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 f => Foldable (Rec1 f)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => Rec1 f m > m # foldMap :: Monoid m => (a > m) > Rec1 f a > m # foldMap' :: Monoid m => (a > m) > Rec1 f a > m # foldr :: (a > b > b) > b > Rec1 f a > b # foldr' :: (a > b > b) > b > Rec1 f a > b # foldl :: (b > a > b) > b > Rec1 f a > b # foldl' :: (b > a > b) > b > Rec1 f a > b # foldr1 :: (a > a > a) > Rec1 f a > a # foldl1 :: (a > a > a) > Rec1 f a > a # elem :: Eq a => a > Rec1 f a > Bool # maximum :: Ord a => Rec1 f a > a # minimum :: Ord a => Rec1 f a > a #  
Foldable (Const m :: Type > Type)  Since: base4.7.0.0 
Defined in Data.Functor.Const fold :: Monoid m0 => Const m m0 > m0 # foldMap :: Monoid m0 => (a > m0) > Const m a > m0 # foldMap' :: Monoid m0 => (a > m0) > Const m a > m0 # foldr :: (a > b > b) > b > Const m a > b # foldr' :: (a > b > b) > b > Const m a > b # foldl :: (b > a > b) > b > Const m a > b # foldl' :: (b > a > b) > b > Const m a > b # foldr1 :: (a > a > a) > Const m a > a # foldl1 :: (a > a > a) > Const m a > a # elem :: Eq a => a > Const m a > Bool # maximum :: Ord a => Const m a > a # minimum :: Ord a => Const m a > a #  
Foldable f => Foldable (Ap f)  Since: base4.12.0.0 
Defined in Data.Foldable fold :: Monoid m => Ap f m > m # foldMap :: Monoid m => (a > m) > Ap f a > m # foldMap' :: Monoid m => (a > m) > Ap f a > m # foldr :: (a > b > b) > b > Ap f a > b # foldr' :: (a > b > b) > b > Ap f a > b # foldl :: (b > a > b) > b > Ap f a > b # foldl' :: (b > a > b) > b > Ap f a > b # foldr1 :: (a > a > a) > Ap f a > a # foldl1 :: (a > a > a) > Ap f a > a # elem :: Eq a => a > Ap f a > Bool # maximum :: Ord a => Ap f a > a #  
Foldable f => Foldable (Alt f)  Since: base4.12.0.0 
Defined in Data.Foldable fold :: Monoid m => Alt f m > m # foldMap :: Monoid m => (a > m) > Alt f a > m # foldMap' :: Monoid m => (a > m) > Alt f a > m # foldr :: (a > b > b) > b > Alt f a > b # foldr' :: (a > b > b) > b > Alt f a > b # foldl :: (b > a > b) > b > Alt f a > b # foldl' :: (b > a > b) > b > Alt f a > b # foldr1 :: (a > a > a) > Alt f a > a # foldl1 :: (a > a > a) > Alt f a > a # elem :: Eq a => a > Alt f a > Bool # maximum :: Ord a => Alt f a > a # minimum :: Ord a => Alt f 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 # 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 #  
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 # 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 (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 # 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 (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 # 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 (WriterT w f)  
Defined in Control.Monad.Trans.Writer.Lazy fold :: Monoid m => WriterT w f m > m # foldMap :: Monoid m => (a > m) > WriterT w f a > m # foldMap' :: Monoid m => (a > m) > WriterT w f a > m # foldr :: (a > b > b) > b > WriterT w f a > b # foldr' :: (a > b > b) > b > WriterT w f a > b # foldl :: (b > a > b) > b > WriterT w f a > b # foldl' :: (b > a > b) > b > WriterT w f a > b # foldr1 :: (a > a > a) > WriterT w f a > a # foldl1 :: (a > a > a) > WriterT w f a > a # toList :: WriterT w f a > [a] # null :: WriterT w f a > Bool # length :: WriterT w f a > Int # elem :: Eq a => a > WriterT w f a > Bool # maximum :: Ord a => WriterT w f a > a # minimum :: Ord a => WriterT w f a > a #  
Foldable f => Foldable (WriterT w f)  
Defined in Control.Monad.Trans.Writer.Strict fold :: Monoid m => WriterT w f m > m # foldMap :: Monoid m => (a > m) > WriterT w f a > m # foldMap' :: Monoid m => (a > m) > WriterT w f a > m # foldr :: (a > b > b) > b > WriterT w f a > b # foldr' :: (a > b > b) > b > WriterT w f a > b # foldl :: (b > a > b) > b > WriterT w f a > b # foldl' :: (b > a > b) > b > WriterT w f a > b # foldr1 :: (a > a > a) > WriterT w f a > a # foldl1 :: (a > a > a) > WriterT w f a > a # toList :: WriterT w f a > [a] # null :: WriterT w f a > Bool # length :: WriterT w f a > Int # elem :: Eq a => a > WriterT w f a > Bool # maximum :: Ord a => WriterT w f a > a # minimum :: Ord a => WriterT w f a > a #  
Foldable (Tagged s)  
Defined in Data.Tagged fold :: Monoid m => Tagged s m > m # foldMap :: Monoid m => (a > m) > Tagged s a > m # foldMap' :: Monoid m => (a > m) > Tagged s a > m # foldr :: (a > b > b) > b > Tagged s a > b # foldr' :: (a > b > b) > b > Tagged s a > b # foldl :: (b > a > b) > b > Tagged s a > b # foldl' :: (b > a > b) > b > Tagged s a > b # foldr1 :: (a > a > a) > Tagged s a > a # foldl1 :: (a > a > a) > Tagged s a > a # 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 :: Type > Type)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => K1 i c m > m # foldMap :: Monoid m => (a > m) > K1 i c a > m # foldMap' :: Monoid m => (a > m) > K1 i c a > m # foldr :: (a > b > b) > b > K1 i c a > b # foldr' :: (a > b > b) > b > K1 i c a > b # foldl :: (b > a > b) > b > K1 i c a > b # foldl' :: (b > a > b) > b > K1 i c a > b # foldr1 :: (a > a > a) > K1 i c a > a # foldl1 :: (a > a > a) > K1 i c a > a # 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)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => (f :+: g) m > m # foldMap :: Monoid m => (a > m) > (f :+: g) a > m # foldMap' :: Monoid m => (a > m) > (f :+: g) a > m # foldr :: (a > b > b) > b > (f :+: g) a > b # foldr' :: (a > b > b) > b > (f :+: g) a > b # foldl :: (b > a > b) > b > (f :+: g) a > b # foldl' :: (b > a > b) > b > (f :+: g) a > b # foldr1 :: (a > a > a) > (f :+: g) a > a # foldl1 :: (a > a > a) > (f :+: g) a > a # toList :: (f :+: g) a > [a] # 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)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => (f :*: g) m > m # foldMap :: Monoid m => (a > m) > (f :*: g) a > m # foldMap' :: Monoid m => (a > m) > (f :*: g) a > m # foldr :: (a > b > b) > b > (f :*: g) a > b # foldr' :: (a > b > b) > b > (f :*: g) a > b # foldl :: (b > a > b) > b > (f :*: g) a > b # foldl' :: (b > a > b) > b > (f :*: g) a > b # foldr1 :: (a > a > a) > (f :*: g) a > a # foldl1 :: (a > a > a) > (f :*: g) a > a # toList :: (f :*: g) a > [a] # 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: base4.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 # 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: base4.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 # 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 (Forget r a :: Type > Type)  
Defined in Data.Profunctor.Types fold :: Monoid m => Forget r a m > m # foldMap :: Monoid m => (a0 > m) > Forget r a a0 > m # foldMap' :: Monoid m => (a0 > m) > Forget r a a0 > m # foldr :: (a0 > b > b) > b > Forget r a a0 > b # foldr' :: (a0 > b > b) > b > Forget r a a0 > b # foldl :: (b > a0 > b) > b > Forget r a a0 > b # foldl' :: (b > a0 > b) > b > Forget r a a0 > b # foldr1 :: (a0 > a0 > a0) > Forget r a a0 > a0 # foldl1 :: (a0 > a0 > a0) > Forget r a a0 > a0 # toList :: Forget r a a0 > [a0] # null :: Forget r a a0 > Bool # length :: Forget r a a0 > Int # elem :: Eq a0 => a0 > Forget r a a0 > Bool # maximum :: Ord a0 => Forget r a a0 > a0 # minimum :: Ord a0 => Forget r a a0 > a0 #  
Foldable f => Foldable (M1 i c f)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => M1 i c f m > m # foldMap :: Monoid m => (a > m) > M1 i c f a > m # foldMap' :: Monoid m => (a > m) > M1 i c f a > m # foldr :: (a > b > b) > b > M1 i c f a > b # foldr' :: (a > b > b) > b > M1 i c f a > b # foldl :: (b > a > b) > b > M1 i c f a > b # foldl' :: (b > a > b) > b > M1 i c f a > b # foldr1 :: (a > a > a) > M1 i c f a > a # foldl1 :: (a > a > a) > M1 i c f a > a # 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)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => (f :.: g) m > m # foldMap :: Monoid m => (a > m) > (f :.: g) a > m # foldMap' :: Monoid m => (a > m) > (f :.: g) a > m # foldr :: (a > b > b) > b > (f :.: g) a > b # foldr' :: (a > b > b) > b > (f :.: g) a > b # foldl :: (b > a > b) > b > (f :.: g) a > b # foldl' :: (b > a > b) > b > (f :.: g) a > b # foldr1 :: (a > a > a) > (f :.: g) a > a # foldl1 :: (a > a > a) > (f :.: g) a > a # toList :: (f :.: g) a > [a] # 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: base4.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 # 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 # 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 # 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 # 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 :: Type > Type)  
Defined in Data.Bifunctor.Clown fold :: Monoid m => Clown f a m > m # foldMap :: Monoid m => (a0 > m) > Clown f a a0 > m # foldMap' :: Monoid m => (a0 > m) > Clown f a a0 > m # foldr :: (a0 > b > b) > b > Clown f a a0 > b # foldr' :: (a0 > b > b) > b > Clown f a a0 > b # foldl :: (b > a0 > b) > b > Clown f a a0 > b # foldl' :: (b > a0 > b) > b > Clown f a a0 > b # foldr1 :: (a0 > a0 > a0) > Clown f a a0 > a0 # foldl1 :: (a0 > a0 > a0) > Clown f a a0 > a0 # toList :: Clown f a a0 > [a0] # null :: Clown f a a0 > Bool # length :: Clown f a a0 > Int # elem :: Eq a0 => a0 > Clown f a a0 > Bool # maximum :: Ord a0 => Clown f a a0 > a0 # minimum :: Ord a0 => Clown f a a0 > a0 #  
(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 # 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 # 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 # 
type family Mutable (v :: Type > Type) = (mv :: Type > Type > Type)  mv > v #
Mutable v s a
is the mutable version of the pure vector type v a
with
the state token s
. It is injective on GHC 8 and newer.
class MVector (Mutable v) a => Vector (v :: Type > Type) a #
Class of immutable vectors. Every immutable vector is associated with its
mutable version through the Mutable
type family. Methods of this class
should not be used directly. Instead, Data.Vector.Generic and other
Data.Vector modules provide safe and fusible wrappers.
Minimum complete implementation: