| Portability | portable |
|---|---|
| Stability | experimental |
| Maintainer | ekmett@gmail.com |
| Safe Haskell | Safe-Infered |
Data.Generator
Description
A Generator c is a possibly-specialized container, which contains values of
type Elem c, and which knows how to efficiently apply a Reducer to extract
an answer.
Since a Generator is not polymorphic in its contents, it is more specialized
than Data.Foldable.Foldable, and a Reducer may supply efficient left-to-right
and right-to-left reduction strategies that a Generator may avail itself of.
- class Generator c where
- newtype Keys c = Keys {
- getKeys :: c
- newtype Values c = Values {
- getValues :: c
- newtype Char8 c = Char8 {
- getChar8 :: c
- reduce :: (Generator c, Elem c `Reducer` m) => c -> m
- mapReduceWith :: (Generator c, e `Reducer` m) => (m -> n) -> (Elem c -> e) -> c -> n
- reduceWith :: (Generator c, Elem c `Reducer` m) => (m -> n) -> c -> n
Generators
Methods
mapReduce :: e `Reducer` m => (Elem c -> e) -> c -> mSource
mapTo :: e `Reducer` m => (Elem c -> e) -> m -> c -> mSource
mapFrom :: e `Reducer` m => (Elem c -> e) -> c -> m -> mSource
Instances
| Generator ByteString | |
| Generator ByteString | |
| Generator IntSet | |
| Generator Text | |
| Generator [c] | |
| Generator (Seq c) | |
| Generator (IntMap v) | |
| Generator (Set a) | |
| Generator (Char8 ByteString) | |
| Generator (Char8 ByteString) | |
| Ix i => Generator (Values (Array i e)) | |
| Generator (Values (Map k v)) | |
| Generator (Values (IntMap v)) | |
| Ix i => Generator (Keys (Array i e)) | |
| Generator (Keys (Map k v)) | |
| Generator (Keys (IntMap v)) | |
| Ix i => Generator (Array i e) | |
| Generator (Map k v) | |
| Measured v e => Generator (FingerTree v e) |
Generator Transformers
a Generator transformer that asks only for the keys of an indexed container
a Generator transformer that asks only for the values contained in an indexed container
a Generator transformer that treats Word8 as Char
This lets you use a ByteString as a Char source without going through a Monoid transformer like UTF8
Instances
Combinators
mapReduceWith :: (Generator c, e `Reducer` m) => (m -> n) -> (Elem c -> e) -> c -> nSource
reduceWith :: (Generator c, Elem c `Reducer` m) => (m -> n) -> c -> nSource