Monad

class Monad m
base Prelude, base Control.Monad, base Control.Monad.Instances
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.
module Control.Monad
base Control.Monad
The Functor, Monad and MonadPlus classes, with some useful operations on monads.
module Data.Graph.Inductive.Monad
fgl Data.Graph.Inductive.Monad
Monadic Graphs
module Data.Graph.Inductive.Query.Monad
fgl Data.Graph.Inductive.Query.Monad
Monadic Graph Algorithms
module Network.CGI.Monad
cgi Network.CGI.Monad
Internal stuff that most people shouldn't have to use. This module mostly deals with the internals of the CGIT monad transformer.
class Monad m => MonadFix m
base Control.Monad.Fix
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.
class Monad m => MonadPlus m
base Control.Monad
Monads that also support choice and failure.
package MonadCatchIO-mtl
package
Provides a monad-transformer version of the Control.Exception.catch function. For this, it defines the MonadCatchIO class, a subset of MonadIO. It defines proper instances for most monad transformers in the mtl library. Version 0.3.0.5
package MonadCatchIO-mtl-foreign
package
Functions like alloca are provided, except not restricted to IO. Version 0.1
package MonadCatchIO-transformers
package
Provides functions to throw and catch exceptions. Unlike the functions from Control.Exception, which work in IO, these work in any stack of monad transformers (from the transformers package) with IO as the base monad. You can extend this functionality to other monads, by creating an instance of the MonadCatchIO class. Warning: this package is deprecated. Use the exceptions package instead, if possible. Version 0.3.1.0
package MonadCatchIO-transformers-foreign
package
Functions like alloca are provided, except not restricted to IO. Version 0.1
class Monad m => MonadCGI m
cgi Network.CGI.Monad, cgi Network.CGI
The class of CGI monads. Most CGI actions can be run in any monad which is an instance of this class, which means that you can use your own monad transformers to add extra functionality.
class Monad m => MonadCont m
mtl Control.Monad.Cont.Class, mtl Control.Monad.Cont
class Monad m => MonadError e m | m -> e
mtl Control.Monad.Error.Class, mtl Control.Monad.Error
The strategy of combining computations that can throw exceptions by bypassing bound functions from the point an exception is thrown to the point that it is handled. Is parameterized over the type of error information and the monad type constructor. It is common to use Either String as the monad type constructor for an error monad in which error descriptions take the form of strings. In that case and many other common cases the resulting monad is already defined as an instance of the MonadError class. You can also define your own error type and/or use a monad type constructor other than Either String or Either IOError. In these cases you will have to explicitly define instances of the Error and/or MonadError classes.
class Monad m => MonadIO (m :: * -> *)
cgi Network.CGI
Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class. Instances should satisfy the following laws, which state that liftIO is a transformer of monads: *  . return = *  (m >>= f) = liftIO m >>= > (liftIO .  
class Monad m => MonadIO m
transformers Control.Monad.IO.Class
Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class. Instances should satisfy the following laws, which state that liftIO is a transformer of monads: *  . return = *  (m >>= f) = liftIO m >>= > (liftIO .  
package Monadius
package
A fast-paced 2-D scrolling vector graphics clone of the arcade game Gradius; it is dedicated to the 20th anniversary of Gradius series. Version 0.99
package MonadLab
package
package MonadPrompt
package
"Prompting" monad that allows splitting the description of a computation from the implementation of the effects used in that computation. http://www.haskell.org/pipermail/haskell-cafe/2008-January/038301.html Version 1.0.0.3
package MonadRandom
package
Support for computations which consume random values. Version 0.1.12
package MonadRandomLazy
package
Support for lazy computations which consume random values. Version 0.1
class Monad m => MonadReader r m | m -> r
mtl Control.Monad.Reader.Class, mtl Control.Monad.Reader
See examples in Control.Monad.Reader. Note, the partially applied function type (->) r is a simple reader monad. See the instance declaration below.
class (Monoid w, MonadReader r m, MonadWriter w m, MonadState s m) => MonadRWS r w s m | m -> r, m -> w, m -> s
mtl Control.Monad.RWS.Class
class Monad m => MonadState s m | m -> s
mtl Control.Monad.State.Class, mtl Control.Monad.State.Lazy, mtl Control.Monad.State.Strict
Minimal definition is either both of get and put or just state
class MonadTrans t
transformers Control.Monad.Trans.Class
The class of monad transformers. Instances should satisfy the following laws, which state that lift is a transformer of monads: *  . return = *  (m >>= f) = lift m >>= > (lift .  
class (Monoid w, Monad m) => MonadWriter w m | m -> w
mtl Control.Monad.Writer.Class, mtl Control.Monad.Writer.Lazy, mtl Control.Monad.Writer.Strict
module Test.QuickCheck.Monadic
QuickCheck Test.QuickCheck.Monadic
Allows testing of monadic values. See the paper "Testing Monadic Code with QuickCheck": http://www.cse.chalmers.se/~rjmh/Papers/QuickCheckST.ps.
package monad-abort-fd
package
This package provides automated lifting of operations via functional dependencies for the transformers-abort package. Version 0.4
package monad-atom
package
package monad-atom-simple
package
Monadically map objects to unique ints. Version 0.0.2
package monad-bool
package
This package has been removed. Version 0.2.0
package monad-codec
package
The library provides functions for encoding and decoding complex data structures with unique integer numbers.  The codec structure can be explicitly defined which distinguishes this package from a monad-atom library. Version 0.2.0
package monad-control
package
This package defines the type class MonadBaseControl, a subset of MonadBase into which generic control operations such as catch can be lifted from IO or any other base monad. Instances are based on monad transformers in MonadTransControl, which includes all standard monad transformers in the transformers library except ContT. See the lifted-base package which uses monad-control to lift IO operations from the base library (like catch or bracket) into any monad that is an instance of MonadBase or MonadBaseControl. Note that this package is a rewrite of Anders Kaseorg's monad-peel library. The main difference is that this package provides CPS style operators and exploits the RankNTypes and TypeFamilies language extensions to simplify and speedup most definitions. The following criterion based benchmark shows that monad-control is on average about 99% faster than monad-peel: git clone https://github.com/basvandijk/bench-monad-peel-control Version 0.3.2.2
package monad-coroutine
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.8
package monad-exception
package
Extensible exceptions are a good solution to the exception problem in Haskell. However, there is one problem: they are not extensible enough! The problem is that the functions defined in Control.Exception for dealing with exceptions can only be used with the IO monad. A lot of Haskell code uses a stack of monads, at the bottom of which is IO, but the IO monad is not used directly. There have been many attempts to solve this problem, but the stumbling block has been the presence of short-circuiting monad transformers: sometimes, these prevented the cleanup actions from being run, making it effectively impossible to catch exceptions in such monads. The monad-control package has been developed as a solution to this problem: it defines a way to turn a monad transformer stack "inside-out", which ensures that cleanup actions are run even when the original action short-circuits. The lifted-base package, built on top of monad-control, exports the Control.Exception.Lifted module, which contains versions of the Control.Exception functions that work on any monad stack with IO at its base. This has pretty much solved the above problems. However, one thing that the solutions that came before monad-control did was provide a type class encapsulating exception functionality that could be implemented by pure monads, allowing you to use the same interface to throw and catch exceptions in both pure and IO-based code. This also makes it possible to express which can throw an exception, but which don't necessarily do any IO and which are polymorphic in their exception throwing (i.e., you could run the function in IO and it would use throwIO, or you could run it as an Either and it would use Left). That's what this package does. It provides a MonadException type class (in the Control.Monad.Exception.Class module), which has instances for IO and IO-like monads (for which monad-control is used to provide the correct instances as described above), as well as for some pure monads. Several overlapping instances (in the spirit of mtl-evil-instances) are provided, so it is not necessary to provide a pass-through instance for MonadException for every monad transformer you write. This package also defines an ExceptionT monad transformer (in Control.Monad.Trans.Exception) that can be used to add MonadException functionality to otherwise pure monad stacks. mtl-evil-instances is used to automatically provide pass-through instances for the mtl type classes for this transformer. Finally, this package includes the module Control.Exception.Monadic, which is a full replacement for Control.Exception, whose functions work on any instance of MonadException and not just IO. The functions for dealing with asynchronous exceptions require IO however, so these are only polymorphic for any IO-like monadic (as determined by monad-control). Version 0.1
package monad-extras
package
package monad-fork
package
package monad-interleave
package
A type class for monads that have an "unsafeInterleave" operation. Instances are provided for IO and both strict and lazy ST. Version 0.1
package monad-logger
package
This package uses template-haskell for determining source code locations of messages. Version 0.3.4.0
package monad-loops
package
Some useful control operators for looping. New in 0.4: STM loop operators have been split into a new package instead of being conditionally-built. 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.4.2

Show more results