ru_lambda: Товарищи, а что бы вы дописали / исправи

{-# Language MultiParamTypeClasses,FunctionalDependencies #-}
module Control.Monad.Classes
where
import Data.Monoid
-- | class for monad transformer itself
class MonadTrans t where
lift :: Monad m => m a -> t m a
-- | class for monads , that allows io
class Monad m => MonadIO m where
liftIO :: IO a -> m a
-- | IO monad allows io ^_^
instance MonadIO IO where
liftIO = id
-- | class for monads that accumulates some results in internal state
class (Monad m,Monoid w) => MonadAccum m w|m -> w where
-- | one more value to be accumulated
accum :: w -> m ()
-- ignore values from specific piece of code
ignore :: m () -> m ()
-- todo: par:: [m ()] -> m ()
-- | class for continuation monad. useful for complex control flow
class Monad m => MonadCont m r | m -> r where
-- | return immidiatly. escapes the whole tail
exit :: r -> m a
-- | a kind of local escape mechanism.
callCC :: ((a -> m b) -> m a) -> m a
-- | class for error handling.
class Monad m => MonadError m e | m -> e where
-- | handle errors from some piece of code
catching :: (e -> m a) -> m a -> m a
-- | signal an error. skip all folloing actions until error is catched
throw :: e -> m a
-- | class for monads, that processes some array of data and returns some value
class Monad m => MonadProc m r p | m -> p, m -> r where
-- | try to get next value. if no next value, execute specific action
next :: m r -> m p
-- | class for query's . It's a kind of ListT.
class Monad m => MonadQuery m where
-- combine values from some queries.
qapp :: m a -> m a -> m a
-- mark this line of query as fail and stop processing it
stop :: m a
-- | class for read-only state. does allow local monad filtering of state.
class Monad m => MonadReader m v | m -> v where
-- | query environment
ask :: m v
-- | modify environment for some action
local :: v -> m a -> m a
-- | class for mutable state
class Monad m => MonadState m s | m -> s where
-- take state
get :: m s
-- put state
put :: s -> m ()
-- | class for writer monad. showld be used for loggers.
class (Monad m) => MonadWrite m w | m -> w where
-- | write some output
tell :: w -> m ()
-- | skip some output
skip :: m a -> m a