Copyright | (c) Andrey Mokhov 2018-2019 |
---|---|

License | MIT (see the file LICENSE) |

Maintainer | andrey.mokhov@gmail.com |

Stability | experimental |

Safe Haskell | None |

Language | Haskell2010 |

This is a library for *selective applicative functors*, or just
*selective functors* for short, an abstraction between applicative functors
and monads, introduced in this paper:
https://www.staff.ncl.ac.uk/andrey.mokhov/selective-functors.pdf.

This module defines *free selective functors* using the ideas from the
Sjoerd Visscher's package 'free-functors':
https://hackage.haskell.org/package/free-functors-1.0.1/docs/Data-Functor-HFree.html.

## Synopsis

- newtype Select f a = Select (forall g. Selective g => (forall x. f x -> g x) -> g a)
- liftSelect :: f a -> Select f a
- getPure :: Select f a -> Maybe a
- getEffects :: Functor f => Select f a -> [f ()]
- getNecessaryEffects :: Functor f => Select f a -> [f ()]
- runSelect :: Selective g => (forall x. f x -> g x) -> Select f a -> g a
- foldSelect :: Monoid m => (forall x. f x -> m) -> Select f a -> m

# Free selective functors

Free selective functors.

liftSelect :: f a -> Select f a Source #

Lift a functor into a free selective computation.

# Static analysis

getPure :: Select f a -> Maybe a Source #

Extract the resulting value if there are no necessary effects.

getEffects :: Functor f => Select f a -> [f ()] Source #

Collect *all possible effects* in the order they appear in a free selective
computation.

getNecessaryEffects :: Functor f => Select f a -> [f ()] Source #

Extract *all necessary effects* in the order they appear in a free
selective computation.

runSelect :: Selective g => (forall x. f x -> g x) -> Select f a -> g a Source #

Given a natural transformation from `f`

to `g`

, this gives a canonical
natural transformation from `Select f`

to `g`

. Note that here we rely on the
fact that `g`

is a lawful selective functor.

foldSelect :: Monoid m => (forall x. f x -> m) -> Select f a -> m Source #

Concatenate all effects of a free selective computation.