Control.RMonad

This module provides alternatives to the Functor, Monad and MonadPlus classes, allowing for constraints on the contained type (a restricted monad). It makes use of associated datatypes (available in GHC 6.8).

To make your own type instances of these classes, first define the Constraints datatype and the Suitable type class for it. For example,

     data instance Constraints Set a = Ord a => SetConstraints
     instance Ord a => Suitable Set a where
        constraints _ = SetConstraints

You need to change Set to your own type, Ord a to your own constraints, and SetConstraints to some distinguished name (this name will not normally be visible to users of your type)

Next you can make an instance of RMonad and if appropriate RMonadPlus by defining the members in the usual way. When you need to make use of the constraint on the contained type, you will need to get hold of the constraint wrapped up in the Constraints datatype. For example here are the instances for Set:

    instance RMonad Set where
       return = Set.singleton
       s >>= f = let res = case constraints res of
                             SetConstraints -> Set.fold (a s' -> Set.union (f a) s') Set.empty s
                 in res
       fail _ = Set.empty

    instance RMonadPlus Set where
       mzero = Set.empty
       mplus s1 s2 = let res = case constraints res of
                                  SetConstraints -> Set.union s1 s2
                     in res

Once you have made your type an instance of RMonad, you can use it in two ways. Firstly, import this module directly and use the RebindableSyntax extension so that do-syntax is rebound. If using ghc<7 use NoImplicitPrelude instead. Secondly, use the wrapper type in Control.RMonad.AsMonad which supports the normal Monad operations.

Documentation

class Suitable m a where

Methods

constraints :: Constraints m a

Instances

Suitable [] a

Suitable IO a

Suitable Maybe a

Ord a => Suitable Set a

Suitable ((->) r) a

(Suitable m a, Suitable m [a]) => Suitable (ListT m) a

(Ord a, Suitable m a, Suitable m (Set a)) => Suitable (SetT m) a

Suitable m a => Suitable (ReaderT r m) a

(Suitable m a, Suitable m r) => Suitable (ContT r m) a

class RFunctor f where

Methods

fmap :: (Suitable f a, Suitable f b) => (a -> b) -> f a -> f b

Instances

RFunctor []

RFunctor IO

RFunctor Maybe

RFunctor Set

RFunctor ((->) r)

class RMonad m where

Methods

return :: Suitable m a => a -> m a

(>>=) :: (Suitable m a, Suitable m b) => m a -> (a -> m b) -> m b

(>>) :: (Suitable m a, Suitable m b) => m a -> m b -> m b

fail :: Suitable m a => String -> m a

Instances

RMonad []

RMonad IO

RMonad Maybe

RMonad Set

RMonad ((->) r)

RMonad m => RMonad (ListT m)

RMonad m => RMonad (SetT m)

RMonad m => RMonad (ReaderT r m)

RMonad m => RMonad (ContT r m)

class RMonad m => RMonadPlus m where

Methods

mzero :: Suitable m a => m a

mplus :: Suitable m a => m a -> m a -> m a

Instances

RMonadPlus []

RMonadPlus Maybe

RMonadPlus Set

(RMonad (ListT m), RMonad m) => RMonadPlus (ListT m)

(RMonad (SetT m), RMonad m) => RMonadPlus (SetT m)

(<=<) :: (RMonad m, Suitable m a, Suitable m b, Suitable m c) => (b -> m c) -> (a -> m b) -> a -> m c

(=<<) :: (RMonad m, Suitable m a, Suitable m b) => (a -> m b) -> m a -> m b

(>=>) :: (RMonad m, Suitable m a, Suitable m b, Suitable m c) => (a -> m b) -> (b -> m c) -> a -> m c

ap :: (RMonad m, Suitable m (a -> b), Suitable m a, Suitable m b) => m (a -> b) -> m a -> m b

filterM :: (RMonad m, Suitable m [a], Suitable m Bool) => (a -> m Bool) -> [a] -> m [a]

foldM :: (RMonad m, Suitable m a) => (a -> b -> m a) -> a -> [b] -> m a

foldM_ :: (RMonad m, Suitable m a, Suitable m ()) => (a -> b -> m a) -> a -> [b] -> m ()

forM :: (RMonad m, Suitable m b, Suitable m [b]) => [a] -> (a -> m b) -> m [b]

forM_ :: (RMonad m, Suitable m b, Suitable m ()) => [a] -> (a -> m b) -> m ()

forever :: (RMonad m, Suitable m a, Suitable m b) => m a -> m b

guard :: (RMonadPlus m, Suitable m ()) => Bool -> m ()

join :: (RMonad m, Suitable m a, Suitable m (m a)) => m (m a) -> m a

liftM :: (RMonad m, Suitable m a1, Suitable m r) => (a1 -> r) -> m a1 -> m r

liftM2 :: (RMonad m, Suitable m a1, Suitable m a2, Suitable m r) => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r

liftM3 :: (RMonad m, Suitable m a1, Suitable m a2, Suitable m a3, Suitable m r) => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r

liftM4 :: (RMonad m, Suitable m a1, Suitable m a2, Suitable m a3, Suitable m a4, Suitable m r) => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r

liftM5 :: (RMonad m, Suitable m a1, Suitable m a2, Suitable m a3, Suitable m a4, Suitable m a5, Suitable m r) => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r

mapAndUnzipM :: (RMonad m, Suitable m (b, c), Suitable m [(b, c)], Suitable m ([b], [c])) => (a -> m (b, c)) -> [a] -> m ([b], [c])

mapM :: (RMonad m, Suitable m b, Suitable m [b]) => (a -> m b) -> [a] -> m [b]

mapM_ :: (RMonad m, Suitable m b, Suitable m ()) => (a -> m b) -> [a] -> m ()

msum :: (RMonadPlus m, Suitable m a) => [m a] -> m a

replicateM :: (RMonad m, Suitable m a, Suitable m [a]) => Int -> m a -> m [a]

replicateM_ :: (RMonad m, Suitable m a, Suitable m ()) => Int -> m a -> m ()

sequence :: (RMonad m, Suitable m a, Suitable m [a]) => [m a] -> m [a]

sequence_ :: (RMonad m, Suitable m a, Suitable m ()) => [m a] -> m ()

unless :: (RMonad m, Suitable m ()) => Bool -> m () -> m ()

when :: (RMonad m, Suitable m ()) => Bool -> m () -> m ()

zipWithM :: (RMonad m, Suitable m c, Suitable m [c]) => (a -> b -> m c) -> [a] -> [b] -> m [c]

zipWithM_ :: (RMonad m, Suitable m c, Suitable m ()) => (a -> b -> m c) -> [a] -> [b] -> m ()