!      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~)Safe/@AHV trans-fx-coreClass representing types which can be compared for equality within an environment. Instances should satisfy the following laws: (1) eqIn env x x === True (2) eqIn env x y === eqIn env y x (3) if (eqIn env x y) && (eqIn env y z) then eqIn env x z else TrueSafe/@ACH#  trans-fx-core=Class representing type constructors which are isomorphic to Maybe/. Instances should satisfy the following laws: @(1) toMaybe . fromMaybe == id (2) fromMaybe . toMaybe == id  trans-fx-core Convert from Maybe a  trans-fx-core Convert to Maybe a  trans-fx-coreeClass representing bifunctors on the category of types. Instances should satisfy the following laws: (1) bimap1 id === id (2) bimap1 (f . g) === bimap1 f . bimap1 g (3) bimap2 id === id (4) bimap2 (f . g) === bimap2 f . bimap2 g (5) bimap1 f . bimap2 g === bimap2 g . bimap1 f  trans-fx-corefmap in the "first" component trans-fx-corefmap in the "second" component trans-fx-coreClass representing Functors which "commute" with every  ApplicativeA in a precise sense. Instances should satisfy the following law: "(1) commute . fmap pure === pureThis looks a lot like the  sequenceA function from  TraversableQ, but that class entails a bunch of extra technology that we don't really need.The motivation for  Commutant< comes from the observation that most useful monads can be run to produce a "value", though in general that value will depend on some other context. In every case I've tried so far that context is a  Commutant- functor, which is enough to make a generic RunMonad instance for Compose. Safe/HV& trans-fx-core-Type representing the left zero semigroup on a* with an identity attached. As a functor LeftZero is isomorphic to Maybe. Safe/HV)@ trans-fx-coreTuple type, isomorphic to (a,b)>. This is here so we can have a partially applied tuple type Pair a without syntax hacks. Safe/@AHV, trans-fx-core.Type representing the right zero semigroup on a* with an identity attached. As a functor  RightZero is isomorphic to Maybe. Safe,y# Safe&'/8=?@ACHSVXqw$ trans-fx-coreJClass representing monads which can prompt an oracle for a monadic result. trans-fx-corePrompt an oracle of type  mark (p a), receiving a monadic result trans-fx-coreHClass representing monads with access to a write-once, read-many state mark w.. Instances should satisfy the following laws. c(1) etch a >> etch b === etch a >> return False (2) etch a >> press === return (Just $ pure a) trans-fx-core2Attempt to record the write-once state, returning True$ if and only if the write succeeds. trans-fx-core/Attempt to read a copy of the write-once state.  trans-fx-coreEClass representing monads with access to a marked append-only state mark w.. Instances should satisfy the following laws: (1) jot mempty === return () (2) jot (a <> b) === jot a >> jot b (3) look === return mempty (4) x >> look >> y === x >> y (5) jot w >> look === jot w >> return w! trans-fx-coreRetrieve the append-only state" trans-fx-coreAppend a value to the state# trans-fx-coreCClass representing monads with access to a marked read-only state mark r.. Instances should satisfy the following laws: (1) local u ask === fmap u ask (2) local u (local v x) === local (v . u) x (3) local u x >> ask === ask >>= \r -> local u x >> return r (4) local u (return a) === return a (5) local u (x >>= f) === local u x >>= (local u . f)$ trans-fx-coreRetrieve the read-only state% trans-fx-core<Run a computation with a locally modified read-only state& trans-fx-coreDClass representing monads with access to a marked write-only state mark w . Note that w must be an instance of Monoid/. Instances should satisfy the following laws: (1) draft (tell w) === return ((),w) (2) tell mempty === return () (3) tell w1 >> tell w2 === tell (mappend w1 w2) (4) draft (return a) === return (a, mempty) (5) draft (x >>= f) === draft x >>= (draft' f) where draft' f (a,w) = mapsnd (mappend w) <$> draft (f a)' trans-fx-core1Combine a value with the current write-only state( trans-fx-coreYRun a computation, returning the write-only state with the result rather than writing it) trans-fx-core@Class representing monads with access to a marked mutable state mark s/. Instances should satisfy the following laws: (1) put s1 >> put s2 === put s2 (2) put s >> get === put s >> return s (3) get >>= put === return () (4) get >>= \\s -> get >>= k s === get >>= \\s -> k s s* trans-fx-coreRetrieve the current state+ trans-fx-coreReplace the current state, trans-fx-corePClass representing monads which can raise and handle marked exceptions of type mark e.. Instances should satisfy the following laws: a(1) catch (return a) h === return a (2) catch (throw e) h === h e (3) throw e >>= f === throw e- trans-fx-coreRaise an exception. trans-fx-core>Run a computation, applying a handler to any raised exceptions/ trans-fx-core{Class representing monads which can fail catastrophically, returning nothing. Instances should satisfy the following laws: (1) halt a >> x === halt a0 trans-fx-core)Fail catastrophically, returning nothing.1 trans-fx-coreoClass representing monads from which we can extract a pure value. Instances should satisfy the following laws: T(1) unwrap . return === id (2) return . unwrap === id (3) x >>= f === f (unwrap x)2 trans-fx-coreExtract a pure value3 trans-fx-core4Class representing monad transformers through which local from  MonadReadOnly can be lifted5 trans-fx-coreThe signature of local from  MonadReadOnly6 trans-fx-core5Class representing monad transformers through which draft from MonadWriteOnly< can be lifted. Instances should satisfy the following law: /(1) liftDraft draft (lift x) === lift (draft x)8 trans-fx-coreThe signature of draft from MonadWriteOnly9 trans-fx-core5Class representing monad transformers through which catch from  MonadExcept< can be lifted. Instances should satisfy the following law: <(1) lift (catch x h) === liftCatch catch (lift x) (lift . h); trans-fx-coreThe signature of catch from  MonadExcept< trans-fx-core|Class representing monad transformers which can be run in an input context, producting a monadic value in an output context.@ trans-fx-core%Class representing monad transformersA trans-fx-core@Lift a computation from the inner monad to the transformed monadB trans-fx-coreAClass representing monads that can be "run" inside some context z+, producing a value in some result context f.E trans-fx-core$Run a monadic computation in contextF trans-fx-coreClass representing monads that F with every other monad. Instances should satisfy the following laws: (1) commute . return === fmap return (2) commute . join === fmap join . commute . fmap commute (3) commute . fmap join === join . fmap commute . commute1 !"#$%&'()*+,.-/0123456789:;<=>?=>@ABCDEDF Safe /1=?@AHV}G trans-fx-core1Concrete append-only state monad with state type wI trans-fx-coref = unAppendOnly x! must have the property that if f w1 = Pair w2 a, then there exists w such that  w2 == w1 <> wK. This cannot be enforced by the type, but the class instance methods for  AppendOnly all preserve it.CDGHI Safe /1=>?HVXq\J trans-fx-coreConcrete composite monad CDJKL Safe /1=?@AHVXM trans-fx-core>Concrete exception monad, throwing marked exceptions of type mark e and producing values of type aN trans-fx-coreExceptional resultO trans-fx-core Normal resultCDMNO Safe /1=?@AHVXDP trans-fx-core2Concrete monad representing catastrophic failure mark e and producing values of type aQ trans-fx-coreProceedR trans-fx-coreBail outCDPRQ Safe /=?@AHVKS trans-fx-coreConcrete identity monadU trans-fx-coreExtract a pure valueCDSTUSafe /1=?@AHV4V trans-fx-core/Concrete read-only state monad with state type rCDVWXSafe /1=?@AHVY trans-fx-coreConcrete state monadCDYZ[Safe /1=?@AHVb\ trans-fx-coreConcrete write-once state monadCD\]^Safe /1=?@AHVO_ trans-fx-core0Concrete write-only state monad with state type wCD_`aSafe !"#$%&'()*+,.-/0123456789:;<=>?@ABCDEFGHIJKLMNOPRQSTUVWXYZ[\]^_`aSafeHSXq'b trans-fx-core!Class representing monad functorsbcSafe/1=?@AHSVXqd trans-fx-core+Concrete write-only state monad transformer'=>defgSafe /1=>?@AHSVXh trans-fx-core Concrete State monad transformer' =  >  hijkSafe /1=?@AHSVXl trans-fx-core Concrete State monad transformer'=>lmnoSafe /1=>?@AHSVXp trans-fx-core Concrete ReadOnly monad transformer'=>pqrsSafe/1=>?@AHSVXqt trans-fx-core#Concrete identity monad transformer'=>tuvwSafe /1=?@AHSVXx trans-fx-core Concrete Maybe monad transformer' !="#>$%xyz{Safe/1=?@AHSVXq| trans-fx-core$Concrete exception monad transformer'&'=()>*+|}~Safe /1=>?@AHSVX trans-fx-core Concrete State monad transformer',-=./>01Safe&'/1=?@AHSVXq trans-fx-corefClass representing monad transformers which can be composed on top of an arbitrary monad transformer. trans-fx-core$Concrete composite monad transformerh &,2 !'-3= "(.4 #)/5> $*06 %+1789:;<=>?@ABCDEFGSafe &,2 !'-3= "(.4 #)/5> $*06 %+17bcdefghijklmnopqrstuvwxyz{|}~89:;<=>?@ABCDEFGSafe =?@ACHSVXq trans-fx-coreAClass representing monad transformer transformers through which local from  MonadReadOnly can be lifted. trans-fx-coreAClass representing monad transformer transformers through which draft from MonadWriteOnly can be lifted. trans-fx-coreAClass representing monad transformer transformers through which catch from  MonadExcept can be lifted. trans-fx-coreRClass representing monad transformer transformers which can be "run" in a context z m, producing a value in context  t m (f a). trans-fx-core1Class representing monad transformer transformersNone/1=?@AHMSVXqp9 &,2H !'-3IJKLM None/1=>?@AHMSVXq 9 &,2N !'-3OPQRS!None/1=>?@AHMSVXq9 &,2T !'-3UVWXY"None/1=>?@AHMSVXqA9 &,2Z !'-3[\]^_#Safe/1=?@AHSVXq" trans-fx-coreDConcrete monad transformer transformer which applies a monad functorK &,2` !'-3abcdefghijklmnopqrstu$Safe/1=>?@AHSVXq trans-fx-core/Concrete identity monad transformer transformer9 &,2v !'-3wxyz{%Safe/1=?@AHSVXqV trans-fx-core+Helper type for running prompt computations trans-fx-core-Concrete prompt monad transformer transformerB &,2v| !'-3w}x~yz{&None/1=>?@AHMSVXq9 &,2 !'-3'None/1=?@AHMSVXqƸ9 &,2 !'-3(None/1=>?@AHMSVXqS9 &,2 !'-3)NonenNHZT`| &,2vOI[Ua} !'-3wPJ\Vb~xQK]WcyRL^XdzSM_Ye{fghijklmnopqrstuNonei &,2HNTZ`v| !'-3IOU[aw}  !"#$%&'()*+,.-/0123456789:;<=>?= "(.4 #)/5> $*06 %+17@ABCDECDFGHIJKLMNOPRQSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~89:;<=>?@ABCDEFGJPV\bx~KQW]cyLRX^dzMSY_e{fghijklmnopqrstu12/0,.-)*+&'(#$% !"STUJKLVWXYZ[MNO_`aPRQGHI\]^tuvwpqrslmnoxyz{|}~defghijkBCDE<=>?;9:867534F  @Abc*+,-./00123456789::;<<=>??@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkl m m n o o p q q r s t s u u vwwxyyz{{|}}~   !!!!""""#####$$$$%%%%%%%&&&&''''((((                     !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWX 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#{#|#}#~##$$$$$$%%%%%%&&&&&&''''''((((((*trans-fx-core-0.0.1-6MpkPClcv42GO9T8TJ81SZ Control.FXControl.FX.EqInControl.FX.Functor.ClassControl.FX.Functor.LeftZeroControl.FX.Functor.PairControl.FX.Functor.RightZeroControl.FX.FunctorControl.FX.Monad.ClassControl.FX.Monad.AppendOnlyControl.FX.Monad.ComposeControl.FX.Monad.ExceptControl.FX.Monad.HaltControl.FX.Monad.IdentityControl.FX.Monad.ReadOnlyControl.FX.Monad.StateControl.FX.Monad.WriteOnceControl.FX.Monad.WriteOnlyControl.FX.MonadControl.FX.Monad.Trans.Class!Control.FX.Monad.Trans.WriteOnlyT!Control.FX.Monad.Trans.WriteOnceTControl.FX.Monad.Trans.StateT Control.FX.Monad.Trans.ReadOnlyT Control.FX.Monad.Trans.IdentityTControl.FX.Monad.Trans.HaltTControl.FX.Monad.Trans.ExceptT"Control.FX.Monad.Trans.AppendOnlyTControl.FX.Monad.Trans.ComposeTControl.FX.Monad.Trans"Control.FX.Monad.Trans.Trans.Class(Control.FX.Monad.Trans.Trans.WriteOnlyTT(Control.FX.Monad.Trans.Trans.WriteOnceTT$Control.FX.Monad.Trans.Trans.StateTT'Control.FX.Monad.Trans.Trans.ReadOnlyTT#Control.FX.Monad.Trans.Trans.OverTT'Control.FX.Monad.Trans.Trans.IdentityTT%Control.FX.Monad.Trans.Trans.PromptTT#Control.FX.Monad.Trans.Trans.HaltTT%Control.FX.Monad.Trans.Trans.ExceptTT)Control.FX.Monad.Trans.Trans.AppendOnlyTTControl.FX.Monad.Trans.TransEqInContexteqInRenaming namingMap namingInvWrapunWrapIsMaybe fromMaybetoMaybe Bifunctorbimap1bimap2 CommutantcommuteLeftZeroLeftUnitPairslot1slot2 RightZero RightUnit MonadPromptpromptMonadWriteOnceetchpressMonadAppendOnlylookjot MonadReadOnlyasklocalMonadWriteOnlytelldraft MonadStategetput MonadExceptthrowcatch MonadHalthalt MonadIdentityunwrap LiftLocal liftLocalLocal LiftDraft liftDraftDraft LiftCatch liftCatchCatch RunMonadTransInputTOutputTrunT MonadTransliftRunMonadInputOutputrunCentral AppendOnly unAppendOnlyCompose unComposeExceptAcceptHaltStepIdentity unIdentityReadOnly unReadOnlyStateunState WriteOnce unWriteOnce WriteOnly unWriteOnly MonadFunctorhoist WriteOnlyT unWriteOnlyT runWriteOnlyT WriteOnceT unWriteOnceT runWriteOnceTStateTunStateT runStateT ReadOnlyT unReadOnlyT runReadOnlyT IdentityT unIdentityT runIdentityTHaltTunHaltTrunHaltTExceptT unExceptT runExceptT AppendOnlyT unAppendOnlyTrunAppendOnlyT ComposableTComposeT toComposeT unComposeT LiftLocalT liftLocalT LiftDraftT liftDraftT LiftCatchT liftCatchTRunMonadTransTransInputTTOutputTTrunTTMonadTransTransliftT WriteOnlyTT unWriteOnlyTTrunWriteOnlyTT WriteOnceTT unWriteOnceTTrunWriteOnceTTStateTT unStateTT runStateTT ReadOnlyTT unReadOnlyTT runReadOnlyTT OverableTOverTTtoOverTTunOverTT runOverTT IdentityTT unIdentityTT runIdentityTTEvalunEvalPromptTT unPromptTT runPromptTTHaltTTunHaltTT runHaltTTExceptTT unExceptTT runExceptTT AppendOnlyTTunAppendOnlyTTrunAppendOnlyTTMaybeCtx EitherCtx unMaybeCtx unEitherCtx LeftZeroCtx unLeftZeroCtxPairCtx unPairCtx RightZeroCtxunRightZeroCtxMaybeOut unMaybeOut AppendOnlyCtxunAppendOnlyCtx AppendOnlyInunAppendOnlyIn AppendOnlyOutunAppendOnlyOut runAppendOnly ComposeIn unComposeIn ComposeOut unComposeOut ExceptCtx unExceptCtxExceptIn unExceptIn ExceptOut unExceptOut runExceptHaltCtx unHaltCtxHaltInunHaltInHaltOut unHaltOut IdentityCtx unIdentityCtx IdentityIn unIdentityIn IdentityOut unIdentityOut ReadOnlyCtx unReadOnlyCtx ReadOnlyIn unReadOnlyIn ReadOnlyOut unReadOnlyOutStateCtx unStateCtxStateIn unStateInStateOut unStateOut WriteOnceCtxunWriteOnceCtx WriteOnceIn unWriteOnceIn WriteOnceOutunWriteOnceOut WriteOnlyCtxunWriteOnlyCtx WriteOnlyIn unWriteOnlyIn WriteOnlyOutunWriteOnlyOut WriteOnlyTCtxunWriteOnlyTCtx WriteOnlyTInunWriteOnlyTIn WriteOnlyTOutunWriteOnlyTOut WriteOnceTCtxunWriteOnceTCtx WriteOnceTInunWriteOnceTIn WriteOnceTOutunWriteOnceTOut StateTCtx unStateTCtxStateTIn unStateTIn StateTOut unStateTOut ReadOnlyTCtxunReadOnlyTCtx ReadOnlyTIn unReadOnlyTIn ReadOnlyTOutunReadOnlyTOut IdentityTCtxunIdentityTCtx IdentityTIn unIdentityTIn IdentityTOutunIdentityTOutHaltTCtx unHaltTCtxHaltTIn unHaltTInHaltTOut unHaltTOut ExceptTCtx unExceptTCtx ExceptTIn unExceptTIn ExceptTOut unExceptTOutAppendOnlyTCtxunAppendOnlyTCtx AppendOnlyTInunAppendOnlyTInAppendOnlyTOutunAppendOnlyTOut ComposeTCtx unComposeTCtx ComposeTIn unComposeTIn ComposeTOut unComposeTOutComposeT_IdentityTComposeT_HaltTComposeT_StateTComposeT_ReadOnlyTComposeT_WriteOnlyTComposeT_WriteOnceTComposeT_AppendOnlyTComposeT_ExceptTunComposeT_IdentityTunComposeT_HaltTunComposeT_StateTunComposeT_ReadOnlyTunComposeT_WriteOnlyTunComposeT_WriteOnceTunComposeT_AppendOnlyTunComposeT_ExceptTWriteOnlyTTCtxunWriteOnlyTTCtx WriteOnlyTTInunWriteOnlyTTInWriteOnlyTTOutunWriteOnlyTTOutWriteOnceTTCtxunWriteOnceTTCtx WriteOnceTTInunWriteOnceTTInWriteOnceTTOutunWriteOnceTTOut StateTTCtx unStateTTCtx StateTTIn unStateTTIn StateTTOut unStateTTOut ReadOnlyTTCtxunReadOnlyTTCtx ReadOnlyTTInunReadOnlyTTIn ReadOnlyTTOutunReadOnlyTTOut OverTTCtx unOverTTCtxOverTTIn unOverTTIn OverTTOut unOverTTOutOverTT_IdentityT OverTT_HaltT OverTT_StateTOverTT_ReadOnlyTOverTT_WriteOnlyTOverTT_WriteOnceTOverTT_AppendOnlyTOverTT_ExceptTunOverTT_IdentityTunOverTT_HaltTunOverTT_StateTunOverTT_ReadOnlyTunOverTT_WriteOnlyTunOverTT_WriteOnceTunOverTT_AppendOnlyTunOverTT_ExceptT IdentityTTCtxunIdentityTTCtx IdentityTTInunIdentityTTIn IdentityTTOutunIdentityTTOut PromptTTCtx unPromptTTCtx PromptTTIn unPromptTTIn PromptTTOut unPromptTTOut HaltTTCtx unHaltTTCtxHaltTTIn unHaltTTIn HaltTTOut unHaltTTOut ExceptTTCtx unExceptTTCtx ExceptTTIn unExceptTTIn ExceptTTOut unExceptTTOutAppendOnlyTTCtxunAppendOnlyTTCtxAppendOnlyTTInunAppendOnlyTTInAppendOnlyTTOutunAppendOnlyTTOut