Algebra.Foldable

Documentation

class Functor t => Foldable t where

Methods

fold :: Monoid m => t m -> m

Instances

Foldable []

Foldable Maybe

Foldable Tree

Foldable Set

Foldable Interleave

Foldable OrdList

Foldable Id

Foldable ZipTree

Foldable ZipList

Foldable TimeVal

Foldable (Either a)

Foldable ((,) a)

Foldable (Map k)

Foldable m => Foldable (MaybeT m)

Foldable m => Foldable (TreeT m)

Foldable m => Foldable (ListT m)

Foldable (Future t)

Foldable (Event t)

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

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

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

(Foldable f, Foldable g) => Foldable (Compose' f g)

Foldable m => Foldable (WriterT w m)

Foldable m => Foldable (EitherT e m)

Foldable m => Foldable (RWST Void w Void m)

newtype Sized f a

Constructors

Sized

Fields

getSized :: f a

Instances

(Foldable f, Semigroup (Sized f a), Monoid n, Num n) => SubSemi n (Sized f a)

foldMap :: (Monoid m, Foldable t) => (a -> m) -> t a -> m

convert :: (Unit f, Monoid (f a), Foldable t) => t a -> f a

concat :: (Monoid m, Foldable t) => t m -> m

sum :: (Monoid m, Foldable t) => t m -> m

size :: (Foldable f, Num n, Monoid n) => f a -> n

count :: (Num n, Monoid n, Foldable f) => f a -> n

length :: (Num n, Monoid n) => [a] -> n

split :: (Foldable t, Monoid b, Monoid c) => t (b :+: c) -> (b, c)

partitionEithers :: (Foldable t, Unit t, Monoid (t a), Monoid (t b)) => t (a :+: b) -> (t a, t b)

partition :: (Unit f, Monoid (f a), Foldable t) => (a -> Bool) -> t a -> (f a, f a)

filter :: (Unit f, Monoid (f a), Foldable t) => (a -> Bool) -> t a -> f a

select :: (Unit f, Monoid (f a), Foldable t) => (a -> Bool) -> t a -> f a

refuse :: (Unit f, Monoid (f a), Foldable t) => (a -> Bool) -> t a -> f a

compose :: (Category k, Foldable t) => t (k a a) -> k a a

foldr :: Foldable t => (b -> a -> a) -> a -> t b -> a

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

foldl' :: Foldable t => (a -> b -> a) -> a -> t b -> a

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

toList :: Foldable t => t a -> [a]

find :: Foldable t => (a -> Bool) -> t a -> Maybe a

or :: Foldable t => t Bool -> Bool

and :: Foldable t => t Bool -> Bool

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

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

elem :: (Eq a, Foldable t) => a -> t a -> Bool

empty :: Foldable f => f a -> Bool