The Monad class defines the basic operations over a monad, a concept from a branch of mathematics known as category theory. From the perspective of a Haskell programmer, however, it is best to think of a monad as an abstract datatype of actions. Haskell's do expressions provide a convenient syntax for writing monadic expressions. Minimal complete definition: >>= and return. Instances of Monad should satisfy the following laws: > return a >>= k == k a > m >>= return == m > m >>= (\x -> k x >>= h) == (m >>= k) >>= h Instances of both Monad and Functor should additionally satisfy the law: > fmap f xs == xs >>= return . f The instances of Monad for lists, Data.Maybe.Maybe and System.IO.IO defined in the Prelude satisfy these laws.
Monads having fixed points with a 'knot-tying' semantics. Instances of MonadFix should satisfy the following laws: * purity mfix (return . h) = return (fix h) * left shrinking (or tightening) mfix (\x -> a >>= \y -> f x y) = a >>= \y -> mfix (\x -> f x y) * sliding mfix (Control.Monad.liftM h . f) = Control.Monad.liftM h (mfix (f . h)), for strict h. * nesting mfix (\x -> mfix (\y -> f x y)) = mfix (\x -> f x x) This class is used in the translation of the recursive do notation supported by GHC and Hugs.
Monads that also support choice and failure.
package
This package provides automated lifting of operations via functional dependencies for the transformers-abort package. Version 0.4
package
package
Monadically map objects to unique ints. Version 0.0.2
package
package
This package defines a monad transformer, applicable to any monad, that allows the monadic computation to suspend and to be later resumed. The transformer is parameterized by an arbitrary functor, used to store the suspended computation's resumption. Version 0.7.1
package
package
package
A type class for monads that have an &quot;unsafeInterleave&quot; operation. Instances are provided for IO and both strict and lazy ST. Version 0.1
package
Some useful control operators for looping. New in 0.3.2.0: various functions for traversing lists and computing minima/maxima using arbitrary procedures to compare or score the elements. Version 0.3.3.0
package
A monad to calculate linear recursive sequence efficiently. Matrix multiplication and fast exponentiation algorithm are used to speed up calculating the number with particular index in the sequence. This library also provides a monadic DSL to describe the sequence. Version 0.0.2.1
package
Memoization monad transformer supporting mutual recursive function definitions and most of the standard monad transformers Version 0.3.0
package
Often we need an efficient way to generate high quality pseudo-random numbers in Haskell. We have good generators themselves (for example, the mersenne-random-pure64 package), however, users are often tempted to store the generator in a lazy state monad. This causes performance problems. This package provides an optimized Rand monad for monadic generation of random numbers from a state, with close attention to performance. You may have results an order of magnitude or more better than using Control.Monad.State to store your generator. Version 0.1
package
This library offers an alternative parallel programming API to that provided by the parallel package. A Par monad allows the simple description of parallel computations, and can be used to add parallelism to pure Haskell code.  The basic API is straightforward: the monad supports forking and simple communication in terms of IVars. The library comes with a work-stealing implementation, but the internals are also exposed so that you can build your own scheduler if necessary. Examples of use can be found in the examples/ directory of the source package. The modules below provide additionaly schedulers, data structures, and other added capabilities layered on top of the Par monad. Version 0.3
package
The modules below provide additional data structures, and other added capabilities layered on top of the Par monad. * Finish These * Module Descriptions Version 0.3.2