Ã_      !"#$%&'()*+, - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  portable experimentalross@soi.city.ac.uk Safe-InferedLifted product of functors.  portable experimentalross@soi.city.ac.uk Safe-Infered'Right-to-left composition of functors. @ The composition of applicative functors is always applicative, 6 but the composition of monads is not always a monad. portable experimentalross@soi.city.ac.uk Safe-InferedIdentity functor and monad. portable experimentalross@soi.city.ac.uk Safe-Infered?The class of monad transformers. Instances should satisfy the " following laws, which state that   is a transformer of monads:    .  =    (m >>= f) =   m >>= (  . f) ELift a computation from the argument monad to the constructed monad.     portable experimentalross@soi.city.ac.uk Safe-Infered Monads in which  computations may be embedded. E Any monad built by applying a sequence of monad transformers to the  * monad will be an instance of this class. >Instances should satisfy the following laws, which state that    is a transformer of monads:    .  =    (m >>= f) =   m >>= (  . f) Lift a computation from the  monad.      portable experimentalross@soi.city.ac.uk Safe-Infered $The continuation monad transformer. :Can be used to add continuation handling to other monads. Continuation monad. Cont r a; is a CPS computation that produces an intermediate result of type a5 within a CPS computation whose final result type is r. The returnC function simply creates a continuation which passes the value on. The >>=? operator adds the bound function into the continuation chain. >Construct a continuation-passing computation from a function.  (The inverse of .) DRuns a CPS computation, returns its result after applying the final  continuation to it.  (The inverse of .) CApply a function to transform the result of a continuation-passing  computation.   ( f m) = f .  m?Apply a function to transform the continuation passed to a CPS  computation.   ( f m) =  m . fCApply a function to transform the result of a continuation-passing  computation.   ( f m) = f .  m?Apply a function to transform the continuation passed to a CPS  computation.   ( f m) =  m . fcallCC5 (call-with-current-continuation) calls its argument = function, passing it the current continuation. It provides < an escape continuation mechanism for use with continuation > monads. Escape continuations one allow to abort the current = computation and return a value immediately. They achieve a  similar effect to   and  within an   monad. The advantage of this  function over calling # is that it makes the continuation 9 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.  ask local yields a local function for   r m.  continuation computation (Cont). 'the final continuation, which produces  the final result (often ).      portable experimentalross@soi.city.ac.uk Safe-Infered BThe error monad transformer. It can be used to add error handling  to other monads. The ErrorT3 Monad structure is parameterized over two things:  e - The error type.  m - The inner monad. The 1 function yields a successful computation, while >>= < sequences two subcomputations, failing on the first error. 5Workaround so that we can have a Haskell 98 instance  . An exception to be thrown. Minimal complete definition:  or . (Creates an exception without a message.  The default implementation is  "". %Creates an exception with a message.  The default implementation of  s is . 8Map the unwrapped computation using the given function.   (  f m) = f ( m)!Signal an error value e.   (! e) =  ( e) ! e >>= m = ! e"Handle an error.  " h (  m) =   m " h (! e) = h e#Lift a callCC operation to the new monad. $Lift a listen operation to the new monad. %Lift a pass operation to the new monad. $A string can be thrown as an error.  !"the inner computation "a handler for errors in the inner  computation #$%      !"#$% !"#$% !"#$%     portable experimentalross@soi.city.ac.uk Safe-Infered&JThe trivial monad transformer, which maps a monad to an equivalent monad. ))Lift a unary operation to the new monad. *Lift a callCC operation to the new monad. +Lift a  catchError operation to the new monad. &'()*+&'()*+&'()+*&'()*+ portable experimentalross@soi.city.ac.uk Safe-Infered,1Parameterizable list monad, with an inner monad. Note:G this does not yield a monad unless the argument monad is commutative. / Map between , computations.  . (/ f m) = f (. m)0Lift a callCC operation to the new monad. 1Lift a  catchError operation to the new monad. ,-./01 !"#$%&'(,-./01,-./01 ,-./01 !"#$%&'( portable experimentalross@soi.city.ac.uk Safe-Infered2DThe parameterizable maybe monad, obtained by composing an arbitrary  monad with the ) monad. ;Computations are actions that may produce a value or fail. The 1 function yields a successful computation, while >>= < sequences two subcomputations, failing on the first error. 5#Transform the computation inside a MaybeT.  4 (5 f m) = f (4 m)6Lift a callCC operation to the new monad. 7Lift a  catchError operation to the new monad. 8Lift a listen operation to the new monad. 9Lift a pass operation to the new monad. 23456789*+,-./0123234567892345678923456789*+,-./0123 portable experimentalross@soi.city.ac.uk Safe-Infered:The reader monad transformer, 8 which adds a read-only environment to the given monad. The ) function ignores the environment, while >>= passes 4 the inherited environment to both subcomputations. <>The underlying computation, as a function of the environment. ="The parameterizable reader monad. 4Computations are functions of a shared environment. The ) function ignores the environment, while >>= passes 4 the inherited environment to both subcomputations. >@Constructor for computations in the reader monad (equivalent to F). ?Runs a Reader' and extracts the final value from it.  (The inverse of >.) @"Transform the value returned by a Reader.  ? (@ f m) = f . ? mA0Execute a computation in a modified environment  (a specialization of C).  ? (A f m) = ? m . fB#Transform the computation inside a ReaderT.  < (B f m) = f . < mC0Execute a computation in a modified environment  (a more general version of E).  < (C f m) = < m . fD$Fetch the value of the environment. E0Execute a computation in a modified environment  (a specialization of C).  < (E f m) = < m . fF0Retrieve a function of the current environment.  F f = 4 f DGLift a callCC operation to the new monad. HLift a  catchError operation to the new monad. :;<=>?A Reader to run. An initial environment. @A(The function to modify the environment. 0Computation to run in the modified environment. BC(The function to modify the environment. 0Computation to run in the modified environment. DE(The function to modify the environment. 0Computation to run in the modified environment. F3The selector function to apply to the environment. GcallCC on the argument monad. Hcatch on the argument monad. Computation to attempt. Exception handler. 56789:;<:;<=>?@ABCDEFGH=>?@A:;<BCDEFGH:;<=>?@ABCDEFGH56789:;< portable experimentalross@soi.city.ac.uk Safe-InferedI:A monad transformer adding reading an environment of type r,  collecting an output of type w and updating a state of type s  to an inner monad m. L*A monad containing an environment of type r, output of type w  and an updatable state of type s. M.Construct an RWS computation from a function.  (The inverse of N.) N)Unwrap an RWS computation as a function.  (The inverse of M.) OEEvaluate a computation with the given initial state and environment, C returning the final value and output, discarding the final state. PEEvaluate a computation with the given initial state and environment, C returning the final state and output, discarding the final value. QDMap the return value, final state and output of a computation using  the given function.  N (Q f m) r s = f (N m r s)RR f m executes action m with an initial environment  and state modified by applying f.  N (R f m) r s = = (N m) (f r s)SEEvaluate a computation with the given initial state and environment, C returning the final value and output, discarding the final state. TEEvaluate a computation with the given initial state and environment, C returning the final state and output, discarding the final value. U4Map the inner computation using the given function.  K (U f m) r s = f (K m r s)VV f m executes action m with an initial environment  and state modified by applying f.  K (V f m) r s = = (K m) (f r s)W@Constructor for computations in the reader monad (equivalent to Z). X$Fetch the value of the environment. Y0Execute a computation in a modified environment  K (Y f m) r s = K m (f r) sZ0Retrieve a function of the current environment.  Z f = 4 f X[=Construct a writer computation from a (result, output) pair. \\ w' is an action that produces the output w. ]] m' is an action that executes the action m and adds its ) output to the value of the computation.  K (] m) r s = 4 (\(a, w) -> ((a, w), w)) (K m r s)^^ 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.  ^ f m = 4 (id *** f) (] m) K (^ f m) r s = 4 (\(a, w) -> ((a, f w), w)) (K m r s)__ m' is an action that executes the action m, which returns F a value and a function, and returns the value, applying the function  to the output.  K (_ m) r s = 4 (\((a, f), w) -> (a, f w)) (K m r s)`` f m' is an action that executes the action m and  applies the function f) to its output, leaving the return value  unchanged.  ` f m = _ (4 (\x -> (x,f)) m) K (` f m) r s = 4 (\(a, w) -> (a, f w)) (K m r s)aGConstruct a state monad computation from a state transformer function. b7Fetch the current value of the state within the monad. cc s$ sets the state within the monad to s. dd f6 is an action that updates the state to the result of  applying f to the current state.  d f = b >>= (c . f)eCGet a specific component of the state, using a projection function  supplied.  e f = 4 f bfUniform lifting of a callCC operation to the new monad. ? This version rolls back to the original state on entering the  continuation. gIn-situ lifting of a callCC operation to the new monad. C This version uses the current state on entering the continuation. hLift a  catchError operation to the new monad. (IJKLMNORWS computation to execute initial environment initial value final value and output PRWS computation to execute initial environment initial value final state and output QRScomputation to execute initial environment initial value ,computation yielding final value and output Tcomputation to execute initial environment initial value ,computation yielding final state and output UVWXYZ[\]^_`abcdefgh>?@ABCDE IJKLMNOPQRSTUVWXYZ[\]^_`abcdefgh LMNOPQRIJKSTUVWXYZ[\]^_`abcdefgh&IJKLMNOPQRSTUVWXYZ[\]^_`abcdefgh>?@ABCDEportable experimentalross@soi.city.ac.uk Safe-Infered IJKLMNOPQRSTUVWXYZ[\]^_`abcdefgh portable experimentalross@soi.city.ac.uk Safe-Inferedi:A monad transformer adding reading an environment of type r,  collecting an output of type w and updating a state of type s  to an inner monad m. l*A monad containing an environment of type r, output of type w  and an updatable state of type s. m.Construct an RWS computation from a function.  (The inverse of n.) n)Unwrap an RWS computation as a function.  (The inverse of m.) oEEvaluate a computation with the given initial state and environment, C returning the final value and output, discarding the final state. pEEvaluate a computation with the given initial state and environment, C returning the final state and output, discarding the final value. qDMap the return value, final state and output of a computation using  the given function.  n (q f m) r s = f (n m r s)rr f m executes action m with an initial environment  and state modified by applying f.  n (r f m) r s = = (n m) (f r s)sEEvaluate a computation with the given initial state and environment, C returning the final value and output, discarding the final state. tEEvaluate a computation with the given initial state and environment, C returning the final state and output, discarding the final value. u4Map the inner computation using the given function.  k (u f m) r s = f (k m r s)vv f m executes action m with an initial environment  and state modified by applying f.  k (v f m) r s = = (k m) (f r s)w@Constructor for computations in the reader monad (equivalent to z). x$Fetch the value of the environment. y0Execute a computation in a modified environment  k (y f m) r s = k m (f r) sz0Retrieve a function of the current environment.  z f = 4 f x{=Construct a writer computation from a (result, output) pair. || w' is an action that produces the output w. }} m' is an action that executes the action m and adds its ) output to the value of the computation.  k (} m) r s = 4 (\(a, w) -> ((a, w), w)) (k m r s)~~ 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.  ~ f m = 4 (id *** f) (} m) k (~ f m) r s = 4 (\(a, w) -> ((a, f w), w)) (k m r s) m' is an action that executes the action m, which returns F a value and a function, and returns the value, applying the function  to the output.  k ( m) r s = 4 (\((a, f), w) -> (a, f w)) (k m r s) f m' is an action that executes the action m and  applies the function f) to its output, leaving the return value  unchanged.   f m =  (4 (\x -> (x,f)) m) k ( f m) r s = 4 (\(a, w) -> (a, f w)) (k m r s)GConstruct a state monad computation from a state transformer function. 7Fetch the current value of the state within the monad.  s$ sets the state within the monad to s.  f6 is an action that updates the state to the result of  applying f to the current state.   f =  >>= ( . f)CGet a specific component of the state, using a projection function  supplied.   f = 4 f Uniform lifting of a callCC operation to the new monad. ? This version rolls back to the original state on entering the  continuation. In-situ lifting of a callCC operation to the new monad. C This version uses the current state on entering the continuation. Lift a  catchError operation to the new monad. (ijklmnoRWS computation to execute initial environment initial value final value and output pRWS computation to execute initial environment initial value final state and output qrscomputation to execute initial environment initial value ,computation yielding final value and output tcomputation to execute initial environment initial value ,computation yielding final state and output uvwxyz{|}~FGHIJKLM ijklmnopqrstuvwxyz{|}~ lmnopqrijkstuvwxyz{|}~&ijklmnopqrstuvwxyz{|}~FGHIJKLMportable experimentalross@soi.city.ac.uk Safe-Infered,A state transformer monad parameterized by:  s - The state.  m - The inner monad. The , function leaves the state unchanged, while >>= uses B the final state of the first computation as the initial state of  the second. (A state monad parameterized by the type s of the state to carry. The , function leaves the state unchanged, while >>= uses B the final state of the first computation as the initial state of  the second. 5Construct a state monad computation from a function.  (The inverse of .) 0Unwrap a state monad computation as a function.  (The inverse of .) :Evaluate a state computation with the given initial state 9 and return the final value, discarding the final state.   m s = N ( m s):Evaluate a state computation with the given initial state 9 and return the final state, discarding the final value.   m s = O ( m s)AMap both the return value and final state of a computation using  the given function.   ( f m) = f .  m f m executes action m on a state modified by  applying f.   f m =  f >> m:Evaluate a state computation with the given initial state 9 and return the final value, discarding the final state.   m s = 4 N ( m s):Evaluate a state computation with the given initial state 9 and return the final state, discarding the final value.   m s = 4 O ( m s)AMap both the return value and final state of a computation using  the given function.   ( f m) = f .  m f m executes action m on a state modified by  applying f.   f m =  f >> m7Fetch the current value of the state within the monad.  s$ sets the state within the monad to s.  f6 is an action that updates the state to the result of  applying f to the current state.   f =  >>= ( . f)CGet a specific component of the state, using a projection function  supplied.   f = 4 f Uniform lifting of a callCC operation to the new monad. ? This version rolls back to the original state on entering the  continuation. In-situ lifting of a callCC operation to the new monad. C This version uses the current state on entering the continuation. 6 It does not satisfy the laws of a monad transformer. Lift a  catchError operation to the new monad. Lift a listen operation to the new monad. Lift a pass operation to the new monad. pure state transformer %equivalent state-passing computation %state-passing computation to execute initial state return value and final state %state-passing computation to execute initial value &return value of the state computation %state-passing computation to execute initial value  final state PQRSTUVWPQRSTUVWportable experimentalross@soi.city.ac.uk Safe-Inferedportable experimentalross@soi.city.ac.uk Safe-Infered,A state transformer monad parameterized by:  s - The state.  m - The inner monad. The , function leaves the state unchanged, while >>= uses B the final state of the first computation as the initial state of  the second. (A state monad parameterized by the type s of the state to carry. The , function leaves the state unchanged, while >>= uses B the final state of the first computation as the initial state of  the second. 5Construct a state monad computation from a function.  (The inverse of .) 0Unwrap a state monad computation as a function.  (The inverse of .) :Evaluate a state computation with the given initial state 9 and return the final value, discarding the final state.   m s = N ( m s):Evaluate a state computation with the given initial state 9 and return the final state, discarding the final value.   m s = O ( m s)AMap both the return value and final state of a computation using  the given function.   ( f m) = f .  m f m executes action m on a state modified by  applying f.   f m =  f >> m:Evaluate a state computation with the given initial state 9 and return the final value, discarding the final state.   m s = 4 N ( m s):Evaluate a state computation with the given initial state 9 and return the final state, discarding the final value.   m s = 4 O ( m s)AMap both the return value and final state of a computation using  the given function.   ( f m) = f .  m f m executes action m on a state modified by  applying f.   f m =  f >> m7Fetch the current value of the state within the monad.  s$ sets the state within the monad to s.  f6 is an action that updates the state to the result of  applying f to the current state.   f =  >>= ( . f)CGet a specific component of the state, using a projection function  supplied.   f = 4 f Uniform lifting of a callCC operation to the new monad. ? This version rolls back to the original state on entering the  continuation. In-situ lifting of a callCC operation to the new monad. C This version uses the current state on entering the continuation. 6 It does not satisfy the laws of a monad transformer. Lift a  catchError operation to the new monad. Lift a listen operation to the new monad. Lift a pass operation to the new monad. pure state transformer %equivalent state-passing computation %state-passing computation to execute initial state return value and final state %state-passing computation to execute initial value &return value of the state computation %state-passing computation to execute initial value  final state XYZ[\]^_XYZ[\]^_portable experimentalross@soi.city.ac.uk Safe-Infered!A writer monad parameterized by:  w - the output to accumulate.  m - The inner monad. The  function produces the output `, while >>= 3 combines the outputs of the subcomputations using a. )A writer monad parameterized by the type w of output to accumulate. The  function produces the output `, while >>= 3 combines the outputs of the subcomputations using a. =Construct a writer computation from a (result, output) pair.  (The inverse of .) 8Unwrap a writer computation as a (result, output) pair.  (The inverse of .) .Extract the output from a writer computation.   m = O ( m)<Map both the return value and output of a computation using  the given function.   ( f m) = f ( m).Extract the output from a writer computation.   m = 4 O ( m)<Map both the return value and output of a computation using  the given function.   ( f m) = f ( m) w' is an action that produces the output w.  m' is an action that executes the action m and adds its ) output to the value of the computation.   ( m) = 4 (\(a, w) -> ((a, w), w)) ( m) 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.   f m = 4 (id *** f) ( m)  ( f m) = 4 (\(a, w) -> ((a, f w), w)) ( m) m' is an action that executes the action m, which returns F a value and a function, and returns the value, applying the function  to the output.   ( m) = 4 (\((a, f), w) -> (a, f w)) ( m) f m' is an action that executes the action m and  applies the function f) to its output, leaving the return value  unchanged.   f m =  (4 (\x -> (x,f)) m)  ( f m) = 4 (\(a, w) -> (a, f w)) ( m)Lift a callCC operation to the new monad. Lift a  catchError operation to the new monad. bcdefghijkbcdefghijkportable experimentalross@soi.city.ac.uk Safe-Inferedportable experimentalross@soi.city.ac.uk Safe-Infered!A writer monad parameterized by:  w - the output to accumulate.  m - The inner monad. The  function produces the output `, while >>= 3 combines the outputs of the subcomputations using a. )A writer monad parameterized by the type w of output to accumulate. The  function produces the output `, while >>= 3 combines the outputs of the subcomputations using a. =Construct a writer computation from a (result, output) pair.  (The inverse of .) 8Unwrap a writer computation as a (result, output) pair.  (The inverse of .) .Extract the output from a writer computation.   m = O ( m)<Map both the return value and output of a computation using  the given function.   ( f m) = f ( m).Extract the output from a writer computation.   m = 4 O ( m)<Map both the return value and output of a computation using  the given function.   ( f m) = f ( m) w' is an action that produces the output w.  m' is an action that executes the action m and adds its ) output to the value of the computation.   ( m) = 4 (\(a, w) -> ((a, w), w)) ( m) 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.   f m = 4 (id *** f) ( m)  ( f m) = 4 (\(a, w) -> ((a, f w), w)) ( m) m' is an action that executes the action m, which returns F a value and a function, and returns the value, applying the function  to the output.   ( m) = 4 (\((a, f), w) -> (a, f w)) ( m) f m' is an action that executes the action m and  applies the function f) to its output, leaving the return value  unchanged.   f m =  (4 (\x -> (x,f)) m)  ( f m) = 4 (\(a, w) -> (a, f w)) ( m)Lift a callCC operation to the new monad. Lift a  catchError operation to the new monad. lmnopqrstulmnopqrstuportable experimentalross@soi.city.ac.uk Safe-InferedConstant functor. vwxyvwxyportable experimentalross@soi.city.ac.uk Safe-InferedFAn applicative functor that collects a monoid (e.g. lists) of errors. C A sequence of computations fails if any of its components do, but  unlike monads made with ErrorT from Control.Monad.Trans.Error, H these computations continue after an error, collecting all the errors. BApplicative functor formed by adding pure computations to a given  applicative functor. !Projection to the other functor. Report an error. zA combination is  only either part is. {A combination is  only if both parts are. z{|}~ z{|}~portable experimentallibraries@haskell.org Safe-InferedThe same functor, but with an  instance that performs  actions in the reverse order. Derived instance. Derived instance. &Try alternatives in the same order as f. Apply f-actions in the reverse order. Derived instance. portable experimentallibraries@haskell.org Safe-InferedThe same functor, but with  and  instances 1 that process the elements in the reverse order. Traverse from right to left. Fold from right to left. Derived instance. Derived instance. Derived instance.   !"#$%&&'()*+,-./0123456789:;;<=8> ? ? @ A 8 > B B C D 8 > 9 : E E F G H I J K L M N O P 8 > Q Q R S T U V W X Y Z [ \ ] H N O P ^ _ ` a b c d e f g h 8 i > Q Q R S T U V W X Y Z [ \ ] H N O P ^ _ ` a b c d e f g h 8 i >jjkldmnopqrstuefgh8i>9:jjkldmnopqrstuefgh8i>9:vvwx^yz{|}_`abc8>vvwx^yz{|}_`abc8>~~        transformers-0.3.0.0Data.Functor.ProductData.Functor.ComposeData.Functor.IdentityControl.Monad.Trans.ClassControl.Monad.IO.ClassControl.Monad.Trans.ContControl.Monad.Trans.ErrorControl.Monad.Trans.IdentityControl.Monad.Trans.ListControl.Monad.Trans.MaybeControl.Monad.Trans.ReaderControl.Monad.Trans.RWS.LazyControl.Monad.Trans.RWS.StrictControl.Monad.Trans.State.Lazy Control.Monad.Trans.State.StrictControl.Monad.Trans.Writer.Lazy!Control.Monad.Trans.Writer.StrictData.Functor.ConstantControl.Applicative.LiftControl.Applicative.BackwardsData.Functor.Reverse throwError catchErrorErrorTControl.Monad.Trans.RWSControl.Monad.Trans.StateControl.Monad.Trans.WriterProductPairCompose getComposeIdentity runIdentity MonadTransliftMonadIOliftIOContTrunContTContcontrunContmapContwithContmapContT withContTcallCC liftLocal runErrorT ErrorListlistMsgErrornoMsgstrMsg mapErrorT liftCallCC liftListenliftPass IdentityT runIdentityT mapIdentityT liftCatchListTrunListTmapListTMaybeT runMaybeT mapMaybeTReaderT runReaderTReaderreader runReader mapReader withReader mapReaderT withReaderTasklocalasksRWSTrunRWSTRWSrwsrunRWSevalRWSexecRWSmapRWSwithRWSevalRWSTexecRWSTmapRWSTwithRWSTwritertelllistenlistenspasscensorstategetputmodifygets liftCallCC'StateT runStateTStaterunState evalState execStatemapState withState evalStateT execStateT mapStateT withStateTWriterT runWriterTWriter runWriter execWriter mapWriter execWriterT mapWriterTConstant getConstantErrorsLiftOtherPureunLiftfailure BackwardsforwardsReverse getReverse$fMonadFixProduct$fMonadPlusProduct$fMonadProduct$fAlternativeProduct$fApplicativeProduct$fTraversableProduct$fFoldableProduct$fFunctorProduct$fAlternativeCompose$fApplicativeCompose$fTraversableCompose$fFoldableCompose$fFunctorCompose$fMonadFixIdentity$fMonadIdentity$fApplicativeIdentity$fTraversableIdentity$fFoldableIdentity$fFunctorIdentitybaseGHC.Basereturnghc-prim GHC.TypesIO $fMonadIOIOid$fMonadIOContT$fMonadTransContT $fMonadContT$fApplicativeContT$fFunctorContTString Data.EitherLeft $fError[]$fMonadIOErrorT$fMonadTransErrorT$fMonadFixErrorT$fMonadPlusErrorT $fMonadErrorT$fAlternativeErrorT$fApplicativeErrorT$fTraversableErrorT$fFoldableErrorT$fFunctorErrorT$fMonadPlusEither$fAlternativeEither$fErrorListChar$fErrorIOException $fMonadPlusIO$fMonadTransIdentityT$fMonadIOIdentityT$fMonadFixIdentityT$fMonadPlusIdentityT$fMonadIdentityT$fAlternativeIdentityT$fApplicativeIdentityT$fTraversableIdentityT$fFoldableIdentityT$fFunctorIdentityT$fMonadIOListT$fMonadTransListT$fMonadPlusListT $fMonadListT$fAlternativeListT$fApplicativeListT$fTraversableListT$fFoldableListT$fFunctorListT Data.MaybeMaybe$fMonadIOMaybeT$fMonadTransMaybeT$fMonadFixMaybeT$fMonadPlusMaybeT $fMonadMaybeT$fAlternativeMaybeT$fApplicativeMaybeT$fTraversableMaybeT$fFoldableMaybeT$fFunctorMaybeT Control.MonadliftM$fMonadIOReaderT$fMonadTransReaderT$fMonadFixReaderT$fMonadPlusReaderT$fMonadReaderT$fAlternativeReaderT$fApplicativeReaderT$fFunctorReaderT Data.Tupleuncurry $fMonadIORWST$fMonadTransRWST$fMonadFixRWST$fMonadPlusRWST $fMonadRWST$fAlternativeRWST$fApplicativeRWST $fFunctorRWSTfstsnd$fMonadIOStateT$fMonadTransStateT$fMonadFixStateT$fMonadPlusStateT $fMonadStateT$fAlternativeStateT$fApplicativeStateT$fFunctorStateT Data.Monoidmemptymappend$fTraversableWriterT$fFoldableWriterT$fMonadIOWriterT$fMonadTransWriterT$fMonadFixWriterT$fMonadPlusWriterT$fMonadWriterT$fAlternativeWriterT$fApplicativeWriterT$fFunctorWriterT$fApplicativeConstant$fTraversableConstant$fFoldableConstant$fFunctorConstant$fAlternativeLift$fApplicativeLift$fTraversableLift$fFoldableLift $fFunctorLiftControl.Applicative Applicative$fTraversableBackwards$fFoldableBackwards$fAlternativeBackwards$fApplicativeBackwards$fFunctorBackwards Data.FoldableFoldableData.Traversable Traversable$fTraversableReverse$fFoldableReverse$fAlternativeReverse$fApplicativeReverse$fFunctorReverse