Copyright | (c) Edward Kmett 2009 |
---|---|

License | BSD3 |

Maintainer | ekmett@gmail.com |

Stability | experimental |

Portability | non-portable (MPTCs) |

Safe Haskell | Trustworthy |

Language | Haskell98 |

A `c`

-`Reducer`

is a `Semigroup`

with a canonical mapping from `c`

to the Semigroup.

- class Semigroup m => Reducer c m where
- foldMapReduce :: (Foldable f, Monoid m, Reducer e m) => (a -> e) -> f a -> m
- foldMapReduce1 :: (Foldable1 f, Reducer e m) => (a -> e) -> f a -> m
- foldReduce :: (Foldable f, Monoid m, Reducer e m) => f e -> m
- foldReduce1 :: (Foldable1 f, Reducer e m) => f e -> m
- pureUnit :: (Applicative f, Reducer c n) => c -> f n
- returnUnit :: (Monad m, Reducer c n) => c -> m n
- newtype Count = Count {}

# Documentation

class Semigroup m => Reducer c m where Source

This type may be best read infix. A `c `

is a `Reducer`

m`Semigroup`

`m`

that maps
values of type `c`

through `unit`

to values of type `m`

. A `c`

-`Reducer`

may also
supply operations which tack-on another `c`

to an existing `Monoid`

`m`

on the left
or right. These specialized reductions may be more efficient in some scenarios
and are used when appropriate by a `Generator`

. The names `cons`

and `snoc`

work
by analogy to the synonymous operations in the list monoid.

This class deliberately avoids functional-dependencies, so that () can be a `c`

-Reducer
for all `c`

, and so many common reducers can work over multiple types, for instance,
First and Last may reduce both `a`

and `Maybe`

`a`

. Since a `Generator`

has a fixed element
type, the input to the reducer is generally known and extracting from the monoid usually
is sufficient to fix the result type. Combinators are available for most scenarios where
this is not the case, and the few remaining cases can be handled by using an explicit
type annotation.

Minimal definition: `unit`

Convert a value into a `Semigroup`

Append a value to a `Semigroup`

for use in left-to-right reduction

Prepend a value onto a `Semigroup`

for use during right-to-left reduction

foldMapReduce :: (Foldable f, Monoid m, Reducer e m) => (a -> e) -> f a -> m Source

foldMapReduce1 :: (Foldable1 f, Reducer e m) => (a -> e) -> f a -> m Source

foldReduce :: (Foldable f, Monoid m, Reducer e m) => f e -> m Source

foldReduce1 :: (Foldable1 f, Reducer e m) => f e -> m Source

pureUnit :: (Applicative f, Reducer c n) => c -> f n Source

returnUnit :: (Monad m, Reducer c n) => c -> m n Source