^      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNO P Q R S T U V W X Y Z [ \ ] None!2 represents the class of monad lifts that support ! lifting control operations. See Documentation.Layers.Overview for a more  complete discussion.  is a version of  that makes it possible to lift ( control operations from an inner monad i to the "outer" monad m. B It takes a continuation, to which it passes an operation we call run,  which is a kind of "inverse" of lift. -Instances should satisfy the following laws: Identity %liftControl . const . return = return  Composition  1liftControl (const m) >>= liftControl . const . f = liftControl (const (m >>= f))  Preservation join (liftControl (\run -> run t)) = t The type class % represents is the subclass of monad  lifts that support the , operation, which is more powerful than the   operation of the  type class. ; represents an (endo)functor in the category of monads. It  takes a transformation f of an inner monad i returns a  transformation of m analogous to f . (i.e.,  liftInvmap lifts an  endomorphism of i to an endomorphism of m). /The following laws hold for valid instances of :  Identity liftMap id = id  Composition 'liftMap f . liftMap g = liftMap (f . g) The difference between  and  is that layerMap only C lifts from the monad directly beneath the top of the stack, while  liftMap can lift from any( monad anywhere in the stack (including  m itself). (layerMap is used to implement liftMap) = is a multi-parameter type class parameterised by two monads  i and m. If the constraint  MonadLift i m is satisfied, this means  that m" supports lifting operations from i. If m is a monad built from I a monad transformer stack, then it supports lifting operations from any  monad i< anywhere in the stack. We call such a relationship between i  and m a " monad lift"(. For a more details, read the in-depth  documentation provided in Documentation.Layers.Overview. ) takes a computation from an inner monad i and lifts it into  the "outer" monad m. /The following laws hold for valid instances of :  Identity lift . return = return  Composition $lift m >>= lift . f = lift (m >>= f) ?These laws are equivalent to the monad transformer laws of the     class from the  transformers  package. 7 represents an invariant (endo)functor in the category & of monads. It takes a transformation f of an inner monad i and its  inverse g (such that  g . f = id ) and returns transformation of m  analogous to f . (i.e.,  liftInvmap lifts an automorphism of i  to an endomorphism of m). /The following laws hold for valid instances of :  Identity liftInvmap id id = id  Composition  liftInvmap f g . liftInvmap f' g' = liftInvmap (f . f') (g' . g) The difference between  and  is that   layerInvmap; only lifts from the monad directly beneath the top of the  stack, while  liftInvmap can lift from any monad anywhere in the  stack (including m itself). ( layerInvmap is used to implement   liftInvmap)  is a variant of  for monad I transformers, i.e., monad layers polymorphic in their inner monad. This A extra polymorphism allows us to specify more type safety in the run  operation of  1, but in practice there is no reason to ever use  this over MonadLayerControl. See Documentation.Layers.Overview for a E discussion of why this class is included despite not being strictly  necessary.   is a version of  whose run operation C is more polymorphic in the returned monad. This provides a static 7 guarantee that there are no remaining side effects in m in the action  returned by run4 which is not possible to express with the types of  2. In practice though there should be no reason to  use this over . The type class   represents is the subclass of  monad layers that support the  # operation, which is more powerful  than the  operation of the   type class.  : represents a functor in the category of monads. It takes  a transformation f4 from the inner monad returns a transformation from  m analogous to f . (i.e., transMap lifts a homomorphism from   m to a homomorphism from m). /The following laws hold for valid instances of  :  Identity transMap id = id  Composition *transMap f . transMap g = transMap (f . g) !Note: this is more powerful than  from the  3 type class because the transformation it produces 5 is a homomorphism rather than just an endomorphism. JMonad transformers are a subclass of monad layers which are parametric in  their inner monad.   m% is the monad constructor from which m is built (by  applying it to  m). 4 represents an invariant functor in the category of # monads. It takes a transformation f from the inner monad and its  inverse g (such that  g . f = id ) and returns transformation of m  analogous to f . (i.e.,  layerInvmap lifts an isomorphism from   m to a homomorphism of m). /The following laws hold for valid instances of  :  Identity transInvmap id id = id  Composition  transInvmap f g . transInvmap f' g' = transInvmap (f . f') (g' . g) !Note: this is more powerful than  from the  E type class because the transformation it produces is a homomorphism # rather than just an endomorphism. 7 represents the class of monad layers through which it - is possible to lift control operations. See Documentation.Layers.Overview ! for a more complete discussion. $The portion of the monadic state of m that is independent of   m.  inspects a ( value and determines whether or not it  is a "zero" value in the monad m (i.e., if m had short-circuited  when the  LayerState/ was captured). (This is used to implement the $ universal pass-through instance of   .)  Construct a m' computation from the monadic state of m that is  returned from a run function given by  layerControl. ,Instances should satisfy the following law:  Preservation layerControl (\run -> run t) >>= restore = t  is a version of  that makes it possible to lift ) control operations from the inner monad  m to the "outer"  monad m>. It takes a continuation, to which it passes an operation we  call run, which is a kind of "inverse" of layer. EInstances should satisfy similar laws as the monad transformer laws: Identity &layerControl . const . return = return  Composition  3layerControl (const m) >>= layerControl . const . f = layerControl (const (m >>= f)) The type class  represents is the subclass of  monad layers that support the # operation, which is more powerful  than the  operation of the  type class. ; represents an (endo)functor in the category of monads. It  takes a transformation f- of the inner monad returns a transformation  of m analogous to f . (i.e., layerMap lifts an endomorphism of   m to a endomorphism of m). /The following laws hold for valid instances of : Identity layerMap id = id  Composition  *layerMap f . layerMap g = layerMap (f . g) A monad m can be an instance of  if it is built  ("layered") on top of some inner monad ( m) and can provide the  operations  and . BMonad layers are a generalisation of monad transformers, with the L difference being that monad layers are not necessarily parametric in their D inner monad. For more details, read the the in-depth documentation  provided in Documentation.Layers.Overview.  The inner monad on top of which m is built. * takes a computation from the inner monad  m and  lifts it into the "outer" monad m. /The following laws hold for valid instances of :  Identity layer . return = return  Composition 'layer m >>= layer . f = layer (m >>= f) ?These laws are equivalent to the monad transformer laws of the     class from the  transformers,  where layer is analgous to the    operation from  MonadTrans. 7 represents an invariant (endo)functor in the category & of monads. It takes a transformation f of the inner monad and its  inverse g (such that  g . f = id ) and returns transformation of m  analogous to f . (i.e.,  layerInvmap lifts an automorphism of   m to an endomorphism of m). /The following laws hold for valid instances of : Identity layerInvmap id id = id  Composition  layerInvmap f g . layerInvmap f' g' = layerInvmap (f . f') (g' . g) An often used composition:  f =  f >>=  layerOp is a particular application of  that allows layering  control operations of type: (a ->  m b) ->  m b to   m => (a -> m b) -> m b.  For example: layerOp . withMVar :: ( m,  m ~ ^) # => MVar a -> (a -> m b) -> m blayerOp_ is a particular application of  that allows & layering control operations of type:  m a ->  m b to   m => m a -> m b.  For example: layerOp_ mask_ :: ( m,  m ~ ^) => m a -> m a layerDiscard is a particular application of  that allows & layering control operations of type:  m () ->  m a to   m => m () -> m a. *Note that, while the argument computation m () has access to the captured  state, all its side-effects in m' are discarded. It is run only for its ! side-effects in the inner monad  m.  For example: layerDiscard forkIO :: ( m,  m ~ ^)  => m () -> m ThreadIdAn often used composition:  f = join .  f liftOp is a particular application of  that allows lifting  control operations of type: (a -> i b) -> i b to   i m => (a -> m b) -> m b.  For example: liftOp . withMVar ::  ^! m => MVar a -> (a -> m b) -> m b liftOp_ is a particular application of  that allows % lifting control operations of type:  i a -> i b to   i m => m a -> m b.  For example: liftOp_ mask_ ::  ^ m => m a -> m a! liftDiscard is a particular application of  that allows % lifting control operations of type:  i () -> i a to   i m => m () -> m a. *Note that, while the argument computation m () has access to the captured  state, all its side-effects in m' are discarded. It is run only for its ! side-effects in the inner monad i.  For example: liftDiscard forkIO ::  ^ m => m () -> m ThreadIdk f g  !_`abcdefghijklmnopqrstuvwxyz{|}~!  !!    ![    !_`abcdefghijklmnopqrstuvwxyz{|}~None"The "; interface represents computations in continuation-passing M style (CPS). In continuation-passing style function result is not returned, D but instead is passed to another function, received as a parameter D (continuation). Computations are built up from sequences of nested M continuations, terminated by a final continuation (often id) which produces I the final result. Since continuations are functions which represent the I future of a computation, manipulation of the continuation functions can I achieve complex manipulations of the future of the computation, such as C interrupting a computation in the middle, aborting a portion of a F computation, restarting a computation, and interleaving execution of  computations. The  MonadCont, interface adapts CPS to the structure of a  monad. Before using the  MonadCont) interface, be sure that you have a firm D understanding of continuation-passing style and that continuations E represent the best solution to your particular design problem. Many J algorithms which require continuations in other languages do not require  them in Haskell, due to Haskell's lazy semantics. Abuse of the  MonadCont K interface can produce code that is impossible to understand and maintain. ##< (call-with-current-continuation) calls a function with the G current continuation as its argument. Provides an escape continuation % mechanism for use with instances of  MonadCont. Escape continuations H allow to abort the current computation and return a value immediately. " They achieve a similar effect to   and   from the   interface. ) Advantage of this function over calling return is that it makes the F continuation explicit, allowing more flexibility and better control. The standard idiom used with callCC# is to provide a lambda-expression H to name the continuation. Then calling the named continuation anywhere G within its scope will escape from the computation, even if it is many * layers deep within nested computations. "#"#"#"#None $You need this when using ). &The &5 type class represents the class of monads which can  ' and ( exceptions. This includes ^-based monads as well as  -like monads. Minimal complete definition: ', (. '3Throw an exception that can be caught by the monad m. (EThis is the simplest of the exception-catching functions. It takes a = single argument, runs it, and if an exception is raised the "handler" E is executed, with the value of the exception passed as an argument. ; Otherwise, the result is returned as normal. For example:  / catch (readFile f) (\(e :: IOException) -> do G hPutStr stderr ("Warning: Couldn't open " ++ f ++ ": " ++ show e)  return "") ENote that we have to give a type signature to e, or the program will G not typecheck as the type is ambiguous. While it is possible to catch ) exceptions of any type, see the section "Catching all exceptions" in  Control.Exception3 for an explanation of the problems with doing so. GFor catching exceptions in pure (non-IO) expressions, see the function  evaluate. Note that due to Haskell'.s unspecified evaluation order, an expression G may throw one of several possible exceptions: consider the expression  (error "urk") + (1  0). Does the expression throw   ErrorCall "urk", or  DivideByZero? The answer is "it might throw either"; the choice is G non-deterministic. If you are catching any type of exception then you 8 might catch either. If you are calling catch with type  +m Int -> (ArithException -> m Int) -> m Int then the handler may get  run with  DivideByZero as an argument, or an  ErrorCall "urk" I exception may be propogated further up. If you call it again, you might 3 get a the opposite behaviour. This is ok, because ( is a monadic  computation. )HSometimes you want to catch two different sorts of exception. You could  do something like  < f = expr `catch` \(ex :: ArithException) -> handleArith ex < `catch` \(ex :: IOException) -> handleIO ex IHowever, there are a couple of problems with this approach. The first is F that having two exception handlers is inefficient. However, the more J serious issue is that the second exception handler will catch exceptions - in the first, e.g. in the example above, if  handleArith throws an   IOException2 then the second exception handler will catch it. Instead, we provide a function ), which would be used thus: K f = expr `catches` [Handler (\ (ex :: ArithException) -> handleArith ex), K Handler (\ (ex :: IOException) -> handleIO ex)] * The function * is like (!, but it takes an extra argument  which is an exception predicate), a function which selects which type of  exceptions we're interested in.  A catchJust (\e -> if isDoesNotExistErrorType (ioeGetErrorType e)  then Just ()  else Nothing)  (readFile f)  (\_ -> do = hPutStrLn stderr ("No such file: " ++ show f)  return "") KAny other exceptions which are not matched by the predicate are re-raised, # and may be caught by an enclosing (, *, etc. + A version of (. with the arguments swapped around; useful in E situations where the code for the handler is shorter. For example: = do handle (\NonTermination -> exitWith (ExitFailure 1)) $  ... , A version of *( with the arguments swapped around (see  +). - Similar to (, but returns an  result which is ( a)  if no exception of type e was raised, or ( ex) if an exception of  type e was raised and its value is ex!. If any other type of exception I is raised than it will be propogated up to the next enclosing exception  handler. 1 try a = catch (Right `liftM` a) (return . Left) . A variant of -3 that takes an exception predicate to select which  exceptions are caught (c.f. *$). If the exception does not match ! the predicate, it is re-thrown. Cheeky orphan instance of  for . This allows   SomeException to be used with the  monad transformer, and thus a  & instance to be defined for ErrorT SomeException. $%&'()*+,-. $%&'()*+,-. &'()$%*+,-.$%&'()*+,-.None/The /9 type class is for dealing with asynchronous exceptions.  It contains the 0 and 1 operations for  getting and setting the % of the current thread. However, you A should never need to use these operations: in particular, using  setMaskingState: can violate some invariants which are assumed internally M by this library. The only reason these functions are exposed at all is that ! they are necessary to implement 2 (which is what you should use  instead), and unlike 2,, their simpler type signature allows us to - define a universal pass-through instance of  MonadMask through any  , while mask would require  . Every monad should be an instance of  MonadMask, and we have provided ' instances for every base monad in the base and  transformers packages.  getMaskingState and setMaskingState$ have default definitions that only & need to be overridden in the case of ^ and monads layered on top of IO I (which we have already done), so it costs nothing to add an instance of   MonadMask to a monad. ( MonadMask$ is a prerequisite for implementing   , which provides the   ' family of functions, which is perhaps  more interesting than  MonadMask on its own.) 1Minimal complete definition: instance head only. 0 Returns the  for the current thread. 1 Sets the , for the current thread to the given value. 24Executes a computation with asynchronous exceptions masked . That is, L any thread which attempts to raise an exception in the current thread with  / will be blocked until asynchronous exceptions  are unmasked again. The argument passed to 2* is a function that takes as its argument M another function, which can be used to restore the prevailing masking state L within the context of the masked computation. For example, a common way to  use 2. is to protect the acquisition of a resource:   mask $ \restore -> do  x <- acquire 5 restore (do_something_with x) `finally` release This code guarantees that acquire is paired with release , by masking I asynchronous exceptions for the critical parts. (Rather than write this * code yourself, it would be better to use bracket which abstracts the  general pattern). Note that the restore" action passed to the argument to mask does not J necessarily unmask asynchronous exceptions, it just restores the masking M state to that of the enclosing context. Thus if asynchronous exceptions are  already masked, mask4 cannot be used to unmask exceptions again. This is K so that if you call a library function with exceptions masked, you can be L sure that the library call will not be able to unmask exceptions again. If K you are writing library code and need to use asynchronous exceptions, the ) only way is to create a new thread; see  . KAsynchronous exceptions may still be received while in the masked state if  the masked thread blocks in certain ways; see  Control.Exception#interruptible. Threads created by  inherit the masked H state from the parent; that is, to start a thread in blocked mode, use  mask_ $ fork ...8. This is particularly useful if you need to establish C an exception handler in the forked thread before any asynchronous  exceptions are received. 3Like 2, but does not pass a restore action to the argument. 4Like 27, but the masked computation is not interruptible (see  Control.Exception#interruptible(). THIS SHOULD BE USED WITH GREAT CARE, " because if a thread executing in 4 blocks for any H reason, then the thread (and possibly the program, if this is the main K thread) will be unresponsive and unkillable. This function should only be M necessary if you need to mask exceptions around an interruptible operation, L and you can guarantee that the interruptible operation will only block for  a short period of time. 5Like 4, but does not pass a restore action to the  argument. /012345/012345/012345/012345None6The 68 type class, for monads which support a fork operation. JAn example of a monad which has a MonadFork instance that is not simply a  lifted form of forkIO is the  ResourceT monad from the  resourcet % package, which defines an operation resourceForkIO. 7CSparks off a new thread to run the computation passed as the first  argument, and returns the  of the newly  created thread. BThe new thread will be a lightweight thread; if you want to use a 5 foreign library that uses thread-local storage, use   instead. (Note that forkOS is not  included in the 6 interface, so your monad m must be an  instance of  'IO m to be able to use  forkOS. FGHC note: the new thread inherits the masked state of the parent (see  ). DThe newly created thread has an exception handler that discards the  exceptions ,  , and  %, and passes all other exceptions to ! the uncaught exception handler. 8Like 75, but lets you specify on which processor the thread  should run. Unlike a 7 thread, a thread created by 8 will 5 stay on the same processor for its entire lifetime (7 threads can A migrate between processors according to the scheduling policy).  8> is useful for overriding the scheduling policy when you know 0 in advance how best to distribute the threads. The - argument specifies a capability number (see   ). Typically capabilities ? correspond to physical processors, but the exact behaviour is / implementation-dependent. The value passed to 8 is interpreted 8 modulo the total number of capabilities as returned by   . 9GHC note: the number of capabilities is specified by the +RTS -N I option when the program is started. Capabilities can be fixed to actual  processor cores with +RTS -qa$ if the underlying operating system F supports that, although in practice this is usually unnecessary (and E may actually degrade perforamnce in some cases - experimentation is  recommended). 9Like 7=, but the child thread is passed a function that can be used L to unmask asynchronous exceptions. This function is typically used in the  following way  , ... mask_ $ forkIOWithUnmask $ \unmask -> , catch (unmask ...) handler Fso that the exception handler in the child thread is established with M asynchronous exceptions masked, meanwhile the main body of the child thread $ is executed in the unmasked state. Note that the unmask4 function passed to the child thread should only be G used in that thread; the behaviour is undefined if it is invoked in a  different thread. :Like 93, but the child thread is pinned to the given CPU,  as with 8. 6789:6789:6789:6789:None ;The type class ;. represents the class of monads which support  mutable variables. The ref0 parameter is the type of the mutable variable;  e.g., for ^, ref is . Minimal complete definition: <, =, >. <:Create a new mutable variable holding the value supplied. =9Return the current value stored in the mutable variable. >4Write the supplied value into the mutable variable ?8Atomically modifies the contents of a mutable variable. GThis function is useful for using mutable varibales in a safe way in a D multithreaded program. If you only have one mutable variable, then  using ?+ to access and modify it will prevent race  conditions. FExtending the atomicity to multiple mutable variables is problematic, G so it is recommended that if you need to do anything more complicated  then using !" instead is a good idea. ?/ does not apply the function strictly. This is E important to know even if all you are doing is replacing the value. % For example, this will leak memory:   ref <- newIORef 1 / forever $ atomicModifyRef ref (\_ -> (2, ())) Use @ or C to avoid this problem. @Strict version of ?'. This forces both the value stored in 5 the mutable variable as well as the value returned. A+Mutate the contents of a mutable variable. Be warned that A2 does not apply the function strictly. This means  if the program calls  modifyRef* many times, but seldomly uses the value, K thunks will pile up in memory resulting in a space leak. This is a common J mistake made when using a mutable varible as a counter. For example, the 1 following will likely produce a stack overflow:   ref <- newRef 0 * replicateM_ 1000000 $ modifyRef ref (+1)  readRef ref >>= print To avoid this problem, use B instead. BStrict version of A. C Variant of > with the "barrier to reordering" property that  ? has. ;<=>?@ABC ;<=>?@ABC ;<=>?@CAB ;<=>?@ABCNoneDThe 'CMonadReader interface monad represents computations which can read I values from a shared environment, pass values from function to function D and execute sub-computations in a modified environment. Using the   MonadReader= interface for such computations is often clearer and easier  than using the # interface. Minimal complete definition: G and one of either E or F. E-Embed a simple reader action into the monad. F!Retrieves the monad environment. G2Executes a computation in a modified environment. H1Retrieves a function of the current environment. DEFGHDEFGHDEFGHDEFGHNoneIDA pure functional language cannot update values in place because it M violates referential transparency. A common idiom to simulate such stateful  computations is to "thread") a state parameter through a sequence of  functions: KThis approach works, but such code can be error-prone, messy and difficult  to maintain. The I, interface hides the threading of the state H parameter inside the binding operation, simultaneously making the code 8 easier to write, easier to read and easier to modify. Minimal complete definition: J or both K and L. J,Embed a simple state action into the monad. K2Return the state from the internals of the monad. L$Replace the state inside the monad. MMonadic state transformer. HMaps an old state to a new state inside a state monad. The old state is  thrown away. :t modify ((+1) :: Int -> Int)*modify (...) :: (MonadState Int a) => a ()This says that  modify (+1) acts over any  that is a member of the  I class with an  state. NBGets specific component of the state, using a projection function  supplied. IJKLMNIJKLMNIJKLMN IJKLMN NoneO;It is often desirable for a computation to generate output "on the  side"D. Logging and tracing are the most common examples in which data is F generated during a computation that we want to retain but is not the $ primary result of the computation. LExplicitly managing the logging or tracing data can clutter up the code and 4 invite subtle bugs such as missed log entries. The O interface I provides a cleaner way to manage the output without cluttering the main  computation. Minimal complete definition: R, S and one of either P or  Q. PP (a,w) embeds a simple writer action. QQ w' is an action that produces the output w. RR m' is an action that executes the action m and adds its ) output to the value of the computation. SS m' is an action that executes the action m, which returns a G value and a function, and returns the value, applying the function to  the output. TT f m' is an action that executes the action m and adds the  result of applying f0 to the output to the value of the computation. 9 listens f m = liftM (\(~(a, w)) -> (a, f w)) (listen m) UU f m' is an action that executes the action m and  applies the function f) to its output, leaving the return value  unchanged. + censor f m = pass (liftM (\a -> (a,f)) m) OPQRSTUOPQRSTUOPQRSTU OPQRSTU NoneVThe V/ interface is defined as a type synonym (using  the ConstraintKinds# extension) for the combination of D,  I and O. VDEFGHIJKLMNOPQRSTUVVV NoneWThe W( type class provides a single operation X , which is a M way to observe short-circuiting in monads. The name refers to the fact that  mtry is a generalised version of $:  whereas try' guards against the specific case of a   short-circuiting due to L an exception being thrown, it can still short-circuit in other ways: e.g.,  if a %& ^ returns  '( (). The action returned by X is $ guaranteed to never short-circuit. .Nearly every monad should have an instance of MonadTry , with the D exception of CPS-style monads whose (possible) short-circuiting is > impossible to observe. Instances for every base monad in the base and   transformers packages. mtry* has a default definition that only needs G to be overridden for monads which actually short-circuit, so it costs # very little to add an instance of MonadTry to a monad. 1Minimal complete definition: instance head only. XX takes a monadic action in m! and returns a new monadic value  in m9 which is guaranteed not to short-circuit. If the action m that  was given to mtry( would have short-circuited, it returns Left m,  otherwise it returns Right a, where a is the value returned by the  computation m. YDWhen you want to acquire a resource, do some work with it, and then 0 release the resource, it is a good idea to use Y , because bracket I will install the necessary handler to release the resource in the event D that the monad short circuits during the computation. If the monad  short-circuits, then bracket! will re-return the monad in its 7 short-circuited state (after performing the release). $A common example is opening a file:   bracket " (openFile "filename" ReadMode)  (hClose)  (\fileHandle -> do { ... }) The arguments to bracket2 are in this order so that we can partially apply  it, e.g.: : withFile name mode = bracket (openFile name mode) hClose Z A variant of Y3 where the return value from the first computation  is not required. [Like Y2, but only performs the final action if the monad 4 short-circuited during the in-between computation. \A specialised variant of Y with just a computation to run  afterward. ]Like \2, but only performs the final action if the monad ) short-circuited during the computation. WXYcomputation to run first ("acquire resource") computation to run last ("release resource") computation to run in-between 2returns the value from the in-between computation Z[\]WXYZ[\]WXYZ[\]WXYZ[\]) Safe-Inferred*+,-./0123456 789:;<=>?@ABCDEFGHIJKLMMNOPQ$RSTUVWXYZ[\]^_`abcdefghi#jklmn o p q r s t u v  w  x y z {|}~******|}**       *             layers-0.1!Control.Monad.Interface.ExceptionControl.Monad.LayerControl.Monad.Interface.ContControl.Monad.Interface.MaskControl.Monad.Interface.ForkControl.Monad.Interface.MutVarControl.Monad.Interface.ReaderControl.Monad.Interface.StateControl.Monad.Interface.WriterControl.Monad.Interface.RWSControl.Monad.Interface.TryControl.Monad.Trans.Class MonadTransMonadTryliftthrowcatchMonadExceptionMonadLayerControlbracketControl.ExceptionthrowToforkWithUnmaskforkControl.ConcurrentforkOS LiftControlmaskBlockedIndefinitelyOnMVarBlockedIndefinitelyOnSTM ThreadKilledgetNumCapabilitiesControl.Concurrent.MVarMVar MonadStatetryControl.Monad.Trans.MaybeMaybeT Control.MonadmzeroDocumentation.Layers.Overviewbase GHC.Exception SomeExceptionMonadLiftControl liftControlMonadLiftFunctorliftMap MonadLift liftInvmapMonadTransControl transControlMonadTransFunctortransMapOuter transInvmap LayerStatezerorestore layerControlMonadLayerFunctorlayerMap MonadLayerInnerlayer layerInvmap controlLayerlayerOplayerOp_ layerDiscardcontrolliftOpliftOp_ liftDiscard MonadContcallCCHandlercatches catchJusthandle handleJusttryJust MonadMaskgetMaskingStatesetMaskingStatemask_uninterruptibleMaskuninterruptibleMask_ MonadForkforkOnforkOnWithUnmask MonadMutVarnewRefreadRefwriteRefatomicModifyRefatomicModifyRef' modifyRef modifyRef'atomicWriteRef MonadReaderreaderasklocalasksstategetputmodifygets MonadWriterwritertelllistenpasslistenscensorMonadRWSmtrybracket_bracketOnErrorfinally onExceptionghc-prim GHC.TypesIO$fMonadLiftControlim$fMonadLiftControlmm$fMonadLiftFunctorim$fMonadLiftFunctormm $fMonadLiftim $fMonadLiftmm$fMonadTransControlWriterT$fMonadTransFunctorWriterT$fMonadTransWriterT$fMonadLayerControlWriterT$fMonadLayerFunctorWriterT$fMonadLayerWriterT$fMonadTransControlWriterT0$fMonadTransFunctorWriterT0$fMonadTransWriterT0$fMonadLayerControlWriterT0$fMonadLayerFunctorWriterT0$fMonadLayerWriterT0$fMonadTransControlStateT$fMonadTransFunctorStateT$fMonadTransStateT$fMonadLayerControlStateT$fMonadLayerFunctorStateT$fMonadLayerStateT$fMonadTransControlStateT0$fMonadTransFunctorStateT0$fMonadTransStateT0$fMonadLayerControlStateT0$fMonadLayerFunctorStateT0$fMonadLayerStateT0$fMonadTransControlRWST$fMonadTransFunctorRWST$fMonadTransRWST$fMonadLayerControlRWST$fMonadLayerFunctorRWST$fMonadLayerRWST$fMonadTransFunctorRWST0$fMonadTransRWST0$fMonadTransControlRWST0$fMonadLayerControlRWST0$fMonadLayerFunctorRWST0$fMonadLayerRWST0$fMonadTransControlReaderT$fMonadTransFunctorReaderT$fMonadTransReaderT$fMonadLayerControlReaderT$fMonadLayerFunctorReaderT$fMonadLayerReaderT$fMonadTransControlMaybeT$fMonadTransFunctorMaybeT$fMonadTransMaybeT$fMonadLayerControlMaybeT$fMonadLayerFunctorMaybeT$fMonadLayerMaybeT$fMonadTransControlListT$fMonadTransFunctorListT$fMonadTransListT$fMonadLayerControlListT$fMonadLayerFunctorListT$fMonadLayerListT$fMonadTransControlIdentityT$fMonadTransFunctorIdentityT$fMonadTransIdentityT$fMonadLayerControlIdentityT$fMonadLayerFunctorIdentityT$fMonadLayerIdentityT$fMonadTransControlErrorT$fMonadTransFunctorErrorT$fMonadTransErrorT$fMonadLayerControlErrorT$fMonadLayerFunctorErrorT$fMonadLayerErrorT$fMonadTransContT$fMonadLayerContT $fMonadContm$fMonadContContT Data.EitherEitherGHC.RealdivRightLeft$fErrorSomeExceptiontransformers-0.3.0.0Control.Monad.Trans.ErrorErrorErrorT$fMonadExceptionm$fMonadExceptionProduct$fMonadExceptionErrorT$fMonadExceptionSTM$fMonadExceptionIO$fMonadExceptionEitherGHC.IO MaskingState $fMonadMaskm $fMonadMaskIO$fMonadMaskSTM $fMonadMaskST$fMonadMaskST0$fMonadMask(->) $fMonadMask[]$fMonadMaskEither$fMonadMaskMaybe$fMonadMaskProduct$fMonadMaskIdentity GHC.Conc.SyncThreadIdInt $fMonadForkm$fMonadForkProduct $fMonadForkIO GHC.IORefIORef$fMonadMutVarrefm$fMonadMutVarrefProduct$fMonadMutVarTVarSTM$fMonadMutVarSTRefST$fMonadMutVarSTRefST0$fMonadMutVarIORefIO$fMonadReaderrm$fMonadReaderrProduct$fMonadReaderrRWST$fMonadReaderrRWST0$fMonadReaderrReaderT$fMonadReaderr(->)GHC.BaseMonad$fMonadStatesm$fMonadStatesProduct$fMonadStatesRWST$fMonadStatesRWST0$fMonadStatesStateT$fMonadStatesStateT0$fMonadWriterwm$fMonadWriterwProduct$fMonadWriterwRWST$fMonadWriterwRWST0$fMonadWriterwWriterT$fMonadWriterwWriterT0 Data.MaybeNothing $fMonadTrym $fMonadTrySTM $fMonadTryST $fMonadTryST0 $fMonadTryIO$fMonadTry(->) $fMonadTry[]$fMonadTryEither$fMonadTryMaybe$fMonadTryProduct$fMonadTryIdentity