base-compat-0.4.0: A compatibility layer for base

Data.Foldable.Compat

Synopsis

# Documentation

class Foldable t where

Data structures that can be folded.

Minimal complete definition: `foldMap` or `foldr`.

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
```

Methods

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.

``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 :: (a -> b -> a) -> a -> t b -> a

Left-associative fold of a structure.

``foldl` f z = `foldl` f z . `toList``

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

Left-associative fold of a structure. but with strict application of the operator.

``foldl` f z = `foldl'` f z . `toList``

foldr1 :: (a -> a -> a) -> t a -> a

A variant of `foldr` that has no base case, and thus may only be applied to non-empty structures.

``foldr1` f = `foldr1` f . `toList``

foldl1 :: (a -> a -> a) -> t a -> a

A variant of `foldl` that has no base case, and thus may only be applied to non-empty structures.

``foldl1` f = `foldl1` f . `toList``

Instances

 Foldable [] Foldable Maybe Foldable (Either a) Foldable ((,) a) Ix i => Foldable (Array i) Foldable (Const m)