Portability | MPTCs, fundeps |
---|---|

Stability | provisional |

Maintainer | Edward Kmett <ekmett@gmail.com> |

Safe Haskell | Safe-Infered |

The free monad transformer

# Documentation

The "free monad transformer" for a functor `f`

.

(Functor f, Monad m) => MonadFree f (FreeT f m) | |

MonadTrans (FreeT f) | |

(Functor f, Monad m) => Monad (FreeT f m) | |

(Functor f, Monad m) => Functor (FreeT f m) | |

(Typeable1 f, Typeable1 w) => Typeable1 (FreeT f w) | |

(Functor f, MonadPlus m) => MonadPlus (FreeT f m) | |

(Functor f, Monad m) => Applicative (FreeT f m) | |

(Foldable m, Foldable f) => Foldable (FreeT f m) | |

(Monad m, Traversable m, Traversable f) => Traversable (FreeT f m) | |

(Functor f, MonadPlus m) => Alternative (FreeT f m) | |

(Functor f, MonadIO m) => MonadIO (FreeT f m) | |

Eq (m (FreeF f a (FreeT f m a))) => Eq (FreeT f m a) | |

(Typeable1 f, Typeable1 w, Typeable a, Data (w (FreeF f a (FreeT f w a))), Data a) => Data (FreeT f w a) | |

Ord (m (FreeF f a (FreeT f m a))) => Ord (FreeT f m a) | |

Read (m (FreeF f a (FreeT f m a))) => Read (FreeT f m a) | |

Show (m (FreeF f a (FreeT f m a))) => Show (FreeT f m a) |

class Monad m => MonadFree f m | m -> f whereSource

Monads provide substitution (`fmap`

) and renormalization (`join`

):

m`>>=`

f =`join`

.`fmap`

f m

A free `Monad`

is one that does no work during the normalization step beyond simply grafting the two monadic values together.

`[]`

is not a free `Monad`

(in this sense) because

smashes the lists flat.
`join`

[[a]]

On the other hand, consider:

data Tree a = Bin (Tree a) (Tree a) | Tip a

instance`Monad`

Tree where`return`

= Tip Tip a`>>=`

f = f a Bin l r`>>=`

f = Bin (l`>>=`

f) (r`>>=`

f)

This `Monad`

is the free `Monad`

of Pair:

data Pair a = Pair a a

And we could make an instance of `MonadFree`

for it directly:

instance`MonadFree`

Pair Tree where`wrap`

(Pair l r) = Bin l r

Or we could choose to program with

instead of `Free`

Pair`Tree`

and thereby avoid having to define our own `Monad`

instance.

Moreover, the `kan-extensions`

package provides `MonadFree`

instances that can
improve the *asymptotic* complexity of code that constructors free monads by
effectively reassociating the use of (`>>=`

).

See `Free`

for a more formal definition of the free `Monad`

for a `Functor`

.

(Functor f, MonadFree f m) => MonadFree f (ListT m) | |

(Functor f, MonadFree f m) => MonadFree f (IdentityT m) | |

(Functor f, MonadFree f m) => MonadFree f (MaybeT m) | |

Functor f => MonadFree f (Free f) | |

(Functor f, MonadFree f m, Error e) => MonadFree f (ErrorT e m) | |

(Functor f, MonadFree f m, Monoid w) => MonadFree f (WriterT w m) | |

(Functor f, MonadFree f m, Monoid w) => MonadFree f (WriterT w m) | |

(Functor f, MonadFree f m) => MonadFree f (StateT s m) | |

(Functor f, MonadFree f m) => MonadFree f (StateT s m) | |

(Functor f, MonadFree f m) => MonadFree f (ReaderT e m) | |

(Functor f, Monad m) => MonadFree f (FreeT f m) | |

(Functor f, MonadFree f m, Monoid w) => MonadFree f (RWST r w s m) | |

(Functor f, MonadFree f m, Monoid w) => MonadFree f (RWST r w s m) |